@zapier/zapier-sdk 0.15.3 → 0.15.8

package/dist/auth.js

@@ -45,3 +45,28 @@ export async function getTokenFromEnvOrConfig(options = {}) {
     // Second priority: CLI login package (if available)
     return getTokenFromCliLogin(options);
 }
+/**
+ * Resolves an auth token from all possible sources with the following precedence:
+ * 1. Explicitly provided token in options
+ * 2. Token from getToken callback in options
+ * 3. ZAPIER_TOKEN environment variable
+ * 4. CLI login package (if available)
+ *
+ * This is the canonical token resolution logic used throughout the SDK.
+ * Returns undefined if no valid token is found.
+ */
+export async function resolveAuthToken(options = {}) {
+    // First priority: explicitly provided token
+    if (options.token) {
+        return options.token;
+    }
+    // Second priority: getToken callback
+    if (options.getToken) {
+        const token = await options.getToken();
+        if (token) {
+            return token;
+        }
+    }
+    // Third and fourth priorities: environment variable or CLI login
+    return getTokenFromEnvOrConfig(options);
+}

package/dist/index.cjs

@@ -2305,49 +2305,68 @@ var getActionPlugin = ({ sdk }) => {
     }
   };
 };
-var GetAuthenticationSchema = zod.z.object({
+var AuthenticationSchema2 = zod.z.object({
+  id: zod.z.number(),
+  date: zod.z.string(),
+  lastchanged: zod.z.string().optional(),
+  account_id: zod.z.number(),
+  customuser_id: zod.z.number().optional(),
+  selected_api: zod.z.string(),
+  destination_selected_api: zod.z.string().nullable().optional(),
+  is_invite_only: zod.z.boolean(),
+  is_private: zod.z.boolean(),
+  shared_with_all: zod.z.boolean(),
+  is_stale: zod.z.string().optional(),
+  is_shared: zod.z.string().optional(),
+  marked_stale_at: zod.z.string().nullable().optional(),
+  label: zod.z.string().nullable().optional(),
+  identifier: zod.z.string().nullable().optional(),
+  title: zod.z.string().nullable().optional(),
+  url: zod.z.string().optional(),
+  groups: zod.z.string().optional(),
+  members: zod.z.string().optional(),
+  permissions: zod.z.record(zod.z.boolean()).optional()
+});
+zod.z.object({
+  count: zod.z.number(),
+  next: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional(),
+  results: zod.z.array(AuthenticationSchema2)
+});
+var AuthenticationItemSchema2 = AuthenticationSchema2.omit({
+  selected_api: true,
+  customuser_id: true
+}).extend({
+  // Renamed fields
+  implementation_id: zod.z.string().optional(),
+  user_id: zod.z.number().optional(),
+  // Mapped fields (originals preserved in ...restOfAuth)
+  is_expired: zod.z.string().optional(),
+  expired_at: zod.z.string().nullable().optional(),
+  // Computed fields
+  app_key: zod.z.string().optional(),
+  app_version: zod.z.string().optional()
+});
+var GetAuthenticationOptionsSchema = zod.z.object({
   authenticationId: zod.z.number().int().positive().describe("Authentication ID to retrieve")
 }).describe("Get a specific authentication by ID");
+var GetAuthenticationHandlerRequestSchema = zod.z.object({
+  authenticationId: zod.z.union([zod.z.string(), zod.z.number()]).describe("Authentication ID - string from searchParams or number")
+}).transform((data) => ({
+  authenticationId: typeof data.authenticationId === "string" ? parseInt(data.authenticationId, 10) : data.authenticationId
+}));
+zod.z.object({
+  data: zod.z.lazy(() => AuthenticationItemSchema2)
+});
 
 // src/plugins/getAuthentication/index.ts
 var getAuthenticationPlugin = ({ context }) => {
   const getAuthentication = createFunction(async function getAuthentication2(options) {
     const { api } = context;
-    const { authenticationId } = options;
-    const data = await api.get(
-      `/zapier/api/v4/authentications/${authenticationId}/`,
-      {
-        customErrorHandler: ({ status }) => {
-          if (status === 401) {
-            return new ZapierAuthenticationError(
-              `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`,
-              { statusCode: status }
-            );
-          }
-          if (status === 403) {
-            return new ZapierAuthenticationError(
-              `Access forbidden. Your token may not have the required scopes to get authentication ${authenticationId}. (HTTP ${status})`,
-              { statusCode: status }
-            );
-          }
-          if (status === 404) {
-            return new ZapierResourceNotFoundError(
-              `Authentication ${authenticationId} not found. It may not exist or you may not have access to it. (HTTP ${status})`,
-              {
-                resourceType: "Authentication",
-                resourceId: String(authenticationId)
-              }
-            );
-          }
-          return void 0;
-        },
-        authRequired: true
-      }
+    return await api.get(
+      `/api/v0/authentications/${options.authenticationId}`
     );
-    return {
-      data: normalizeAuthenticationItem(data)
-    };
-  }, GetAuthenticationSchema);
+  }, GetAuthenticationOptionsSchema);
   return {
     getAuthentication,
     context: {
@@ -2356,7 +2375,7 @@ var getAuthenticationPlugin = ({ context }) => {
           categories: ["authentication"],
           type: "item",
           itemType: "Authentication",
-          inputSchema: GetAuthenticationSchema,
+          inputSchema: GetAuthenticationOptionsSchema,
           outputSchema: AuthenticationItemSchema,
           resolvers: {
             authenticationId: authenticationIdGenericResolver
@@ -3193,12 +3212,46 @@ function isJwt(token) {
   const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
   return parts.every((part) => part.length > 0 && base64UrlPattern.test(part));
 }
+function parseJwt(token) {
+  if (!isJwt(token)) {
+    return null;
+  }
+  return token.split(".");
+}
 function getAuthorizationHeader(token) {
   if (isJwt(token)) {
     return `JWT ${token}`;
   }
   return `Bearer ${token}`;
 }
+function extractUserIdsFromJwt(token) {
+  const parts = parseJwt(token);
+  if (!parts) {
+    return { customuser_id: null, account_id: null };
+  }
+  try {
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    let actualPayload = payload;
+    if (payload.sub_type === "service" && payload.njwt) {
+      const nestedParts = payload.njwt.split(".");
+      if (nestedParts.length === 3) {
+        actualPayload = JSON.parse(
+          Buffer.from(nestedParts[1], "base64url").toString("utf-8")
+        );
+      }
+    }
+    const accountId = actualPayload["zap:acc"] != null ? parseInt(String(actualPayload["zap:acc"]), 10) : null;
+    const customUserId = actualPayload.sub_type === "customuser" && actualPayload.sub != null ? parseInt(String(actualPayload.sub), 10) : null;
+    return {
+      customuser_id: customUserId !== null && !isNaN(customUserId) ? customUserId : null,
+      account_id: accountId !== null && !isNaN(accountId) ? accountId : null
+    };
+  } catch {
+    return { customuser_id: null, account_id: null };
+  }
+}
 
 // src/api/debug.ts
 var utilModule = null;
@@ -3483,6 +3536,18 @@ async function getTokenFromEnvOrConfig(options = {}) {
   }
   return getTokenFromCliLogin(options);
 }
+async function resolveAuthToken(options = {}) {
+  if (options.token) {
+    return options.token;
+  }
+  if (options.getToken) {
+    const token = await options.getToken();
+    if (token) {
+      return token;
+    }
+  }
+  return getTokenFromEnvOrConfig(options);
+}
 
 // src/utils/url-utils.ts
 function getZapierBaseUrl(baseUrl) {
@@ -3530,7 +3595,7 @@ function getTrackingBaseUrl({
   return ZAPIER_BASE_URL;
 }
 
-// src/temporary-internal-core/utils/app-locators.ts
+// src/temporary-internal-core/utils/string-utils.ts
 function splitVersionedKey2(versionedKey) {
   const parts = versionedKey.split("@");
   if (parts.length >= 2) {
@@ -3565,6 +3630,44 @@ function extractPaginationCursor(response) {
     return void 0;
   }
 }
+function normalizeAuthenticationItem2(auth, options = {}) {
+  let appKey = options.app_key;
+  let appVersion = options.app_version;
+  if (auth.selected_api) {
+    const [extractedAppKey, extractedVersion] = splitVersionedKey2(
+      auth.selected_api
+    );
+    if (!appKey) {
+      appKey = extractedAppKey;
+    }
+    if (!appVersion) {
+      appVersion = extractedVersion;
+    }
+  }
+  const {
+    selected_api: selectedApi,
+    customuser_id: userId,
+    ...restOfAuth
+  } = auth;
+  return {
+    ...restOfAuth,
+    // Pass through all other API response fields except selected_api
+    implementation_id: selectedApi,
+    // Rename selected_api to implementation_id
+    title: auth.title || auth.label || void 0,
+    // Coerce title from label if missing
+    is_expired: auth.is_stale,
+    // Map is_stale to is_expired
+    expired_at: auth.marked_stale_at,
+    // Map marked_stale_at to expired_at
+    app_key: appKey,
+    // App key from implementations endpoint or parsed from selected_api
+    app_version: appVersion,
+    // Version from selected_api or provided
+    user_id: userId
+    // Map customuser_id to user_id
+  };
+}
 
 // src/temporary-internal-core/handlers/listApps.ts
 var DEFAULT_PAGE_SIZE = 20;
@@ -3659,6 +3762,111 @@ var handleListApps = async ({ request, deps }) => {
   };
 };
 
+// src/temporary-internal-core/schemas/errors/index.ts
+var ZapierError2 = class extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.statusCode = options.statusCode;
+    this.errors = options.errors;
+    this.cause = options.cause;
+    this.response = options.response;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ZapierAuthenticationError2 = class extends ZapierError2 {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierAuthenticationError";
+  }
+};
+var ZapierResourceNotFoundError2 = class extends ZapierError2 {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierResourceNotFoundError";
+    this.resourceType = options.resourceType;
+    this.resourceId = options.resourceId;
+  }
+};
+
+// src/temporary-internal-core/handlers/getAuthentication.ts
+var handleGetAuthentication = async ({ request, deps }) => {
+  const validatedRequest = GetAuthenticationHandlerRequestSchema.parse(request);
+  const { httpClient } = deps;
+  const { authenticationId } = validatedRequest;
+  const authentication = await httpClient.get(
+    `/zapier/api/v4/authentications/${authenticationId}/`,
+    {
+      authRequired: true,
+      customErrorHandler: ({ status }) => {
+        if (status === 401) {
+          return new ZapierAuthenticationError2(
+            `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`,
+            { statusCode: status }
+          );
+        }
+        if (status === 403) {
+          return new ZapierAuthenticationError2(
+            `Access forbidden. Your token may not have the required scopes to get authentication ${authenticationId}. (HTTP ${status})`,
+            { statusCode: status }
+          );
+        }
+        if (status === 404) {
+          return new ZapierResourceNotFoundError2(
+            `Authentication ${authenticationId} not found. It may not exist or you may not have access to it. (HTTP ${status})`,
+            {
+              resourceType: "Authentication",
+              resourceId: String(authenticationId)
+            }
+          );
+        }
+        return void 0;
+      }
+    }
+  );
+  const normalizedAuthentication = normalizeAuthenticationItem2(authentication);
+  return {
+    data: normalizedAuthentication
+  };
+};
+
+// src/api/router.ts
+var routes = [
+  {
+    method: "GET",
+    pattern: /^\/api\/v0\/apps$/,
+    handler: handleListApps,
+    paramMap: []
+  },
+  {
+    method: "GET",
+    pattern: /^\/api\/v0\/authentications\/([^\/]+)$/,
+    handler: handleGetAuthentication,
+    paramMap: ["authenticationId"]
+  }
+];
+function findMatchingRoute(routeList, method, path) {
+  for (const route of routeList) {
+    if (route.method !== method) {
+      continue;
+    }
+    const match = path.match(route.pattern);
+    if (match) {
+      const params = {};
+      route.paramMap.forEach((name, index) => {
+        params[name] = match[index + 1];
+      });
+      return {
+        handler: route.handler,
+        params
+      };
+    }
+  }
+  return null;
+}
+function matchRoute(method, path) {
+  return findMatchingRoute(routes, method, path);
+}
+
 // src/api/client.ts
 var pathConfig = {
   // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
@@ -3670,9 +3878,6 @@ var pathConfig = {
   "/zapier": {
     authHeader: "Authorization",
     pathPrefix: "/api/v0/sdk/zapier"
-  },
-  "/api/v0/apps": {
-    handlerOverride: handleListApps
   }
 };
 var ZapierApiClient = class {
@@ -3718,16 +3923,9 @@ var ZapierApiClient = class {
   }
   // Helper to get a token from the different places it could be gotten
   async getAuthToken() {
-    if (this.options.token) {
-      return this.options.token;
-    }
-    if (this.options.getToken) {
-      const token = await this.options.getToken();
-      if (token) {
-        return token;
-      }
-    }
-    return getTokenFromEnvOrConfig({
+    return resolveAuthToken({
+      token: this.options.token,
+      getToken: this.options.getToken,
       onEvent: this.options.onEvent,
       fetch: this.options.fetch,
       baseUrl: this.options.baseUrl,
@@ -3830,14 +4028,6 @@ var ZapierApiClient = class {
     }
     return void 0;
   }
-  // Helper to check if a path config has a handler override
-  hasHandlerOverride(pathConfig2) {
-    return pathConfig2 !== void 0 && "handlerOverride" in pathConfig2 && typeof pathConfig2.handlerOverride === "function";
-  }
-  // Helper to check if a path config is a standard path config
-  isStandardPathConfig(pathConfig2) {
-    return pathConfig2 !== void 0 && !this.hasHandlerOverride(pathConfig2);
-  }
   // Helper to parse API error response
   parseErrorResponse(errorInfo) {
     const fallbackMessage = `HTTP ${errorInfo.status}: ${errorInfo.statusText}`;
@@ -3889,8 +4079,10 @@ var ZapierApiClient = class {
         pathConfig: config
       };
     }
+    const baseUrl = new URL(this.options.baseUrl);
+    const fullPath = baseUrl.pathname.replace(/\/$/, "") + path;
     return {
-      url: new URL(path, this.options.baseUrl),
+      url: new URL(fullPath, baseUrl.origin),
       pathConfig: config
     };
   }
@@ -3909,7 +4101,7 @@ var ZapierApiClient = class {
     const headers = new Headers(options.headers ?? {});
     const authToken = await this.getAuthToken();
     if (authToken) {
-      const authHeaderName = this.isStandardPathConfig(pathConfig2) && pathConfig2.authHeader ? pathConfig2.authHeader : "Authorization";
+      const authHeaderName = pathConfig2 && pathConfig2.authHeader ? pathConfig2.authHeader : "Authorization";
       headers.set(authHeaderName, getAuthorizationHeader(authToken));
     }
     if (options.authRequired) {
@@ -3923,10 +4115,14 @@ var ZapierApiClient = class {
   }
   // Helper to perform HTTP requests with JSON handling
   async fetchJson(method, path, data, options = {}) {
-    const { pathConfig: pathConfig2 } = this.buildUrl(path, options.searchParams);
-    if (this.hasHandlerOverride(pathConfig2)) {
-      const handlerRequest = method === "GET" ? options.searchParams : data;
-      return pathConfig2.handlerOverride({
+    const routeMatch = matchRoute(method, path);
+    if (routeMatch) {
+      const handlerRequest = {
+        ...typeof data === "object" ? data : {},
+        ...options.searchParams,
+        ...routeMatch.params
+      };
+      return routeMatch.handler({
         request: handlerRequest,
         deps: {
           httpClient: this
@@ -4595,7 +4791,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.15.3"};
+  version: "0.15.8"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {
@@ -4666,17 +4862,26 @@ function buildErrorEventWithContext(data, context = {}) {
 }
 
 // src/plugins/eventEmission/index.ts
+var TELEMETRY_EMIT_TIMEOUT_MS = 300;
 var APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
 var ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
 var transportStates = /* @__PURE__ */ new WeakMap();
-async function silentEmit(transport, subject, event) {
+async function silentEmit(transport, subject, event, userContextPromise) {
   try {
     let state = transportStates.get(transport);
     if (!state) {
       state = { hasWorked: false, hasLoggedFailure: false };
       transportStates.set(transport, state);
     }
-    transport.emit(subject, event).then(() => {
+    let enrichedEvent = event;
+    if (userContextPromise) {
+      try {
+        const userContext = await userContextPromise;
+        enrichedEvent = Object.assign({}, event, userContext);
+      } catch {
+      }
+    }
+    transport.emit(subject, enrichedEvent).then(() => {
       state.hasWorked = true;
     }).catch((error) => {
       if (!state.hasWorked && !state.hasLoggedFailure) {
@@ -4724,6 +4929,24 @@ var eventEmissionPlugin = ({ context }) => {
       )
     )
   };
+  const getUserContext = (async () => {
+    try {
+      const token = await resolveAuthToken({
+        token: context.options.token,
+        getToken: context.options.getToken,
+        baseUrl: context.options.baseUrl,
+        authBaseUrl: context.options.authBaseUrl,
+        authClientId: context.options.authClientId,
+        onEvent: context.options.onEvent,
+        fetch: context.options.fetch
+      });
+      if (token) {
+        return extractUserIdsFromJwt(token);
+      }
+    } catch {
+    }
+    return { customuser_id: null, account_id: null };
+  })();
   const startupTime = Date.now();
   let shutdownStartTime = null;
   if (!config.enabled) {
@@ -4734,7 +4957,7 @@ var eventEmissionPlugin = ({ context }) => {
           config,
           emit: () => {
           },
-          createBaseEvent: () => ({
+          createBaseEvent: async () => ({
             event_id: generateEventId(),
             timestamp_ms: getCurrentTimestamp(),
             release_id: getReleaseId(),
@@ -4754,21 +4977,34 @@ var eventEmissionPlugin = ({ context }) => {
   } catch {
     transport = createTransport({ type: "noop" });
   }
-  const createBaseEventHelper = () => ({
-    event_id: generateEventId(),
-    timestamp_ms: getCurrentTimestamp(),
-    release_id: getReleaseId(),
-    customuser_id: null,
-    account_id: null,
-    identity_id: null,
-    visitor_id: null,
-    correlation_id: null
-  });
+  const createBaseEventHelper = async () => {
+    const baseEvent = {
+      event_id: generateEventId(),
+      timestamp_ms: getCurrentTimestamp(),
+      release_id: getReleaseId(),
+      customuser_id: null,
+      account_id: null,
+      identity_id: null,
+      visitor_id: null,
+      correlation_id: null
+    };
+    try {
+      const userContext = await getUserContext;
+      return { ...baseEvent, ...userContext };
+    } catch {
+      return baseEvent;
+    }
+  };
   if (config.enabled) {
     const startupEvent = buildApplicationLifecycleEvent({
       lifecycle_event_type: "startup"
     });
-    silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, startupEvent);
+    silentEmit(
+      transport,
+      APPLICATION_LIFECYCLE_EVENT_SUBJECT,
+      startupEvent,
+      getUserContext
+    );
     if (typeof process?.on === "function") {
       process.on("exit", (code) => {
         const uptime = Date.now() - startupTime;
@@ -4780,10 +5016,15 @@ var eventEmissionPlugin = ({ context }) => {
           is_graceful_shutdown: code === 0,
           shutdown_duration_ms: shutdownDuration
         });
-        silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent);
+        silentEmit(
+          transport,
+          APPLICATION_LIFECYCLE_EVENT_SUBJECT,
+          exitEvent,
+          getUserContext
+        );
       });
       process.on("uncaughtException", async (error) => {
-        const errorEvent = buildErrorEventWithContext({
+        let errorEvent = buildErrorEventWithContext({
           error_message: error.message || "Unknown error",
           error_type: "UncaughtException",
           error_stack_trace: error.stack || null,
@@ -4792,10 +5033,17 @@ var eventEmissionPlugin = ({ context }) => {
           is_recoverable: false,
           execution_start_time: startupTime
         });
+        try {
+          const userContext = await getUserContext;
+          errorEvent = { ...errorEvent, ...userContext };
+        } catch {
+        }
         try {
           await Promise.race([
             transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-            new Promise((resolve2) => setTimeout(resolve2, 300))
+            new Promise(
+              (resolve2) => setTimeout(resolve2, TELEMETRY_EMIT_TIMEOUT_MS)
+            )
           ]);
         } catch {
         }
@@ -4805,7 +5053,7 @@ var eventEmissionPlugin = ({ context }) => {
         async (reason, promise) => {
           const errorMessage = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
           const errorStack = reason instanceof Error ? reason.stack : null;
-          const errorEvent = buildErrorEventWithContext({
+          let errorEvent = buildErrorEventWithContext({
             error_message: errorMessage,
             error_type: "UnhandledRejection",
             error_stack_trace: errorStack,
@@ -4817,10 +5065,17 @@ var eventEmissionPlugin = ({ context }) => {
               promise: String(promise)
             }
           });
+          try {
+            const userContext = await getUserContext;
+            errorEvent = { ...errorEvent, ...userContext };
+          } catch {
+          }
           try {
             await Promise.race([
               transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-              new Promise((resolve2) => setTimeout(resolve2, 300))
+              new Promise(
+                (resolve2) => setTimeout(resolve2, TELEMETRY_EMIT_TIMEOUT_MS)
+              )
             ]);
           } catch {
           }
@@ -4829,16 +5084,23 @@ var eventEmissionPlugin = ({ context }) => {
       const handleSignal = async (signal) => {
         shutdownStartTime = Date.now();
         const uptime = Date.now() - startupTime;
-        const signalEvent = buildApplicationLifecycleEvent({
+        let signalEvent = buildApplicationLifecycleEvent({
           lifecycle_event_type: "signal_termination",
           signal_name: signal,
           uptime_ms: uptime,
           is_graceful_shutdown: true
         });
+        try {
+          const userContext = await getUserContext;
+          signalEvent = { ...signalEvent, ...userContext };
+        } catch {
+        }
         try {
           await Promise.race([
             transport.emit(APPLICATION_LIFECYCLE_EVENT_SUBJECT, signalEvent),
-            new Promise((resolve2) => setTimeout(resolve2, 300))
+            new Promise(
+              (resolve2) => setTimeout(resolve2, TELEMETRY_EMIT_TIMEOUT_MS)
+            )
           ]);
         } catch {
         }
@@ -4854,7 +5116,7 @@ var eventEmissionPlugin = ({ context }) => {
         transport,
         config,
         emit: (subject, event) => {
-          silentEmit(transport, subject, event);
+          silentEmit(transport, subject, event, getUserContext);
         },
         createBaseEvent: createBaseEventHelper
       }
@@ -4994,6 +5256,7 @@ exports.manifestPlugin = manifestPlugin;
 exports.readManifestFromFile = readManifestFromFile;
 exports.registryPlugin = registryPlugin;
 exports.requestPlugin = requestPlugin;
+exports.resolveAuthToken = resolveAuthToken;
 exports.runActionPlugin = runActionPlugin;
 exports.toSnakeCase = toSnakeCase;
 exports.toTitleCase = toTitleCase;