@zapier/zapier-sdk 0.4.1 → 0.5.1

package/dist/sdk.test.js

@@ -0,0 +1,135 @@
+// Test the flat plugin system
+import { describe, it, expect } from "vitest";
+import { createZapierSdk, createSdk } from "./sdk";
+describe("Flat Plugin System", () => {
+    it("should create SDK with all expected methods", () => {
+        const sdk = createZapierSdk();
+        // Test that all core methods are available
+        expect(sdk.listApps).toBeDefined();
+        expect(sdk.listAuthentications).toBeDefined();
+        expect(sdk.getAuthentication).toBeDefined();
+        expect(sdk.runAction).toBeDefined();
+        expect(sdk.request).toBeDefined();
+        // Test that plugin methods are available
+        expect(sdk.fetch).toBeDefined();
+        expect(sdk.apps).toBeDefined();
+        expect(sdk.getProfile).toBeDefined();
+        // Test that getContext method is available
+        expect(sdk.getContext).toBeDefined();
+        expect(typeof sdk.getContext).toBe("function");
+    });
+    it("should have getContext method that returns context", () => {
+        const sdk = createZapierSdk();
+        const context = sdk.getContext(); // Type assertion to work around complex context inference
+        // Context should be an object
+        expect(typeof context).toBe("object");
+        expect(context).not.toBeNull();
+        // Context should have some properties (specific properties depend on plugin composition)
+        expect(Object.keys(context).length).toBeGreaterThan(0);
+        // Should have meta object
+        expect(context.meta).toBeDefined();
+        expect(typeof context.meta).toBe("object");
+        // Should have getProfile metadata from the plugin (verify it exists in meta)
+        expect("getProfile" in context.meta).toBe(true);
+        expect(context.meta.getProfile).toBeDefined();
+        expect(context.meta.getProfile.inputSchema).toBeDefined();
+    });
+    it("should have plugins return flat structure", () => {
+        const sdk = createZapierSdk();
+        // fetch should be directly available (not sdk.plugins.fetch or sdk.fetch.fetch)
+        expect(typeof sdk.fetch).toBe("function");
+        // apps should be directly available
+        expect(typeof sdk.apps).toBe("object");
+        // getProfile should be directly available
+        expect(typeof sdk.getProfile).toBe("function");
+    });
+    it("should support fluent plugin chaining with createSdk", () => {
+        // Test that createSdk().addPlugin().addPlugin() works and returns properly typed SDK
+        const testPlugin = () => ({
+            testMethod: () => "test result",
+        });
+        const sdk = createSdk().addPlugin(testPlugin);
+        // Should have getContext method
+        expect(typeof sdk.getContext).toBe("function");
+        // Should have addPlugin method for further chaining
+        expect(typeof sdk.addPlugin).toBe("function");
+        // Should have the plugin method
+        expect(typeof sdk.testMethod).toBe("function");
+        expect(sdk.testMethod()).toBe("test result");
+    });
+    it("should support fluent plugin chaining without .getSdk()", () => {
+        // This demonstrates the simplified API - no .getSdk() needed!
+        const plugin1 = () => ({ method1: () => "method1" });
+        const plugin2 = () => ({ method2: () => "method2" });
+        // Fluent chaining - each addPlugin returns a new SDK
+        const sdk = createSdk().addPlugin(plugin1).addPlugin(plugin2);
+        expect(sdk.method1()).toBe("method1");
+        expect(sdk.method2()).toBe("method2");
+        expect(typeof sdk.getContext).toBe("function");
+        expect(typeof sdk.addPlugin).toBe("function"); // Can still add more plugins!
+    });
+    it("should support plugins with options", () => {
+        // Test that addPlugin(pluginFn, options) works correctly
+        const pluginWithOptions = (params) => ({
+            getMessage: () => params.message,
+        });
+        const sdk = createSdk().addPlugin(pluginWithOptions, {
+            message: "Hello from options!",
+        });
+        expect(typeof sdk.getMessage).toBe("function");
+        expect(sdk.getMessage()).toBe("Hello from options!");
+    });
+    it("should merge context.meta from multiple plugins", () => {
+        // Test that multiple plugins can provide meta without overwriting each other
+        const plugin1 = () => ({
+            method1: () => "method1",
+            context: {
+                meta: {
+                    plugin1: { info: "Plugin 1 metadata" },
+                },
+            },
+        });
+        const plugin2 = () => ({
+            method2: () => "method2",
+            context: {
+                meta: {
+                    plugin2: { info: "Plugin 2 metadata" },
+                },
+            },
+        });
+        const sdk = createSdk().addPlugin(plugin1).addPlugin(plugin2);
+        const context = sdk.getContext();
+        // Both plugins should have their meta preserved
+        expect(context.meta.plugin1.info).toBe("Plugin 1 metadata");
+        expect(context.meta.plugin2.info).toBe("Plugin 2 metadata");
+        // Both methods should work
+        expect(sdk.method1()).toBe("method1");
+        expect(sdk.method2()).toBe("method2");
+    });
+    it("should support context requirements for cleaner plugin definitions", () => {
+        // Test context requirements work correctly
+        const pluginWithHelper = ({ sdk, context }) => ({
+            helperMethod: () => `Helper: ${sdk.existingMethod()} + ${context.customContext}`,
+        });
+        const baseSdk = { existingMethod: () => "base" };
+        const baseContext = { customContext: "custom", meta: {} };
+        const sdk = createSdk(baseSdk, baseContext).addPlugin(pluginWithHelper);
+        expect(sdk.helperMethod()).toBe("Helper: base + custom");
+        expect(sdk.existingMethod()).toBe("base"); // Original method still works
+    });
+    it("should ensure context.meta is always available", () => {
+        // Test that context.meta is always at least an empty object, even without explicit initialization
+        const plugin = ({ context }) => ({
+            testMethod: () => `Meta keys: ${Object.keys(context.meta).length}`,
+        });
+        // Create SDK without explicitly providing meta
+        const sdk = createSdk({}).addPlugin(plugin);
+        // Should work without error - meta should be at least an empty object
+        expect(sdk.testMethod()).toBe("Meta keys: 0");
+        // getContext() should also provide meta
+        const context = sdk.getContext();
+        expect(context.meta).toBeDefined();
+        expect(typeof context.meta).toBe("object");
+        expect(context.meta).not.toBeNull();
+    });
+});

