@zapier/zapier-sdk 0.8.3 → 0.10.0

package/src/types/plugin.ts

@@ -22,7 +22,12 @@ export interface PluginProvides extends Record<string, any> {
 
 export interface PluginMeta {
   categories: string[];
+  type?: "list" | "item";
+  itemType?: string;
+  returnType?: string;
   inputSchema: z.ZodSchema;
+  outputSchema?: z.ZodSchema;
+  resolvers?: Record<string, any>;
   [key: string]: any;
 }
 
@@ -41,6 +46,9 @@ export type GetSdkType<TPluginProvides extends PluginProvides> =
     getContext(): NonNullable<ExtractContextProperties<TPluginProvides>>;
   };
 
+export type GetContextType<TPluginProvides extends PluginProvides> =
+  NonNullable<ExtractContextProperties<TPluginProvides>>;
+
 // Helper type for standard plugin options with SDK dependency and meta context
 export type PluginOptions<TSdk = {}, TContext = {}> = {
   sdk: TSdk;

package/src/types/sdk.ts

@@ -29,12 +29,12 @@ import type { GetAuthenticationSdkFunction } from "../plugins/getAuthentication/
 import type { FindFirstAuthenticationSdkFunction } from "../plugins/findFirstAuthentication/schemas";
 import type { FindUniqueAuthenticationSdkFunction } from "../plugins/findUniqueAuthentication/schemas";
 import type { RelayRequestSdkFunction } from "../plugins/request/schemas";
-import type { LockVersionPluginProvides } from "../plugins/lockVersion";
 
 import type { z } from "zod";
 import type { RegistryPluginProvides } from "../plugins/registry";
 import type { GetProfilePluginProvides } from "../plugins/getProfile";
-import type { AppsPluginProvides } from "../plugins/apps";
+import type { AppsPluginProvides, ZapierSdkApps } from "../plugins/apps";
+import type { ActionProxy } from "../plugins/apps/types";
 import type { FetchPluginProvides } from "../plugins/fetch";
 import type { ListAppsPluginProvides } from "../plugins/listApps";
 import type { GetAppPluginProvides } from "../plugins/getApp";
@@ -46,6 +46,7 @@ import type { GetAuthenticationPluginProvides } from "../plugins/getAuthenticati
 import type { FindFirstAuthenticationPluginProvides } from "../plugins/findFirstAuthentication";
 import type { FindUniqueAuthenticationPluginProvides } from "../plugins/findUniqueAuthentication";
 import type { ListInputFieldsPluginProvides } from "../plugins/listInputFields";
+import type { ListInputFieldChoicesPluginProvides } from "../plugins/listInputFieldChoices";
 import type { RequestPluginProvides } from "../plugins/request";
 import type { GetSdkType } from "./plugin";
 import type { ManifestPluginProvides } from "../plugins/manifest";
@@ -56,8 +57,13 @@ import type { ManifestPluginProvides } from "../plugins/manifest";
 // Registry entry interface with proper types
 export interface FunctionRegistryEntry {
   name: string;
+  type?: "list" | "item";
+  itemType?: string;
+  returnType?: string;
   inputSchema: z.ZodSchema;
+  outputSchema?: z.ZodSchema;
   categories: string[];
+  resolvers?: Record<string, any>;
 }
 
 // Compose SDK functions from individual function interfaces
@@ -78,22 +84,26 @@ export interface ZapierSdkFunctions
 // Note: ZapierSdk type removed - use ReturnType<typeof createZapierSdk> instead
 // This ensures the type matches exactly what the builder produces
 
-export type ZapierSdk = GetSdkType<
-  RegistryPluginProvides &
-    FetchPluginProvides &
-    AppsPluginProvides &
-    ListAppsPluginProvides &
-    ManifestPluginProvides &
-    GetAppPluginProvides &
-    ListActionsPluginProvides &
-    GetActionPluginProvides &
-    RunActionPluginProvides &
-    LockVersionPluginProvides &
-    ListAuthenticationsPluginProvides &
-    GetAuthenticationPluginProvides &
-    FindFirstAuthenticationPluginProvides &
-    FindUniqueAuthenticationPluginProvides &
-    ListInputFieldsPluginProvides &
-    RequestPluginProvides &
-    GetProfilePluginProvides
->;
+export interface ZapierSdk
+  extends GetSdkType<
+    RegistryPluginProvides &
+      FetchPluginProvides &
+      AppsPluginProvides &
+      ListAppsPluginProvides &
+      ManifestPluginProvides &
+      GetAppPluginProvides &
+      ListActionsPluginProvides &
+      GetActionPluginProvides &
+      RunActionPluginProvides &
+      ListAuthenticationsPluginProvides &
+      GetAuthenticationPluginProvides &
+      FindFirstAuthenticationPluginProvides &
+      FindUniqueAuthenticationPluginProvides &
+      ListInputFieldsPluginProvides &
+      ListInputFieldChoicesPluginProvides &
+      RequestPluginProvides &
+      GetProfilePluginProvides
+  > {
+  // Override apps property to intersect ActionProxy with our typed apps
+  apps: ActionProxy & ZapierSdkApps;
+}

package/src/utils/domain-utils.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect } from "vitest";
 import {
   groupVersionedAppKeysByType,
   groupAppKeysByType,
+  toAppLocator,
 } from "./domain-utils";
 
 describe("domain-utils", () => {
@@ -134,11 +135,13 @@ describe("domain-utils", () => {
         "FormatterCLIAPI@1.0.0",
         "slack@2.1.0", // exact duplicate
         "FormatterCLIAPI@1.0.0", // exact duplicate
+        "slack@2.1.1",
+        "FormatterCLIAPI@1.0.1",
       ]);
 
       expect(result).toEqual({
-        selectedApi: ["FormatterCLIAPI@1.0.0"],
-        slug: ["slack@2.1.0"],
+        selectedApi: ["FormatterCLIAPI@1.0.0", "FormatterCLIAPI@1.0.1"],
+        slug: ["slack@2.1.0", "slack@2.1.1"],
       });
     });
   });
