merge conflict

Author: wellingtonjr3873

MAINTAINERS.txt

@@ -4,3 +4,6 @@ viktormarinho
 mcandeia
 pedrofrxncx
 lucis
+vitoUwu
+IncognitaDev
+stherzada

NewAppPrompt.md

@@ -301,6 +301,9 @@ const action = async (
 export default action;
 ```
 
+If a method has no props, just don't type the Props. Don't export an empty
+interface.
+
 ### deco.ts
 
 In root `deco.ts`, add a new entry for the newly created app.

airtable/actions/createField.ts

@@ -0,0 +1,66 @@
+import type { AppContext } from "../mod.ts";
+import type { CreateFieldBody, Field } from "../types.ts";
+
+// Props will be CreateFieldBody plus baseId and tableId
+interface Props extends CreateFieldBody {
+  /**
+   * @title Base ID
+   */
+  baseId: string;
+
+  /**
+   * @title Table ID
+   * @description The ID of the table to add the field to.
+   */
+  tableId: string;
+  /**
+   * @title API Key
+   */
+  apiKey?: string;
+  // name, type, description, options are inherited from CreateFieldBody
+}
+
+/**
+ * @title Create Airtable Field
+ * @description Creates a new field in a specified table (Metadata API).
+ * @see https://airtable.com/developers/web/api/create-field
+ */
+const action = async (
+  props: Props,
+  req: Request,
+  ctx: AppContext,
+): Promise<Field | Response> => {
+  const { baseId, tableId, name, type, description, options, apiKey } = props;
+
+  const authHeader = req.headers.get("Authorization")?.split(" ")[1];
+  const resolvedApiKey = authHeader || apiKey;
+
+  if (!resolvedApiKey) {
+    return new Response("API Key is required", { status: 403 });
+  }
+
+  const body: CreateFieldBody = {
+    name,
+    type,
+  };
+  if (description) {
+    body.description = description;
+  }
+  if (options) {
+    body.options = options;
+  }
+
+  const response = await ctx.api(resolvedApiKey)
+    ["POST /v0/meta/bases/:baseId/tables/:tableId/fields"](
+      { baseId, tableId }, // URL params
+      { body }, // Request body
+    );
+
+  if (!response.ok) {
+    throw new Error(`Error creating field: ${response.statusText}`);
+  }
+
+  return response.json();
+};
+
+export default action;

airtable/actions/createRecord.ts

@@ -0,0 +1,69 @@
+import type { AppContext } from "../mod.ts";
+import type { AirtableRecord, FieldSet } from "../types.ts";
+
+interface Props {
+  /**
+   * @title Base ID
+   */
+  baseId: string;
+
+  /**
+   * @title Table ID or Name
+   */
+  tableIdOrName: string;
+
+  /**
+   * @title Record Fields
+   * @description The fields for the new record.
+   */
+  fields: FieldSet;
+
+  /**
+   * @title Typecast
+   * @description Optional. If true, Airtable will attempt to convert cell values to the appropriate type.
+   */
+  typecast?: boolean;
+
+  /**
+   * @title API Key
+   */
+  apiKey?: string;
+}
+
+/**
+ * @title Create Airtable Record
+ * @description Creates a new record in a specified table.
+ */
+const action = async (
+  props: Props,
+  req: Request,
+  ctx: AppContext,
+): Promise<AirtableRecord | Response> => {
+  const { baseId, tableIdOrName, fields, typecast, apiKey } = props;
+
+  const authHeader = req.headers.get("Authorization")?.split(" ")[1];
+  const resolvedApiKey = authHeader || apiKey;
+
+  if (!resolvedApiKey) {
+    return new Response("API Key is required", { status: 403 });
+  }
+
+  const body = {
+    fields,
+    ...(typecast !== undefined && { typecast }),
+  };
+
+  const response = await ctx.api(resolvedApiKey)
+    ["POST /v0/:baseId/:tableIdOrName"](
+      { baseId, tableIdOrName }, // URL parameters
+      { body }, // Request body and other options
+    );
+
+  if (!response.ok) {
+    throw new Error(`Error creating record: ${response.statusText}`);
+  }
+
+  return response.json();
+};
+
+export default action;

airtable/actions/createTable.ts

@@ -0,0 +1,97 @@
+import type { AppContext } from "../mod.ts";
+import type { CreateTableBody, Field, Table } from "../types.ts";
+
+interface Props {
+  /**
+   * @title Base ID
+   */
+  baseId: string;
+
+  /**
+   * @title Table Name
+   */
+  name: string;
+
+  /**
+   * @title Table Description
+   * @description Optional description for the new table.
+   */
+  description?: string;
+
+  /**
+   * @title Table Fields
+   * @description Array of field definitions for the new table.
+   * @see https://airtable.com/developers/web/api/field-model
+   */
+  fields: Array<Omit<Field, "id">>; // When creating a table, field IDs are not provided for new fields.
+
+  /**
+   * @title Primary Field ID or Name
+   * @description Optional. The name or ID of the field to be set as primary.
+   * If not provided, Airtable usually defaults to the first field or requires one with a supported type.
+   */
+  primaryFieldNameOrId?: string; // Airtable API for create table can take primaryFieldId. This simplifies it to a name.
+  // This will need to be translated to the correct structure for CreateTableBody.fields if needed
+  // Or CreateTableBody might need primaryFieldId directly.
+  // For simplicity, let's assume CreateTableBody handles fields definitions correctly.
+}
+
+/**
+ * @title API Key
+ */
+interface PropsWithApiKey extends Props {
+  apiKey?: string;
+}
+
+/**
+ * @title Create Airtable Table
+ * @description Creates a new table within a specified base (Metadata API).
+ */
+const action = async (
+  props: PropsWithApiKey,
+  req: Request,
+  ctx: AppContext,
+): Promise<Table | Response> => {
+  const { baseId, name, description, fields, apiKey } = props;
+
+  const authHeader = req.headers.get("Authorization")?.split(" ")[1];
+  const resolvedApiKey = authHeader || apiKey;
+
+  if (!resolvedApiKey) {
+    return new Response("API Key is required", { status: 403 });
+  }
+
+  // The client expects `body: CreateTableBody`
+  // CreateTableBody is { name: string, description?: string, fields: Field[], primaryFieldId?: string }
+  // Our Props.fields is Array<Omit<Field, "id">>. This is compatible with Field[] where id is optional.
+  const body: CreateTableBody = {
+    name,
+    fields: fields as Field[], // Cast Omit<Field, "id">[] to Field[]
+  };
+
+  if (description) {
+    body.description = description;
+  }
+  // Handling primaryFieldNameOrId would typically involve finding that field in the `fields` array
+  // (if it's a name) and then setting its ID to `body.primaryFieldId` IF the API expects that.
+  // The Airtable API for creating tables usually infers the primary field or requires one of the fields
+  // to be of a primary-compatible type.
+  // The `CreateTableBody` includes `primaryFieldId?: string;`. If the user provides it, we pass it.
+  // Let's adjust Props to take primaryFieldId to align better with CreateTableBody
+  // For now, this example will omit direct primaryFieldId setting from Props to simplify, assuming field definitions suffice or a default is used.
+  // If `primaryFieldNameOrId` was intended to be `primaryFieldId` from `CreateTableBody` it should be named so in `Props`.
+
+  const response = await ctx.api(resolvedApiKey)
+    ["POST /v0/meta/bases/:baseId/tables"](
+      { baseId }, // URL params
+      { body }, // Request body
+    );
+
+  if (!response.ok) {
+    throw new Error(`Error creating table: ${response.statusText}`);
+  }
+
+  return response.json();
+};
+
+export default action;

airtable/actions/deleteRecords.ts

@@ -0,0 +1,64 @@
+import type { AppContext } from "../mod.ts";
+
+interface Props {
+  /**
+   * @title Base ID
+   */
+  baseId: string;
+
+  /**
+   * @title Table ID or Name
+   */
+  tableIdOrName: string;
+
+  /**
+   * @title Record IDs to Delete
+   * @description An array of record IDs to be deleted.
+   */
+  recordIds: string[];
+
+  /**
+   * @title API Key
+   */
+  apiKey?: string;
+}
+
+/**
+ * @title Delete Airtable Records
+ * @description Deletes one or more records from a specified table.
+ */
+const action = async (
+  props: Props,
+  req: Request,
+  ctx: AppContext,
+): Promise<{ records: Array<{ id: string; deleted: boolean }> } | Response> => {
+  const { baseId, tableIdOrName, recordIds, apiKey } = props;
+
+  const authHeader = req.headers.get("Authorization")?.split(" ")[1];
+  const resolvedApiKey = authHeader || apiKey;
+
+  if (!resolvedApiKey) {
+    return new Response("API Key is required", { status: 403 });
+  }
+
+  // The client expects searchParams: { "records[]": string[] }
+  // The parameters to the client call should be flat, including URL params and searchParams
+  const params = {
+    baseId,
+    tableIdOrName,
+    "records[]": recordIds,
+  };
+
+  const response = await ctx.api(resolvedApiKey)
+    ["DELETE /v0/:baseId/:tableIdOrName"](
+      params,
+    );
+
+  if (!response.ok) {
+    throw new Error(`Error deleting records: ${response.statusText}`);
+  }
+
+  return response.json();
+};
+
+export default action;

airtable/actions/updateField.ts

@@ -0,0 +1,75 @@
+import type { AppContext } from "../mod.ts";
+import type { Field, UpdateFieldBody } from "../types.ts";
+
+// Props will be UpdateFieldBody plus baseId, tableId, and fieldId
+interface Props extends UpdateFieldBody {
+  /**
+   * @title Base ID
+   */
+  baseId: string;
+
+  /**
+   * @title Table ID
+   */
+  tableId: string;
+
+  /**
+   * @title Field ID
+   * @description The ID of the field to update.
+   */
+  fieldId: string;
+  /**
+   * @title API Key
+   */
+  apiKey?: string;
+  // name, description are inherited from UpdateFieldBody
+  // type and options changes are complex and generally not advised via simple updates.
+}
+
+/**
+ * @title Update Airtable Field
+ * @description Updates an existing field's properties like name or description (Metadata API).
+ * @see https://airtable.com/developers/web/api/update-field
+ */
+const action = async (
+  props: Props,
+  req: Request,
+  ctx: AppContext,
+): Promise<Field | Response> => {
+  const { baseId, tableId, fieldId, name, description, apiKey } = props;
+
+  const authHeader = req.headers.get("Authorization")?.split(" ")[1];
+  const resolvedApiKey = authHeader || apiKey;
+
+  if (!resolvedApiKey) {
+    return new Response("API Key is required", { status: 403 });
+  }
+
+  const body: UpdateFieldBody = {};
+  if (name) {
+    body.name = name;
+  }
+  if (description) {
+    body.description = description;
+  }
+
+  if (Object.keys(body).length === 0) {
+    throw new Error(
+      "No updates provided for the field. Please specify name or description.",
+    );
+  }
+
+  const response = await ctx.api(resolvedApiKey)
+    ["PATCH /v0/meta/bases/:baseId/tables/:tableId/fields/:fieldId"](
+      { baseId, tableId, fieldId }, // URL params
+      { body }, // Request body
+    );
+
+  if (!response.ok) {
+    throw new Error(`Error updating field: ${response.statusText}`);
+  }
+
+  return response.json();
+};
+
+export default action;