package/dist/types/domain.d.ts

@@ -0,0 +1,36 @@
+import type { z } from "zod";
+/**
+ * Domain model types - representing business entities returned by SDK functions
+ * These types are inferred from Item schemas and represent transformed/formatted data.
+ */
+import type { AppItemSchema } from "../schemas/App";
+import type { AuthenticationItemSchema } from "../schemas/Auth";
+import type { ActionItemSchema } from "../schemas/Action";
+import type { InputFieldItemSchema } from "../schemas/Field";
+import type { UserProfileItemSchema } from "../schemas/UserProfile";
+/**
+ * Represents an app item returned by getApp and listApps functions
+ * Inferred from AppItemSchema which extends the base App API schema
+ */
+export type AppItem = z.infer<typeof AppItemSchema>;
+/**
+ * Represents an authentication item returned by listAuthentications functions
+ * Inferred from AuthenticationItemSchema which extends the base Authentication API schema
+ */
+export type AuthenticationItem = z.infer<typeof AuthenticationItemSchema>;
+/**
+ * Represents an action item returned by listActions functions
+ * Inferred from ActionItemSchema which extends the base Action API schema
+ */
+export type ActionItem = z.infer<typeof ActionItemSchema>;
+/**
+ * Represents an input field item returned by listInputFields functions
+ * Inferred from InputFieldItemSchema which extends the base Need API schema
+ */
+export type InputFieldItem = z.infer<typeof InputFieldItemSchema>;
+/**
+ * Represents a user profile item returned by getProfile function
+ * Inferred from UserProfileItemSchema which extends the base UserProfile API schema
+ */
+export type UserProfileItem = z.infer<typeof UserProfileItemSchema>;
+//# sourceMappingURL=domain.d.ts.map

