@robinpath/airtable - npm Package Compare versions

Comparing version

0.1.1

0.1.2

+16

-3

package.json

		{
		"name": "@robinpath/airtable",
		"version": "0.1.1",
		"version": "0.1.2",
		"publishConfig": {
		@@ -23,8 +23,21 @@ "access": "public"
		"peerDependencies": {
		"@wiredwp/robinpath": ">=0.20.0"
		"@robinpath/core": ">=0.20.0"
		},
		"devDependencies": {
		"@wiredwp/robinpath": "^0.30.1",
		"@robinpath/core": "^0.30.1",
		"typescript": "^5.6.0"
		},
		"description": "Airtable module for RobinPath.",
		"keywords": [
		"airtable",
		"productivity"
		],
		"license": "MIT",
		"robinpath": {
		"category": "productivity",
		"type": "integration",
		"auth": "bearer-token",
		"functionCount": 16,
		"baseUrl": "https://api.airtable.com/v0"
		}
		}

-218

dist/airtable.d.ts

		import type { BuiltinHandler } from "@wiredwp/robinpath";
		export declare const AirtableFunctions: Record<string, BuiltinHandler>;
		export declare const AirtableFunctionMetadata: {
		setToken: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		listBases: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		getBaseSchema: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		listRecords: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		getRecord: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		createRecord: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		createRecords: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		updateRecord: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		updateRecords: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		replaceRecord: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		deleteRecord: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		deleteRecords: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		createTable: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		updateTable: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		createField: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		updateField: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		};
		export declare const AirtableModuleMetadata: {
		description: string;
		methods: string[];
		category: string;
		};
		//# sourceMappingURL=airtable.d.ts.map

-1

dist/airtable.d.ts.map

{"version":3,"file":"airtable.d.ts","sourceRoot":"","sources":["../src/airtable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAA2C,MAAM,oBAAoB,CAAC;AA0UlG,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAiB5D,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMpC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;CAIlC,CAAC"}

-534

dist/airtable.js

		// ── Internal State ──────────────────────────────────────────────────
		const API_BASE = "https://api.airtable.com/v0";
		const tokens = new Map();
		// ── Helper ──────────────────────────────────────────────────────────
		function getToken(key) {
		const token = tokens.get(key);
		if (!token) {
		throw new Error(`Airtable token "${key}" not configured. Call airtable.setToken first.`);
		}
		return token;
		}
		async function airtableRequest(tokenKey, path, method = "GET", body) {
		const token = getToken(tokenKey);
		const headers = {
		Authorization: `Bearer ${token}`,
		"Content-Type": "application/json",
		};
		const opts = { method, headers };
		if (body !== undefined) {
		opts.body = JSON.stringify(body);
		}
		const response = await fetch(`${API_BASE}${path}`, opts);
		if (!response.ok) {
		const errBody = await response.text();
		let message;
		try {
		const parsed = JSON.parse(errBody);
		const err = parsed.error;
		message = err ? `${String(err.type ?? "UNKNOWN")}: ${String(err.message ?? errBody)}` : errBody;
		}
		catch {
		message = errBody;
		}
		throw new Error(`Airtable API ${method} ${path} failed (${response.status}): ${message}`);
		}
		// DELETE with 200 may return empty body
		const text = await response.text();
		if (!text)
		return { ok: true };
		return JSON.parse(text);
		}
		// ── Function Handlers ───────────────────────────────────────────────
		const setToken = (args) => {
		const key = String(args[0] ?? "default");
		const token = String(args[1] ?? "");
		if (!token)
		throw new Error("API token is required");
		tokens.set(key, token);
		return { key, configured: true };
		};
		const listBases = async (args) => {
		const key = String(args[0] ?? "default");
		const opts = (typeof args[1] === "object" && args[1] !== null ? args[1] : {});
		let path = "/meta/bases";
		const params = [];
		if (opts.offset)
		params.push(`offset=${encodeURIComponent(String(opts.offset))}`);
		if (params.length)
		path += `?${params.join("&")}`;
		const result = (await airtableRequest(key, path));
		return { bases: result.bases, offset: result.offset ?? null };
		};
		const getBaseSchema = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		if (!baseId)
		throw new Error("Base ID is required");
		const result = (await airtableRequest(key, `/meta/bases/${encodeURIComponent(baseId)}/tables`));
		return { tables: result.tables };
		};
		const listRecords = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableIdOrName = String(args[2] ?? "");
		const opts = (typeof args[3] === "object" && args[3] !== null ? args[3] : {});
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableIdOrName)
		throw new Error("Table ID or name is required");
		const params = [];
		if (opts.filterByFormula)
		params.push(`filterByFormula=${encodeURIComponent(String(opts.filterByFormula))}`);
		if (opts.maxRecords)
		params.push(`maxRecords=${encodeURIComponent(String(opts.maxRecords))}`);
		if (opts.pageSize)
		params.push(`pageSize=${encodeURIComponent(String(opts.pageSize))}`);
		if (opts.offset)
		params.push(`offset=${encodeURIComponent(String(opts.offset))}`);
		if (opts.view)
		params.push(`view=${encodeURIComponent(String(opts.view))}`);
		if (opts.cellFormat)
		params.push(`cellFormat=${encodeURIComponent(String(opts.cellFormat))}`);
		if (opts.timeZone)
		params.push(`timeZone=${encodeURIComponent(String(opts.timeZone))}`);
		if (opts.userLocale)
		params.push(`userLocale=${encodeURIComponent(String(opts.userLocale))}`);
		if (Array.isArray(opts.fields)) {
		for (const f of opts.fields) {
		params.push(`fields[]=${encodeURIComponent(String(f))}`);
		}
		}
		if (Array.isArray(opts.sort)) {
		const sortArr = opts.sort;
		for (let i = 0; i < sortArr.length; i++) {
		const s = sortArr[i];
		if (s.field)
		params.push(`sort[${i}][field]=${encodeURIComponent(String(s.field))}`);
		if (s.direction)
		params.push(`sort[${i}][direction]=${encodeURIComponent(String(s.direction))}`);
		}
		}
		let path = `/${encodeURIComponent(baseId)}/${encodeURIComponent(tableIdOrName)}`;
		if (params.length)
		path += `?${params.join("&")}`;
		const result = (await airtableRequest(key, path));
		return { records: result.records, offset: result.offset ?? null };
		};
		const getRecord = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableIdOrName = String(args[2] ?? "");
		const recordId = String(args[3] ?? "");
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableIdOrName)
		throw new Error("Table ID or name is required");
		if (!recordId)
		throw new Error("Record ID is required");
		const path = `/${encodeURIComponent(baseId)}/${encodeURIComponent(tableIdOrName)}/${encodeURIComponent(recordId)}`;
		return (await airtableRequest(key, path));
		};
		const createRecord = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableIdOrName = String(args[2] ?? "");
		const fields = args[3] ?? {};
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableIdOrName)
		throw new Error("Table ID or name is required");
		const path = `/${encodeURIComponent(baseId)}/${encodeURIComponent(tableIdOrName)}`;
		return (await airtableRequest(key, path, "POST", { fields }));
		};
		const createRecords = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableIdOrName = String(args[2] ?? "");
		const records = args[3];
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableIdOrName)
		throw new Error("Table ID or name is required");
		if (!Array.isArray(records))
		throw new Error("Records must be an array");
		if (records.length > 10)
		throw new Error("Bulk create supports up to 10 records at a time");
		const payload = records.map((r) => {
		if (typeof r === "object" && r !== null && "fields" in r)
		return r;
		return { fields: r };
		});
		const path = `/${encodeURIComponent(baseId)}/${encodeURIComponent(tableIdOrName)}`;
		return (await airtableRequest(key, path, "POST", { records: payload }));
		};
		const updateRecord = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableIdOrName = String(args[2] ?? "");
		const recordId = String(args[3] ?? "");
		const fields = args[4] ?? {};
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableIdOrName)
		throw new Error("Table ID or name is required");
		if (!recordId)
		throw new Error("Record ID is required");
		const path = `/${encodeURIComponent(baseId)}/${encodeURIComponent(tableIdOrName)}/${encodeURIComponent(recordId)}`;
		return (await airtableRequest(key, path, "PATCH", { fields }));
		};
		const updateRecords = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableIdOrName = String(args[2] ?? "");
		const records = args[3];
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableIdOrName)
		throw new Error("Table ID or name is required");
		if (!Array.isArray(records))
		throw new Error("Records must be an array");
		if (records.length > 10)
		throw new Error("Bulk update supports up to 10 records at a time");
		const path = `/${encodeURIComponent(baseId)}/${encodeURIComponent(tableIdOrName)}`;
		return (await airtableRequest(key, path, "PATCH", { records }));
		};
		const replaceRecord = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableIdOrName = String(args[2] ?? "");
		const recordId = String(args[3] ?? "");
		const fields = args[4] ?? {};
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableIdOrName)
		throw new Error("Table ID or name is required");
		if (!recordId)
		throw new Error("Record ID is required");
		const path = `/${encodeURIComponent(baseId)}/${encodeURIComponent(tableIdOrName)}/${encodeURIComponent(recordId)}`;
		return (await airtableRequest(key, path, "PUT", { fields }));
		};
		const deleteRecord = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableIdOrName = String(args[2] ?? "");
		const recordId = String(args[3] ?? "");
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableIdOrName)
		throw new Error("Table ID or name is required");
		if (!recordId)
		throw new Error("Record ID is required");
		const path = `/${encodeURIComponent(baseId)}/${encodeURIComponent(tableIdOrName)}/${encodeURIComponent(recordId)}`;
		return (await airtableRequest(key, path, "DELETE"));
		};
		const deleteRecords = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableIdOrName = String(args[2] ?? "");
		const recordIds = args[3];
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableIdOrName)
		throw new Error("Table ID or name is required");
		if (!Array.isArray(recordIds))
		throw new Error("Record IDs must be an array");
		if (recordIds.length > 10)
		throw new Error("Bulk delete supports up to 10 records at a time");
		const params = recordIds.map((id) => `records[]=${encodeURIComponent(String(id))}`).join("&");
		const path = `/${encodeURIComponent(baseId)}/${encodeURIComponent(tableIdOrName)}?${params}`;
		return (await airtableRequest(key, path, "DELETE"));
		};
		const createTable = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const name = String(args[2] ?? "");
		const fields = args[3];
		if (!baseId)
		throw new Error("Base ID is required");
		if (!name)
		throw new Error("Table name is required");
		if (!Array.isArray(fields))
		throw new Error("Fields must be an array of field definitions");
		const body = { name, fields };
		const path = `/meta/bases/${encodeURIComponent(baseId)}/tables`;
		return (await airtableRequest(key, path, "POST", body));
		};
		const updateTable = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableId = String(args[2] ?? "");
		const opts = (typeof args[3] === "object" && args[3] !== null ? args[3] : {});
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableId)
		throw new Error("Table ID is required");
		const body = {};
		if (opts.name !== undefined)
		body.name = String(opts.name);
		if (opts.description !== undefined)
		body.description = String(opts.description);
		const path = `/meta/bases/${encodeURIComponent(baseId)}/tables/${encodeURIComponent(tableId)}`;
		return (await airtableRequest(key, path, "PATCH", body));
		};
		const createField = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableId = String(args[2] ?? "");
		const name = String(args[3] ?? "");
		const type = String(args[4] ?? "");
		const opts = (typeof args[5] === "object" && args[5] !== null ? args[5] : {});
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableId)
		throw new Error("Table ID is required");
		if (!name)
		throw new Error("Field name is required");
		if (!type)
		throw new Error("Field type is required");
		const body = { name, type };
		if (opts.description !== undefined)
		body.description = String(opts.description);
		if (opts.options !== undefined)
		body.options = opts.options;
		const path = `/meta/bases/${encodeURIComponent(baseId)}/tables/${encodeURIComponent(tableId)}/fields`;
		return (await airtableRequest(key, path, "POST", body));
		};
		const updateField = async (args) => {
		const key = String(args[0] ?? "default");
		const baseId = String(args[1] ?? "");
		const tableId = String(args[2] ?? "");
		const fieldId = String(args[3] ?? "");
		const opts = (typeof args[4] === "object" && args[4] !== null ? args[4] : {});
		if (!baseId)
		throw new Error("Base ID is required");
		if (!tableId)
		throw new Error("Table ID is required");
		if (!fieldId)
		throw new Error("Field ID is required");
		const body = {};
		if (opts.name !== undefined)
		body.name = String(opts.name);
		if (opts.description !== undefined)
		body.description = String(opts.description);
		const path = `/meta/bases/${encodeURIComponent(baseId)}/tables/${encodeURIComponent(tableId)}/fields/${encodeURIComponent(fieldId)}`;
		return (await airtableRequest(key, path, "PATCH", body));
		};
		// ── Exports ─────────────────────────────────────────────────────────
		export const AirtableFunctions = {
		setToken,
		listBases,
		getBaseSchema,
		listRecords,
		getRecord,
		createRecord,
		createRecords,
		updateRecord,
		updateRecords,
		replaceRecord,
		deleteRecord,
		deleteRecords,
		createTable,
		updateTable,
		createField,
		updateField,
		};
		export const AirtableFunctionMetadata = {
		setToken: {
		description: "Store an Airtable personal access token for authentication",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier (e.g. 'default')", formInputType: "text", required: true },
		{ name: "apiToken", dataType: "string", description: "Airtable personal access token", formInputType: "text", required: true },
		],
		returnType: "object",
		returnDescription: "{key, configured}",
		example: 'airtable.setToken "default" "patXXXXXXXXXXXXXX"',
		},
		listBases: {
		description: "List all bases accessible by the configured token",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{offset?} for pagination", formInputType: "json", required: false },
		],
		returnType: "object",
		returnDescription: "{bases, offset}",
		example: 'airtable.listBases "default"',
		},
		getBaseSchema: {
		description: "Get the schema (tables and fields) for a base",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Airtable base ID (e.g. 'appXXXXXXXXXXXXXX')", formInputType: "text", required: true },
		],
		returnType: "object",
		returnDescription: "{tables} with field definitions",
		example: 'airtable.getBaseSchema "default" "appABC123"',
		},
		listRecords: {
		description: "List records from a table with optional filtering, sorting, and pagination",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableIdOrName", dataType: "string", description: "Table ID or name", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{filterByFormula?, sort?, fields?, maxRecords?, pageSize?, offset?, view?}", formInputType: "json", required: false },
		],
		returnType: "object",
		returnDescription: "{records, offset}",
		example: 'airtable.listRecords "default" "appABC123" "Tasks" {"filterByFormula": "{Status}=\'Done\'", "maxRecords": 50}',
		},
		getRecord: {
		description: "Get a single record by ID",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableIdOrName", dataType: "string", description: "Table ID or name", formInputType: "text", required: true },
		{ name: "recordId", dataType: "string", description: "Record ID (e.g. 'recXXXXXXXXXXXXXX')", formInputType: "text", required: true },
		],
		returnType: "object",
		returnDescription: "Record object with id, fields, createdTime",
		example: 'airtable.getRecord "default" "appABC123" "Tasks" "recDEF456"',
		},
		createRecord: {
		description: "Create a single record in a table",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableIdOrName", dataType: "string", description: "Table ID or name", formInputType: "text", required: true },
		{ name: "fields", dataType: "object", description: "Field name-value pairs", formInputType: "json", required: true },
		],
		returnType: "object",
		returnDescription: "Created record with id, fields, createdTime",
		example: 'airtable.createRecord "default" "appABC123" "Tasks" {"Name": "New task", "Status": "Todo"}',
		},
		createRecords: {
		description: "Bulk create up to 10 records in a table",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableIdOrName", dataType: "string", description: "Table ID or name", formInputType: "text", required: true },
		{ name: "records", dataType: "array", description: "Array of {fields: {...}} objects (max 10)", formInputType: "json", required: true },
		],
		returnType: "object",
		returnDescription: "{records} array of created records",
		example: 'airtable.createRecords "default" "appABC123" "Tasks" [{"fields": {"Name": "Task A"}}, {"fields": {"Name": "Task B"}}]',
		},
		updateRecord: {
		description: "Update a single record (PATCH - only updates specified fields)",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableIdOrName", dataType: "string", description: "Table ID or name", formInputType: "text", required: true },
		{ name: "recordId", dataType: "string", description: "Record ID", formInputType: "text", required: true },
		{ name: "fields", dataType: "object", description: "Field name-value pairs to update", formInputType: "json", required: true },
		],
		returnType: "object",
		returnDescription: "Updated record",
		example: 'airtable.updateRecord "default" "appABC123" "Tasks" "recDEF456" {"Status": "Done"}',
		},
		updateRecords: {
		description: "Bulk update up to 10 records (PATCH)",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableIdOrName", dataType: "string", description: "Table ID or name", formInputType: "text", required: true },
		{ name: "records", dataType: "array", description: "Array of {id, fields} objects (max 10)", formInputType: "json", required: true },
		],
		returnType: "object",
		returnDescription: "{records} array of updated records",
		example: 'airtable.updateRecords "default" "appABC123" "Tasks" [{"id": "recDEF456", "fields": {"Status": "Done"}}]',
		},
		replaceRecord: {
		description: "Replace a single record (PUT - clears unspecified fields)",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableIdOrName", dataType: "string", description: "Table ID or name", formInputType: "text", required: true },
		{ name: "recordId", dataType: "string", description: "Record ID", formInputType: "text", required: true },
		{ name: "fields", dataType: "object", description: "Complete field name-value pairs", formInputType: "json", required: true },
		],
		returnType: "object",
		returnDescription: "Replaced record",
		example: 'airtable.replaceRecord "default" "appABC123" "Tasks" "recDEF456" {"Name": "Replaced", "Status": "New"}',
		},
		deleteRecord: {
		description: "Delete a single record by ID",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableIdOrName", dataType: "string", description: "Table ID or name", formInputType: "text", required: true },
		{ name: "recordId", dataType: "string", description: "Record ID", formInputType: "text", required: true },
		],
		returnType: "object",
		returnDescription: "{id, deleted: true}",
		example: 'airtable.deleteRecord "default" "appABC123" "Tasks" "recDEF456"',
		},
		deleteRecords: {
		description: "Bulk delete up to 10 records by ID",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableIdOrName", dataType: "string", description: "Table ID or name", formInputType: "text", required: true },
		{ name: "recordIds", dataType: "array", description: "Array of record IDs (max 10)", formInputType: "json", required: true },
		],
		returnType: "object",
		returnDescription: "{records} array of {id, deleted}",
		example: 'airtable.deleteRecords "default" "appABC123" "Tasks" ["recDEF456", "recGHI789"]',
		},
		createTable: {
		description: "Create a new table in a base with field definitions",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "name", dataType: "string", description: "Table name", formInputType: "text", required: true },
		{ name: "fields", dataType: "array", description: "Array of field definitions [{name, type, options?}]", formInputType: "json", required: true },
		],
		returnType: "object",
		returnDescription: "Created table object with id, name, fields",
		example: 'airtable.createTable "default" "appABC123" "Projects" [{"name": "Name", "type": "singleLineText"}, {"name": "Status", "type": "singleSelect", "options": {"choices": [{"name": "Active"}, {"name": "Done"}]}}]',
		},
		updateTable: {
		description: "Update a table's name or description",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableId", dataType: "string", description: "Table ID", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{name?, description?}", formInputType: "json", required: true },
		],
		returnType: "object",
		returnDescription: "Updated table object",
		example: 'airtable.updateTable "default" "appABC123" "tblXYZ" {"name": "Renamed Table", "description": "Updated description"}',
		},
		createField: {
		description: "Create a new field in a table",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableId", dataType: "string", description: "Table ID", formInputType: "text", required: true },
		{ name: "name", dataType: "string", description: "Field name", formInputType: "text", required: true },
		{ name: "type", dataType: "string", description: "Field type (e.g. singleLineText, number, singleSelect)", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{description?, options?} field-type-specific options", formInputType: "json", required: false },
		],
		returnType: "object",
		returnDescription: "Created field object with id, name, type",
		example: 'airtable.createField "default" "appABC123" "tblXYZ" "Priority" "singleSelect" {"options": {"choices": [{"name": "High"}, {"name": "Low"}]}}',
		},
		updateField: {
		description: "Update a field's name or description",
		parameters: [
		{ name: "key", dataType: "string", description: "Token identifier", formInputType: "text", required: true },
		{ name: "baseId", dataType: "string", description: "Base ID", formInputType: "text", required: true },
		{ name: "tableId", dataType: "string", description: "Table ID", formInputType: "text", required: true },
		{ name: "fieldId", dataType: "string", description: "Field ID", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{name?, description?}", formInputType: "json", required: true },
		],
		returnType: "object",
		returnDescription: "Updated field object",
		example: 'airtable.updateField "default" "appABC123" "tblXYZ" "fldABC" {"name": "Renamed Field", "description": "Updated desc"}',
		},
		};
		export const AirtableModuleMetadata = {
		description: "Airtable REST API client for managing bases, tables, fields, and records with full CRUD support",
		methods: Object.keys(AirtableFunctions),
		category: "database",
		};
		//# sourceMappingURL=airtable.js.map

