@zapier/zapier-sdk 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from "../../shared-sdk/dist";
-export * from "../../actions-sdk/dist";
-export { createZapierSDK, ZapierSDK, ZapierSDKOptions } from "./sdk";
+export * from "./types";
+export * from "./actions-sdk";
+export { createZapierSdk, ZapierSdk, ZapierSdkOptions } from "./sdk";

package/dist/index.js

@@ -14,10 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZapierSDK = void 0;
-// Export everything from shared and actions
-__exportStar(require("../../shared-sdk/dist"), exports);
-__exportStar(require("../../actions-sdk/dist"), exports);
+exports.createZapierSdk = void 0;
+// Export everything from types and actions-sdk
+__exportStar(require("./types"), exports);
+__exportStar(require("./actions-sdk"), exports);
 // Export the main combined SDK
 var sdk_1 = require("./sdk");
-Object.defineProperty(exports, "createZapierSDK", { enumerable: true, get: function () { return sdk_1.createZapierSDK; } });
+Object.defineProperty(exports, "createZapierSdk", { enumerable: true, get: function () { return sdk_1.createZapierSdk; } });

package/dist/output-schemas.d.ts

@@ -0,0 +1,95 @@
+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 withOutputSchema<T extends z.ZodType>(inputSchema: T, outputSchema: z.ZodType): T;
+export declare function getFormatMetadata(schema: z.ZodType): FormatMetadata | undefined;
+export declare function getOutputSchema(inputSchema: z.ZodType): z.ZodType | undefined;
+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 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;
+    name?: string | undefined;
+    description?: string | undefined;
+    appKey?: string | undefined;
+}, {
+    type: string;
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    appKey?: string | undefined;
+}>;
+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 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 AppItem = z.infer<typeof AppItemSchema>;
+export type ActionItem = z.infer<typeof ActionItemSchema>;
+export type AuthItem = z.infer<typeof AuthItemSchema>;
+export type FieldItem = z.infer<typeof FieldItemSchema>;

package/dist/output-schemas.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldItemSchema = exports.AuthItemSchema = exports.ActionItemSchema = exports.AppItemSchema = void 0;
+exports.withOutputSchema = withOutputSchema;
+exports.getFormatMetadata = getFormatMetadata;
+exports.getOutputSchema = getOutputSchema;
+const zod_1 = require("zod");
+// ============================================================================
+// Schema Enhancement Helpers
+// ============================================================================
+// 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 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 format metadata from a schema
+function getFormatMetadata(schema) {
+    return schema._def.formatMeta;
+}
+// Helper function to get output schema from an input schema
+function getOutputSchema(inputSchema) {
+    return inputSchema._def.outputSchema;
+}
+// ============================================================================
+// Output Item Schemas
+// ============================================================================
+exports.AppItemSchema = 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,
+        };
+    },
+});
+exports.ActionItemSchema = 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,
+        };
+    },
+});
+exports.AuthItemSchema = withFormatter(zod_1.z.object({
+    id: zod_1.z.number(),
+    title: zod_1.z.string().optional(),
+    label: 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",
+            });
+        }
+        if (item.label && item.title && item.label !== item.title) {
+            details.push({
+                text: `Label: ${item.label}`,
+                style: "normal",
+            });
+        }
+        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 || item.label || `Authentication ${item.id}`,
+            subtitle: `(ID: ${item.id})`,
+            details,
+        };
+    },
+});
+exports.FieldItemSchema = 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/schemas.d.ts

