@zapier/zapier-sdk 0.34.0 → 0.35.0

package/dist/plugins/tables/utils.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import type { ApiClient } from "../../api";
+import type { TableApiItem, TableItem } from "./listTables/schemas";
+import type { RecordApiItem, RecordItem } from "./getTableRecord/schemas";
+import type { FieldApiItem, FieldItem } from "./listTableFields/schemas";
+export declare function formatFieldValue(v: unknown): string;
+/**
+ * Convert a field ID to its numeric form for the Tables API.
+ * Accepts "f6", "6", or 6 and returns 6.
+ */
+export declare function toNumericFieldId(id: string | number): number;
+export declare function transformTableItem(apiItem: TableApiItem): TableItem;
+export declare function transformFieldItem(apiItem: FieldApiItem): FieldItem;
+export declare function transformRecordItem(apiItem: RecordApiItem): RecordItem;
+/**
+ * Check a record API item for field-level validation errors and throw if any
+ * are present. The errors dict is keyed by field ID, and each value has
+ * `{s, v, e, h}` where `h` is the human-friendly message and `e` is the
+ * technical one.
+ */
+export declare function throwOnRecordErrors(record: RecordApiItem): void;
+/**
+ * Check an API response for top-level validation errors (in `meta.errors`)
+ * and throw if any are present.
+ */
+export declare function throwOnResponseErrors(response: {
+    meta?: {
+        errors?: unknown[];
+    } | null;
+}): void;
+export declare const KeyModeSchema: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+    names: "names";
+    ids: "ids";
+}>>>;
+export type KeyMode = z.infer<typeof KeyModeSchema>;
+export declare function isFieldId(key: string): boolean;
+export declare const NESTED_COMPONENTS: Record<string, Set<string>>;
+/**
+ * Resolve an array of field keys (names like "Email" or IDs like "f6", "6", 6)
+ * to numeric field IDs for the API. Only fetches field metadata if any
+ * non-ID keys are present.
+ */
+export declare function resolveFieldKeys({ api, tableId, fieldKeys, }: {
+    api: ApiClient;
+    tableId: string;
+    fieldKeys: Array<string | number>;
+}): Promise<number[]>;
+export interface FieldKeyTranslator {
+    translateInput(data: Record<string, unknown>): Record<string, unknown>;
+    translateOutput(data: Record<string, unknown>): Record<string, unknown>;
+    translateFieldKey(key: string): string;
+}
+/**
+ * Resolve the field mapping for a table and return a translator.
+ * Fetches field metadata from the API once (when keyMode is "names"),
+ * then all translate methods are synchronous.
+ */
+export declare function createFieldKeyTranslator({ api, tableId, keyMode, }: {
+    api: ApiClient;
+    tableId: string;
+    keyMode: KeyMode;
+}): Promise<FieldKeyTranslator>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/plugins/tables/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/plugins/tables/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAEzE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAUnD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAS5D;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CAYnE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CAUnE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,UAAU,CAOtE;AAkCD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAgB/D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE;IAC9C,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,EAAE,CAAA;KAAE,GAAG,IAAI,CAAC;CACtC,GAAG,IAAI,CASP;AAED,eAAO,MAAM,aAAa;;;IAMvB,CAAC;AAEJ,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAIpD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAKzD,CAAC;AA6CF;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,GAAG,EACH,OAAO,EACP,SAAS,GACV,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;CACnC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAyBpB;AAED,MAAM,WAAW,kBAAkB;IACjC,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvE,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxE,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACxC;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAAC,EAC7C,GAAG,EACH,OAAO,EACP,OAAO,GACR,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAkF9B"}

package/dist/plugins/tables/utils.js

