@zapier/zapier-sdk 0.0.3 → 0.1.0

package/dist/plugins/apps/index.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppsPlugin = createAppsPlugin;
+const runAction_1 = require("../../functions/runAction");
+function createActionFunction(appKey, actionType, actionKey, options, pinnedAuthId) {
+    return async (actionOptions = {}) => {
+        const { api, token } = options;
+        const { inputs, authenticationId: providedAuthenticationId } = actionOptions;
+        // Use pinned auth ID first, then provided auth ID
+        const authenticationId = pinnedAuthId || providedAuthenticationId;
+        if (!authenticationId) {
+            throw new Error(`Authentication ID is required. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }) or provide authenticationId in the action call.`);
+        }
+        // Call runAction with the resolved parameters
+        return (0, runAction_1.runAction)({
+            appKey,
+            actionType: actionType,
+            actionKey,
+            inputs,
+            authenticationId,
+            api: api,
+            token,
+        });
+    };
+}
+function createActionTypeProxy(appKey, actionType, options, pinnedAuthId) {
+    return new Proxy({}, {
+        get(_, actionKey) {
+            if (typeof actionKey === "string") {
+                return createActionFunction(appKey, actionType, actionKey, options, pinnedAuthId);
+            }
+            return undefined;
+        },
+    });
+}
+function createPinnedAppProxy(appKey, options, pinnedAuthId) {
+    return new Proxy({}, {
+        get(_, actionType) {
+            if (typeof actionType === "string") {
+                return createActionTypeProxy(appKey, actionType, options, pinnedAuthId);
+            }
+            return undefined;
+        },
+    });
+}
+function createAppProxy(appKey, options) {
+    // Create the factory function that returns a pinned version
+    const appFactory = (factoryOptions) => {
+        return createPinnedAppProxy(appKey, options, factoryOptions.authenticationId);
+    };
+    // Add properties for direct usage (backward compatibility)
+    return new Proxy(appFactory, {
+        get(_, actionType) {
+            if (typeof actionType === "string") {
+                return createActionTypeProxy(appKey, actionType, options);
+            }
+            return undefined;
+        },
+    });
+}
+function createAppsProxy(options) {
+    // Create a proxy object that intercepts property access
+    const appsProxy = new Proxy({}, {
+        get(_, prop) {
+            if (typeof prop === "string") {
+                // First level: App names (e.g., 'slack')
+                return createAppProxy(prop, options);
+            }
+            return undefined;
+        },
+    });
+    return appsProxy;
+}
+// Export the plugin creation function
+function createAppsPlugin(options) {
+    return createAppsProxy(options);
+}

package/dist/plugins/apps/info.d.ts

@@ -0,0 +1,6 @@
+import type { AppsPluginOptions } from "./index";
+export declare const appsPluginInfo: {
+    plugin: (_sdk: any, options: AppsPluginOptions) => {
+        apps: import("./types").ActionProxy;
+    };
+};

package/dist/plugins/apps/info.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appsPluginInfo = void 0;
+const index_1 = require("./index");
+// Plugin info object for registry (keeping for compatibility)
+exports.appsPluginInfo = {
+    plugin: (_sdk, options) => {
+        const appsProxy = (0, index_1.createAppsPlugin)(options);
+        return {
+            apps: appsProxy,
+        };
+    },
+};

package/dist/plugins/apps/types.d.ts

@@ -0,0 +1,21 @@
+import type { ActionExecutionOptions, ActionExecutionResult } from "../../types/domain";
+interface AppFactoryOptions {
+    authenticationId: number;
+}
+interface ActionTypeProxy {
+    [action: string]: (options?: ActionExecutionOptions) => Promise<ActionExecutionResult>;
+}
+interface AppProxy {
+    [type: string]: ActionTypeProxy;
+}
+interface AppFactory {
+    (options: AppFactoryOptions): AppProxy;
+}
+type AppProxyWithFactory = AppFactory & AppProxy;
+export interface ActionProxy {
+    [app: string]: AppProxyWithFactory;
+}
+export interface AppsPluginSdkExtension {
+    apps: ActionProxy;
+}
+export {};