@@ -236,4 +239,195 @@ describe("domain-utils", () => {
       });
     });
   });
+
+  describe("toAppLocator", () => {
+    it("should reject UUID app keys", () => {
+      expect(() => {
+        toAppLocator("61e47557-af91-4b0c-a3e0-c28606357664");
+      }).toThrow(
+        "UUID app keys are not supported. Use app slug or implementation ID instead of: 61e47557-af91-4b0c-a3e0-c28606357664",
+      );
+    });
+
+    it("should reject UUID app keys with versions", () => {
+      expect(() => {
+        toAppLocator("61e47557-af91-4b0c-a3e0-c28606357664@1.0.0");
+      }).toThrow(
+        "UUID app keys are not supported. Use app slug or implementation ID instead of: 61e47557-af91-4b0c-a3e0-c28606357664@1.0.0",
+      );
+    });
+
+    it("should reject uppercase UUID app keys", () => {
+      expect(() => {
+        toAppLocator("61E47557-AF91-4B0C-A3E0-C28606357664");
+      }).toThrow(
+        "UUID app keys are not supported. Use app slug or implementation ID instead of: 61E47557-AF91-4B0C-A3E0-C28606357664",
+      );
+    });
+
+    it("should handle simple slug without version", () => {
+      const result = toAppLocator("slack");
+
+      expect(result).toEqual({
+        lookupAppKey: "slack",
+        slug: "slack",
+        implementationName: undefined,
+        version: undefined,
+      });
+    });
+
+    it("should handle slug with version", () => {
+      const result = toAppLocator("slack@1.0.0");
+
+      expect(result).toEqual({
+        lookupAppKey: "slack",
+        slug: "slack",
+        implementationName: undefined,
+        version: "1.0.0",
+      });
+    });
+
+    it("should handle dashified slug", () => {
+      const result = toAppLocator("google-sheets");
+
+      expect(result).toEqual({
+        lookupAppKey: "google-sheets",
+        slug: "google-sheets",
+        implementationName: undefined,
+        version: undefined,
+      });
+    });
+
+    it("should handle dashified slug with version", () => {
+      const result = toAppLocator("google-sheets@2.1.3");
+
+      expect(result).toEqual({
+        lookupAppKey: "google-sheets",
+        slug: "google-sheets",
+        implementationName: undefined,
+        version: "2.1.3",
+      });
+    });
+
+    it("should handle snake_cased slug and convert to dash", () => {
+      const result = toAppLocator("google_sheets");
+
+      expect(result).toEqual({
+        lookupAppKey: "google_sheets",
+        slug: "google-sheets",
+        implementationName: undefined,
+        version: undefined,
+      });
+    });
+
+    it("should handle snake_cased slug with version and convert to dash", () => {
+      const result = toAppLocator("google_sheets@2.1.3");
+
+      expect(result).toEqual({
+        lookupAppKey: "google_sheets",
+        slug: "google-sheets",
+        implementationName: undefined,
+        version: "2.1.3",
+      });
+    });
+
+    it("should handle leading underscore snake_cased slug", () => {
+      const result = toAppLocator("_100hires_ats");
+
+      expect(result).toEqual({
+        lookupAppKey: "_100hires_ats",
+        slug: "100hires-ats",
+        implementationName: undefined,
+        version: undefined,
+      });
+    });
+
+    it("should handle leading underscore snake_cased slug with version", () => {
+      const result = toAppLocator("_100hires_ats@3.0.0");
+
+      expect(result).toEqual({
+        lookupAppKey: "_100hires_ats",
+        slug: "100hires-ats",
+        implementationName: undefined,
+        version: "3.0.0",
+      });
+    });
+
+    it("should handle implementation name without version", () => {
+      const result = toAppLocator("SlackCLIAPI");
+
+      expect(result).toEqual({
+        lookupAppKey: "SlackCLIAPI",
+        slug: undefined,
+        implementationName: "SlackCLIAPI",
+        version: undefined,
+      });
+    });
+
+    it("should handle implementation name with version", () => {
+      const result = toAppLocator("SlackCLIAPI@1.29.0");
+
+      expect(result).toEqual({
+        lookupAppKey: "SlackCLIAPI",
+        slug: undefined,
+        implementationName: "SlackCLIAPI",
+        version: "1.29.0",
+      });
+    });
+
+    it("should handle edge cases with complex version numbers", () => {
+      const result = toAppLocator("slack@1.2.3-beta.4+build.5");
+
+      expect(result).toEqual({
+        lookupAppKey: "slack",
+        slug: "slack",
+        implementationName: undefined,
+        version: "1.2.3-beta.4+build.5",
+      });
+    });
+
+    it("should handle single character app keys", () => {
+      const result = toAppLocator("a");
+
+      expect(result).toEqual({
+        lookupAppKey: "a",
+        slug: "a",
+        implementationName: undefined,
+        version: undefined,
+      });
+    });
+
+    it("should handle app keys with numbers", () => {
+      const result = toAppLocator("app123");
+
+      expect(result).toEqual({
+        lookupAppKey: "app123",
+        slug: "app123",
+        implementationName: undefined,
+        version: undefined,
+      });
+    });
+
+    it("should handle mixed case app keys that aren't implementation names", () => {
+      const result = toAppLocator("SlackBot");
+
+      expect(result).toEqual({
+        lookupAppKey: "SlackBot",
+        slug: undefined,
+        implementationName: "SlackBot",
+        version: undefined,
+      });
+    });
+
+    it("should handle empty version (app key ending with @)", () => {
+      const result = toAppLocator("slack@");
+
+      expect(result).toEqual({
+        lookupAppKey: "slack",
+        slug: "slack",
+        implementationName: undefined,
+        version: "",
+      });
+    });
+  });
 });