@@ -0,0 +1,262 @@
+import { z } from "zod";
+import { ZapierValidationError } from "../../types/errors";
+export function formatFieldValue(v) {
+    if (v == null)
+        return "";
+    if (typeof v === "object") {
+        try {
+            return JSON.stringify(v);
+        }
+        catch {
+            return String(v);
+        }
+    }
+    return String(v);
+}
+/**
+ * Convert a field ID to its numeric form for the Tables API.
+ * Accepts "f6", "6", or 6 and returns 6.
+ */
+export function toNumericFieldId(id) {
+    if (typeof id === "number")
+        return id;
+    const num = parseInt(id.replace(/^f/, ""), 10);
+    if (isNaN(num)) {
+        throw new ZapierValidationError(`Invalid field ID: "${id}". Expected a numeric ID like "f6", "6", or 6.`);
+    }
+    return num;
+}
+export function transformTableItem(apiItem) {
+    return {
+        id: apiItem.id,
+        name: apiItem.name,
+        description: apiItem.description ?? undefined,
+        created_at: apiItem.created_at,
+        edited_at: apiItem.edited_at,
+        kind: apiItem.kind,
+        owner_account_id: String(apiItem.owner_account_id),
+        profile_id: String(apiItem.owner_zapier_customuser_id),
+        parent_table_id: apiItem.parent_table_id ?? undefined,
+    };
+}
+export function transformFieldItem(apiItem) {
+    return {
+        id: `f${apiItem.id}`,
+        type: apiItem.type,
+        name: apiItem.name,
+        created_at: apiItem.created_at,
+        edited_at: apiItem.edited_at,
+        options: apiItem.options,
+        config: apiItem.config,
+    };
+}
+export function transformRecordItem(apiItem) {
+    return {
+        id: apiItem.id,
+        data: apiItem.data,
+        created_at: apiItem.created_at,
+        edited_at: apiItem.edited_at,
+    };
+}
+function formatRecordError(fieldId, err) {
+    const message = err.h || err.e || "validation error";
+    if (err.v !== undefined) {
+        return `Field ${fieldId}: ${message} (value: ${JSON.stringify(err.v)})`;
+    }
+    return `Field ${fieldId}: ${message}`;
+}
+function formatResponseError(err) {
+    const message = err.human_title || err.title || "Unknown error";
+    if (err.meta && Object.keys(err.meta).length > 0) {
+        const metaParts = Object.entries(err.meta)
+            .map(([key, val]) => `${key}: ${JSON.stringify(val)}`)
+            .join(", ");
+        return `${message} (${metaParts})`;
+    }
+    return message;
+}
+/**
+ * Check a record API item for field-level validation errors and throw if any
+ * are present. The errors dict is keyed by field ID, and each value has
+ * `{s, v, e, h}` where `h` is the human-friendly message and `e` is the
+ * technical one.
+ */
+export function throwOnRecordErrors(record) {
+    if (!record.errors)
+        return;
+    const messages = [];
+    for (const [fieldId, error] of Object.entries(record.errors)) {
+        const err = error;
+        if (err.s === "error") {
+            messages.push(formatRecordError(fieldId, err));
+        }
+    }
+    if (messages.length > 0) {
+        throw new ZapierValidationError(`Record ${record.id} has errors: ${messages.join("; ")}`);
+    }
+}
+/**
+ * Check an API response for top-level validation errors (in `meta.errors`)
+ * and throw if any are present.
+ */
+export function throwOnResponseErrors(response) {
+    const errors = response.meta?.errors;
+    if (!errors || errors.length === 0)
+        return;
+    const messages = errors.map((err) => formatResponseError(err));
+    throw new ZapierValidationError(messages.join("; "));
+}
+export const KeyModeSchema = z
+    .enum(["names", "ids"])
+    .optional()
+    .default("names")
+    .describe('How to interpret field keys in record data. "names" (default) uses human-readable field names, "ids" uses raw field IDs (f1, f2).');
+const FIELD_ID_PATTERN = /^f\d+$/;
+export function isFieldId(key) {
+    return FIELD_ID_PATTERN.test(key);
+}
+export const NESTED_COMPONENTS = {
+    labeled_string: new Set(["value"]),
+    ai_formula: new Set(["value"]),
+    link: new Set(["link", "text"]),
+    linked_record: new Set(["label", "source"]),
+};
+async function getFieldMapping(api, tableId, keyMode) {
+    if (keyMode === "ids") {
+        return null;
+    }
+    // "names" mode — fetch from API
+    const rawResponse = await api.get(`/tables/api/v1/tables/${tableId}/fields`, {
+        authRequired: true,
+    });
+    const data = rawResponse.data;
+    // First match wins for duplicate names
+    const nameToId = new Map();
+    const idToName = new Map();
+    const idToType = new Map();
+    for (const field of data) {
+        const id = `f${field.id}`;
+        if (!nameToId.has(field.name)) {
+            nameToId.set(field.name, id);
+        }
+        if (!idToName.has(id)) {
+            idToName.set(id, field.name);
+        }
+        idToType.set(id, field.type);
+    }
+    return { nameToId, idToName, idToType };
+}
+/**
+ * Resolve an array of field keys (names like "Email" or IDs like "f6", "6", 6)
+ * to numeric field IDs for the API. Only fetches field metadata if any
+ * non-ID keys are present.
+ */
+export async function resolveFieldKeys({ api, tableId, fieldKeys, }) {
+    const allAreIds = fieldKeys.every((key) => typeof key === "number" || /^(f?\d+)$/.test(key));
+    if (allAreIds) {
+        return fieldKeys.map(toNumericFieldId);
+    }
+    const mapping = await getFieldMapping(api, tableId, "names");
+    if (!mapping) {
+        return fieldKeys.map(toNumericFieldId);
+    }
+    return fieldKeys.map((key) => {
+        if (typeof key === "number")
+            return key;
+        if (FIELD_ID_PATTERN.test(key))
+            return toNumericFieldId(key);
+        const id = mapping.nameToId.get(key);
+        if (!id) {
+            throw new ZapierValidationError(`Unknown field name: "${key}". Use a valid field name or ID.`);
+        }
+        return toNumericFieldId(id);
+    });
+}
+/**
+ * Resolve the field mapping for a table and return a translator.
+ * Fetches field metadata from the API once (when keyMode is "names"),
+ * then all translate methods are synchronous.
+ */
+export async function createFieldKeyTranslator({ api, tableId, keyMode, }) {
+    const mapping = await getFieldMapping(api, tableId, keyMode);
+    return {
+        translateInput(data) {
+            if (!mapping)
+                return data;
+            const result = {};
+            for (const [key, value] of Object.entries(data)) {
+                if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
+                    result[key] = value;
+                }
+                else if (mapping.nameToId.has(key)) {
+                    result[mapping.nameToId.get(key)] = value;
+                }
+                else {
+                    result[key] = value;
+                }
+            }
+            return result;
+        },
+        translateOutput(data) {
+            if (!mapping)
+                return data;
+            const result = {};
+            for (const [key, value] of Object.entries(data)) {
+                if (mapping.idToName.has(key)) {
+                    result[mapping.idToName.get(key)] = value;
+                }
+                else {
+                    result[key] = value;
+                }
+            }
+            return result;
+        },
+        translateFieldKey(key) {
+            if (!mapping)
+                return key;
+            if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
+                // Auto-append component for single-component types (e.g., f3 → f3__value for labeled_string)
+                const fieldType = mapping.idToType.get(key);
+                if (fieldType) {
+                    const components = NESTED_COMPONENTS[fieldType];
+                    if (components?.size === 1) {
+                        return `${key}__${[...components][0]}`;
+                    }
+                }
+                return key;
+            }
+            if (mapping.nameToId.has(key)) {
+                const fieldId = mapping.nameToId.get(key);
+                // Auto-append component for single-component types (e.g., Status → f3__value for labeled_string)
+                const fieldType = mapping.idToType.get(fieldId);
+                if (fieldType) {
+                    const components = NESTED_COMPONENTS[fieldType];
+                    if (components?.size === 1) {
+                        return `${fieldId}__${[...components][0]}`;
+                    }
+                }
+                return fieldId;
+            }
+            // Handle nested component syntax (e.g., "Status__value" → "f3__value")
+            const sepIndex = key.lastIndexOf("__");
+            if (sepIndex > 0) {
+                const prefix = key.slice(0, sepIndex);
+                const component = key.slice(sepIndex + 2);
+                let fieldId;
+                if (FIELD_ID_PATTERN.test(prefix) && mapping.idToName.has(prefix)) {
+                    fieldId = prefix;
+                }
+                else {
+                    fieldId = mapping.nameToId.get(prefix);
+                }
+                if (fieldId) {
+                    const fieldType = mapping.idToType.get(fieldId);
+                    if (fieldType && NESTED_COMPONENTS[fieldType]?.has(component)) {
+                        return `${fieldId}__${component}`;
+                    }
+                }
+            }
+            return key;
+        },
+    };
+}