package/dist/plugins/apps/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resolvers/actionKey.d.ts

@@ -0,0 +1,8 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface ActionKeyResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const actionKeyResolver: ActionKeyResolver;

package/dist/resolvers/actionKey.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionKeyResolver = void 0;
+exports.actionKeyResolver = {
+    type: "dynamic",
+    depends: ["appKey", "actionType"],
+    fetch: async (sdk, resolvedParams) => {
+        const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
+        return actions.filter((action) => action.type === resolvedParams.actionType);
+    },
+    prompt: (actions) => ({
+        type: "list",
+        name: "actionKey",
+        message: "Select action:",
+        choices: actions.map((action) => ({
+            name: `${action.name || action.key} - ${action.description || "No description"}`,
+            value: action.key,
+        })),
+    }),
+};

package/dist/resolvers/actionType.d.ts

@@ -0,0 +1,8 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface ActionTypeResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const actionTypeResolver: ActionTypeResolver;

package/dist/resolvers/actionType.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionTypeResolver = void 0;
+exports.actionTypeResolver = {
+    type: "dynamic",
+    depends: ["appKey"],
+    fetch: async (sdk, resolvedParams) => {
+        const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
+        const types = [...new Set(actions.map((action) => action.type))];
+        return types.map((type) => ({ key: type, name: type }));
+    },
+    prompt: (types) => ({
+        type: "list",
+        name: "actionType",
+        message: "Select action type:",
+        choices: types.map((type) => ({
+            name: type.name,
+            value: type.key,
+        })),
+    }),
+};

package/dist/resolvers/appKey.d.ts

@@ -0,0 +1,6 @@
+export interface AppKeyResolver {
+    type: "static";
+    inputType?: "text" | "password" | "email";
+    placeholder?: string;
+}
+export declare const appKeyResolver: AppKeyResolver;

package/dist/resolvers/appKey.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appKeyResolver = void 0;
+exports.appKeyResolver = {
+    type: "static",
+    inputType: "text",
+    placeholder: "Enter app slug (e.g., 'slack', 'github')",
+};

package/dist/resolvers/authenticationId.d.ts

@@ -0,0 +1,8 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface AuthenticationIdResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const authenticationIdResolver: AuthenticationIdResolver;

package/dist/resolvers/authenticationId.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticationIdResolver = void 0;
+exports.authenticationIdResolver = {
+    type: "dynamic",
+    depends: ["appKey"],
+    fetch: async (sdk, resolvedParams) => {
+        // Get auths for the specific app (owned auths will be prioritized automatically)
+        return await sdk.listAuths({
+            appKey: resolvedParams.appKey,
+            limit: 1000,
+        });
+    },
+    prompt: (auths, params) => ({
+        type: "list",
+        name: "authenticationId",
+        message: `Select authentication for ${params.appKey}:`,
+        choices: [
+            ...auths.map((auth) => ({
+                name: `${auth.title || auth.label || "Authentication"} (ID: ${auth.id})`,
+                value: auth.id,
+            })),
+            {
+                name: "↗ Skip authentication (may fail)",
+                value: null,
+            },
+        ],
+    }),
+};

package/dist/resolvers/index.d.ts

