@zapier/zapier-sdk 0.64.0 → 0.67.0

package/dist/utils/plugin-utils.d.ts

@@ -1,245 +0,0 @@
-/**
- * ------------------------------
- * Plugin authoring helpers
- * ------------------------------
- *
- * - `definePlugin`: identity wrapper that constrains a plugin's return to
- *   `PluginProvides` while preserving the narrow inferred shape, so callers
- *   can derive their `*PluginProvides` type via `ReturnType<typeof plugin>`
- *   instead of declaring it by hand.
- * - `createPluginMethod` / `createPaginatedPluginMethod`: per-method
- *   primitives that sit inside a `definePlugin` callback and build the
- *
- *     { [name]: wrappedFn, context: { meta: { [name]: meta } } }
- *
- *   fragment a plugin returns for a single method, wiring up
- *   `createFunction` / `createPaginatedFunction`, the telemetry callback,
- *   and the doubled `name` (function key + meta key) in one place.
- *
- * Two method helpers (rather than one with a `paginated: true` discriminant)
- * because the handler signature changes shape across pagination, and
- * discriminated unions on optional booleans produce noisy TS errors.
- */
-import type { z } from "zod";
-import type { PaginatedSdkResult } from "../types/functions";
-import type { Plugin, PluginMeta, PluginProvides } from "../types/plugin";
-/**
- * Identity helper that preserves the narrow inferred return type of a plugin.
- *
- * Wrapping a plugin function with `definePlugin(...)` lets callers derive the
- * plugin's contribution via `ReturnType<typeof plugin>` instead of declaring a
- * matching `*PluginProvides` interface by hand. The constraint
- * `TProvides extends PluginProvides` enforces the structural floor (must
- * return a valid plugin output); beyond that the inferred shape flows through.
- */
-export declare function definePlugin<TSdk, TProvides extends PluginProvides>(fn: (sdk: TSdk & {
-    context: {
-        meta: Record<string, PluginMeta>;
-    };
-}) => TProvides): (sdk: TSdk & {
-    context: {
-        meta: Record<string, PluginMeta>;
-    };
-}) => TProvides;
-/**
- * Method-level meta fields. Mirrors `PluginMeta` minus `inputSchema`, which is
- * passed at the top level alongside the handler and merged into the meta by
- * the helpers themselves.
- */
-type MethodMeta = Omit<PluginMeta, "inputSchema">;
-interface PluginMethodConfig<TSdk, TInput, TResult, TName extends string> extends MethodMeta {
-    name: TName;
-    /**
-     * Schema for runtime input validation; drives the handler's `options`
-     * type. For plugins that accept deprecated parameter aliases this is a
-     * `z.union([CanonicalSchema, DeprecatedSchema])` — the registry
-     * unwraps unions and exposes only the first variant (canonical) to
-     * docs, CLI help, and MCP tool definitions.
-     */
-    inputSchema?: z.ZodSchema<TInput>;
-    handler: (args: {
-        sdk: TSdk;
-        options: TInput;
-    }) => Promise<TResult>;
-}
-type PluginMethodReturn<TName extends string, TInput, TResult> = {
-    [K in TName]: (options?: TInput) => Promise<TResult>;
-} & {
-    context: {
-        meta: {
-            [K in TName]: PluginMeta;
-        };
-    };
-};
-/**
- * Build the method fragment for a non-paginated SDK method. Used inside a
- * `definePlugin(...)` callback:
- *
- *   export const getProfilePlugin = definePlugin(
- *     (sdk: ApiPluginProvides & EventEmissionProvides) =>
- *       createPluginMethod(sdk, {
- *         name: "getProfile",
- *         categories: ["account"],
- *         inputSchema: GetProfileSchema,
- *         handler: async ({ sdk }) => { ... },
- *       }),
- *   );
- */
-export declare function createPluginMethod<const TName extends string, TSdk extends {
-    context: unknown;
-}, TInput, TResult>(sdk: TSdk, config: PluginMethodConfig<TSdk, TInput, TResult, TName>): PluginMethodReturn<TName, TInput, TResult>;
-interface PaginatedPluginMethodConfig<TSdk, TInput, TResponse extends {
-    data: unknown[];
-}, TName extends string> extends MethodMeta {
-    name: TName;
-    /** Same semantics as `createPluginMethod`'s `inputSchema`. */
-    inputSchema?: z.ZodSchema<TInput>;
-    /**
-     * Optional default page size when the caller doesn't pass one. Mirrors
-     * `createPaginatedFunction`'s `defaultPageSize` arg.
-     */
-    defaultPageSize?: number;
-    /**
-     * Page handler. Returns whatever shape the upstream API gives back, as
-     * long as it has a `data: TItem[]` field. JSON:API envelopes
-     * (`{ data, links, meta }`) work directly: pair them with
-     * `extractCursor` below to pull the next-page cursor out of the response.
-     */
-    handler: (args: {
-        sdk: TSdk;
-        options: TInput & {
-            cursor?: string;
-            pageSize?: number;
-        };
-    }) => Promise<TResponse>;
-    /**
-     * Pull the next-page cursor out of the handler's response. Most JSON:API
-     * endpoints will use `(response) => extractCursor(response.links)` from
-     * `function-utils`. Provide a custom extractor for non-standard shapes
-     * (e.g. `(response) => response.meta?.pagination?.end_cursor`).
-     *
-     * If omitted, the runtime falls back to its built-in detection
-     * (`response.nextCursor` or `response.links?.next` URL parsing) — i.e.
-     * the same auto-detection that worked before this helper existed. New
-     * plugins should set `extractCursor` explicitly so the pagination shape
-     * is visible at the call site.
-     */
-    extractCursor?: (response: TResponse) => string | undefined;
-}
-type ItemOf<TResponse extends {
-    data: unknown[];
-}> = TResponse extends {
-    data: readonly (infer TItem)[];
-} ? TItem : never;
-type PaginatedPluginMethodReturn<TName extends string, TInput, TItem> = {
-    [K in TName]: (options?: TInput & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) => PaginatedSdkResult<TItem>;
-} & {
-    context: {
-        meta: {
-            [K in TName]: PluginMeta;
-        };
-    };
-};
-/**
- * Paginated variant of `createPluginMethod`. The handler receives
- * `{ cursor?, pageSize? }` in `options` and returns whatever shape the
- * upstream API gives back, as long as it has a `data: TItem[]` field.
- * Pair JSON:API responses with `extractCursor` to make the cursor
- * extraction visible at the call site:
- *
- *   createPaginatedPluginMethod(sdk, {
- *     name: "listApps",
- *     inputSchema: ListAppsSchema,
- *     handler: ({ sdk, options }) =>
- *       sdk.context.api.get<ListAppsResponse>("/api/v0/apps", {...}),
- *     extractCursor: (response) => extractCursor(response.links),
- *   });
- */
-export declare function createPaginatedPluginMethod<const TName extends string, TSdk extends {
-    context: unknown;
-}, TInput, TResponse extends {
-    data: unknown[];
-}>(sdk: TSdk, config: PaginatedPluginMethodConfig<TSdk, TInput, TResponse, TName>): PaginatedPluginMethodReturn<TName, TInput, ItemOf<TResponse>>;
-/**
- * Maps a tuple of plugins to a tuple of their TSdk requirement types.
- *
- *   SdkRequirementsOf<[Plugin<{ api }, _>, Plugin<{ options }, _>]>
- *     = [{ api }, { options }]
- */
-type SdkRequirementsOf<T extends readonly Plugin<any, any>[]> = {
-    [K in keyof T]: T[K] extends Plugin<infer Sdk, any> ? Sdk : never;
-};
-/**
- * Maps a tuple of plugins to a tuple of their TProvides output types.
- *
- *   ProvidesOf<[Plugin<_, { hello }>, Plugin<_, { goodbye }>]>
- *     = [{ hello }, { goodbye }]
- */
-type ProvidesOf<T extends readonly Plugin<any, any>[]> = {
-    [K in keyof T]: T[K] extends Plugin<any, infer Provides> ? Provides : never;
-};
-/**
- * Intersects every member of a tuple into a single combined type. The
- * result is an object that has every property of every member at once.
- *
- *   IntersectAll<[{ api }, { options }]> = { api } & { options }
- *   IntersectAll<[]>                     = {}
- *
- * Walks recursively: head & IntersectAll<tail>, base case is the empty
- * tuple. Why intersection (`&`) and not union (`|`): the composed plugin
- * must require ALL of the sub-plugins' needs at once — an SDK that has
- * both `api` AND `options` — not "either api or options."
- */
-type IntersectAll<T extends readonly unknown[]> = T extends readonly [
-    infer Head,
-    ...infer Tail
-] ? Head & IntersectAll<Tail> : {};
-/**
- * The TSdk a composed plugin requires: every sub-plugin's TSdk requirement,
- * all at once. Composing a plugin that needs `{ api }` with one that needs
- * `{ options }` yields a composed plugin that needs `{ api } & { options }`.
- */
-type ComposeSdk<T extends readonly Plugin<any, any>[]> = IntersectAll<SdkRequirementsOf<T>>;
-/**
- * What a composed plugin provides: every sub-plugin's TProvides combined.
- * Composing a plugin that provides `{ hello }` with one that provides
- * `{ goodbye }` yields `{ hello } & { goodbye }`.
- */
-type ComposeProvides<T extends readonly Plugin<any, any>[]> = IntersectAll<ProvidesOf<T>>;
-/**
- * Bundle N plugins into a single plugin so a consumer can call
- * `addPlugin(combined)` once. Use this when an extension package wants to
- * expose granular sub-plugins for tree-shaking *and* a one-call convenience
- * entry point.
- *
- * Three commitments (per the boilerplate-reduction design):
- * 1. **Bag mode.** Sub-plugins must not depend on each other; order is
- *    irrelevant. If you need pipeline composition (later sub-plugins
- *    reading earlier sub-plugins' outputs), use a regular `definePlugin`
- *    callback that calls each `createPluginMethod` in turn.
- * 2. **Over-approximation of TSdk.** The composed plugin requires the
- *    intersection of every sub-plugin's requirements (all of them, all at
- *    once). Works fine for homogeneous-deps groups; widens slightly for
- *    heterogeneous ones, which keeps the variadic types tractable.
- * 3. **Collision detection.** Throws on duplicate root keys, duplicate
- *    `context.meta` keys, and duplicate non-meta `context.*` keys
- *    *inside* a single `composePlugins(...)` call. Cross-`addPlugin`
- *    collisions are handled separately by `addPlugin` itself, which
- *    warns-and-skips the colliding plugin (the first registration
- *    wins). Pure meta-only overrides (e.g. `cliOverridesPlugin`
- *    patching `meta.fetch.deprecated` without re-registering `fetch`)
- *    stay legitimate in both code paths.
- *
- * Why prefer this over an `addPlugin([...])` array overload: TypeScript's
- * overload resolution interacts badly with arrays carrying a mix of
- * `TProvides` shapes — chained inference downstream of `addPlugin([...])`
- * tends to widen and lose individual method types. A single composed
- * plugin flows through the existing single-plugin `addPlugin` cleanly.
- */
-export declare function composePlugins<const Ts extends readonly Plugin<any, any>[]>(...plugins: Ts): Plugin<ComposeSdk<Ts>, ComposeProvides<Ts>>;
-export {};
-//# sourceMappingURL=plugin-utils.d.ts.map