package/dist/resolvers/index.d.ts

@@ -11,4 +11,12 @@ export { inputFieldKeyResolver } from "./inputFieldKey";
 export { inputsAllOptionalResolver } from "./inputs";
 export { clientCredentialsNameResolver } from "./clientCredentialsName";
 export { clientIdResolver } from "./clientId";
+export { tableIdResolver } from "./tableId";
+export { tableRecordIdResolver, tableRecordIdsResolver } from "./tableRecordId";
+export { tableFieldIdsResolver } from "./tableFieldIds";
+export { tableNameResolver } from "./tableName";
+export { tableFieldsResolver } from "./tableFields";
+export { tableRecordsResolver, tableUpdateRecordsResolver, } from "./tableRecords";
+export { tableFiltersResolver } from "./tableFilters";
+export { tableSortResolver } from "./tableSort";
 //# sourceMappingURL=index.d.ts.map

package/dist/resolvers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolvers/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,oBAAoB,EACpB,2BAA2B,GAC5B,MAAM,gBAAgB,CAAC;AAGxB,mDAAmD;AACnD,OAAO,EAAE,oBAAoB,IAAI,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAClF,0DAA0D;AAC1D,OAAO,EAAE,2BAA2B,IAAI,+BAA+B,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolvers/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,oBAAoB,EACpB,2BAA2B,GAC5B,MAAM,gBAAgB,CAAC;AAGxB,mDAAmD;AACnD,OAAO,EAAE,oBAAoB,IAAI,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAClF,0DAA0D;AAC1D,OAAO,EAAE,2BAA2B,IAAI,+BAA+B,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}