package/src/utils/domain-utils.ts

@@ -2,14 +2,7 @@
  * Domain utility functions for working with app identifiers and data normalization
  */
 
-import type {
-  Action,
-  App,
-  Authentication,
-  Implementation,
-  ImplementationMeta,
-  Service,
-} from "../api/types";
+import type { Action, Authentication, ImplementationMeta } from "../api/types";
 import type { ActionItem, AppItem, AuthenticationItem } from "../types/domain";
 
 /**
@@ -34,48 +27,6 @@ export function splitVersionedKey(
   return [versionedKey, undefined];
 }
 
-/**
- * Converts an API App to an AppItem with normalized field names
- *
- * @param app - Raw App from API
- * @returns Normalized AppItem
- */
-export function normalizeAppItem(app: App): AppItem {
-  // Extract API name and version from current_implementation_id
-  const [apiName, appVersion] = app.current_implementation_id
-    ? splitVersionedKey(app.current_implementation_id)
-    : [app.current_implementation_id || "", undefined];
-
-  return {
-    title: app.name,
-    key: app.slug || apiName,
-    current_implementation_id: app.current_implementation_id || "",
-    version: appVersion, // Extract version separately
-  };
-}
-
-/**
- * Converts an Implementation to an AppItem with normalized field names
- *
- * @param implementation - Raw Implementation from API
- * @returns Normalized AppItem
- */
-export function normalizeImplementationToAppItem(
-  implementation: Implementation,
-): AppItem {
-  // Extract API name and version from selected_api
-  const [selectedApi, appVersion] = implementation.selected_api
-    ? splitVersionedKey(implementation.selected_api)
-    : [implementation.selected_api || "", undefined];
-
-  return {
-    title: implementation.name || selectedApi,
-    key: selectedApi,
-    current_implementation_id: implementation.selected_api || "",
-    version: appVersion, // Extract version separately
-  };
-}
-
 /**
  * Converts a lightweight ImplementationMeta to a slimmed AppItem
  *
@@ -88,26 +39,17 @@ export function normalizeImplementationMetaToAppItem(
   // Extract API name and version from the implementation ID
   const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
 
-  return {
-    title: implementationMeta.name,
-    key: selectedApi,
-    current_implementation_id: implementationMeta.id, // Keep the full versioned ID
-    version: appVersion, // Extract version separately
-    slug: implementationMeta.slug,
-  };
-}
-
-export function normalizeServiceToAppItem(service: Service): AppItem {
-  const [selectedApi, appVersion] = service.current_implementation_id
-    ? splitVersionedKey(service.current_implementation_id)
-    : ["", undefined];
+  // Destructure to exclude id and name before spreading
+  const { id, name, ...restOfImplementationMeta } = implementationMeta;
 
   return {
-    title: service.name,
+    // Pass through all ImplementationMeta fields except id and name
+    ...restOfImplementationMeta,
+    // Transform key fields
+    title: name,
     key: selectedApi,
-    current_implementation_id: service.current_implementation_id,
-    version: appVersion,
-    description: service.description,
+    implementation_id: id, // Keep the full versioned ID
+    version: appVersion, // Extract version separately
   };
 }
 
@@ -204,40 +146,23 @@ export function groupVersionedAppKeysByType(appKeys: string[]): {
   const seenSlugs = new Set<string>();
 
   for (const key of appKeys) {
-    // Split by @ to get base name for classification (but preserve full key in results)
-    const [keyWithoutVersion, version] = splitVersionedKey(key);
-
-    // Check if it's a UUID (canonical ID) - not supported
-    const uuidRegex =
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (uuidRegex.test(keyWithoutVersion)) {
-      throw new Error(
-        `UUID app keys are not supported. Use app slug or implementation ID instead of: ${key}`,
-      );
-    }
-
-    // Check if it's a snake_case string
-    if (isSnakeCasedSlug(keyWithoutVersion)) {
-      const dashified = dashifySnakeCasedSlug(keyWithoutVersion);
-      const slugWithVersion = version ? `${dashified}@${version}` : dashified;
-      if (!seenSlugs.has(slugWithVersion)) {
-        seenSlugs.add(slugWithVersion);
-        result.slug.push(slugWithVersion); // Preserve full key including version
+    const appLocator = toAppLocator(key);
+
+    if (appLocator.slug) {
+      // For slugs, we need to reconstruct the versioned slug
+      const versionedSlug = appLocator.version
+        ? `${appLocator.slug}@${appLocator.version}`
+        : appLocator.slug;
+      if (!seenSlugs.has(versionedSlug)) {
+        seenSlugs.add(versionedSlug);
+        result.slug.push(versionedSlug);
+      }
+    } else {
+      // For implementation names (selectedApi)
+      if (!seenSelectedApi.has(key)) {
+        seenSelectedApi.add(key);
+        result.selectedApi.push(key);
       }
-      continue;
-    }
-
-    // Check if it's a slug (lowercase and dashes)
-    if (keyWithoutVersion.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)) {
-      seenSlugs.add(key);
-      result.slug.push(key);
-      continue;
-    }
-
-    // Everything else is a selected_api
-    if (!seenSelectedApi.has(key)) {
-      seenSelectedApi.add(key);
-      result.selectedApi.push(key); // Preserve full key including version
     }
   }
 
@@ -259,7 +184,11 @@ export function groupAppKeysByType(appKeys: string[]): {
   };
 }
 
-function isSnakeCasedSlug(slug: string): boolean {
+export function isSlug(slug: string): boolean {
+  return !!slug.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+}
+
+export function isSnakeCasedSlug(slug: string): boolean {
   // Allow leading underscore for slugs starting with a number.
   if (slug.match(/^_[0-9]/)) {
     slug = slug.slice(1);
@@ -268,7 +197,7 @@ function isSnakeCasedSlug(slug: string): boolean {
   return !!slug.match(/^[a-z0-9]+(?:_[a-z0-9]+)*$/);
 }
 
-function dashifySnakeCasedSlug(slug: string): string {
+export function dashifySnakeCasedSlug(slug: string): string {
   // Only dashify if it's a valid snake_cased slug.
   if (!isSnakeCasedSlug(slug)) {
     return slug;
@@ -281,3 +210,49 @@ function dashifySnakeCasedSlug(slug: string): string {
 
   return slug.replace(/_/g, "-");
 }
+
+export interface AppLocator {
+  lookupAppKey: string;
+  slug?: string;
+  implementationName?: string;
+  version?: string;
+}
+export interface ResolvedAppLocator extends AppLocator {
+  implementationName: string;
+}
+
+export function isUuid(appKey: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    appKey,
+  );
+}
+
+export function toAppLocator(appKey: string): AppLocator {
+  const [appKeyWithoutVersion, version] = splitVersionedKey(appKey);
+  if (isUuid(appKeyWithoutVersion)) {
+    throw new Error(
+      `UUID app keys are not supported. Use app slug or implementation ID instead of: ${appKey}`,
+    );
+  }
+  const slug = isSlug(appKeyWithoutVersion)
+    ? appKeyWithoutVersion
+    : isSnakeCasedSlug(appKeyWithoutVersion)
+      ? dashifySnakeCasedSlug(appKeyWithoutVersion)
+      : undefined;
+  return {
+    lookupAppKey: appKeyWithoutVersion,
+    slug,
+    implementationName: slug ? undefined : appKeyWithoutVersion,
+    version,
+  };
+}
+
+export function isResolvedAppLocator(
+  appLocator: AppLocator,
+): appLocator is ResolvedAppLocator {
+  return !!appLocator.implementationName;
+}
+
+export function toImplementationId(appLocator: ResolvedAppLocator): string {
+  return `${appLocator.implementationName}@${appLocator.version || "latest"}`;
+}

package/src/utils/file-utils.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi } from "vitest";
+import { resolve, writeFile, readFile } from "./file-utils";
+
+// Mock the dynamic imports to simulate missing modules
+vi.mock("fs/promises", () => {
+  throw new Error("Module not found");
+});
+
+vi.mock("path", () => {
+  throw new Error("Module not found");
+});
+
+describe("file-utils", () => {
+  describe("resolve", () => {
+    it("should handle absolute paths", async () => {
+      expect(await resolve("/absolute/path")).toBe("/absolute/path");
+    });
+
+    it("should handle relative paths with ./", async () => {
+      expect(await resolve("./relative/path")).toBe("/relative/path");
+      expect(await resolve("./relative/path", "/base")).toBe(
+        "/base/relative/path",
+      );
+      expect(await resolve("./relative/path", "/base/")).toBe(
+        "/base/relative/path",
+      );
+    });
+
+    it("should handle parent directory paths with ../", async () => {
+      expect(await resolve("../parent/path")).toBe("/parent/path");
+      expect(await resolve("../../nested/parent/path")).toBe(
+        "/nested/parent/path",
+      );
+      expect(await resolve("../parent/path", "/base")).toBe(
+        "/base/parent/path",
+      );
+    });
+
+    it("should handle paths without prefix", async () => {
+      expect(await resolve("simple/path")).toBe("/simple/path");
+      expect(await resolve("simple/path", "/base")).toBe("/base/simple/path");
+      expect(await resolve("simple/path", "/base/")).toBe("/base/simple/path");
+    });
+  });
+
+  describe("writeFile and readFile with in-memory filesystem", () => {
+    it("should write and read files using in-memory filesystem when fs is not available", async () => {
+      const filePath = "/test/file.txt";
+      const content = "Hello, world!";
+
+      await writeFile(filePath, content);
+
+      const readContent = await readFile(filePath);
+      expect(readContent).toBe(content);
+    });
+
+    it("should throw error when reading non-existent file", async () => {
+      await expect(readFile("/non/existent/file.txt")).rejects.toThrow(
+        "File not found: /non/existent/file.txt",
+      );
+    });
+
+    it("should handle multiple files in in-memory filesystem", async () => {
+      await writeFile("/file1.txt", "content1");
+      await writeFile("/file2.txt", "content2");
+      await writeFile("/dir/file3.txt", "content3");
+
+      expect(await readFile("/file1.txt")).toBe("content1");
+      expect(await readFile("/file2.txt")).toBe("content2");
+      expect(await readFile("/dir/file3.txt")).toBe("content3");
+    });
+  });
+});