package/dist/utils/plugin-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-utils.d.ts","sourceRoot":"","sources":["../../src/utils/plugin-utils.ts"],"names":[],"mappings":"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"}

package/dist/utils/plugin-utils.js

@@ -1,234 +0,0 @@
-/**
- * ------------------------------
- * Plugin authoring helpers
- * ------------------------------
- *
- * - `definePlugin`: identity wrapper that constrains a plugin's return to
- *   `PluginProvides` while preserving the narrow inferred shape, so callers
- *   can derive their `*PluginProvides` type via `ReturnType<typeof plugin>`
- *   instead of declaring it by hand.
- * - `createPluginMethod` / `createPaginatedPluginMethod`: per-method
- *   primitives that sit inside a `definePlugin` callback and build the
- *
- *     { [name]: wrappedFn, context: { meta: { [name]: meta } } }
- *
- *   fragment a plugin returns for a single method, wiring up
- *   `createFunction` / `createPaginatedFunction`, the telemetry callback,
- *   and the doubled `name` (function key + meta key) in one place.
- *
- * Two method helpers (rather than one with a `paginated: true` discriminant)
- * because the handler signature changes shape across pagination, and
- * discriminated unions on optional booleans produce noisy TS errors.
- */
-import { createFunction, createPaginatedFunction } from "./function-utils";
-import { createTelemetryCallback } from "./telemetry-utils";
-/**
- * Identity helper that preserves the narrow inferred return type of a plugin.
- *
- * Wrapping a plugin function with `definePlugin(...)` lets callers derive the
- * plugin's contribution via `ReturnType<typeof plugin>` instead of declaring a
- * matching `*PluginProvides` interface by hand. The constraint
- * `TProvides extends PluginProvides` enforces the structural floor (must
- * return a valid plugin output); beyond that the inferred shape flows through.
- */
-export function definePlugin(fn) {
-    return fn;
-}
-/**
- * Build a telemetry callback only when the SDK actually has eventEmission
- * wired up. Plugin tests sometimes assemble a minimal SDK without the
- * eventEmission plugin; in that case telemetry is silently skipped, matching
- * the legacy `createFunction` behavior of accepting an undefined telemetry
- * arg.
- */
-function maybeTelemetry(sdk, name) {
-    const ctx = sdk.context;
-    if (!ctx.eventEmission)
-        return undefined;
-    return createTelemetryCallback(ctx.eventEmission.emitMethodCalled, name);
-}
-/**
- * Build the method fragment for a non-paginated SDK method. Used inside a
- * `definePlugin(...)` callback:
- *
- *   export const getProfilePlugin = definePlugin(
- *     (sdk: ApiPluginProvides & EventEmissionProvides) =>
- *       createPluginMethod(sdk, {
- *         name: "getProfile",
- *         categories: ["account"],
- *         inputSchema: GetProfileSchema,
- *         handler: async ({ sdk }) => { ... },
- *       }),
- *   );
- */
-export function createPluginMethod(sdk, config) {
-    const { name, inputSchema, handler, ...metaFields } = config;
-    // Preserve the method name on the inner function so telemetry and any
-    // `function.name`-based diagnostics see the right value.
-    const namedHandlers = {
-        [name]: async function (options) {
-            return handler({ sdk, options });
-        },
-    };
-    const wrappedFn = createFunction(namedHandlers[name], inputSchema, maybeTelemetry(sdk, name));
-    return {
-        [name]: wrappedFn,
-        context: {
-            meta: {
-                [name]: {
-                    ...metaFields,
-                    ...(inputSchema ? { inputSchema } : {}),
-                },
-            },
-        },
-    };
-}
-/**
- * Paginated variant of `createPluginMethod`. The handler receives
- * `{ cursor?, pageSize? }` in `options` and returns whatever shape the
- * upstream API gives back, as long as it has a `data: TItem[]` field.
- * Pair JSON:API responses with `extractCursor` to make the cursor
- * extraction visible at the call site:
- *
- *   createPaginatedPluginMethod(sdk, {
- *     name: "listApps",
- *     inputSchema: ListAppsSchema,
- *     handler: ({ sdk, options }) =>
- *       sdk.context.api.get<ListAppsResponse>("/api/v0/apps", {...}),
- *     extractCursor: (response) => extractCursor(response.links),
- *   });
- */
-export function createPaginatedPluginMethod(sdk, config) {
-    const { name, inputSchema, handler, extractCursor: extractCursorFn, defaultPageSize, ...metaFields } = config;
-    const namedPageHandlers = {
-        [name]: async function (options) {
-            const response = await handler({ sdk, options });
-            if (extractCursorFn) {
-                const extracted = extractCursorFn(response);
-                // Pass through the original response when the extractor doesn't
-                // produce a cursor — that way the runtime in `createPageFunction`
-                // can still auto-detect `nextCursor` or JSON:API `links.next` if
-                // they're present (e.g. from test mocks that don't go through the
-                // real API envelope).
-                if (extracted !== undefined) {
-                    return { data: response.data, nextCursor: extracted };
-                }
-            }
-            return response;
-        },
-    };
-    const wrappedFn = createPaginatedFunction(namedPageHandlers[name], inputSchema, maybeTelemetry(sdk, name), name, defaultPageSize);
-    return {
-        [name]: wrappedFn,
-        context: {
-            meta: {
-                [name]: {
-                    ...metaFields,
-                    ...(inputSchema ? { inputSchema } : {}),
-                },
-            },
-        },
-    };
-}
-// ----------------------------------------------------------------------------
-// composePlugins — runtime merge helpers
-// ----------------------------------------------------------------------------
-// Three merge rules, one per shape of key the function deals with. Each is
-// a small, single-purpose helper so the main loop reads top-to-bottom.
-/**
- * Merge root-level keys (the SDK methods a plugin contributes) into the
- * accumulator. Throws on collision: composePlugins is bag-mode, so two
- * sub-plugins registering the same method name is a programmer error.
- */
-function mergeRootKeysWithCollisionCheck(target, source, seen) {
-    for (const key of Object.keys(source)) {
-        if (seen.has(key)) {
-            throw new Error(`composePlugins: duplicate root key "${key}". Plugins composed in the same call must register distinct method names.`);
-        }
-        seen.add(key);
-        target[key] = source[key];
-    }
-}
-/**
- * Merge per-method metadata (the registry view of input/output schemas,
- * categories, etc.) with the same collision rule as root keys. Even when
- * two sub-plugins' root method keys differ, registry-level shadowing
- * is dangerous, so silent overwrites aren't allowed.
- */
-function mergeMetaKeysWithCollisionCheck(target, source, seen) {
-    for (const key of Object.keys(source)) {
-        if (seen.has(key)) {
-            throw new Error(`composePlugins: duplicate context.meta key "${key}". Two sub-plugins registered metadata for the same name.`);
-        }
-        seen.add(key);
-        target[key] = source[key];
-    }
-}
-/**
- * Merge non-meta context keys (everything under `context.*` that isn't
- * `meta`) into the accumulator. Throws on collision — bag mode says
- * sub-plugins shouldn't be re-providing shared infrastructure like
- * `context.api`, so two of them claiming the same context slot is a
- * programmer error. Note that this only applies *inside* a single
- * `composePlugins(...)` call; cross-`addPlugin` overrides go through
- * `addPlugin`'s last-write-wins merge, which is unaffected by this check.
- */
-function mergeContextKeysWithCollisionCheck(target, source, seen) {
-    for (const key of Object.keys(source)) {
-        if (seen.has(key)) {
-            throw new Error(`composePlugins: duplicate context key "${key}". Two sub-plugins contributed the same context.${key} field.`);
-        }
-        seen.add(key);
-        target[key] = source[key];
-    }
-}
-/**
- * Bundle N plugins into a single plugin so a consumer can call
- * `addPlugin(combined)` once. Use this when an extension package wants to
- * expose granular sub-plugins for tree-shaking *and* a one-call convenience
- * entry point.
- *
- * Three commitments (per the boilerplate-reduction design):
- * 1. **Bag mode.** Sub-plugins must not depend on each other; order is
- *    irrelevant. If you need pipeline composition (later sub-plugins
- *    reading earlier sub-plugins' outputs), use a regular `definePlugin`
- *    callback that calls each `createPluginMethod` in turn.
- * 2. **Over-approximation of TSdk.** The composed plugin requires the
- *    intersection of every sub-plugin's requirements (all of them, all at
- *    once). Works fine for homogeneous-deps groups; widens slightly for
- *    heterogeneous ones, which keeps the variadic types tractable.
- * 3. **Collision detection.** Throws on duplicate root keys, duplicate
- *    `context.meta` keys, and duplicate non-meta `context.*` keys
- *    *inside* a single `composePlugins(...)` call. Cross-`addPlugin`
- *    collisions are handled separately by `addPlugin` itself, which
- *    warns-and-skips the colliding plugin (the first registration
- *    wins). Pure meta-only overrides (e.g. `cliOverridesPlugin`
- *    patching `meta.fetch.deprecated` without re-registering `fetch`)
- *    stay legitimate in both code paths.
- *
- * Why prefer this over an `addPlugin([...])` array overload: TypeScript's
- * overload resolution interacts badly with arrays carrying a mix of
- * `TProvides` shapes — chained inference downstream of `addPlugin([...])`
- * tends to widen and lose individual method types. A single composed
- * plugin flows through the existing single-plugin `addPlugin` cleanly.
- */
-export function composePlugins(...plugins) {
-    return ((sdk) => {
-        const merged = { context: { meta: {} } };
-        const seenRoot = new Set();
-        const seenMeta = new Set();
-        const seenContext = new Set();
-        for (const plugin of plugins) {
-            const { context, ...rootKeys } = plugin(sdk);
-            mergeRootKeysWithCollisionCheck(merged, rootKeys, seenRoot);
-            if (context) {
-                const { meta, ...nonMetaContext } = context;
-                if (meta) {
-                    mergeMetaKeysWithCollisionCheck(merged.context.meta, meta, seenMeta);
-                }
-                mergeContextKeysWithCollisionCheck(merged.context, nonMetaContext, seenContext);
-            }
-        }
-        return merged;
-    });
-}