package/dist/resolvers/index.js

@@ -13,3 +13,11 @@ export { inputFieldKeyResolver } from "./inputFieldKey";
 export { inputsAllOptionalResolver } from "./inputs";
 export { clientCredentialsNameResolver } from "./clientCredentialsName";
 export { clientIdResolver } from "./clientId";
+export { tableIdResolver } from "./tableId";
+export { tableRecordIdResolver, tableRecordIdsResolver } from "./tableRecordId";
+export { tableFieldIdsResolver } from "./tableFieldIds";
+export { tableNameResolver } from "./tableName";
+export { tableFieldsResolver } from "./tableFields";
+export { tableRecordsResolver, tableUpdateRecordsResolver, } from "./tableRecords";
+export { tableFiltersResolver } from "./tableFilters";
+export { tableSortResolver } from "./tableSort";

package/dist/resolvers/tableFieldIds.d.ts

@@ -0,0 +1,6 @@
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { FieldItem } from "../plugins/tables/listTableFields/schemas";
+export declare const tableFieldIdsResolver: DynamicResolver<FieldItem, {
+    tableId: string;
+}>;
+//# sourceMappingURL=tableFieldIds.d.ts.map

package/dist/resolvers/tableFieldIds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableFieldIds.d.ts","sourceRoot":"","sources":["../../src/resolvers/tableFieldIds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAC;AAE3E,eAAO,MAAM,qBAAqB,EAAE,eAAe,CACjD,SAAS,EACT;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAoBpB,CAAC"}

package/dist/resolvers/tableFieldIds.js

@@ -0,0 +1,19 @@
+export const tableFieldIdsResolver = {
+    type: "dynamic",
+    depends: ["tableId"],
+    fetch: (sdk, params) => {
+        return sdk.listTableFields({ tableId: params.tableId });
+    },
+    prompt: (fields) => ({
+        type: "checkbox",
+        name: "fieldKeys",
+        message: "Select fields:",
+        choices: fields.map((field) => ({
+            name: `${field.name} (${field.id}, ${field.type})`,
+            value: field.id,
+        })),
+        validate: (value) => Array.isArray(value) && value.length > 0
+            ? true
+            : "Select at least one field",
+    }),
+};

package/dist/resolvers/tableFields.d.ts

@@ -0,0 +1,3 @@
+import type { ArrayResolver } from "../utils/schema-utils";
+export declare const tableFieldsResolver: ArrayResolver;
+//# sourceMappingURL=tableFields.d.ts.map

package/dist/resolvers/tableFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableFields.d.ts","sourceRoot":"","sources":["../../src/resolvers/tableFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAkB,MAAM,uBAAuB,CAAC;AA8B3E,eAAO,MAAM,mBAAmB,EAAE,aAIjC,CAAC"}

package/dist/resolvers/tableFields.js

