@zapier/zapier-sdk 0.8.2 → 0.9.0

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

@@ -204,40 +204,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 +242,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 +255,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 +268,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");
+    });
+  });
+});

package/src/utils/file-utils.ts

@@ -0,0 +1,94 @@
+// In-memory filesystem fallback for browser environments
+const inMemoryFiles: { [path: string]: string } = {};
+
+// Lazy-loaded modules
+let fsPromises: any = null;
+let pathModule: any = null;
+
+async function loadFsPromises() {
+  if (fsPromises) return fsPromises;
+
+  try {
+    fsPromises = await import("fs/promises");
+    return fsPromises;
+  } catch {
+    return null;
+  }
+}
+
+async function loadPathModule() {
+  if (pathModule) return pathModule;
+
+  try {
+    pathModule = await import("path");
+    return pathModule;
+  } catch {
+    return null;
+  }
+}
+
+export async function resolve(
+  path: string,
+  basePath: string = "/",
+): Promise<string> {
+  const pathModule = await loadPathModule();
+
+  if (pathModule) {
+    return pathModule.resolve(path);
+  }
+
+  // Simple fallback path resolution assuming root "/" location
+  if (path.startsWith("/")) {
+    return path;
+  }
+
+  if (path.startsWith("./")) {
+    // Remove ./ prefix and join to base
+    const cleanPath = path.slice(2);
+    return basePath.endsWith("/")
+      ? basePath + cleanPath
+      : basePath + "/" + cleanPath;
+  }
+
+  if (path.startsWith("../")) {
+    // Remove ../ prefix since we're already at root
+    const cleanPath = path.replace(/^(\.\.\/)+/, "");
+    return basePath.endsWith("/")
+      ? basePath + cleanPath
+      : basePath + "/" + cleanPath;
+  }
+
+  // No slash prefix, join to base
+  return basePath.endsWith("/") ? basePath + path : basePath + "/" + path;
+}
+
+export async function writeFile(
+  filePath: string,
+  content: string,
+): Promise<void> {
+  const fs = await loadFsPromises();
+
+  if (fs) {
+    await fs.writeFile(filePath, content, "utf8");
+    return;
+  }
+
+  // Fallback to in-memory filesystem
+  inMemoryFiles[filePath] = content;
+}
+
+export async function readFile(filePath: string): Promise<string> {
+  const fs = await loadFsPromises();
+
+  if (fs) {
+    return await fs.readFile(filePath, "utf8");
+  }
+
+  // Fallback to in-memory filesystem
+  const content = inMemoryFiles[filePath];
+  if (content !== undefined) {
+    return content;
+  }
+
+  throw new Error(`File not found: ${filePath}`);
+}