@zapier/zapier-sdk 0.34.1 → 0.36.0

package/dist/plugins/tables/deleteTableRecords/index.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { DeleteTableRecordsOptionsSchema, type DeleteTableRecordsOptions, type DeleteTableRecordsResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface DeleteTableRecordsPluginProvides {
+    deleteTableRecords: (options: DeleteTableRecordsOptions) => Promise<DeleteTableRecordsResult>;
+    context: {
+        meta: {
+            deleteTableRecords: {
+                inputSchema: typeof DeleteTableRecordsOptionsSchema;
+            };
+        };
+    };
+}
+export declare const deleteTableRecordsPlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, DeleteTableRecordsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/deleteTableRecords/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableRecords/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EACL,+BAA+B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC9B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAKhE,MAAM,WAAW,gCAAgC;IAC/C,kBAAkB,EAAE,CAClB,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACvC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,kBAAkB,EAAE;gBAClB,WAAW,EAAE,OAAO,+BAA+B,CAAC;aACrD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAC3C,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,gCAAgC,CA8DjC,CAAC"}

package/dist/plugins/tables/deleteTableRecords/index.js

@@ -0,0 +1,44 @@
+import { createFunction } from "../../../utils/function-utils";
+import { DeleteTableRecordsOptionsSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver, tableRecordIdsResolver } from "../../../resolvers";
+export const deleteTableRecordsPlugin = ({ context }) => {
+    async function deleteTableRecords(options) {
+        const { api } = context;
+        await api.delete(`/tables/api/v1/tables/${options.tableId}/records`, { record_ids: options.recordIds }, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to delete records or may be expired. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 403) {
+                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to delete records. (HTTP ${status})`, { statusCode: status });
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        return {
+            success: true,
+        };
+    }
+    const deleteTableRecordsDefinition = createFunction(deleteTableRecords, DeleteTableRecordsOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, deleteTableRecords.name));
+    return {
+        deleteTableRecords: deleteTableRecordsDefinition,
+        context: {
+            meta: {
+                deleteTableRecords: {
+                    categories: ["table"],
+                    type: "delete",
+                    itemType: "Record",
+                    inputSchema: DeleteTableRecordsOptionsSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                        recordIds: tableRecordIdsResolver,
+                    },
+                    confirm: "delete",
+                },
+            },
+        },
+    };
+};

package/dist/plugins/tables/deleteTableRecords/schemas.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+export declare const DeleteTableRecordsOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    recordIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type DeleteTableRecordsOptions = z.infer<typeof DeleteTableRecordsOptionsSchema> & FunctionOptions;
+export interface DeleteTableRecordsResult {
+    success: boolean;
+}
+export type DeleteTableRecordsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface DeleteTableRecordsSdkFunction {
+    deleteTableRecords: (options: DeleteTableRecordsOptions) => Promise<DeleteTableRecordsResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/deleteTableRecords/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/deleteTableRecords/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,+BAA+B;;;iBAcU,CAAC;AAEvD,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,GACC,eAAe,CAAC;AAElB,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,uBAAuB,GAC/B,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,6BAA6B;IAC5C,kBAAkB,EAAE,CAClB,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,wBAAwB,CAAC,CAAC;CACxC"}

package/dist/plugins/tables/deleteTableRecords/schemas.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export const DeleteTableRecordsOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table"),
+    recordIds: z
+        .array(z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"))
+        .min(1)
+        .max(100)
+        .describe("Array of record IDs to delete (max 100)"),
+})
+    .describe("Delete one or more records from a table");

package/dist/plugins/tables/getTable/index.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { GetTableOptionsSchema, type GetTableOptions, type TableItem } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface GetTablePluginProvides {
+    getTable: (options: GetTableOptions) => Promise<{
+        data: TableItem;
+    }>;
+    context: {
+        meta: {
+            getTable: {
+                inputSchema: typeof GetTableOptionsSchema;
+            };
+        };
+    };
+}
+export declare const getTablePlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, GetTablePluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/getTable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/getTable/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EAEL,qBAAqB,EAErB,KAAK,eAAe,EACpB,KAAK,SAAS,EACf,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAMhE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;IACrE,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,QAAQ,EAAE;gBACR,WAAW,EAAE,OAAO,qBAAqB,CAAC;aAC3C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,sBAAsB,CAgEvB,CAAC"}

package/dist/plugins/tables/getTable/index.js

@@ -0,0 +1,48 @@
+import { createFunction } from "../../../utils/function-utils";
+import { GetTableApiResponseSchema, GetTableOptionsSchema, TableItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver } from "../../../resolvers";
+import { transformTableItem } from "../utils";
+export const getTablePlugin = ({ context }) => {
+    async function getTable(options) {
+        const { api } = context;
+        const rawResponse = await api.get(`/tables/api/v1/tables/${options.tableId}`, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to access this table or may be expired. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 403) {
+                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to access this table. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 404) {
+                    return new Error(`Table not found: ${options.tableId}`);
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        const response = GetTableApiResponseSchema.parse(rawResponse);
+        return {
+            data: transformTableItem(response.data),
+        };
+    }
+    const getTableDefinition = createFunction(getTable, GetTableOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, getTable.name));
+    return {
+        getTable: getTableDefinition,
+        context: {
+            meta: {
+                getTable: {
+                    categories: ["table"],
+                    type: "item",
+                    itemType: "Table",
+                    inputSchema: GetTableOptionsSchema,
+                    outputSchema: TableItemSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                    },
+                },
+            },
+        },
+    };
+};

package/dist/plugins/tables/getTable/schemas.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+import { TableItemSchema, TableApiItemSchema, type TableItem, type TableApiItem } from "../listTables/schemas";
+export { TableItemSchema, TableApiItemSchema };
+export type { TableItem, TableApiItem };
+export declare const GetTableApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodString;
+        edited_at: z.ZodString;
+        kind: z.ZodEnum<{
+            table: "table";
+            virtual_table: "virtual_table";
+        }>;
+        owner_account_id: z.ZodNumber;
+        owner_user_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        owner_zapier_customuser_id: z.ZodNumber;
+        parent_table_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type GetTableApiResponse = z.infer<typeof GetTableApiResponseSchema>;
+export declare const GetTableOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+}, z.core.$strip>;
+export type GetTableOptions = z.infer<typeof GetTableOptionsSchema>;
+export type GetTableError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface GetTableSdkFunction {
+    getTable: (options: GetTableOptions) => Promise<{
+        data: TableItem;
+    }>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/getTable/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/getTable/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,KAAK,SAAS,EACd,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAC;AAC/C,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;AAExC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;iBAEpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,qBAAqB;;iBAO4B,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAGpE,MAAM,MAAM,aAAa,GACrB,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;CACtE"}

package/dist/plugins/tables/getTable/schemas.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { TableItemSchema, TableApiItemSchema, } from "../listTables/schemas";
+// Re-export for consumers
+export { TableItemSchema, TableApiItemSchema };
+export const GetTableApiResponseSchema = z.object({
+    data: TableApiItemSchema,
+});
+export const GetTableOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table to retrieve"),
+})
+    .describe("Get detailed information about a specific table");

package/dist/plugins/tables/getTableRecord/index.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { GetTableRecordOptionsSchema, type GetTableRecordOptions, type GetTableRecordResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface GetTableRecordPluginProvides {
+    getTableRecord: (options: GetTableRecordOptions) => Promise<GetTableRecordResult>;
+    context: {
+        meta: {
+            getTableRecord: {
+                inputSchema: typeof GetTableRecordOptionsSchema;
+            };
+        };
+    };
+}
+export declare const getTableRecordPlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, GetTableRecordPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/getTableRecord/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/getTableRecord/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EACL,2BAA2B,EAG3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EAC1B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAQhE,MAAM,WAAW,4BAA4B;IAC3C,cAAc,EAAE,CACd,OAAO,EAAE,qBAAqB,KAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,cAAc,EAAE;gBACd,WAAW,EAAE,OAAO,2BAA2B,CAAC;aACjD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,oBAAoB,EAAE,MAAM,CACvC,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,4BAA4B,CA4E7B,CAAC"}

package/dist/plugins/tables/getTableRecord/index.js

@@ -0,0 +1,60 @@
+import { createFunction } from "../../../utils/function-utils";
+import { GetTableRecordOptionsSchema, GetTableRecordApiResponseSchema, RecordItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver, tableRecordIdResolver } from "../../../resolvers";
+import { tableRecordFormatter } from "../../../formatters";
+import { createFieldKeyTranslator } from "../utils";
+import { transformRecordItem } from "../utils";
+export const getTableRecordPlugin = ({ context }) => {
+    async function getTableRecord(options) {
+        const { api } = context;
+        const rawResponse = await api.get(`/tables/api/v1/tables/${options.tableId}/records/${options.recordId}`, {
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to access this record or may be expired. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 403) {
+                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to access this record. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 404) {
+                    return new Error(`Record not found: ${options.recordId}`);
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        const response = GetTableRecordApiResponseSchema.parse(rawResponse);
+        const translator = await createFieldKeyTranslator({
+            api,
+            tableId: options.tableId,
+            keyMode: options.keyMode,
+        });
+        return {
+            data: {
+                ...transformRecordItem(response.data),
+                data: translator.translateOutput(response.data.data),
+            },
+        };
+    }
+    const getTableRecordDefinition = createFunction(getTableRecord, GetTableRecordOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, getTableRecord.name));
+    return {
+        getTableRecord: getTableRecordDefinition,
+        context: {
+            meta: {
+                getTableRecord: {
+                    categories: ["table"],
+                    type: "item",
+                    itemType: "Record",
+                    inputSchema: GetTableRecordOptionsSchema,
+                    outputSchema: RecordItemSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                        recordId: tableRecordIdResolver,
+                    },
+                    formatter: tableRecordFormatter,
+                },
+            },
+        },
+    };
+};

package/dist/plugins/tables/getTableRecord/schemas.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
+export declare const RecordApiItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    created_at: z.ZodString;
+    edited_at: z.ZodString;
+    schema_revision_id: z.ZodNumber;
+    errors: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    orig_data: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    is_source_record: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type RecordApiItem = z.infer<typeof RecordApiItemSchema>;
+export declare const RecordItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    created_at: z.ZodString;
+    edited_at: z.ZodString;
+}, z.core.$strip>;
+export type RecordItem = z.infer<typeof RecordItemSchema>;
+export declare const GetTableRecordApiResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        created_at: z.ZodString;
+        edited_at: z.ZodString;
+        schema_revision_id: z.ZodNumber;
+        errors: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        orig_data: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        is_source_record: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type GetTableRecordApiResponse = z.infer<typeof GetTableRecordApiResponseSchema>;
+export declare const GetTableRecordOptionsSchema: z.ZodObject<{
+    tableId: z.ZodString;
+    recordId: z.ZodString;
+    keyMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        names: "names";
+        ids: "ids";
+    }>>>;
+}, z.core.$strip>;
+export type GetTableRecordOptions = z.infer<typeof GetTableRecordOptionsSchema> & FunctionOptions;
+export interface GetTableRecordResult {
+    data: RecordItem;
+}
+export type GetTableRecordError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
+export interface GetTableRecordSdkFunction {
+    getTableRecord: (options: GetTableRecordOptions) => Promise<GetTableRecordResult>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/tables/getTableRecord/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/getTableRecord/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAI/B,eAAO,MAAM,mBAAmB;;;;;;;;;iBAS9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAUhE,eAAO,MAAM,gBAAgB;;;;;iBAO3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,+BAA+B;;;;;;;;;;;iBAE1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;iBAYa,CAAC;AAEtD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CACzC,OAAO,2BAA2B,CACnC,GACC,eAAe,CAAC;AAElB,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,MAAM,mBAAmB,GAC3B,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,yBAAyB;IACxC,cAAc,EAAE,CACd,OAAO,EAAE,qBAAqB,KAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACpC"}

package/dist/plugins/tables/getTableRecord/schemas.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { withFormatter } from "../../../utils/schema-utils";
+import { KeyModeSchema } from "../utils";
+export const RecordApiItemSchema = z.object({
+    id: z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"),
+    data: z.record(z.string(), z.unknown()),
+    created_at: z.string(),
+    edited_at: z.string(),
+    schema_revision_id: z.number(),
+    errors: z.record(z.string(), z.unknown()).nullable().optional(),
+    orig_data: z.record(z.string(), z.unknown()).nullable().optional(),
+    is_source_record: z.boolean().nullable().optional(),
+});
+// SDK output schema (simplified)
+const RecordItemSchemaBase = z.object({
+    id: z.string(),
+    data: z.record(z.string(), z.unknown()),
+    created_at: z.string(),
+    edited_at: z.string(),
+});
+export const RecordItemSchema = withFormatter(RecordItemSchemaBase, {
+    format: (item) => ({
+        title: `Record ${item.id}`,
+        id: item.id,
+        data: item.data,
+        details: [],
+    }),
+});
+export const GetTableRecordApiResponseSchema = z.object({
+    data: RecordApiItemSchema,
+});
+export const GetTableRecordOptionsSchema = z
+    .object({
+    tableId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID")
+        .describe("The unique identifier of the table"),
+    recordId: z
+        .string()
+        .regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID")
+        .describe("The unique identifier of the record"),
+    keyMode: KeyModeSchema,
+})
+    .describe("Get a single record from a table by ID");

package/dist/plugins/tables/listTableFields/index.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "../../../types/plugin";
+import type { ApiClient } from "../../../api";
+import { ListTableFieldsOptionsSchema, type ListTableFieldsOptions, type ListTableFieldsResult } from "./schemas";
+import type { EventEmissionContext } from "../../eventEmission";
+export interface ListTableFieldsPluginProvides {
+    listTableFields: (options: ListTableFieldsOptions) => Promise<ListTableFieldsResult>;
+    context: {
+        meta: {
+            listTableFields: {
+                inputSchema: typeof ListTableFieldsOptionsSchema;
+            };
+        };
+    };
+}
+export declare const listTableFieldsPlugin: Plugin<{}, {
+    api: ApiClient;
+} & EventEmissionContext, ListTableFieldsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/tables/listTableFields/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableFields/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EACL,4BAA4B,EAG5B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC3B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAMhE,MAAM,WAAW,6BAA6B;IAC5C,eAAe,EAAE,CACf,OAAO,EAAE,sBAAsB,KAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACpC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,eAAe,EAAE;gBACf,WAAW,EAAE,OAAO,4BAA4B,CAAC;aAClD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CACxC,EAAE,EACF;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EACzC,6BAA6B,CA6E9B,CAAC"}

package/dist/plugins/tables/listTableFields/index.js

@@ -0,0 +1,58 @@
+import { createFunction } from "../../../utils/function-utils";
+import { ListTableFieldsOptionsSchema, ListTableFieldsApiResponseSchema, FieldItemSchema, } from "./schemas";
+import { createTelemetryCallback } from "../../../utils/telemetry-utils";
+import { ZapierAuthenticationError } from "../../../types/errors";
+import { tableIdResolver } from "../../../resolvers";
+import { resolveFieldKeys, transformFieldItem } from "../utils";
+export const listTableFieldsPlugin = ({ context }) => {
+    async function listTableFields(options) {
+        const { api } = context;
+        const searchParams = {};
+        if (options.fieldKeys && options.fieldKeys.length > 0) {
+            const numericIds = await resolveFieldKeys({
+                api,
+                tableId: options.tableId,
+                fieldKeys: options.fieldKeys,
+            });
+            searchParams.field_ids = numericIds.join(",");
+        }
+        const rawResponse = await api.get(`/tables/api/v1/tables/${options.tableId}/fields`, {
+            searchParams: Object.keys(searchParams).length > 0 ? searchParams : undefined,
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to access this table or may be expired. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 403) {
+                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to access this table. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 404) {
+                    return new Error(`Table not found: ${options.tableId}`);
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        const response = ListTableFieldsApiResponseSchema.parse(rawResponse);
+        return {
+            data: response.data.map(transformFieldItem),
+        };
+    }
+    const listTableFieldsDefinition = createFunction(listTableFields, ListTableFieldsOptionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, listTableFields.name));
+    return {
+        listTableFields: listTableFieldsDefinition,
+        context: {
+            meta: {
+                listTableFields: {
+                    categories: ["table"],
+                    type: "list",
+                    itemType: "Field",
+                    inputSchema: ListTableFieldsOptionsSchema,
+                    outputSchema: FieldItemSchema,
+                    resolvers: {
+                        tableId: tableIdResolver,
+                    },
+                },
+            },
+        },
+    };
+};