package/dist/types/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../src/types/domain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAEpE;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/types/domain.js

@@ -0,0 +1 @@
+export {};

package/dist/types/domain.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=domain.test.d.ts.map

package/dist/types/domain.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.test.d.ts","sourceRoot":"","sources":["../../src/types/domain.test.ts"],"names":[],"mappings":""}

package/dist/types/domain.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { splitVersionedKey } from "../utils/domain-utils";
+describe("splitVersionedKey", () => {
+    it("should split versioned key with version", () => {
+        const [baseKey, version] = splitVersionedKey("SlackCLIAPI@1.21.1");
+        expect(baseKey).toBe("SlackCLIAPI");
+        expect(version).toBe("1.21.1");
+    });
+    it("should split versioned key with complex version", () => {
+        const [baseKey, version] = splitVersionedKey("GoogleSheetsAPI@2.5.0-beta.1");
+        expect(baseKey).toBe("GoogleSheetsAPI");
+        expect(version).toBe("2.5.0-beta.1");
+    });
+    it("should handle versioned key without version", () => {
+        const [baseKey, version] = splitVersionedKey("SomeAPI");
+        expect(baseKey).toBe("SomeAPI");
+        expect(version).toBeUndefined();
+    });
+    it("should handle versioned key with multiple @ symbols", () => {
+        const [baseKey, version] = splitVersionedKey("ComplexAPI@1.0.0@beta");
+        expect(baseKey).toBe("ComplexAPI");
+        expect(version).toBe("1.0.0@beta");
+    });
+    it("should handle edge case with many @ symbols", () => {
+        const [baseKey, version] = splitVersionedKey("API@with@multiple@at@symbols@1.2.3");
+        expect(baseKey).toBe("API");
+        expect(version).toBe("with@multiple@at@symbols@1.2.3");
+    });
+    it("should handle empty string", () => {
+        const [baseKey, version] = splitVersionedKey("");
+        expect(baseKey).toBe("");
+        expect(version).toBeUndefined();
+    });
+    it("should handle string that starts with @", () => {
+        const [baseKey, version] = splitVersionedKey("@version");
+        expect(baseKey).toBe("");
+        expect(version).toBe("version");
+    });
+});

