@zapier/zapier-sdk 0.9.0 → 0.11.0

package/src/api/debug.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from "vitest";
+import { censorHeaders } from "./debug";
+
+describe("censorHeaders", () => {
+  it("should return undefined for undefined headers", () => {
+    expect(censorHeaders(undefined)).toBeUndefined();
+  });
+
+  it("should return headers unchanged for non-auth headers", () => {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": "test",
+    };
+    const result = censorHeaders(headers);
+    // Headers API normalizes header names to lowercase
+    expect(result!["content-type"]).toBe("application/json");
+    expect(result!["user-agent"]).toBe("test");
+  });
+
+  it("should censor authorization header with Bearer prefix - long token", () => {
+    const headers = { authorization: "Bearer abcdef1234567890xyz" };
+    const result = censorHeaders(headers);
+
+    expect(result!.authorization).toBe("Bearer abcd...0xyz");
+  });
+
+  it("should censor authorization header with Bearer prefix - short token", () => {
+    const headers = { authorization: "Bearer short123" };
+    const result = censorHeaders(headers);
+
+    expect(result!.authorization).toBe("Bearer s...");
+  });
+
+  it("should censor x-api-key header - long token", () => {
+    const headers = { "x-api-key": "sk-1234567890abcdefghij" };
+    const result = censorHeaders(headers);
+
+    expect(result!["x-api-key"]).toBe("sk-1...ghij");
+  });
+
+  it("should censor x-api-key header - short token", () => {
+    const headers = { "x-api-key": "short" };
+    const result = censorHeaders(headers);
+
+    expect(result!["x-api-key"]).toBe("s...");
+  });
+
+  it("should handle Headers object input", () => {
+    const headers = new Headers();
+    headers.set("authorization", "Bearer verylongtoken123456789");
+
+    const result = censorHeaders(headers);
+    expect(result!.authorization).toBe("Bearer very...6789");
+  });
+
+  it("should handle mixed case authorization headers", () => {
+    const headers = { Authorization: "Bearer mixedcasetoken123" };
+    const result = censorHeaders(headers);
+
+    expect(result!.authorization).toBe("Bearer mixe...n123");
+  });
+
+  it("should preserve non-auth headers while censoring auth headers", () => {
+    const headers = {
+      "Content-Type": "application/json",
+      authorization: "Bearer shouldbecensored123456789",
+      "User-Agent": "test-agent",
+    };
+
+    const result = censorHeaders(headers);
+
+    expect(result!["content-type"]).toBe("application/json");
+    expect(result!["user-agent"]).toBe("test-agent");
+    expect(result!.authorization).toBe("Bearer shou...6789");
+  });
+});

package/src/api/debug.ts

@@ -12,11 +12,55 @@ export function createDebugLogger(enabled: boolean): DebugLogger {
     return () => {}; // No-op function when debug is disabled
   }
 
-  return (message: string, data?: any) => {
+  return (message: string, data?: unknown) => {
     console.log(`[Zapier SDK] ${message}`, data || "");
   };
 }
 
