runline 0.1.0

package/dist/plugins/airtable/src/index.js

@@ -0,0 +1,280 @@
+const BASE_URL = "https://api.airtable.com/v0";
+async function apiRequest(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}/${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v === undefined)
+                continue;
+            if (Array.isArray(v)) {
+                for (const item of v)
+                    url.searchParams.append(`${k}[]`, String(item));
+            }
+            else {
+                url.searchParams.set(k, String(v));
+            }
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Airtable API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+async function paginateRecords(token, endpoint, qs, limit) {
+    const results = [];
+    const _qs = { pageSize: 100, ...qs };
+    let offset;
+    while (true) {
+        if (offset)
+            _qs.offset = offset;
+        const data = (await apiRequest(token, "GET", endpoint, undefined, _qs));
+        results.push(...data.records);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        if (!data.offset)
+            break;
+        offset = data.offset;
+    }
+    return results;
+}
+/** Airtable limits batch writes to 10 records at a time */
+async function batchWrite(token, method, endpoint, records, extraBody) {
+    const results = [];
+    const batchSize = 10;
+    for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const body = { ...extraBody, records: batch };
+        const data = (await apiRequest(token, method, endpoint, body));
+        results.push(...data.records);
+    }
+    return results;
+}
+function getToken(ctx) {
+    return ctx.connection.config.token;
+}
+export default function airtable(rl) {
+    rl.setName("airtable");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        token: {
+            type: "string",
+            required: true,
+            description: "Airtable personal access token or API key",
+            env: "AIRTABLE_TOKEN",
+        },
+    });
+    // ── Base ────────────────────────────────────────────
+    rl.registerAction("base.list", {
+        description: "List all accessible bases",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { limit } = input ?? {};
+            const token = getToken(ctx);
+            const results = [];
+            let offset;
+            while (true) {
+                const qs = {};
+                if (offset)
+                    qs.offset = offset;
+                const data = (await apiRequest(token, "GET", "meta/bases", undefined, qs));
+                results.push(...data.bases);
+                if (limit && results.length >= limit)
+                    return results.slice(0, limit);
+                if (!data.offset)
+                    break;
+                offset = data.offset;
+            }
+            return results;
+        },
+    });
+    rl.registerAction("base.getSchema", {
+        description: "Get the schema (tables and fields) of a base",
+        inputSchema: {
+            baseId: { type: "string", required: true, description: "Base ID (e.g. appXXXXXXXXXXXXXX)" },
+        },
+        async execute(input, ctx) {
+            const { baseId } = input;
+            return apiRequest(getToken(ctx), "GET", `meta/bases/${baseId}/tables`);
+        },
+    });
+    // ── Record ──────────────────────────────────────────
+    rl.registerAction("record.create", {
+        description: "Create a record in a table",
+        inputSchema: {
+            baseId: { type: "string", required: true, description: "Base ID" },
+            tableId: { type: "string", required: true, description: "Table ID or name" },
+            fields: { type: "object", required: true, description: "Field values as key-value pairs" },
+            typecast: {
+                type: "boolean",
+                required: false,
+                description: "Automatically convert field values to appropriate types",
+            },
+        },
+        async execute(input, ctx) {
+            const { baseId, tableId, fields, typecast } = input;
+            const body = { fields };
+            if (typecast)
+                body.typecast = true;
+            return apiRequest(getToken(ctx), "POST", `${baseId}/${tableId}`, body);
+        },
+    });
+    rl.registerAction("record.createMany", {
+        description: "Create multiple records in a table (batched in groups of 10)",
+        inputSchema: {
+            baseId: { type: "string", required: true, description: "Base ID" },
+            tableId: { type: "string", required: true, description: "Table ID or name" },
+            records: {
+                type: "array",
+                required: true,
+                description: "Array of { fields: { ... } } objects",
+            },
+            typecast: { type: "boolean", required: false, description: "Auto-typecast values" },
+        },
+        async execute(input, ctx) {
+            const { baseId, tableId, records, typecast } = input;
+            const extra = {};
+            if (typecast)
+                extra.typecast = true;
+            return batchWrite(getToken(ctx), "POST", `${baseId}/${tableId}`, records, extra);
+        },
+    });
+    rl.registerAction("record.get", {
+        description: "Get a single record by ID",
+        inputSchema: {
+            baseId: { type: "string", required: true, description: "Base ID" },
+            tableId: { type: "string", required: true, description: "Table ID or name" },
+            recordId: { type: "string", required: true, description: "Record ID (e.g. recXXX)" },
+        },
+        async execute(input, ctx) {
+            const { baseId, tableId, recordId } = input;
+            return apiRequest(getToken(ctx), "GET", `${baseId}/${tableId}/${recordId}`);
+        },
+    });
+    rl.registerAction("record.search", {
+        description: "Search/list records with optional formula filter and sorting",
+        inputSchema: {
+            baseId: { type: "string", required: true, description: "Base ID" },
+            tableId: { type: "string", required: true, description: "Table ID or name" },
+            filterByFormula: {
+                type: "string",
+                required: false,
+                description: "Airtable formula to filter records",
+            },
+            fields: {
+                type: "array",
+                required: false,
+                description: "Array of field names to include in response",
+            },
+            sort: {
+                type: "array",
+                required: false,
+                description: "Array of { field, direction } objects (direction: 'asc' or 'desc')",
+            },
+            view: { type: "string", required: false, description: "View ID or name" },
+            limit: { type: "number", required: false, description: "Max records to return" },
+        },
+        async execute(input, ctx) {
+            const { baseId, tableId, filterByFormula, fields, sort, view, limit } = input;
+            const qs = {};
+            if (filterByFormula)
+                qs.filterByFormula = filterByFormula;
+            if (fields)
+                qs.fields = fields;
+            if (sort)
+                qs.sort = sort;
+            if (view)
+                qs.view = view;
+            if (limit && !filterByFormula)
+                qs.maxRecords = limit;
+            return paginateRecords(getToken(ctx), `${baseId}/${tableId}`, qs, limit);
+        },
+    });
+    rl.registerAction("record.update", {
+        description: "Update a record by ID (PATCH — only updates specified fields)",
+        inputSchema: {
+            baseId: { type: "string", required: true, description: "Base ID" },
+            tableId: { type: "string", required: true, description: "Table ID or name" },
+            recordId: { type: "string", required: true, description: "Record ID" },
+            fields: { type: "object", required: true, description: "Fields to update" },
+            typecast: { type: "boolean", required: false, description: "Auto-typecast values" },
+        },
+        async execute(input, ctx) {
+            const { baseId, tableId, recordId, fields, typecast } = input;
+            const body = { fields };
+            if (typecast)
+                body.typecast = true;
+            return apiRequest(getToken(ctx), "PATCH", `${baseId}/${tableId}/${recordId}`, body);
+        },
+    });
+    rl.registerAction("record.updateMany", {
+        description: "Update multiple records (batched in groups of 10)",
+        inputSchema: {
+            baseId: { type: "string", required: true, description: "Base ID" },
+            tableId: { type: "string", required: true, description: "Table ID or name" },
+            records: {
+                type: "array",
+                required: true,
+                description: "Array of { id, fields: { ... } } objects",
+            },
+            typecast: { type: "boolean", required: false, description: "Auto-typecast values" },
+        },
+        async execute(input, ctx) {
+            const { baseId, tableId, records, typecast } = input;
+            const extra = {};
+            if (typecast)
+                extra.typecast = true;
+            return batchWrite(getToken(ctx), "PATCH", `${baseId}/${tableId}`, records, extra);
+        },
+    });
+    rl.registerAction("record.upsert", {
+        description: "Create or update a record based on matching fields (uses Airtable's performUpsert)",
+        inputSchema: {
+            baseId: { type: "string", required: true, description: "Base ID" },
+            tableId: { type: "string", required: true, description: "Table ID or name" },
+            fields: { type: "object", required: true, description: "Field values" },
+            fieldsToMergeOn: {
+                type: "array",
+                required: true,
+                description: "Field names to match on for upsert",
+            },
+            typecast: { type: "boolean", required: false, description: "Auto-typecast values" },
+        },
+        async execute(input, ctx) {
+            const { baseId, tableId, fields, fieldsToMergeOn, typecast } = input;
+            const body = {
+                records: [{ fields }],
+                performUpsert: { fieldsToMergeOn },
+            };
+            if (typecast)
+                body.typecast = true;
+            return apiRequest(getToken(ctx), "PATCH", `${baseId}/${tableId}`, body);
+        },
+    });
+    rl.registerAction("record.delete", {
+        description: "Delete a record by ID",
+        inputSchema: {
+            baseId: { type: "string", required: true, description: "Base ID" },
+            tableId: { type: "string", required: true, description: "Table ID or name" },
+            recordId: { type: "string", required: true, description: "Record ID" },
+        },
+        async execute(input, ctx) {
+            const { baseId, tableId, recordId } = input;
+            return apiRequest(getToken(ctx), "DELETE", `${baseId}/${tableId}/${recordId}`);
+        },
+    });
+}