@@ -0,0 +1,338 @@
+import { z } from "zod";
+export interface StaticResolver {
+    type: "static";
+    inputType?: "input" | "password" | "editor";
+    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 interface ResolverMetadata {
+    resolver?: StaticResolver | DynamicResolver | FieldsResolver;
+}
+export declare const AppsListSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    category: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    category?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    category?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const AppsGetSchema: z.ZodObject<{
+    key: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+}, {
+    key: string;
+}>;
+export declare const FieldsListSchema: z.ZodObject<{
+    app: z.ZodString;
+    type: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    action: z.ZodString;
+    authId: z.ZodOptional<z.ZodNumber>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    action: string;
+    type: "create" | "update" | "search" | "delete" | "read" | "write";
+    app: string;
+    params?: Record<string, any> | undefined;
+    authId?: number | undefined;
+}, {
+    action: string;
+    type: "create" | "update" | "search" | "delete" | "read" | "write";
+    app: string;
+    params?: Record<string, any> | undefined;
+    authId?: number | undefined;
+}>;
+export declare const ActionsListSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+}, {
+    appKey: string;
+    type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+}>;
+export declare const ActionsGetSchema: z.ZodObject<{
+    app: z.ZodString;
+    type: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    action: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    action: string;
+    type: "create" | "update" | "search" | "delete" | "read" | "write";
+    app: string;
+}, {
+    action: string;
+    type: "create" | "update" | "search" | "delete" | "read" | "write";
+    app: string;
+}>;
+export declare const ActionsRunSchema: z.ZodObject<{
+    app: z.ZodString;
+    type: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    action: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    authId: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    action: string;
+    type: "create" | "update" | "search" | "delete" | "read" | "write";
+    app: string;
+    authId?: number | undefined;
+    inputs?: Record<string, any> | undefined;
+}, {
+    action: string;
+    type: "create" | "update" | "search" | "delete" | "read" | "write";
+    app: string;
+    authId?: number | undefined;
+    inputs?: Record<string, any> | undefined;
+}>;
+export declare const AuthsListSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    appKey: z.ZodString;
+    account_id: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    account_id?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    owner?: string | undefined;
+}, {
+    appKey: string;
+    account_id?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    owner?: string | undefined;
+}>;
+export declare const AuthsFindSchema: z.ZodObject<{
+    appKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+}, {
+    appKey: string;
+}>;
+export declare const GenerateSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    token: z.ZodOptional<z.ZodString>;
+    authId: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodString>;
+    debug: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    debug: boolean;
+    authId?: number | undefined;
+    token?: string | undefined;
+    output?: string | undefined;
+}, {
+    appKey: string;
+    authId?: number | undefined;
+    token?: string | undefined;
+    output?: string | undefined;
+    debug?: boolean | undefined;
+}>;
+export declare const BundleSchema: z.ZodObject<{
+    input: z.ZodString;
+    output: z.ZodOptional<z.ZodString>;
+    string: z.ZodDefault<z.ZodBoolean>;
+    minify: z.ZodDefault<z.ZodBoolean>;
+    target: z.ZodDefault<z.ZodString>;
+    cjs: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    string: boolean;
+    input: string;
+    minify: boolean;
+    target: string;
+    cjs: boolean;
+    output?: string | undefined;
+}, {
+    input: string;
+    string?: boolean | undefined;
+    output?: string | undefined;
+    minify?: boolean | undefined;
+    target?: string | undefined;
+    cjs?: boolean | undefined;
+}>;
+export declare const SdkSchemas: {
+    readonly apps: {
+        readonly list: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+            category: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            category?: string | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }, {
+            category?: string | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }>;
+        readonly get: z.ZodObject<{
+            key: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+        }, {
+            key: string;
+        }>;
+    };
+    readonly actions: {
+        readonly list: z.ZodObject<{
+            appKey: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>>;
+        }, "strip", z.ZodTypeAny, {
+            appKey: string;
+            type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+        }, {
+            appKey: string;
+            type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+        }>;
+        readonly get: z.ZodObject<{
+            app: z.ZodString;
+            type: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+            action: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            action: string;
+            type: "create" | "update" | "search" | "delete" | "read" | "write";
+            app: string;
+        }, {
+            action: string;
+            type: "create" | "update" | "search" | "delete" | "read" | "write";
+            app: string;
+        }>;
+        readonly run: z.ZodObject<{
+            app: z.ZodString;
+            type: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+            action: z.ZodString;
+            inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            authId: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            action: string;
+            type: "create" | "update" | "search" | "delete" | "read" | "write";
+            app: string;
+            authId?: number | undefined;
+            inputs?: Record<string, any> | undefined;
+        }, {
+            action: string;
+            type: "create" | "update" | "search" | "delete" | "read" | "write";
+            app: string;
+            authId?: number | undefined;
+            inputs?: Record<string, any> | undefined;
+        }>;
+    };
+    readonly auths: {
+        readonly list: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+            appKey: z.ZodString;
+            account_id: z.ZodOptional<z.ZodString>;
+            owner: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            appKey: string;
+            account_id?: string | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+            owner?: string | undefined;
+        }, {
+            appKey: string;
+            account_id?: string | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+            owner?: string | undefined;
+        }>;
+        readonly find: z.ZodObject<{
+            appKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            appKey: string;
+        }, {
+            appKey: string;
+        }>;
+    };
+    readonly fields: {
+        readonly list: z.ZodObject<{
+            app: z.ZodString;
+            type: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+            action: z.ZodString;
+            authId: z.ZodOptional<z.ZodNumber>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            action: string;
+            type: "create" | "update" | "search" | "delete" | "read" | "write";
+            app: string;
+            params?: Record<string, any> | undefined;
+            authId?: number | undefined;
+        }, {
+            action: string;
+            type: "create" | "update" | "search" | "delete" | "read" | "write";
+            app: string;
+            params?: Record<string, any> | undefined;
+            authId?: number | undefined;
+        }>;
+    };
+    readonly generate: z.ZodObject<{
+        appKey: z.ZodString;
+        token: z.ZodOptional<z.ZodString>;
+        authId: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodString>;
+        debug: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        appKey: string;
+        debug: boolean;
+        authId?: number | undefined;
+        token?: string | undefined;
+        output?: string | undefined;
+    }, {
+        appKey: string;
+        authId?: number | undefined;
+        token?: string | undefined;
+        output?: string | undefined;
+        debug?: boolean | undefined;
+    }>;
+    readonly bundle: z.ZodObject<{
+        input: z.ZodString;
+        output: z.ZodOptional<z.ZodString>;
+        string: z.ZodDefault<z.ZodBoolean>;
+        minify: z.ZodDefault<z.ZodBoolean>;
+        target: z.ZodDefault<z.ZodString>;
+        cjs: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        string: boolean;
+        input: string;
+        minify: boolean;
+        target: string;
+        cjs: boolean;
+        output?: string | undefined;
+    }, {
+        input: string;
+        string?: boolean | undefined;
+        output?: string | undefined;
+        minify?: boolean | undefined;
+        target?: string | undefined;
+        cjs?: boolean | undefined;
+    }>;
+};
+export type AppsListOptions = z.infer<typeof AppsListSchema>;
+export type AppsGetOptions = z.infer<typeof AppsGetSchema>;
+export type ActionsListOptions = z.infer<typeof ActionsListSchema>;
+export type ActionsGetOptions = z.infer<typeof ActionsGetSchema>;
+export type ActionsRunOptions = z.infer<typeof ActionsRunSchema>;
+export type AuthsListOptions = z.infer<typeof AuthsListSchema>;
+export type AuthsFindOptions = z.infer<typeof AuthsFindSchema>;
+export type FieldsListOptions = z.infer<typeof FieldsListSchema>;
+export type GenerateOptions = z.infer<typeof GenerateSchema>;
+export type BundleOptions = z.infer<typeof BundleSchema>;
+export declare function getSchemaDescription(schema: z.ZodSchema): string | undefined;
+export declare function getFieldDescriptions(schema: z.ZodObject<any>): Record<string, string>;