@@ -0,0 +1,31 @@
+import { FieldTypeSchema } from "../plugins/tables/listTableFields/schemas";
+// Get the field type values from the schema
+const fieldTypeChoices = FieldTypeSchema.options.map((type) => ({
+    label: type,
+    value: type,
+}));
+const singleFieldResolver = {
+    type: "fields",
+    fetch: async () => {
+        return [
+            {
+                type: "input_field",
+                key: "type",
+                title: "Field type",
+                is_required: true,
+                choices: fieldTypeChoices,
+            },
+            {
+                type: "input_field",
+                key: "name",
+                title: "Field name",
+                is_required: true,
+            },
+        ];
+    },
+};
+export const tableFieldsResolver = {
+    type: "array",
+    fetch: async () => singleFieldResolver,
+    minItems: 1,
+};

package/dist/resolvers/tableFilters.d.ts

@@ -0,0 +1,5 @@
+import type { ArrayResolver } from "../utils/schema-utils";
+export declare const tableFiltersResolver: ArrayResolver<{
+    tableId: string;
+}>;
+//# sourceMappingURL=tableFilters.d.ts.map

package/dist/resolvers/tableFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableFilters.d.ts","sourceRoot":"","sources":["../../src/resolvers/tableFilters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAGd,MAAM,uBAAuB,CAAC;AA6E/B,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAUnE,CAAC"}

package/dist/resolvers/tableFilters.js

@@ -0,0 +1,74 @@
+import { NESTED_COMPONENTS } from "../plugins/tables/utils";
+const FILTER_OPERATORS = [
+    { label: "equals", value: "exact" },
+    { label: "not equals", value: "different" },
+    { label: "contains", value: "contains" },
+    { label: "contains (case-insensitive)", value: "icontains" },
+    { label: "starts with", value: "startswith" },
+    { label: "search", value: "search" },
+    { label: "greater than", value: "gt" },
+    { label: "greater than or equal", value: "gte" },
+    { label: "less than", value: "lt" },
+    { label: "less than or equal", value: "lte" },
+    { label: "in range", value: "range" },
+    { label: "in list", value: "in" },
+    { label: "is empty", value: "isnull" },
+    { label: "is within (date)", value: "is_within" },
+];
+function createSingleFilterResolver({ sdk, tableId, }) {
+    return {
+        type: "fields",
+        fetch: async () => {
+            const { data: fields } = await sdk.listTableFields({ tableId });
+            const fieldChoices = fields.flatMap((field) => {
+                const components = NESTED_COMPONENTS[field.type];
+                if (components && components.size > 1) {
+                    return [...components].map((component) => ({
+                        label: `${field.name}__${component} (${field.id}, ${field.type})`,
+                        value: `${field.name}__${component}`,
+                    }));
+                }
+                return {
+                    label: `${field.name} (${field.id}${components ? `, ${field.type}` : ""})`,
+                    value: components
+                        ? `${field.name}__${[...components][0]}`
+                        : field.name,
+                };
+            });
+            const fieldItems = [
+                {
+                    type: "input_field",
+                    key: "fieldKey",
+                    title: "Field",
+                    is_required: true,
+                    choices: fieldChoices,
+                },
+                {
+                    type: "input_field",
+                    key: "operator",
+                    title: "Operator",
+                    is_required: true,
+                    choices: FILTER_OPERATORS,
+                },
+                {
+                    type: "input_field",
+                    key: "value",
+                    title: "Value",
+                    is_required: false,
+                },
+            ];
+            return fieldItems;
+        },
+    };
+}
+export const tableFiltersResolver = {
+    type: "array",
+    depends: ["tableId"],
+    fetch: async (sdk, params) => {
+        return createSingleFilterResolver({
+            sdk,
+            tableId: params.tableId,
+        });
+    },
+    minItems: 0,
+};

package/dist/resolvers/tableId.d.ts

@@ -0,0 +1,4 @@
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { TableItem } from "../plugins/tables/listTables/schemas";
+export declare const tableIdResolver: DynamicResolver<TableItem, {}>;
+//# sourceMappingURL=tableId.d.ts.map

package/dist/resolvers/tableId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableId.d.ts","sourceRoot":"","sources":["../../src/resolvers/tableId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGtE,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,SAAS,EAAE,EAAE,CAiB1D,CAAC"}

package/dist/resolvers/tableId.js