@@ -0,0 +1,39 @@
+export declare const resolverRegistry: {
+    readonly appKey: import("./appKey").AppKeyResolver;
+    readonly actionType: import("./actionType").ActionTypeResolver;
+    readonly actionKey: import("./actionKey").ActionKeyResolver;
+    readonly authenticationId: import("./authenticationId").AuthenticationIdResolver;
+    readonly inputs: import("./inputs").InputsResolver;
+};
+export type ResolverName = keyof typeof resolverRegistry;
+export type ResolverType = (typeof resolverRegistry)[ResolverName];
+/**
+ * Get a resolver by name
+ */
+export declare function getResolver(name: string): ResolverType | undefined;
+/**
+ * Get all resolvers for a list of missing parameters
+ */
+export declare function getResolversForMissingParams(missingParams: string[]): Record<string, ResolverType>;
+/**
+ * Check if a parameter has a resolver
+ */
+export declare function hasResolver(paramName: string): boolean;
+/**
+ * Get all parameter names that have resolvers
+ */
+export declare function getResolvableParams(): string[];
+/**
+ * Resolve dependency chain for a parameter
+ * Returns parameters in the order they need to be resolved
+ */
+export declare function getResolutionOrder(paramName: string, resolved?: Set<string>): string[];
+/**
+ * Get resolution order for multiple parameters
+ */
+export declare function getResolutionOrderForParams(paramNames: string[]): string[];
+export { appKeyResolver } from "./appKey";
+export { actionTypeResolver } from "./actionType";
+export { actionKeyResolver } from "./actionKey";
+export { authenticationIdResolver } from "./authenticationId";
+export { inputsResolver } from "./inputs";

package/dist/resolvers/index.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputsResolver = exports.authenticationIdResolver = exports.actionKeyResolver = exports.actionTypeResolver = exports.appKeyResolver = exports.resolverRegistry = void 0;
+exports.getResolver = getResolver;
+exports.getResolversForMissingParams = getResolversForMissingParams;
+exports.hasResolver = hasResolver;
+exports.getResolvableParams = getResolvableParams;
+exports.getResolutionOrder = getResolutionOrder;
+exports.getResolutionOrderForParams = getResolutionOrderForParams;
+const appKey_1 = require("./appKey");
+const actionType_1 = require("./actionType");
+const actionKey_1 = require("./actionKey");
+const authenticationId_1 = require("./authenticationId");
+const inputs_1 = require("./inputs");
+// Centralized resolver registry
+exports.resolverRegistry = {
+    appKey: appKey_1.appKeyResolver,
+    actionType: actionType_1.actionTypeResolver,
+    actionKey: actionKey_1.actionKeyResolver,
+    authenticationId: authenticationId_1.authenticationIdResolver,
+    inputs: inputs_1.inputsResolver,
+};
+// Utility functions for working with resolvers
+/**
+ * Get a resolver by name
+ */
+function getResolver(name) {
+    return exports.resolverRegistry[name];
+}
+/**
+ * Get all resolvers for a list of missing parameters
+ */
+function getResolversForMissingParams(missingParams) {
+    const resolvers = {};
+    for (const param of missingParams) {
+        const resolver = exports.resolverRegistry[param];
+        if (resolver) {
+            resolvers[param] = resolver;
+        }
+    }
+    return resolvers;
+}
+/**
+ * Check if a parameter has a resolver
+ */
+function hasResolver(paramName) {
+    return paramName in exports.resolverRegistry;
+}
+/**
+ * Get all parameter names that have resolvers
+ */
+function getResolvableParams() {
+    return Object.keys(exports.resolverRegistry);
+}
+/**
+ * Resolve dependency chain for a parameter
+ * Returns parameters in the order they need to be resolved
+ */
+function getResolutionOrder(paramName, resolved = new Set()) {
+    const resolver = getResolver(paramName);
+    if (!resolver || resolver.type === "static") {
+        return [paramName];
+    }
+    const order = [];
+    if ("depends" in resolver && resolver.depends) {
+        for (const dependency of resolver.depends) {
+            if (!resolved.has(dependency)) {
+                order.push(...getResolutionOrder(dependency, resolved));
+                resolved.add(dependency);
+            }
+        }
+    }
+    if (!resolved.has(paramName)) {
+        order.push(paramName);
+        resolved.add(paramName);
+    }
+    return order;
+}
+/**
+ * Get resolution order for multiple parameters
+ */
+function getResolutionOrderForParams(paramNames) {
+    const resolved = new Set();
+    const order = [];
+    for (const paramName of paramNames) {
+        const paramOrder = getResolutionOrder(paramName, resolved);
+        for (const param of paramOrder) {
+            if (!order.includes(param)) {
+                order.push(param);
+            }
+        }
+    }
+    return order;
+}
+// Re-export individual resolvers for direct access if needed
+var appKey_2 = require("./appKey");
+Object.defineProperty(exports, "appKeyResolver", { enumerable: true, get: function () { return appKey_2.appKeyResolver; } });
+var actionType_2 = require("./actionType");
+Object.defineProperty(exports, "actionTypeResolver", { enumerable: true, get: function () { return actionType_2.actionTypeResolver; } });
+var actionKey_2 = require("./actionKey");
+Object.defineProperty(exports, "actionKeyResolver", { enumerable: true, get: function () { return actionKey_2.actionKeyResolver; } });
+var authenticationId_2 = require("./authenticationId");
+Object.defineProperty(exports, "authenticationIdResolver", { enumerable: true, get: function () { return authenticationId_2.authenticationIdResolver; } });
+var inputs_2 = require("./inputs");
+Object.defineProperty(exports, "inputsResolver", { enumerable: true, get: function () { return inputs_2.inputsResolver; } });