-1

dist/airtable.js.map

-6

dist/index.d.ts

		import type { ModuleAdapter } from "@wiredwp/robinpath";
		declare const AirtableModule: ModuleAdapter;
		export default AirtableModule;
		export { AirtableModule };
		export { AirtableFunctions, AirtableFunctionMetadata, AirtableModuleMetadata } from "./airtable.js";
		//# sourceMappingURL=index.d.ts.map

-1

dist/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,QAAA,MAAM,cAAc,EAAE,aAMrB,CAAC;AAEF,eAAe,cAAc,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC"}

-12

dist/index.js

		import { AirtableFunctions, AirtableFunctionMetadata, AirtableModuleMetadata } from "./airtable.js";
		const AirtableModule = {
		name: "airtable",
		functions: AirtableFunctions,
		functionMetadata: AirtableFunctionMetadata,
		moduleMetadata: AirtableModuleMetadata,
		global: false,
		}; // as ModuleAdapter
		export default AirtableModule;
		export { AirtableModule };
		export { AirtableFunctions, AirtableFunctionMetadata, AirtableModuleMetadata } from "./airtable.js";
		//# sourceMappingURL=index.js.map

-1

dist/index.js.map

{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAEpG,MAAM,cAAc,GAAkB;IACpC,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,iBAAiB;IAC5B,gBAAgB,EAAE,wBAA+B;IACjD,cAAc,EAAE,sBAA6B;IAC7C,MAAM,EAAE,KAAK;CACd,CAAC,CAAC,mBAAmB;AAEtB,eAAe,cAAc,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC"}

@robinpath/airtable - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics