@zapier/zapier-sdk 0.18.4 → 0.19.0

package/dist/api/auth.test.js

@@ -1,220 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { isJwt, getAuthorizationHeader, extractUserIdsFromJwt } from "./auth";
-describe("api/auth", () => {
-    describe("isJwt", () => {
-        it("should return true for valid JWT tokens", () => {
-            const validJwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c";
-            expect(isJwt(validJwt)).toBe(true);
-        });
-        it("should return true for JWT with minimal valid parts", () => {
-            const minimalJwt = "a.b.c";
-            expect(isJwt(minimalJwt)).toBe(true);
-        });
-        it("should return false for tokens with fewer than 3 parts", () => {
-            expect(isJwt("header.payload")).toBe(false);
-            expect(isJwt("onlyonepart")).toBe(false);
-            expect(isJwt("")).toBe(false);
-        });
-        it("should return false for tokens with more than 3 parts", () => {
-            expect(isJwt("part1.part2.part3.part4")).toBe(false);
-        });
-        it("should return false for tokens with empty parts", () => {
-            expect(isJwt("..")).toBe(false);
-            expect(isJwt(".payload.signature")).toBe(false);
-            expect(isJwt("header..signature")).toBe(false);
-            expect(isJwt("header.payload.")).toBe(false);
-        });
-        it("should return false for tokens with invalid base64url characters", () => {
-            expect(isJwt("header+plus.payload.signature")).toBe(false);
-            expect(isJwt("header.payload/slash.signature")).toBe(false);
-            expect(isJwt("header.payload=padding.signature")).toBe(false);
-            expect(isJwt("header.payload with space.signature")).toBe(false);
-        });
-        it("should accept valid base64url characters including dashes and underscores", () => {
-            const validBase64Url = "abc-123_XYZ.def-456_UVW.ghi-789_RST";
-            expect(isJwt(validBase64Url)).toBe(true);
-        });
-    });
-    describe("getAuthorizationHeader", () => {
-        it("should return JWT prefix for valid JWT tokens", () => {
-            const jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U";
-            expect(getAuthorizationHeader(jwt)).toBe(`JWT ${jwt}`);
-        });
-        it("should return Bearer prefix for non-JWT tokens", () => {
-            const apiKey = "sk_test_1234567890abcdef";
-            expect(getAuthorizationHeader(apiKey)).toBe(`Bearer ${apiKey}`);
-        });
-        it("should return Bearer prefix for tokens with wrong number of parts", () => {
-            expect(getAuthorizationHeader("header.payload")).toBe("Bearer header.payload");
-        });
-        it("should return Bearer prefix for empty string", () => {
-            expect(getAuthorizationHeader("")).toBe("Bearer ");
-        });
-    });
-    describe("extractUserIdsFromJwt", () => {
-        function createJwt(payload) {
-            const header = Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" })).toString("base64url");
-            const payloadEncoded = Buffer.from(JSON.stringify(payload)).toString("base64url");
-            const signature = "fake_signature_for_testing";
-            return `${header}.${payloadEncoded}.${signature}`;
-        }
-        it("should return null values for invalid JWT tokens", () => {
-            expect(extractUserIdsFromJwt("not-a-jwt")).toEqual({
-                customuser_id: null,
-                account_id: null,
-            });
-        });
-        it("should return null values for JWT with invalid payload", () => {
-            const invalidJwt = "header.not-valid-base64!.signature";
-            expect(extractUserIdsFromJwt(invalidJwt)).toEqual({
-                customuser_id: null,
-                account_id: null,
-            });
-        });
-        it("should extract customuser_id and account_id from regular JWT", () => {
-            const payload = {
-                sub: "12345",
-                sub_type: "customuser",
-                "zap:acc": "67890",
-            };
-            const jwt = createJwt(payload);
-            expect(extractUserIdsFromJwt(jwt)).toEqual({
-                customuser_id: 12345,
-                account_id: 67890,
-            });
-        });
-        it("should handle numeric sub and zap:acc values", () => {
-            const payload = {
-                sub: 99999,
-                sub_type: "customuser",
-                "zap:acc": 11111,
-            };
-            const jwt = createJwt(payload);
-            expect(extractUserIdsFromJwt(jwt)).toEqual({
-                customuser_id: 99999,
-                account_id: 11111,
-            });
-        });
-        it("should return null customuser_id when sub_type is not customuser", () => {
-            const payload = {
-                sub: "12345",
-                sub_type: "other",
-                "zap:acc": "67890",
-            };
-            const jwt = createJwt(payload);
-            expect(extractUserIdsFromJwt(jwt)).toEqual({
-                customuser_id: null,
-                account_id: 67890,
-            });
-        });
-        it("should return null customuser_id when sub is missing", () => {
-            const payload = {
-                sub_type: "customuser",
-                "zap:acc": "67890",
-            };
-            const jwt = createJwt(payload);
-            expect(extractUserIdsFromJwt(jwt)).toEqual({
-                customuser_id: null,
-                account_id: 67890,
-            });
-        });
-        it("should return null account_id when zap:acc is missing", () => {
-            const payload = {
-                sub: "12345",
-                sub_type: "customuser",
-            };
-            const jwt = createJwt(payload);
-            expect(extractUserIdsFromJwt(jwt)).toEqual({
-                customuser_id: 12345,
-                account_id: null,
-            });
-        });
-        it("should return null values when both fields are missing", () => {
-            const payload = {
-                other_field: "value",
-            };
-            const jwt = createJwt(payload);
-            expect(extractUserIdsFromJwt(jwt)).toEqual({
-                customuser_id: null,
-                account_id: null,
-            });
-        });
-        it("should handle nested JWT for service tokens", () => {
-            const nestedPayload = {
-                sub: "12345",
-                sub_type: "customuser",
-                "zap:acc": "67890",
-            };
-            const nestedJwt = createJwt(nestedPayload);
-            const servicePayload = {
-                sub_type: "service",
-                njwt: nestedJwt,
-            };
-            const serviceJwt = createJwt(servicePayload);
-            expect(extractUserIdsFromJwt(serviceJwt)).toEqual({
-                customuser_id: 12345,
-                account_id: 67890,
-            });
-        });
-        it("should fall back to outer payload when nested JWT is invalid", () => {
-            const servicePayload = {
-                sub_type: "service",
-                njwt: "invalid.jwt",
-                "zap:acc": "99999",
-            };
-            const serviceJwt = createJwt(servicePayload);
-            expect(extractUserIdsFromJwt(serviceJwt)).toEqual({
-                customuser_id: null,
-                account_id: 99999,
-            });
-        });
-        it("should use outer payload when sub_type is service but njwt is missing", () => {
-            const servicePayload = {
-                sub: "12345",
-                sub_type: "service",
-                "zap:acc": "67890",
-            };
-            const serviceJwt = createJwt(servicePayload);
-            expect(extractUserIdsFromJwt(serviceJwt)).toEqual({
-                customuser_id: null,
-                account_id: 67890,
-            });
-        });
-        it("should return null for non-numeric sub values", () => {
-            const payload = {
-                sub: "not-a-number",
-                sub_type: "customuser",
-                "zap:acc": "67890",
-            };
-            const jwt = createJwt(payload);
-            expect(extractUserIdsFromJwt(jwt)).toEqual({
-                customuser_id: null,
-                account_id: 67890,
-            });
-        });
-        it("should return null for non-numeric zap:acc values", () => {
-            const payload = {
-                sub: "12345",
-                sub_type: "customuser",
-                "zap:acc": "not-a-number",
-            };
-            const jwt = createJwt(payload);
-            expect(extractUserIdsFromJwt(jwt)).toEqual({
-                customuser_id: 12345,
-                account_id: null,
-            });
-        });
-        it("should return null for values that parse to NaN", () => {
-            const payload = {
-                sub: "abc",
-                sub_type: "customuser",
-                "zap:acc": "xyz",
-            };
-            const jwt = createJwt(payload);
-            expect(extractUserIdsFromJwt(jwt)).toEqual({
-                customuser_id: null,
-                account_id: null,
-            });
-        });
-    });
-});

