@zapier/zapier-sdk 0.46.0 → 0.46.1

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

@@ -1,24 +1,72 @@
-import type { Plugin } from "../../../types/plugin";
-import { ListTableRecordsOptionsSchema, type ListTableRecordsOptions, type RecordItem } from "./schemas";
-import type { ApiPluginProvides } from "../../api";
-import type { EventEmissionProvides } from "../../eventEmission";
-export interface ListTableRecordsPluginProvides {
-    listTableRecords: (options: ListTableRecordsOptions) => Promise<{
-        data: RecordItem[];
-        nextCursor?: string;
-    }> & AsyncIterable<{
-        data: RecordItem[];
-        nextCursor?: string;
-    }> & {
-        items(): AsyncIterable<RecordItem>;
+export declare const listTableRecordsPlugin: (sdk: {
+    context: {
+        api: import("../../../api").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
     };
+}) => {
+    listTableRecords: (options?: (({
+        table: string;
+        keyMode: "names" | "ids";
+        filters?: {
+            fieldKey: string;
+            operator: "in" | "contains" | "gt" | "gte" | "lt" | "lte" | "search" | "exact" | "different" | "icontains" | "range" | "isnull" | "startswith" | "is_within";
+            value?: unknown;
+        }[] | undefined;
+        sort?: {
+            fieldKey: string;
+            direction: "asc" | "desc";
+        } | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } | {
+        tableId: string;
+        keyMode: "names" | "ids";
+        filters?: {
+            fieldKey: string;
+            operator: "in" | "contains" | "gt" | "gte" | "lt" | "lte" | "search" | "exact" | "different" | "icontains" | "range" | "isnull" | "startswith" | "is_within";
+            value?: unknown;
+        }[] | undefined;
+        sort?: {
+            fieldKey: string;
+            direction: "asc" | "desc";
+        } | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    }) & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../../..").PaginatedSdkResult<{
+        id: string;
+        data: Record<string, unknown>;
+        created_at: string;
+        edited_at: string;
+    }>;
+} & {
     context: {
         meta: {
-            listTableRecords: {
-                inputSchema: typeof ListTableRecordsOptionsSchema;
-            };
+            listTableRecords: import("../../..").PluginMeta;
         };
     };
-}
-export declare const listTableRecordsPlugin: Plugin<ApiPluginProvides & EventEmissionProvides, ListTableRecordsPluginProvides>;
+};
+export type ListTableRecordsPluginProvides = ReturnType<typeof listTableRecordsPlugin>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableRecords/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAEL,6BAA6B,EAG7B,KAAK,uBAAuB,EAC5B,KAAK,UAAU,EAChB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AA6BjE,MAAM,WAAW,8BAA8B;IAC7C,gBAAgB,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,OAAO,CAAC;QAC9D,IAAI,EAAE,UAAU,EAAE,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,UAAU,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAC3D,KAAK,IAAI,aAAa,CAAC,UAAU,CAAC,CAAC;KACpC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,gBAAgB,EAAE;gBAChB,WAAW,EAAE,OAAO,6BAA6B,CAAC;aACnD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CACzC,iBAAiB,GAAG,qBAAqB,EACzC,8BAA8B,CAmH/B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableRecords/index.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFlC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,UAAU,CACrD,OAAO,sBAAsB,CAC9B,CAAC"}

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

@@ -1,20 +1,26 @@
-import { createPaginatedFunction } from "../../../utils/function-utils";
-import { ListTableRecordsApiResponseSchema, ListTableRecordsOptionsSchema, ListTableRecordsOptionsInputSchema, RecordItemSchema, } from "./schemas";
-import { createTelemetryCallback } from "../../../utils/telemetry-utils";
-import { stripPageSuffix } from "../../../utils/string-utils";
-import { ZapierAuthenticationError } from "../../../types/errors";
+import { definePlugin } from "../../../utils/plugin-utils";
+import { createPaginatedPluginMethod } from "../../../utils/plugin-utils";
+import { ListTableRecordsApiResponseSchema, ListTableRecordsOptionsInputSchema, RecordItemSchema, } from "./schemas";
 import { tableIdResolver, tableFiltersResolver, tableSortResolver, } from "../../../resolvers";
 import { tableRecordFormatter } from "../../../formatters";
 import { createFieldKeyTranslator, transformRecordItem, throwOnResponseErrors, } from "../utils";
 import { DEFAULT_PAGE_SIZE } from "../../../constants";
-function extractNextCursor(meta) {
-    if (!meta?.pagination?.has_more || !meta.pagination.end_cursor) {
-        return undefined;
-    }
-    return meta.pagination.end_cursor;
-}
-export const listTableRecordsPlugin = (sdk) => {
-    async function listTableRecordsPage(options) {
+import { tablesDefaults } from "../shared";
+export const listTableRecordsPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
+    ...tablesDefaults,
+    name: "listTableRecords",
+    type: "list",
+    itemType: "Record",
+    inputSchema: ListTableRecordsOptionsInputSchema,
+    outputSchema: RecordItemSchema,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    resolvers: {
+        table: tableIdResolver,
+        filters: tableFiltersResolver,
+        sort: tableSortResolver,
+    },
+    formatter: tableRecordFormatter,
+    handler: async ({ sdk, options, }) => {
         const { api } = sdk.context;
         const tableId = "table" in options ? options.table : options.tableId;
         const translator = await createFieldKeyTranslator({
@@ -49,50 +55,21 @@ export const listTableRecordsPlugin = (sdk) => {
         }
         const rawResponse = await api.post(`/tables/api/v1/tables/${tableId}/records/query`, body, {
             searchParams: { allow_nested_queries: "true" },
-            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: ${tableId}`);
-                }
-                return undefined;
-            },
             authRequired: true,
+            resource: { type: "table", id: tableId },
         });
         throwOnResponseErrors(rawResponse);
         const response = ListTableRecordsApiResponseSchema.parse(rawResponse);
+        const pagination = response.meta?.pagination;
+        const nextCursor = pagination?.has_more && pagination.end_cursor
+            ? pagination.end_cursor
+            : undefined;
         return {
             data: response.data.map((item) => ({
                 ...transformRecordItem(item),
                 data: translator.translateOutput(item.data),
             })),
-            nextCursor: extractNextCursor(response.meta),
+            nextCursor,
         };
-    }
-    const methodName = stripPageSuffix(listTableRecordsPage.name);
-    const listTableRecordsDefinition = createPaginatedFunction(listTableRecordsPage, ListTableRecordsOptionsInputSchema, createTelemetryCallback(sdk.context.eventEmission.emitMethodCalled, methodName), methodName, DEFAULT_PAGE_SIZE);
-    return {
-        listTableRecords: listTableRecordsDefinition,
-        context: {
-            meta: {
-                listTableRecords: {
-                    categories: ["table"],
-                    type: "list",
-                    itemType: "Record",
-                    inputSchema: ListTableRecordsOptionsSchema,
-                    outputSchema: RecordItemSchema,
-                    resolvers: {
-                        table: tableIdResolver,
-                        filters: tableFiltersResolver,
-                        sort: tableSortResolver,
-                    },
-                    formatter: tableRecordFormatter,
-                },
-            },
-        },
-    };
-};
+    },
+}));

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

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import type { PaginatedSdkFunction } from "../../../types/functions";
-import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
 import { RecordItemSchema, type RecordItem } from "../getTableRecord/schemas";
 export { RecordItemSchema };
 export type { RecordItem };
@@ -230,7 +229,6 @@ export interface ListTableRecordsPage {
     data: RecordItem[];
     nextCursor?: string;
 }
-export type ListTableRecordsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
 export interface ListTableRecordsSdkFunction {
     listTableRecords: PaginatedSdkFunction<ListTableRecordsOptions, RecordItem>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableRecords/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,gBAAgB,EAChB,KAAK,UAAU,EAChB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,CAAC;AAE3B,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;iBAc5C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AAEF,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;EAexB,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAIzB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIpE,eAAO,MAAM,mBAAmB;;;;;;iBAK9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AA2BhE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMA,CAAC;AAG3C,QAAA,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOf,CAAC;AAG/B,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAKP,CAAC;AAGzC,MAAM,MAAM,uBAAuB,GAC/B,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,GAC7C,CAAC,IAAI,CACH,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,EACvD,SAAS,CACV,GAAG;IACF,uCAAuC;IACvC,OAAO,EAAE,CAAC,CAAC,KAAK,CACd,OAAO,uCAAuC,CAC/C,CAAC,SAAS,CAAC,CAAC;CACd,CAAC,CAAC;AAEP,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,qBAAqB,GAC7B,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,EAAE,oBAAoB,CAAC,uBAAuB,EAAE,UAAU,CAAC,CAAC;CAC7E"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTableRecords/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,EAEL,gBAAgB,EAChB,KAAK,UAAU,EAChB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,CAAC;AAE3B,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;iBAc5C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AAEF,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;EAexB,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAIzB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIpE,eAAO,MAAM,mBAAmB;;;;;;iBAK9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AA2BhE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMA,CAAC;AAG3C,QAAA,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOf,CAAC;AAG/B,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAKP,CAAC;AAGzC,MAAM,MAAM,uBAAuB,GAC/B,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,GAC7C,CAAC,IAAI,CACH,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,EACvD,SAAS,CACV,GAAG;IACF,uCAAuC;IACvC,OAAO,EAAE,CAAC,CAAC,KAAK,CACd,OAAO,uCAAuC,CAC/C,CAAC,SAAS,CAAC,CAAC;CACd,CAAC,CAAC;AAEP,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,EAAE,oBAAoB,CAAC,uBAAuB,EAAE,UAAU,CAAC,CAAC;CAC7E"}

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

@@ -1,27 +1,60 @@
-import type { Plugin } from "../../../types/plugin";
-import { ListTablesOptionsSchema, type ListTablesOptions, type TableItem } from "./schemas";
-import type { ApiPluginProvides } from "../../api";
-import type { EventEmissionProvides } from "../../eventEmission";
 import type { CapabilitiesContext } from "../../capabilities";
-export interface ListTablesPluginProvides {
-    listTables: (options?: ListTablesOptions) => Promise<{
-        data: TableItem[];
-        nextCursor?: string;
-    }> & AsyncIterable<{
-        data: TableItem[];
-        nextCursor?: string;
-    }> & {
-        items(): AsyncIterable<TableItem>;
+export declare const listTablesPlugin: (sdk: {
+    context: {
+        api: import("../../../api").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
     };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: CapabilitiesContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    listTables: (options?: ({
+        tables?: string[] | undefined;
+        tableIds?: string[] | undefined;
+        kind?: "table" | "virtual_table" | "both" | undefined;
+        search?: string | undefined;
+        owner?: string | undefined;
+        includeShared?: boolean | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../../..").PaginatedSdkResult<{
+        id: string;
+        name: string;
+        created_at: string;
+        edited_at: string;
+        kind: "table" | "virtual_table";
+        account_id: string;
+        profile_id: string;
+        description?: string | undefined;
+        parent_table_id?: string | undefined;
+    }>;
+} & {
     context: {
         meta: {
-            listTables: {
-                inputSchema: typeof ListTablesOptionsSchema;
-            };
+            listTables: import("../../..").PluginMeta;
         };
     };
-}
-export declare const listTablesPlugin: Plugin<ApiPluginProvides & EventEmissionProvides & {
-    context: CapabilitiesContext;
-}, ListTablesPluginProvides>;
+};
+export type ListTablesPluginProvides = ReturnType<typeof listTablesPlugin>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTables/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAEL,uBAAuB,EAEvB,KAAK,iBAAiB,EACtB,KAAK,SAAS,EACf,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAOjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAmB9D,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,iBAAiB,KAAK,OAAO,CAAC;QACnD,IAAI,EAAE,SAAS,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAC1D,KAAK,IAAI,aAAa,CAAC,SAAS,CAAC,CAAC;KACnC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,UAAU,EAAE;gBACV,WAAW,EAAE,OAAO,uBAAuB,CAAC;aAC7C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,iBAAiB,GAAG,qBAAqB,GAAG;IAAE,OAAO,EAAE,mBAAmB,CAAA;CAAE,EAC5E,wBAAwB,CAsGzB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTables/index.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAK9D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;aAGY,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoE3D,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

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

@@ -1,25 +1,20 @@
-import { createPaginatedFunction } from "../../../utils/function-utils";
+import { definePlugin } from "../../../utils/plugin-utils";
+import { createPaginatedPluginMethod } from "../../../utils/plugin-utils";
 import { ListTablesApiResponseSchema, ListTablesOptionsSchema, TableItemSchema, } from "./schemas";
-import { createTelemetryCallback } from "../../../utils/telemetry-utils";
-import { stripPageSuffix } from "../../../utils/string-utils";
-import { ZapierAuthenticationError, ZapierValidationError, } from "../../../types/errors";
+import { extractCursor } from "../../../utils/function-utils";
+import { ZapierValidationError } from "../../../types/errors";
 import { transformTableItem } from "../utils";
 import { DEFAULT_PAGE_SIZE } from "../../../constants";
-function extractNextCursor(links) {
-    if (!links?.next) {
-        return undefined;
-    }
-    try {
-        const url = new URL(links.next);
-        const offset = url.searchParams.get("offset");
-        return offset || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export const listTablesPlugin = (sdk) => {
-    async function listTablesPage(options) {
+import { tablesDefaults } from "../shared";
+export const listTablesPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
+    ...tablesDefaults,
+    name: "listTables",
+    type: "list",
+    itemType: "Table",
+    inputSchema: ListTablesOptionsSchema,
+    outputSchema: TableItemSchema,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    handler: async ({ sdk, options }) => {
         if (options.includeShared) {
             await sdk.context.checkCapability("canIncludeSharedTables");
         }
@@ -28,17 +23,19 @@ export const listTablesPlugin = (sdk) => {
         if (options.pageSize !== undefined) {
             searchParams.limit = options.pageSize.toString();
         }
-        const tableIds = "tables" in options && options.tables ? options.tables : options.tableIds;
+        const tableIds = "tables" in options && options.tables
+            ? options.tables
+            : options.tableIds;
         if (tableIds && tableIds.length > 0) {
             searchParams.ids = tableIds.join(",");
         }
-        if (options?.kind) {
+        if (options.kind) {
             searchParams.kind = options.kind;
         }
-        if (options?.search) {
+        if (options.search) {
             searchParams.q = options.search;
         }
-        if (options?.owner && options.owner !== "me" && !options.includeShared) {
+        if (options.owner && options.owner !== "me" && !options.includeShared) {
             throw new ZapierValidationError('The "owner" option requires "includeShared" to be true. Without includeShared, only your own tables are returned.');
         }
         const owner = options.includeShared ? options.owner : "me";
@@ -58,37 +55,13 @@ export const listTablesPlugin = (sdk) => {
         }
         const rawResponse = await api.get("/tables/api/v1/tables", {
             searchParams,
-            customErrorHandler: ({ status }) => {
-                if (status === 401) {
-                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to list tables 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 list tables. (HTTP ${status})`, { statusCode: status });
-                }
-                return undefined;
-            },
             authRequired: true,
         });
         const response = ListTablesApiResponseSchema.parse(rawResponse);
         return {
             data: response.data.map(transformTableItem),
-            nextCursor: extractNextCursor(response.links),
+            links: response.links,
         };
-    }
-    const methodName = stripPageSuffix(listTablesPage.name);
-    const listTablesDefinition = createPaginatedFunction(listTablesPage, ListTablesOptionsSchema, createTelemetryCallback(sdk.context.eventEmission.emitMethodCalled, methodName), methodName, DEFAULT_PAGE_SIZE);
-    return {
-        listTables: listTablesDefinition,
-        context: {
-            meta: {
-                listTables: {
-                    categories: ["table"],
-                    type: "list",
-                    itemType: "Table",
-                    inputSchema: ListTablesOptionsSchema,
-                    outputSchema: TableItemSchema,
-                },
-            },
-        },
-    };
-};
+    },
+    extractCursor: (response) => extractCursor(response.links),
+}));

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

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import type { PaginatedSdkFunction } from "../../../types/functions";
-import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
 export declare const TableApiItemSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -80,7 +79,6 @@ export interface ListTablesPage {
     data: TableItem[];
     nextCursor?: string;
 }
-export type ListTablesError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
 export interface ListTablesSdkFunction {
     listTables: PaginatedSdkFunction<ListTablesOptions, TableItem>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTables/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;iBAa7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;iBAOtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,eAAe;;;;;;;;;;;;;iBAU1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAwC0B,CAAC;AAE/D,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAClC,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,EACvC,UAAU,CACX,GAAG;IACF,wCAAwC;IACxC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC,UAAU,CAAC,CAAC;CAChE,CAAC;AAGF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,MAAM,eAAe,GACvB,yBAAyB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,oBAAoB,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;CAChE"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/listTables/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGrE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;iBAa7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;iBAOtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,eAAe;;;;;;;;;;;;;iBAU1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAwC0B,CAAC;AAE/D,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAClC,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,EACvC,UAAU,CACX,GAAG;IACF,wCAAwC;IACxC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC,UAAU,CAAC,CAAC;CAChE,CAAC;AAGF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,oBAAoB,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;CAChE"}

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

@@ -0,0 +1,10 @@
+/**
+ * Method-meta defaults shared across every plugin in the `tables/` domain.
+ * Each plugin spreads `...tablesDefaults` into its `createPluginMethod` /
+ * `createPaginatedPluginMethod` config so we declare `categories: ["table"]`
+ * once instead of 12 times.
+ */
+export declare const tablesDefaults: {
+    categories: string[];
+};
+//# sourceMappingURL=shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/plugins/tables/shared.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;CAEI,CAAC"}

