@zapier/zapier-sdk 0.3.1 → 0.4.1

package/dist/resolvers/actionKey.js

@@ -1,20 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-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

@@ -1,21 +0,0 @@
-"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

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

package/dist/resolvers/appKey.js

@@ -1,8 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-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

@@ -1,29 +0,0 @@
-"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.listAuthentications({
-            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

@@ -1,39 +0,0 @@
-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

@@ -1,105 +0,0 @@
-"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

@@ -1,7 +0,0 @@
-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

@@ -1,15 +0,0 @@
-"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

@@ -1,44 +0,0 @@
-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>;
-export interface PositionalMetadata {
-    positional: true;
-}
-export declare function withPositional<T extends z.ZodType>(schema: T): T;
-export declare function isPositional(schema: z.ZodType): boolean;

package/dist/schema-utils.js

@@ -1,76 +0,0 @@
-"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;
-exports.withPositional = withPositional;
-exports.isPositional = isPositional;
-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;
-}
-// Helper function to mark a parameter as positional for CLI
-function withPositional(schema) {
-    // Store positional metadata on the schema definition
-    schema._def.positionalMeta = { positional: true };
-    return schema;
-}
-// Helper function to check if a parameter should be positional
-function isPositional(schema) {
-    // Check the current schema first
-    if (schema._def.positionalMeta?.positional) {
-        return true;
-    }
-    // If this is a ZodOptional, check the inner type
-    if (schema instanceof zod_1.z.ZodOptional) {
-        return isPositional(schema._def.innerType);
-    }
-    // If this is a ZodDefault, check the inner type
-    if (schema instanceof zod_1.z.ZodDefault) {
-        return isPositional(schema._def.innerType);
-    }
-    return false;
-}

package/dist/schemas/Action.d.ts

@@ -1,21 +0,0 @@
-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

@@ -1,31 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-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

@@ -1,32 +0,0 @@
-"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

@@ -1,27 +0,0 @@
-import { z } from "zod";
-export declare const AuthItemSchema: z.ZodObject<{
-    id: z.ZodNumber;
-    title: 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;
-    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;
-    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>;

package/dist/schemas/Auth.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthItemSchema = void 0;
-const zod_1 = require("zod");
-const schema_utils_1 = require("../schema-utils");
-// ============================================================================
-// Auth Schemas
-// ============================================================================
-exports.AuthItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
-    id: zod_1.z.number(),
-    title: zod_1.z.string().optional(),
-    identifier: zod_1.z.string().optional(),
-    account_id: zod_1.z.string().optional(),
-    is_private: zod_1.z.boolean().optional(),
-    shared_with_all: zod_1.z.boolean().optional(),
-    marked_stale_at: zod_1.z.string().optional(),
-}), {
-    format: (item) => {
-        const details = [];
-        if (item.identifier) {
-            details.push({
-                text: `Identifier: ${item.identifier}`,
-                style: "accent",
-            });
-        }
-        details.push({
-            text: `Account: ${item.account_id || "unknown"} | Private: ${item.is_private || false} | Shared: ${item.shared_with_all || false}`,
-            style: "dim",
-        });
-        if (item.marked_stale_at) {
-            details.push({
-                text: `⚠️  Marked stale: ${new Date(item.marked_stale_at).toLocaleDateString()}`,
-                style: "warning",
-            });
-        }
-        return {
-            title: item.title || `Authentication ${item.id}`,
-            subtitle: `(ID: ${item.id})`,
-            details,
-        };
-    },
-});

package/dist/schemas/Field.d.ts

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

package/dist/schemas/Field.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldItemSchema = void 0;
-const zod_1 = require("zod");
-const schema_utils_1 = require("../schema-utils");
-// ============================================================================
-// Field Schemas
-// ============================================================================
-exports.FieldItemSchema = (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(),
-}), {
-    format: (item) => {
-        const details = [];
-        if (item.description) {
-            details.push({ text: item.description, style: "dim" });
-        }
-        return {
-            title: item.name || item.key,
-            subtitle: `(${item.key})`,
-            details,
-        };
-    },
-});

package/dist/sdk.d.ts

@@ -1,6 +0,0 @@
-import { BaseSdkOptions } from "./types/domain";
-import type { ZapierSdk } from "./types/sdk";
-export type { ZapierSdk } from "./types/sdk";
-export interface ZapierSdkOptions extends BaseSdkOptions {
-}
-export declare function createZapierSdk(options?: ZapierSdkOptions): ZapierSdk;