package/dist/api/client.d.ts

@@ -1,9 +0,0 @@
-/**
- * API Client Implementation
- *
- * This module contains the core API client implementation, including
- * HTTP method handlers, response processing, and client factory functions.
- */
-import type { ApiClient, ApiClientOptions } from "./types";
-export declare const createZapierApi: (options: ApiClientOptions) => ApiClient;
-//# sourceMappingURL=client.d.ts.map

package/dist/api/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AA4ejB,eAAO,MAAM,eAAe,GAAI,SAAS,gBAAgB,KAAG,SAW3D,CAAC"}

package/dist/api/client.js

@@ -1,356 +0,0 @@
-/**
- * API Client Implementation
- *
- * This module contains the core API client implementation, including
- * HTTP method handlers, response processing, and client factory functions.
- */
-import { getAuthorizationHeader } from "./auth";
-import { createDebugLogger, createDebugFetch } from "./debug";
-import { pollUntilComplete } from "./polling";
-import { resolveAuthToken } from "../auth";
-import { getZapierBaseUrl } from "../utils/url-utils";
-import { ZapierApiError, ZapierAuthenticationError, ZapierValidationError, ZapierNotFoundError, } from "../types/errors";
-// Configuration for paths
-const pathConfig = {
-    // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
-    "/relay": {
-        authHeader: "X-Relay-Authorization",
-        pathPrefix: "/api/v0/sdk/relay",
-    },
-    // e.g. /zapier -> https://sdkapi.zapier.com/api/v0/sdk/zapier/...
-    "/zapier": {
-        authHeader: "Authorization",
-        pathPrefix: "/api/v0/sdk/zapier",
-    },
-};
-class ZapierApiClient {
-    constructor(options) {
-        this.options = options;
-        this.fetch = async (path, init) => {
-            return this.plainFetch(path, init);
-        };
-        this.get = async (path, options = {}) => {
-            return this.fetchJson("GET", path, undefined, options);
-        };
-        this.post = async (path, data, options = {}) => {
-            return this.fetchJson("POST", path, data, options);
-        };
-        this.put = async (path, data, options = {}) => {
-            return this.fetchJson("PUT", path, data, options);
-        };
-        this.delete = async (path, options = {}) => {
-            return this.fetchJson("DELETE", path, undefined, options);
-        };
-        this.poll = async (path, options = {}) => {
-            return pollUntilComplete({
-                fetchPoll: () => this.plainFetch(path, {
-                    method: "GET",
-                    searchParams: options.searchParams,
-                    authRequired: options.authRequired,
-                }),
-                initialDelay: options.initialDelay,
-                timeoutMs: options.timeoutMs,
-                successStatus: options.successStatus,
-                pendingStatus: options.pendingStatus,
-                resultExtractor: options.resultExtractor,
-            });
-        };
-    }
-    // Helper to parse response data
-    async parseResult(response) {
-        try {
-            return { type: "json", data: await response.json() };
-        }
-        catch {
-            return { type: "text", data: await response.text() };
-        }
-    }
-    // Helper to get a token from the different places it could be gotten
-    async getAuthToken() {
-        return resolveAuthToken({
-            token: this.options.token,
-            getToken: this.options.getToken,
-            onEvent: this.options.onEvent,
-            fetch: this.options.fetch,
-            baseUrl: this.options.baseUrl,
-            authBaseUrl: this.options.authBaseUrl,
-            authClientId: this.options.authClientId,
-        });
-    }
-    // Helper to handle responses
-    async handleResponse(params) {
-        const { response, customErrorHandler, wasMissingAuthToken } = params;
-        const { data: responseData } = await this.parseResult(response);
-        if (response.ok) {
-            return responseData;
-        }
-        const errorInfo = {
-            status: response.status,
-            statusText: response.statusText,
-            data: responseData,
-        };
-        // Check for custom error handling first
-        if (customErrorHandler) {
-            const customError = customErrorHandler(errorInfo);
-            if (customError) {
-                // javascript may not respect customErrorHandler return type, so we need to throw a proper error if it's not an Error
-                if (customError instanceof Error) {
-                    throw customError;
-                }
-                else {
-                    throw new Error(`customErrorHandler returned a non-Error: ${JSON.stringify(customError)}`);
-                }
-            }
-        }
-        // Parse the error response
-        const { message, errors } = this.parseErrorResponse(errorInfo);
-        const errorOptions = {
-            statusCode: response.status,
-            errors,
-        };
-        // Use appropriate error type based on status code
-        if (response.status === 404) {
-            throw new ZapierNotFoundError(message, errorOptions);
-        }
-        if (response.status === 401 || response.status === 403) {
-            // If we get a 401/403 error and no auth token was provided, give helpful message
-            if (wasMissingAuthToken) {
-                throw new ZapierAuthenticationError(`Authentication required (HTTP ${response.status}). Please provide a token in options or set ZAPIER_TOKEN environment variable.`, errorOptions);
-            }
-            throw new ZapierAuthenticationError(message, errorOptions);
-        }
-        if (response.status === 400) {
-            throw new ZapierValidationError(message, errorOptions);
-        }
-        // Generic API error for other status codes
-        throw new ZapierApiError(message, errorOptions);
-    }
-    hasErrorArray(data) {
-        return (typeof data === "object" &&
-            data !== null &&
-            "errors" in data &&
-            Array.isArray(data.errors));
-    }
-    // Helper to check if data has API errors
-    isApiErrorArray(dataArray) {
-        const data = dataArray[0];
-        return (typeof data === "object" &&
-            data !== null &&
-            "message" in data &&
-            "code" in data &&
-            "title" in data &&
-            "detail" in data);
-    }
-    // Do our best to extract an error message from the response data
-    extractErrorMessage(data) {
-        if (typeof data === "string") {
-            return data;
-        }
-        if (typeof data === "object" && data !== null) {
-            if ("message" in data && typeof data.message === "string") {
-                return data.message;
-            }
-            if ("error" in data) {
-                if (typeof data.error === "string") {
-                    return data.error;
-                }
-                if (typeof data.error === "object" && data.error !== null) {
-                    if ("message" in data.error &&
-                        typeof data.error.message === "string") {
-                        return data.error.message;
-                    }
-                }
-                try {
-                    return JSON.stringify(data.error);
-                }
-                catch {
-                    /* defend against circular objects, even though they shouldn't be coming back from the wire */
-                }
-            }
-            if ("errors" in data && Array.isArray(data.errors)) {
-                if (this.isApiErrorArray(data.errors)) {
-                    return data.errors[0].detail || data.errors[0].title;
-                }
-                else if (data.errors.length > 0) {
-                    // Handle simple string errors array
-                    const firstError = data.errors[0];
-                    if (typeof firstError === "string") {
-                        return firstError;
-                    }
-                    // For non-string errors, stringify them
-                    try {
-                        return JSON.stringify(firstError);
-                    }
-                    catch {
-                        return String(firstError);
-                    }
-                }
-            }
-        }
-        return undefined;
-    }
-    // Helper to parse API error response
-    parseErrorResponse(errorInfo) {
-        // If we can't parse data, use status text
-        const fallbackMessage = `HTTP ${errorInfo.status}: ${errorInfo.statusText}`;
-        try {
-            // Check if the response has the standard error format
-            if (typeof errorInfo.data === "string") {
-                return { message: `${fallbackMessage}: ${errorInfo.data}` };
-            }
-            const errorMessage = this.extractErrorMessage(errorInfo.data) || fallbackMessage;
-            if (this.hasErrorArray(errorInfo.data)) {
-                if (this.isApiErrorArray(errorInfo.data.errors)) {
-                    return {
-                        message: errorMessage,
-                        errors: errorInfo.data.errors,
-                    };
-                }
-                else {
-                    return {
-                        message: errorMessage,
-                        errors: errorInfo.data.errors.map((e) => ({
-                            status: errorInfo.status,
-                            code: String(errorInfo.status),
-                            title: errorInfo.statusText,
-                            detail: JSON.stringify(e),
-                        })),
-                    };
-                }
-            }
-            return { message: errorMessage };
-        }
-        catch {
-            return { message: fallbackMessage };
-        }
-    }
-    // Apply any special routing logic for configured paths.
-    applyPathConfiguration(path) {
-        // Find matching path configuration.
-        const matchingPathKey = Object.keys(pathConfig).find((configPath) => path === configPath || path.startsWith(configPath + "/"));
-        const config = matchingPathKey ? pathConfig[matchingPathKey] : undefined;
-        // Check if baseUrl is a Zapier-inferred base URL.
-        const zapierBaseUrl = getZapierBaseUrl(this.options.baseUrl);
-        // Let's remain compatible with a base URL that is set to a Zapier-inferred
-        // domain, rather than requiring the base URL to go to our proxy. Later, the
-        // proxy will be removed, so this should make that transition easier.
-        if (zapierBaseUrl === this.options.baseUrl) {
-            // If baseUrl is already the Zapier base URL, use sdkapi subdomain.
-            const originalBaseUrl = new URL(this.options.baseUrl);
-            const finalBaseUrl = `https://sdkapi.${originalBaseUrl.hostname}`;
-            // Only prepend pathPrefix if there's a matching config with pathPrefix.
-            let finalPath = path;
-            if (config &&
-                "pathPrefix" in config &&
-                config.pathPrefix &&
-                matchingPathKey) {
-                // Strip the matching path key, and use the pathPrefix instead.
-                const pathWithoutPrefix = path.slice(matchingPathKey.length) || "/";
-                finalPath = `${config.pathPrefix}${pathWithoutPrefix}`;
-            }
-            return {
-                url: new URL(finalPath, finalBaseUrl),
-                pathConfig: config,
-            };
-        }
-        // For a base URL that isn't a Zapier-inferred domain, use the whole base URL.
-        const baseUrl = new URL(this.options.baseUrl);
-        const fullPath = baseUrl.pathname.replace(/\/$/, "") + path;
-        return {
-            url: new URL(fullPath, baseUrl.origin),
-            pathConfig: config,
-        };
-    }
-    // Helper to build full URLs and return routing info
-    buildUrl(path, searchParams) {
-        const { url, pathConfig: config } = this.applyPathConfiguration(path);
-        if (searchParams) {
-            Object.entries(searchParams).forEach(([key, value]) => {
-                url.searchParams.set(key, value);
-            });
-        }
-        return { url: url.toString(), pathConfig: config };
-    }
-    // Helper to build headers
-    async buildHeaders(options = {}, pathConfig) {
-        const headers = new Headers(options.headers ?? {});
-        // Even if auth is not required, we still want to add it in case it adds
-        // useful context to the API. The session is a good example of this. Auth
-        // is not required, but if we don't add auth, then we won't get the user's
-        // session!
-        const authToken = await this.getAuthToken();
-        if (authToken) {
-            const authHeaderName = pathConfig && pathConfig.authHeader
-                ? pathConfig.authHeader
-                : "Authorization";
-            headers.set(authHeaderName, getAuthorizationHeader(authToken));
-        }
-        // If we know auth is required, and we don't have a token, throw an error
-        // before we even make a request.
-        if (options.authRequired) {
-            if (headers.get("Authorization") == null && authToken == null) {
-                throw new ZapierAuthenticationError(`Authentication required but no token available. Please set ZAPIER_TOKEN, or run the 'login' command with the CLI.`);
-            }
-        }
-        return headers;
-    }
-    // Helper to perform HTTP requests with JSON handling
-    async fetchJson(method, path, data, options = {}) {
-        const headers = { ...options.headers };
-        // Add Content-Type for JSON requests with body data
-        if (data && typeof data === "object") {
-            headers["Content-Type"] = "application/json";
-        }
-        // Check if we have an auth token available
-        const wasMissingAuthToken = options.authRequired && (await this.getAuthToken()) == null;
-        const response = await this.plainFetch(path, {
-            ...options,
-            method,
-            body: data != null ? JSON.stringify(data) : undefined,
-            headers,
-        });
-        // plainFetch already handled all auth and headers
-        const result = await this.handleResponse({
-            response,
-            customErrorHandler: options.customErrorHandler,
-            wasMissingAuthToken,
-        });
-        if (typeof result === "string") {
-            throw new ZapierValidationError(`Response could not be parsed as JSON: ${result}`);
-        }
-        return result;
-    }
-    // Plain fetch method for API paths (must start with /)
-    async plainFetch(path, fetchOptions) {
-        if (!path.startsWith("/")) {
-            throw new ZapierValidationError(`plainFetch expects a path starting with '/', got: ${path}`);
-        }
-        if (fetchOptions?.body && typeof fetchOptions.body === "object") {
-            fetchOptions.body = JSON.stringify(fetchOptions.body);
-        }
-        const { url, pathConfig } = this.buildUrl(path, fetchOptions?.searchParams);
-        const builtHeaders = await this.buildHeaders(fetchOptions, pathConfig);
-        const inputHeaders = new Headers(fetchOptions?.headers ?? {});
-        const mergedHeaders = new Headers();
-        builtHeaders.forEach((value, key) => {
-            mergedHeaders.set(key, value);
-        });
-        inputHeaders.forEach((value, key) => {
-            mergedHeaders.set(key, value);
-        });
-        return await this.options.fetch(url, {
-            ...fetchOptions,
-            headers: mergedHeaders,
-        });
-    }
-}
-export const createZapierApi = (options) => {
-    const { debug = false, fetch: originalFetch = globalThis.fetch } = options;
-    const debugLog = createDebugLogger(debug);
-    const debugFetch = createDebugFetch({ originalFetch, debugLog });
-    return new ZapierApiClient({
-        ...options,
-        debug,
-        fetch: debugFetch,
-    });
-};

package/dist/api/client.test.d.ts

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

package/dist/api/client.test.d.ts.map

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