package/dist/plugins/tables/shared.js

@@ -0,0 +1,9 @@
+/**
+ * Method-meta defaults shared across every plugin in the `tables/` domain.
+ * Each plugin spreads `...tablesDefaults` into its `createPluginMethod` /
+ * `createPaginatedPluginMethod` config so we declare `categories: ["table"]`
+ * once instead of 12 times.
+ */
+export const tablesDefaults = {
+    categories: ["table"],
+};

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

@@ -1,16 +1,54 @@
-import type { Plugin } from "../../../types/plugin";
-import { UpdateTableRecordsOptionsSchema, type UpdateTableRecordsOptions, type UpdateTableRecordsResult } from "./schemas";
-import type { ApiPluginProvides } from "../../api";
-import type { EventEmissionProvides } from "../../eventEmission";
-export interface UpdateTableRecordsPluginProvides {
-    updateTableRecords: (options: UpdateTableRecordsOptions) => Promise<UpdateTableRecordsResult>;
+export declare const updateTableRecordsPlugin: (sdk: {
+    context: {
+        api: import("../../../api").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    updateTableRecords: (options?: {
+        table: string;
+        records: {
+            id: string;
+            data: Record<string, unknown>;
+        }[];
+        keyMode: "names" | "ids";
+    } | {
+        tableId: string;
+        records: {
+            id: string;
+            data: Record<string, unknown>;
+        }[];
+        keyMode: "names" | "ids";
+    } | undefined) => Promise<{
+        data: {
+            data: Record<string, unknown>;
+            id: string;
+            created_at: string;
+            edited_at: string;
+        }[];
+    }>;
+} & {
     context: {
         meta: {
-            updateTableRecords: {
-                inputSchema: typeof UpdateTableRecordsOptionsSchema;
-            };
+            updateTableRecords: import("../../..").PluginMeta;
         };
     };
-}
-export declare const updateTableRecordsPlugin: Plugin<ApiPluginProvides & EventEmissionProvides, UpdateTableRecordsPluginProvides>;
+};
+export type UpdateTableRecordsPluginProvides = ReturnType<typeof updateTableRecordsPlugin>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/updateTableRecords/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EACL,+BAA+B,EAI/B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC9B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAejE,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,iBAAiB,GAAG,qBAAqB,EACzC,gCAAgC,CAwFjC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/tables/updateTableRecords/index.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDpC,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC"}

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

@@ -1,12 +1,23 @@
-import { createFunction } from "../../../utils/function-utils";
-import { UpdateTableRecordsOptionsSchema, UpdateTableRecordsOptionsInputSchema, UpdateTableRecordsApiResponseSchema, RecordItemSchema, } from "./schemas";
-import { createTelemetryCallback } from "../../../utils/telemetry-utils";
-import { ZapierAuthenticationError } from "../../../types/errors";
+import { definePlugin } from "../../../utils/plugin-utils";
+import { createPluginMethod } from "../../../utils/plugin-utils";
+import { UpdateTableRecordsOptionsInputSchema, UpdateTableRecordsApiResponseSchema, RecordItemSchema, } from "./schemas";
 import { tableIdResolver, tableUpdateRecordsResolver, } from "../../../resolvers";
 import { tableRecordFormatter } from "../../../formatters";
 import { createFieldKeyTranslator, transformRecordItem, throwOnRecordErrors, throwOnResponseErrors, } from "../utils";
-export const updateTableRecordsPlugin = (sdk) => {
-    async function updateTableRecords(options) {
+import { tablesDefaults } from "../shared";
+export const updateTableRecordsPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...tablesDefaults,
+    name: "updateTableRecords",
+    type: "update",
+    itemType: "Record",
+    inputSchema: UpdateTableRecordsOptionsInputSchema,
+    outputSchema: RecordItemSchema,
+    resolvers: {
+        table: tableIdResolver,
+        records: tableUpdateRecordsResolver,
+    },
+    formatter: tableRecordFormatter,
+    handler: async ({ sdk, options }) => {
         const { api } = sdk.context;
         const tableId = "table" in options ? options.table : options.tableId;
         const translator = await createFieldKeyTranslator({
@@ -19,21 +30,7 @@ export const updateTableRecordsPlugin = (sdk) => {
                 id: record.id,
                 data: translator.translateInput(record.data),
             })),
-        }, {
-            customErrorHandler: ({ status }) => {
-                if (status === 401) {
-                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to update 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 update records. (HTTP ${status})`, { statusCode: status });
-                }
-                if (status === 404) {
-                    return new Error(`Table not found: ${tableId}`);
-                }
-                return undefined;
-            },
-            authRequired: true,
-        });
+        }, { authRequired: true, resource: { type: "table", id: tableId } });
         throwOnResponseErrors(rawResponse);
         const response = UpdateTableRecordsApiResponseSchema.parse(rawResponse);
         for (const changeset of response.data) {
@@ -45,25 +42,5 @@ export const updateTableRecordsPlugin = (sdk) => {
                 data: translator.translateOutput(changeset.new.data),
             })),
         };
-    }
-    const updateTableRecordsDefinition = createFunction(updateTableRecords, UpdateTableRecordsOptionsInputSchema, createTelemetryCallback(sdk.context.eventEmission.emitMethodCalled, updateTableRecords.name));
-    return {
-        updateTableRecords: updateTableRecordsDefinition,
-        context: {
-            meta: {
-                updateTableRecords: {
-                    categories: ["table"],
-                    type: "update",
-                    itemType: "Record",
-                    inputSchema: UpdateTableRecordsOptionsSchema,
-                    outputSchema: RecordItemSchema,
-                    resolvers: {
-                        table: tableIdResolver,
-                        records: tableUpdateRecordsResolver,
-                    },
-                    formatter: tableRecordFormatter,
-                },
-            },
-        },
-    };
-};
+    },
+}));

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

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import type { FunctionOptions } from "../../../types/functions";
-import type { ZapierAuthenticationError, ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../../types/errors";
 import { RecordItemSchema, type RecordItem } from "../getTableRecord/schemas";
 export { RecordItemSchema };
 export type { RecordItem };
@@ -91,7 +90,6 @@ export type UpdateTableRecordsOptions = (z.infer<typeof UpdateTableRecordsOption
 export interface UpdateTableRecordsResult {
     data: RecordItem[];
 }
-export type UpdateTableRecordsError = ZapierAuthenticationError | ZapierApiError | ZapierValidationError | ZapierUnknownError;
 export interface UpdateTableRecordsSdkFunction {
     updateTableRecords: (options: UpdateTableRecordsOptions) => Promise<UpdateTableRecordsResult>;
 }