package/dist/types/errors.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Standard error format returned by the Zapier API
+ */
+export interface ApiError {
+    status: number;
+    code: string;
+    title: string;
+    detail: string;
+    source?: any;
+    meta?: any;
+}
+/**
+ * Base options for all error constructors
+ */
+export interface ErrorOptions {
+    statusCode?: number;
+    errors?: ApiError[];
+    cause?: unknown;
+    response?: any;
+}
+/**
+ * Base class for all Zapier SDK errors
+ * Use instanceof ZapierError to check if an error is from the SDK
+ */
+export declare abstract class ZapierError extends Error {
+    abstract readonly name: string;
+    statusCode?: number;
+    errors?: ApiError[];
+    cause?: unknown;
+    response?: any;
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when API requests fail
+ */
+export declare class ZapierApiError extends ZapierError {
+    readonly name = "ZapierApiError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when an app is not found
+ */
+export declare class ZapierAppNotFoundError extends ZapierError {
+    readonly name = "ZapierAppNotFoundError";
+    appKey?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        appKey?: string;
+    });
+}
+/**
+ * Error thrown when validation fails (e.g., invalid parameters)
+ */
+export declare class ZapierValidationError extends ZapierError {
+    readonly name = "ZapierValidationError";
+    details?: any;
+    constructor(message: string, options?: ErrorOptions & {
+        details?: any;
+    });
+}
+/**
+ * Error for unrecognized/unknown errors that get wrapped by safe functions
+ */
+export declare class ZapierUnknownError extends ZapierError {
+    readonly name = "ZapierUnknownError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown for authentication and authorization failures (401/403)
+ */
+export declare class ZapierAuthenticationError extends ZapierError {
+    readonly name = "ZapierAuthenticationError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when a requested resource is not found
+ */
+export declare class ZapierResourceNotFoundError extends ZapierError {
+    readonly name = "ZapierResourceNotFoundError";
+    resourceType?: string;
+    resourceId?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        resourceType?: string;
+        resourceId?: string;
+    });
+}
+/**
+ * Error thrown when required app or implementation configuration is missing
+ */
+export declare class ZapierConfigurationError extends ZapierError {
+    readonly name = "ZapierConfigurationError";
+    configType?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        configType?: string;
+    });
+}
+/**
+ * Error thrown when code bundling or compilation fails
+ */
+export declare class ZapierBundleError extends ZapierError {
+    readonly name = "ZapierBundleError";
+    buildErrors?: string[];
+    constructor(message: string, options?: ErrorOptions & {
+        buildErrors?: string[];
+    });
+}
+/**
+ * Error thrown when operations timeout or exceed retry limits
+ */
+export declare class ZapierTimeoutError extends ZapierError {
+    readonly name = "ZapierTimeoutError";
+    attempts?: number;
+    maxAttempts?: number;
+    constructor(message: string, options?: ErrorOptions & {
+        attempts?: number;
+        maxAttempts?: number;
+    });
+}
+/**
+ * Error thrown when action execution fails due to errors returned from the third-party service
+ * This happens when the Actions API returns a 200 status but includes errors in the response
+ */
+export declare class ZapierActionError extends ZapierError {
+    readonly name = "ZapierActionError";
+    appKey?: string;
+    actionKey?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        appKey?: string;
+        actionKey?: string;
+    });
+    get actionErrors(): ApiError[] | undefined;
+}
+/**
+ * Error thrown when a resource is not found (404)
+ */
+export declare class ZapierNotFoundError extends ZapierError {
+    readonly name = "ZapierNotFoundError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Utility function to format error messages for display
+ */
+export declare function formatErrorMessage(error: ZapierError): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED;;;GAGG;AACH,8BAAsB,WAAY,SAAQ,KAAK;IAC7C,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,GAAG,CAAC;gBAEV,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB;CASxD;AAED;;GAEG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,QAAQ,CAAC,IAAI,oBAAoB;gBAErB,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB;CAGxD;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,WAAW;IACrD,QAAQ,CAAC,IAAI,4BAA4B;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;gBAGrB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,YAAY,GAAG;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAO;CAKnD;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,WAAW;IACpD,QAAQ,CAAC,IAAI,2BAA2B;IACjC,OAAO,CAAC,EAAE,GAAG,CAAC;gBAET,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAY,GAAG;QAAE,OAAO,CAAC,EAAE,GAAG,CAAA;KAAO;CAI5E;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,WAAW;IACjD,QAAQ,CAAC,IAAI,wBAAwB;gBAEzB,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB;CAGxD;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,WAAW;IACxD,QAAQ,CAAC,IAAI,+BAA+B;gBAEhC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB;CAGxD;AAED;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,WAAW;IAC1D,QAAQ,CAAC,IAAI,iCAAiC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;gBAGzB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,YAAY,GAAG;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO;CAM9E;AAED;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,WAAW;IACvD,QAAQ,CAAC,IAAI,8BAA8B;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;gBAGzB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,YAAY,GAAG;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO;CAKvD;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,QAAQ,CAAC,IAAI,uBAAuB;IAC7B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;gBAG5B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,YAAY,GAAG;QAAE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO;CAK1D;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,WAAW;IACjD,QAAQ,CAAC,IAAI,wBAAwB;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;gBAG1B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,YAAY,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;CAM3E;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,QAAQ,CAAC,IAAI,uBAAuB;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;gBAGxB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,YAAY,GAAG;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO;IAQtE,IAAI,YAAY,2BAEf;CACF;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;IAClD,QAAQ,CAAC,IAAI,yBAAyB;gBAE1B,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB;CAGxD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CA8D7D"}

package/dist/types/errors.js

@@ -0,0 +1,187 @@
+/**
+ * Base class for all Zapier SDK errors
+ * Use instanceof ZapierError to check if an error is from the SDK
+ */
+export class ZapierError extends Error {
+    constructor(message, options = {}) {
+        super(message);
+        this.statusCode = options.statusCode;
+        this.errors = options.errors;
+        this.cause = options.cause;
+        this.response = options.response;
+        // Maintain proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Error thrown when API requests fail
+ */
+export class ZapierApiError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierApiError";
+    }
+}
+/**
+ * Error thrown when an app is not found
+ */
+export class ZapierAppNotFoundError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierAppNotFoundError";
+        this.appKey = options.appKey;
+    }
+}
+/**
+ * Error thrown when validation fails (e.g., invalid parameters)
+ */
+export class ZapierValidationError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierValidationError";
+        this.details = options.details;
+    }
+}
+/**
+ * Error for unrecognized/unknown errors that get wrapped by safe functions
+ */
+export class ZapierUnknownError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierUnknownError";
+    }
+}
+/**
+ * Error thrown for authentication and authorization failures (401/403)
+ */
+export class ZapierAuthenticationError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierAuthenticationError";
+    }
+}
+/**
+ * Error thrown when a requested resource is not found
+ */
+export class ZapierResourceNotFoundError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierResourceNotFoundError";
+        this.resourceType = options.resourceType;
+        this.resourceId = options.resourceId;
+    }
+}
+/**
+ * Error thrown when required app or implementation configuration is missing
+ */
+export class ZapierConfigurationError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierConfigurationError";
+        this.configType = options.configType;
+    }
+}
+/**
+ * Error thrown when code bundling or compilation fails
+ */
+export class ZapierBundleError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierBundleError";
+        this.buildErrors = options.buildErrors;
+    }
+}
+/**
+ * Error thrown when operations timeout or exceed retry limits
+ */
+export class ZapierTimeoutError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierTimeoutError";
+        this.attempts = options.attempts;
+        this.maxAttempts = options.maxAttempts;
+    }
+}
+/**
+ * Error thrown when action execution fails due to errors returned from the third-party service
+ * This happens when the Actions API returns a 200 status but includes errors in the response
+ */
+export class ZapierActionError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierActionError";
+        this.appKey = options.appKey;
+        this.actionKey = options.actionKey;
+    }
+    // Legacy accessor for backward compatibility
+    get actionErrors() {
+        return this.errors;
+    }
+}
+/**
+ * Error thrown when a resource is not found (404)
+ */
+export class ZapierNotFoundError extends ZapierError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "ZapierNotFoundError";
+    }
+}
+/**
+ * Utility function to format error messages for display
+ */
+export function formatErrorMessage(error) {
+    let message = error.message;
+    // Add additional context from errors array if available
+    if (error.errors && error.errors.length > 0) {
+        const additionalErrors = error.errors.slice(1); // Skip first error (already in message)
+        if (additionalErrors.length > 0) {
+            const errorDetails = additionalErrors
+                .map((err) => `  • ${err.detail || err.title || err.code}`)
+                .join("\n");
+            message += "\n\nAdditional errors:\n" + errorDetails;
+        }
+    }
+    // Add error-specific context
+    if (error instanceof ZapierAppNotFoundError && error.appKey) {
+        message += `\nApp key: ${error.appKey}`;
+    }
+    if (error instanceof ZapierActionError && (error.appKey || error.actionKey)) {
+        const context = [];
+        if (error.appKey)
+            context.push(`App: ${error.appKey}`);
+        if (error.actionKey)
+            context.push(`Action: ${error.actionKey}`);
+        message += `\n${context.join(", ")}`;
+    }
+    if (error instanceof ZapierResourceNotFoundError &&
+        (error.resourceType || error.resourceId)) {
+        const context = [];
+        if (error.resourceType)
+            context.push(`Type: ${error.resourceType}`);
+        if (error.resourceId)
+            context.push(`ID: ${error.resourceId}`);
+        message += `\n${context.join(", ")}`;
+    }
+    if (error instanceof ZapierTimeoutError &&
+        (error.attempts || error.maxAttempts)) {
+        const context = [];
+        if (error.attempts)
+            context.push(`Attempts: ${error.attempts}`);
+        if (error.maxAttempts)
+            context.push(`Max attempts: ${error.maxAttempts}`);
+        message += `\n${context.join(", ")}`;
+    }
+    if (error instanceof ZapierBundleError &&
+        error.buildErrors &&
+        error.buildErrors.length > 0) {
+        message +=
+            "\n\nBuild errors:\n" +
+                error.buildErrors.map((err) => `  • ${err}`).join("\n");
+    }
+    // Add status code if available and not already obvious from the message
+    if (error.statusCode && !message.includes(`${error.statusCode}`)) {
+        message += `\nHTTP Status: ${error.statusCode}`;
+    }
+    return message;
+}