+export function censorHeaders(
+  headers?: HeadersInit,
+): Record<string, string> | undefined {
+  if (!headers) return headers;
+
+  const headersObj = new Headers(headers);
+  const authKeys = ["authorization", "x-api-key"];
+
+  for (const [key, value] of headersObj.entries()) {
+    if (authKeys.some((authKey) => key.toLowerCase() === authKey)) {
+      // Find space after prefix (like "Bearer ")
+      const spaceIndex = value.indexOf(" ");
+      if (spaceIndex > 0 && spaceIndex < value.length - 1) {
+        const prefix = value.substring(0, spaceIndex + 1); // Include the space
+        const token = value.substring(spaceIndex + 1);
+
+        if (token.length > 12) {
+          // Show first 4 and last 4 chars, truncate middle
+          const start = token.substring(0, 4);
+          const end = token.substring(token.length - 4);
+          headersObj.set(key, `${prefix}${start}...${end}`);
+        } else {
+          // Short token, use first character + three dots
+          const firstChar = token.charAt(0);
+          headersObj.set(key, `${prefix}${firstChar}...`);
+        }
+      } else {
+        // No prefix found, truncate the whole value
+        if (value.length > 12) {
+          const start = value.substring(0, 4);
+          const end = value.substring(value.length - 4);
+          headersObj.set(key, `${start}...${end}`);
+        } else {
+          // Short token, use first character + three dots
+          const firstChar = value.charAt(0);
+          headersObj.set(key, `${firstChar}...`);
+        }
+      }
+    }
+  }
+
+  return Object.fromEntries(headersObj);
+}
+
 export function createDebugFetch(options: {
   originalFetch: typeof globalThis.fetch;
   debugLog: DebugLogger;
@@ -30,7 +74,7 @@ export function createDebugFetch(options: {
     const method = options?.method || "GET";
 
     debugLog(`→ ${method} ${url}`, {
-      headers: options?.headers,
+      headers: censorHeaders(options?.headers),
       body:
         options?.body && typeof options.body === "string"
           ? (() => {

package/src/api/schemas.ts

@@ -118,7 +118,7 @@ export const FieldSchema = z.object({
 });
 
 export const ActionExecutionResultSchema = z.object({
-  data: z.array(z.any()),
+  data: z.array(z.unknown()),
 });
 
 export const ActionFieldChoiceSchema = z.object({
@@ -217,9 +217,9 @@ export const UserProfileSchema = z.object({
   enable_totp_2fa: z.boolean(),
   viewed_help: z.record(z.boolean()),
   show_editor_migration_mesaging: z.boolean(),
-  switches: z.record(z.any()),
-  organizations: z.array(z.any().nullable()),
-  primary_organization: z.any().nullable(),
+  switches: z.record(z.unknown()),
+  organizations: z.array(z.record(z.unknown()).nullable()),
+  primary_organization: z.record(z.unknown()).nullable(),
   has_active_zaps: z.boolean(),
   has_google_sso: z.boolean(),
   auth_realm: z.string(),
@@ -236,7 +236,7 @@ export const AppSchema = z.object({
   api_docs_url: z.string().nullable().optional(),
   app_profile_url: z.string(),
   banner: z.string().optional(),
-  categories: z.array(z.any()).optional(), // TODO: Define proper service_category type
+  categories: z.array(z.string()).optional(), // Service category names
   canonical_id: z.string().optional(),
   current_implementation_id: z.string(),
   days_since_last_update: z.string().optional(),
@@ -294,7 +294,7 @@ export const NeedsRequestSchema = z.object({
   action: z.string(),
   type_of: z.string(),
   authentication_id: z.number().optional(),
-  params: z.record(z.any()).optional(),
+  params: z.record(z.unknown()).optional(),
 });
 
 export const NeedsResponseSchema = z.object({
@@ -341,20 +341,11 @@ export const ImplementationsResponseSchema = z.object({
 // ============================================================================
 
 export const ImplementationMetaSchema = z.object({
-  id: z.string(), // e.g. "ZapierFormatterCLIAPI@1.0.7"
+  id: z.string(), // e.g. "100HiresCLIAPI@1.2.1"
   name: z.string(),
   slug: z.string(),
-  images: z
-    .object({
-      url_16x16: z.string().optional(),
-      url_32x32: z.string().optional(),
-      url_64x64: z.string().optional(),
-      url_128x128: z.string().optional(),
-    })
-    .optional(),
-  // Include other fields for completeness but we'll only use what we need
-  ageInDays: z.union([z.string(), z.number()]).optional(),
-  authType: z.string().nullable().optional(),
+  age_in_days: z.number().optional(),
+  auth_type: z.string().optional(),
   banner: z.string().optional(),
   categories: z
     .array(
@@ -365,18 +356,49 @@ export const ImplementationMetaSchema = z.object({
       }),
     )
     .optional(),
-  isBeta: z.boolean().optional(),
-  isBuiltIn: z.boolean().optional(),
-  isDeprecated: z.boolean().optional(),
-  isFeatured: z.boolean().optional(),
-  isHidden: z.boolean().optional(),
-  isInvite: z.boolean().optional(),
-  isPremium: z.boolean().optional(),
-  isPublic: z.boolean().optional(),
-  isUpcoming: z.boolean().optional(),
+  images: z
+    .object({
+      url_16x16: z.string().optional(),
+      url_32x32: z.string().optional(),
+      url_64x64: z.string().optional(),
+      url_128x128: z.string().optional(),
+    })
+    .optional(),
   popularity: z.number().optional(),
-  apiDocsUrl: z.string().optional(),
+  has_filters: z.boolean().optional(),
+  has_reads: z.boolean().optional(),
+  has_searches: z.boolean().optional(),
+  has_searches_or_writes: z.boolean().optional(),
+  has_upfront_fields: z.boolean().optional(),
+  has_writes: z.boolean().optional(),
+  is_beta: z.boolean().optional(),
+  is_built_in: z.boolean().optional(),
+  is_deprecated: z.boolean().optional(),
+  is_featured: z.boolean().optional(),
+  is_hidden: z.boolean().optional(),
+  is_invite: z.boolean().optional(),
+  is_premium: z.boolean().optional(),
+  is_public: z.boolean().optional(),
+  is_upcoming: z.boolean().optional(),
+  version: z.string().optional(),
+  visibility: z.string().optional(),
+  actions: z
+    .object({
+      read: z.number().optional(),
+      read_bulk: z.number().optional(),
+      write: z.number().optional(),
+      search: z.number().optional(),
+      search_or_write: z.number().optional(),
+      search_and_write: z.number().optional(),
+      filter: z.number().optional(),
+    })
+    .optional(),
+  description: z.string().optional(),
+  primary_color: z.string().optional(),
+  secondary_color: z.string().optional(),
   classification: z.string().optional(),
+  api_docs_url: z.string().optional(),
+  image: z.string().optional(),
 });
 
 export const ImplementationsMetaResponseSchema = z.object({
@@ -413,7 +435,7 @@ export const NeedChoicesRequestSchema = z.object({
       "If the app needs auth, provide an `authentication_id` that has the `selected_api` of the app you want to run. Can be any auth visible to the user (including shared).",
     ),
   params: z
-    .record(z.any())
+    .record(z.unknown())
     .optional()
     .describe(
       "Object that matches the input the node would normally get. Has all the same keys/types as the `needs` of the action.",

package/src/index.ts

@@ -38,16 +38,15 @@ export type {
 } from "./api/types";
 
 // Export schema utilities for CLI
-export { isPositional } from "./utils/schema-utils";
-export { hasResolver } from "./resolvers";
+export { isPositional, PositionalMetadata } from "./utils/schema-utils";
 export { createFunction } from "./utils/function-utils";
 
+// Export resolver utilities for CLI
+export * from "./resolvers";
+
 // Export auth utilities for CLI use
 export * from "./auth";
 
-// Export resolvers for CLI use
-export * from "./resolvers";
-
 // All functions now available through the plugin system via createZapierSdk()
 // Export plugin schemas for external use
 export {

package/src/plugins/findFirstAuthentication/index.test.ts

@@ -132,17 +132,20 @@ describe("findFirstAuthentication plugin", () => {
       expect(result.data).toEqual(mockAuth);
     });
 
-    it("should return null when no authentications found", async () => {
+    it("should throw error when no authentications found", async () => {
       mockListAuthentications.mockResolvedValue({
         data: [],
       });
 
       const sdk = createTestSdk();
-      const result = await sdk.findFirstAuthentication({
-        appKey: "nonexistent",
-      });
 
-      expect(result.data).toBeNull();
+      await expect(
+        sdk.findFirstAuthentication({
+          appKey: "nonexistent",
+        }),
+      ).rejects.toThrow(
+        "No authentication found matching the specified criteria",
+      );
     });
 
     it("should return first authentication when multiple found", async () => {

package/src/plugins/findFirstAuthentication/index.ts

@@ -6,11 +6,13 @@ import {
 } from "./schemas";
 import { createFunction } from "../../utils/function-utils";
 import type { ListAuthenticationsPluginProvides } from "../listAuthentications";
+import { AuthenticationItemSchema } from "../../schemas/Auth";
+import { ZapierResourceNotFoundError } from "../../types/errors";
 
 export interface FindFirstAuthenticationPluginProvides {
   findFirstAuthentication: (
     options?: FindFirstAuthenticationOptions,
-  ) => Promise<{ data: AuthenticationItem | null }>;
+  ) => Promise<{ data: AuthenticationItem }>;
   context: {
     meta: {
       findFirstAuthentication: {
@@ -35,8 +37,15 @@ export const findFirstAuthenticationPlugin: Plugin<
         maxItems: 1,
       });
 
+      if (authsResponse.data.length === 0) {
+        throw new ZapierResourceNotFoundError(
+          "No authentication found matching the specified criteria",
+          { resourceType: "Authentication" },
+        );
+      }
+
       return {
-        data: authsResponse.data.length > 0 ? authsResponse.data[0] : null,
+        data: authsResponse.data[0],
       };
     },
     FindFirstAuthenticationSchema,
@@ -48,7 +57,10 @@ export const findFirstAuthenticationPlugin: Plugin<
       meta: {
         findFirstAuthentication: {
           categories: ["authentication"],
+          type: "item",
+          itemType: "Authentication",
           inputSchema: FindFirstAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema,
         },
       },
     },

package/src/plugins/findUniqueAuthentication/index.ts

@@ -10,6 +10,7 @@ import {
 } from "../../types/errors";
 import { createFunction } from "../../utils/function-utils";
 import type { ListAuthenticationsPluginProvides } from "../listAuthentications";
+import { AuthenticationItemSchema } from "../../schemas/Auth";
 
 export interface FindUniqueAuthenticationPluginProvides {
   findUniqueAuthentication: (
@@ -65,7 +66,10 @@ export const findUniqueAuthenticationPlugin: Plugin<
       meta: {
         findUniqueAuthentication: {
           categories: ["authentication"],
+          type: "item",
+          itemType: "Authentication",
           inputSchema: FindUniqueAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema,
         },
       },
     },

package/src/plugins/getAction/index.ts

@@ -5,6 +5,12 @@ import { GetActionSchema, type GetActionOptions } from "./schemas";
 import { ZapierResourceNotFoundError } from "../../types/errors";
 import { createFunction } from "../../utils/function-utils";
 import type { ListActionsPluginProvides } from "../listActions";
+import {
+  appKeyResolver,
+  actionTypeResolver,
+  actionKeyResolver,
+} from "../../resolvers";
+import { ActionItemSchema } from "../../schemas/Action";
 
 export interface GetActionPluginProvides {
   getAction: (options: GetActionOptions) => Promise<{ data: ActionItem }>;
@@ -50,7 +56,15 @@ export const getActionPlugin: Plugin<
       meta: {
         getAction: {
           categories: ["action"],
+          type: "item",
+          itemType: "Action",
           inputSchema: GetActionSchema,
+          outputSchema: ActionItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+          },
         },
       },
     },

package/src/plugins/getApp/index.test.ts

@@ -72,7 +72,7 @@ describe("getApp plugin", () => {
 
       expect(result.data.title).toBe("Slack");
       expect(result.data.key).toBe("SlackCLIAPI");
-      expect(result.data.current_implementation_id).toBe("SlackCLIAPI@1.0.0");
+      expect(result.data.implementation_id).toBe("SlackCLIAPI@1.0.0");
       expect(result.data.version).toBe("1.0.0");
     });
   });
@@ -121,7 +121,7 @@ describe("getApp plugin", () => {
 
       expect(result.data.title).toBeDefined();
       expect(result.data.key).toBeDefined();
-      expect(result.data.current_implementation_id).toBeDefined();
+      expect(result.data.implementation_id).toBeDefined();
       expect(result.data.title).toBe("Test App");
       expect(result.data.key).toBe("TestCLIAPI");
     });

package/src/plugins/getApp/index.ts

@@ -3,9 +3,11 @@ import { createFunction } from "../../utils/function-utils";
 import { GetAppSchema } from "./schemas";
 import type { GetAppOptions } from "./schemas";
 import type { AppItem } from "../../types/domain";
+import { AppItemSchema } from "../../schemas/App";
 import { ZapierAppNotFoundError } from "../../types/errors";
 import type { GetSdkType } from "../../types/plugin";
 import type { ListAppsPluginProvides } from "../listApps";
+import { appKeyResolver } from "../../resolvers";
 
 // GetApp plugin provides interface - getApp goes directly to SDK root
 export interface GetAppPluginProvides {
@@ -44,7 +46,13 @@ export const getAppPlugin: Plugin<
       meta: {
         getApp: {
           categories: ["app"],
+          type: "item",
+          itemType: "App",
           inputSchema: GetAppSchema,
+          outputSchema: AppItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+          },
         },
       },
     },

package/src/plugins/getApp/schemas.ts

@@ -1,7 +1,5 @@
 import { z } from "zod";
 import { AppKeyPropertySchema } from "../../types/properties";
-import { withOutputSchema } from "../../utils/schema-utils";
-import { AppItemSchema } from "../../schemas/App";
 import type { AppItem } from "../../types/domain";
 import type {
   ZapierApiError,
@@ -18,16 +16,13 @@ export type GetAppError =
   | ZapierValidationError;
 
 // Pure Zod schema - no resolver metadata!
-export const GetAppSchema = withOutputSchema(
-  z
-    .object({
-      appKey: AppKeyPropertySchema.describe(
-        "App key of app to fetch (e.g., 'SlackCLIAPI')",
-      ),
-    })
-    .describe("Get detailed information about a specific app"),
-  AppItemSchema,
-);
+export const GetAppSchema = z
+  .object({
+    appKey: AppKeyPropertySchema.describe(
+      "App key of app to fetch (e.g., 'SlackCLIAPI')",
+    ),
+  })
+  .describe("Get detailed information about a specific app");
 
 // Type inferred from schema
 export type GetAppOptions = z.infer<typeof GetAppSchema>;

package/src/plugins/getAuthentication/index.ts

@@ -12,6 +12,8 @@ import {
 } from "../../types/errors";
 import { createFunction } from "../../utils/function-utils";
 import { normalizeAuthenticationItem } from "../../utils/domain-utils";
+import { authenticationIdGenericResolver } from "../../resolvers";
+import { AuthenticationItemSchema } from "../../schemas/Auth";
 
 export interface GetAuthenticationPluginProvides {
   getAuthentication: (
@@ -79,7 +81,13 @@ export const getAuthenticationPlugin: Plugin<
       meta: {
         getAuthentication: {
           categories: ["authentication"],
+          type: "item",
+          itemType: "Authentication",
           inputSchema: GetAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema,
+          resolvers: {
+            authenticationId: authenticationIdGenericResolver,
+          },
         },
       },
     },

package/src/plugins/getProfile/index.ts

@@ -4,6 +4,7 @@ import { createFunction } from "../../utils/function-utils";
 import type { Plugin } from "../../types/plugin";
 import type { UserProfileItem } from "../../types/domain";
 import { GetProfileSchema } from "./schemas";
+import { UserProfileItemSchema } from "../../schemas/UserProfile";
 
 // GetProfile plugin provides interface - getProfile goes directly to SDK root
 export interface GetProfilePluginProvides {
@@ -48,7 +49,10 @@ export const getProfilePlugin: Plugin<
       meta: {
         getProfile: {
           categories: ["account"],
+          type: "item",
+          itemType: "Profile",
           inputSchema: GetProfileSchema,
+          outputSchema: UserProfileItemSchema,
         },
       },
     },

package/src/plugins/getProfile/schemas.ts

@@ -1,6 +1,4 @@
 import { z } from "zod";
-import { withOutputSchema } from "../../utils/schema-utils";
-import { UserProfileItemSchema } from "../../schemas/UserProfile";
 import type { FunctionOptions } from "../../types/functions";
 import type { UserProfileItem } from "../../types/domain";
 import type { ZapierApiError, ZapierValidationError } from "../../types/errors";
@@ -9,10 +7,10 @@ import type { ZapierApiError, ZapierValidationError } from "../../types/errors";
 export type GetProfileError = ZapierApiError | ZapierValidationError;
 
 // Pure Zod schema - no resolver metadata!
-export const GetProfileSchema = withOutputSchema(
-  z.object({}).optional().describe("Get current user's profile information"),
-  UserProfileItemSchema,
-);
+export const GetProfileSchema = z
+  .object({})
+  .optional()
+  .describe("Get current user's profile information");
 
 // Type inferred from schema + function config
 export type GetProfileOptions = z.infer<typeof GetProfileSchema> &

package/src/plugins/listActions/index.ts

@@ -7,6 +7,7 @@ import {
   type ListActionsOptions,
   type ListActionsPage,
 } from "./schemas";
+import { ActionItemSchema } from "../../schemas/Action";
 import {
   ZapierConfigurationError,
   ZapierAuthenticationError,
@@ -14,6 +15,7 @@ import {
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { ManifestPluginProvides } from "../manifest";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
+import { appKeyResolver, actionTypeResolver } from "../../resolvers";
 
 export interface ListActionsPluginProvides {
   listActions: (options?: ListActionsOptions) => Promise<{
@@ -114,7 +116,14 @@ export const listActionsPlugin: Plugin<
       meta: {
         listActions: {
           categories: ["action"],
+          type: "list",
+          itemType: "Action",
           inputSchema: ListActionsSchema,
+          outputSchema: ActionItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+          },
         },
       },
     },

package/src/plugins/listActions/schemas.ts

@@ -3,8 +3,6 @@ import {
   AppKeyPropertySchema,
   ActionTypePropertySchema,
 } from "../../types/properties";
-import { withOutputSchema } from "../../utils/schema-utils";
-import { ActionItemSchema } from "../../schemas/Action";
 import type { ActionItem } from "../../types/domain";
 import type { PaginatedSdkFunction } from "../../types/functions";
 import type {
@@ -14,29 +12,26 @@ import type {
 } from "../../types/errors";
 
 // Pure Zod schema - no resolver metadata!
-export const ListActionsSchema = withOutputSchema(
-  z
-    .object({
-      appKey: AppKeyPropertySchema.describe(
-        "App key of actions to list (e.g., 'SlackCLIAPI')",
-      ),
-      actionType: ActionTypePropertySchema.optional().describe(
-        "Filter actions by type",
-      ),
-      pageSize: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Number of actions per page"),
-      maxItems: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Maximum total items to return across all pages"),
-    })
-    .describe("List all actions for a specific app"),
-  ActionItemSchema,
-);
+export const ListActionsSchema = z
+  .object({
+    appKey: AppKeyPropertySchema.describe(
+      "App key of actions to list (e.g., 'SlackCLIAPI')",
+    ),
+    actionType: ActionTypePropertySchema.optional().describe(
+      "Filter actions by type",
+    ),
+    pageSize: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Number of actions per page"),
+    maxItems: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Maximum total items to return across all pages"),
+  })
+  .describe("List all actions for a specific app");
 
 // Type inferred from schema
 export type ListActionsOptions = z.infer<typeof ListActionsSchema>;

package/src/plugins/listApps/index.test.ts

@@ -228,7 +228,7 @@ describe("listApps plugin", () => {
 
       expect(result.data[0]).toHaveProperty("title");
       expect(result.data[0]).toHaveProperty("key");
-      expect(result.data[0]).toHaveProperty("current_implementation_id");
+      expect(result.data[0]).toHaveProperty("implementation_id");
       // Version is optional
       expect(result.data[0]).toHaveProperty("version");
     });