package/dist/resolvers/inputs.d.ts

@@ -0,0 +1,7 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface InputsResolver {
+    type: "fields";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+}
+export declare const inputsResolver: InputsResolver;

package/dist/resolvers/inputs.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputsResolver = void 0;
+exports.inputsResolver = {
+    type: "fields",
+    depends: ["appKey", "actionKey", "actionType", "authenticationId"],
+    fetch: async (sdk, resolvedParams) => {
+        return await sdk.listFields({
+            appKey: resolvedParams.appKey,
+            actionKey: resolvedParams.actionKey,
+            actionType: resolvedParams.actionType,
+            authenticationId: resolvedParams.authenticationId,
+        });
+    },
+};

package/dist/schema-utils.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export interface FormattedItem {
+    title: string;
+    subtitle?: string;
+    details: Array<{
+        text: string;
+        style: "normal" | "dim" | "accent" | "warning" | "success";
+    }>;
+}
+export interface FormatMetadata {
+    format: (item: any) => FormattedItem;
+}
+export declare function withFormatter<T extends z.ZodType>(schema: T, formatMeta: FormatMetadata): T;
+export declare function getFormatMetadata(schema: z.ZodType): FormatMetadata | undefined;
+export declare function withOutputSchema<T extends z.ZodType>(inputSchema: T, outputSchema: z.ZodType): T;
+export declare function getOutputSchema(inputSchema: z.ZodType): z.ZodType | undefined;
+export interface StaticResolver {
+    type: "static";
+    inputType?: "text" | "password" | "email";
+    placeholder?: string;
+}
+export interface DynamicResolver {
+    type: "dynamic";
+    fetch: (sdk: any, resolvedParams: any) => Promise<any[]>;
+    prompt: (items: any[], params: any) => any;
+    depends?: string[];
+}
+export interface FieldsResolver {
+    type: "fields";
+    fetch: (sdk: any, resolvedParams: any) => Promise<any[]>;
+    depends?: string[];
+}
+export type ResolverMetadata = StaticResolver | DynamicResolver | FieldsResolver;
+export interface ResolverConfig {
+    resolver: ResolverMetadata;
+}
+export declare function withResolver<T extends z.ZodType>(schema: T, config: ResolverConfig): T;
+export declare function getSchemaDescription(schema: z.ZodSchema): string | undefined;
+export declare function getFieldDescriptions(schema: z.ZodObject<any>): Record<string, string>;