package/dist/types/events.d.ts

@@ -0,0 +1,38 @@
+/**
+ * SDK Event System
+ *
+ * This module provides common event type definitions for the SDK's
+ * event system, including authentication, API, and loading events.
+ */
+export interface SdkEvent {
+    type: string;
+    payload?: Record<string, any>;
+    timestamp?: number;
+}
+export interface AuthEvent extends SdkEvent {
+    type: "auth_refreshing" | "auth_success" | "auth_error" | "auth_logout";
+    payload?: {
+        message?: string;
+        error?: string;
+        operation?: string;
+    };
+}
+export interface ApiEvent extends SdkEvent {
+    type: "api_request" | "api_response" | "api_error";
+    payload?: {
+        url?: string;
+        method?: string;
+        status?: number;
+        duration?: number;
+        error?: string;
+    };
+}
+export interface LoadingEvent extends SdkEvent {
+    type: "loading_start" | "loading_end";
+    payload?: {
+        operation?: string;
+        resource?: string;
+    };
+}
+export type EventCallback = (event: SdkEvent) => void;
+//# sourceMappingURL=events.d.ts.map

package/dist/types/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/types/events.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,SAAU,SAAQ,QAAQ;IACzC,IAAI,EAAE,iBAAiB,GAAG,cAAc,GAAG,YAAY,GAAG,aAAa,CAAC;IACxE,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH;AAED,MAAM,WAAW,QAAS,SAAQ,QAAQ;IACxC,IAAI,EAAE,aAAa,GAAG,cAAc,GAAG,WAAW,CAAC;IACnD,OAAO,CAAC,EAAE;QACR,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAED,MAAM,WAAW,YAAa,SAAQ,QAAQ;IAC5C,IAAI,EAAE,eAAe,GAAG,aAAa,CAAC;IACtC,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC"}