@@ -0,0 +1,19 @@
+import { concatPaginated } from "../utils/pagination-utils";
+export const tableIdResolver = {
+    type: "dynamic",
+    fetch: (sdk) => {
+        return concatPaginated({
+            sources: [() => sdk.listTables({ owner: "me" }), () => sdk.listTables()],
+            dedupe: (table) => table.id,
+        });
+    },
+    prompt: (tables) => ({
+        type: "list",
+        name: "tableId",
+        message: "Select a table:",
+        choices: tables.map((table) => ({
+            name: `${table.name} (${table.id})`,
+            value: table.id,
+        })),
+    }),
+};

package/dist/resolvers/tableName.d.ts

@@ -0,0 +1,3 @@
+import type { StaticResolver } from "../utils/schema-utils";
+export declare const tableNameResolver: StaticResolver;
+//# sourceMappingURL=tableName.d.ts.map

package/dist/resolvers/tableName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableName.d.ts","sourceRoot":"","sources":["../../src/resolvers/tableName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,eAAO,MAAM,iBAAiB,EAAE,cAI/B,CAAC"}

package/dist/resolvers/tableName.js

@@ -0,0 +1,5 @@
+export const tableNameResolver = {
+    type: "static",
+    inputType: "text",
+    placeholder: "Enter a name for the table",
+};

package/dist/resolvers/tableRecordId.d.ts

@@ -0,0 +1,9 @@
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { RecordItem } from "../plugins/tables/getTableRecord/schemas";
+export declare const tableRecordIdResolver: DynamicResolver<RecordItem, {
+    tableId: string;
+}>;
+export declare const tableRecordIdsResolver: DynamicResolver<RecordItem, {
+    tableId: string;
+}>;
+//# sourceMappingURL=tableRecordId.d.ts.map

package/dist/resolvers/tableRecordId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableRecordId.d.ts","sourceRoot":"","sources":["../../src/resolvers/tableRecordId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAgC3E,eAAO,MAAM,qBAAqB,EAAE,eAAe,CACjD,UAAU,EACV;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAWpB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAAe,CAClD,UAAU,EACV;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAepB,CAAC"}

package/dist/resolvers/tableRecordId.js

@@ -0,0 +1,48 @@
+import { formatFieldValue } from "../plugins/tables/utils";
+function summarizeRecord(record) {
+    const values = Object.values(record.data);
+    const preview = values
+        .slice(0, 3)
+        .map((v) => formatFieldValue(v).replace(/\s+/g, " ").trim())
+        .filter((s) => s.length > 0)
+        .join(", ");
+    const truncated = preview.length > 60 ? preview.slice(0, 57) + "..." : preview;
+    return truncated ? `${record.id} — ${truncated}` : record.id;
+}
+function fetchRecords(sdk, params) {
+    return sdk.listTableRecords({
+        tableId: params.tableId,
+        keyMode: "names",
+    });
+}
+function recordChoices(records) {
+    return records.map((record) => ({
+        name: summarizeRecord(record),
+        value: record.id,
+    }));
+}
+export const tableRecordIdResolver = {
+    type: "dynamic",
+    depends: ["tableId"],
+    fetch: fetchRecords,
+    prompt: (records) => ({
+        type: "list",
+        name: "recordId",
+        message: "Select a record:",
+        choices: recordChoices(records),
+    }),
+};
+export const tableRecordIdsResolver = {
+    type: "dynamic",
+    depends: ["tableId"],
+    fetch: fetchRecords,
+    prompt: (records) => ({
+        type: "checkbox",
+        name: "recordIds",
+        message: "Select records to delete:",
+        choices: recordChoices(records),
+        validate: (value) => Array.isArray(value) && value.length > 0
+            ? true
+            : "Select at least one record",
+    }),
+};

package/dist/resolvers/tableRecords.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayResolver } from "../utils/schema-utils";
+export declare const tableRecordsResolver: ArrayResolver<{
+    tableId: string;
+}>;
+export declare const tableUpdateRecordsResolver: ArrayResolver<{
+    tableId: string;
+}>;
+//# sourceMappingURL=tableRecords.d.ts.map

package/dist/resolvers/tableRecords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableRecords.d.ts","sourceRoot":"","sources":["../../src/resolvers/tableRecords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAkB,MAAM,uBAAuB,CAAC;AAqE3E,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAUnE,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,aAAa,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAWzE,CAAC"}