package/dist/schema-utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFormatter = withFormatter;
+exports.getFormatMetadata = getFormatMetadata;
+exports.withOutputSchema = withOutputSchema;
+exports.getOutputSchema = getOutputSchema;
+exports.withResolver = withResolver;
+exports.getSchemaDescription = getSchemaDescription;
+exports.getFieldDescriptions = getFieldDescriptions;
+const zod_1 = require("zod");
+// Helper function to add format metadata to schemas
+function withFormatter(schema, formatMeta) {
+    // Store format metadata on the schema definition
+    schema._def.formatMeta = formatMeta;
+    return schema;
+}
+// Helper function to get format metadata from a schema
+function getFormatMetadata(schema) {
+    return schema._def.formatMeta;
+}
+// Helper function to link input schemas to output schemas
+function withOutputSchema(inputSchema, outputSchema) {
+    // Store output schema reference on the input schema
+    inputSchema._def.outputSchema = outputSchema;
+    return inputSchema;
+}
+// Helper function to get output schema from an input schema
+function getOutputSchema(inputSchema) {
+    return inputSchema._def.outputSchema;
+}
+// Helper function to add resolver metadata to schemas
+function withResolver(schema, config) {
+    // Store resolver metadata on the schema definition
+    schema._def.resolverMeta = config;
+    return schema;
+}
+// ============================================================================
+// Schema Description Utilities
+// ============================================================================
+function getSchemaDescription(schema) {
+    return schema.description;
+}
+function getFieldDescriptions(schema) {
+    const descriptions = {};
+    const shape = schema.shape;
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+        if (fieldSchema instanceof zod_1.z.ZodType && fieldSchema.description) {
+            descriptions[key] = fieldSchema.description;
+        }
+    }
+    return descriptions;
+}

package/dist/schemas/Action.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const ActionItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+    appKey: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    key: string;
+    appKey?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+}, {
+    type: string;
+    key: string;
+    appKey?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+}>;
+export type ActionItem = z.infer<typeof ActionItemSchema>;

package/dist/schemas/Action.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionItemSchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
+// ============================================================================
+// Action Schemas
+// ============================================================================
+exports.ActionItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
+    key: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    type: zod_1.z.string(),
+    appKey: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        details.push({ text: `Type: ${item.type}`, style: "accent" });
+        if (item.appKey) {
+            details.push({ text: `App: ${item.appKey}`, style: "normal" });
+        }
+        if (item.description) {
+            details.push({ text: item.description, style: "dim" });
+        }
+        return {
+            title: item.name || item.key,
+            subtitle: `(${item.key})`,
+            details,
+        };
+    },
+});

package/dist/schemas/App.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export { FormattedItem, FormatMetadata } from "../schema-utils";
+export declare const AppItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+}, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+}>;
+export type AppItem = z.infer<typeof AppItemSchema>;

package/dist/schemas/App.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppItemSchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
+// ============================================================================
+// App Schemas
+// ============================================================================
+exports.AppItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
+    key: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    category: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        if (item.description) {
+            details.push({ text: item.description, style: "dim" });
+        }
+        if (item.category) {
+            details.push({
+                text: `Category: ${item.category}`,
+                style: "accent",
+            });
+        }
+        return {
+            title: item.name || item.key,
+            subtitle: `(${item.key})`,
+            details,
+        };
+    },
+});

package/dist/schemas/Auth.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const AuthItemSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    identifier: z.ZodOptional<z.ZodString>;
+    account_id: z.ZodOptional<z.ZodString>;
+    is_private: z.ZodOptional<z.ZodBoolean>;
+    shared_with_all: z.ZodOptional<z.ZodBoolean>;
+    marked_stale_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    title?: string | undefined;
+    label?: string | undefined;
+    identifier?: string | undefined;
+    account_id?: string | undefined;
+    is_private?: boolean | undefined;
+    shared_with_all?: boolean | undefined;
+    marked_stale_at?: string | undefined;
+}, {
+    id: number;
+    title?: string | undefined;
+    label?: string | undefined;
+    identifier?: string | undefined;
+    account_id?: string | undefined;
+    is_private?: boolean | undefined;
+    shared_with_all?: boolean | undefined;
+    marked_stale_at?: string | undefined;
+}>;
+export type AuthItem = z.infer<typeof AuthItemSchema>;