package/dist/types/events.js

@@ -0,0 +1,7 @@
+/**
+ * SDK Event System
+ *
+ * This module provides common event type definitions for the SDK's
+ * event system, including authentication, API, and loading events.
+ */
+export {};

package/dist/types/functions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Function-related types and interfaces
+ */
+export interface FunctionOptions {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Function to dynamically resolve authentication token */
+    getToken?: () => Promise<string | undefined>;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+}
+export type PaginatedSdkFunction<TOptions, TItem> = (options: TOptions) => Promise<{
+    data: TItem[];
+}> & AsyncIterable<{
+    data: TItem[];
+    nextCursor?: string;
+}> & {
+    items(): AsyncIterable<TItem>;
+};
+//# sourceMappingURL=functions.d.ts.map

package/dist/types/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../src/types/functions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,MAAM,WAAW,eAAe;IAC9B,8BAA8B;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C,2CAA2C;IAC3C,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kCAAkC;IAClC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAGD,MAAM,MAAM,oBAAoB,CAAC,QAAQ,EAAE,KAAK,IAAI,CAClD,OAAO,EAAE,QAAQ,KACd,OAAO,CAAC;IAAE,IAAI,EAAE,KAAK,EAAE,CAAA;CAAE,CAAC,GAC7B,aAAa,CAAC;IAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG;IACtD,KAAK,IAAI,aAAa,CAAC,KAAK,CAAC,CAAC;CAC/B,CAAC"}

package/dist/types/functions.js

@@ -0,0 +1,4 @@
+/**
+ * Function-related types and interfaces
+ */
+export {};