@zapier/zapier-sdk 0.13.6 → 0.13.8

package/src/utils/domain-utils.ts

@@ -1,267 +0,0 @@
-/**
- * Domain utility functions for working with app identifiers and data normalization
- */
-
-import type { Action, Authentication, ImplementationMeta } from "../api/types";
-import type { ActionItem, AppItem, AuthenticationItem } from "../types/domain";
-
-/**
- * Splits a versioned key to extract the base key and version
- *
- * @param versionedKey - Versioned key in format "KeyName@version" (e.g., "SlackCLIAPI@1.21.1")
- * @returns Tuple of [baseKey, version] or [versionedKey, undefined] if no @ symbol
- *
- * @example
- * splitVersionedKey("SlackCLIAPI@1.21.1") // ["SlackCLIAPI", "1.21.1"]
- * splitVersionedKey("SomeAPI") // ["SomeAPI", undefined]
- */
-export function splitVersionedKey(
-  versionedKey: string,
-): [string, string | undefined] {
-  const parts = versionedKey.split("@");
-  if (parts.length >= 2) {
-    const baseKey = parts[0];
-    const version = parts.slice(1).join("@"); // Handle edge case of multiple @ symbols
-    return [baseKey, version];
-  }
-  return [versionedKey, undefined];
-}
-
-/**
- * Converts a lightweight ImplementationMeta to a slimmed AppItem
- *
- * @param implementationMeta - Raw ImplementationMeta from API
- * @returns Normalized AppItem with essential fields only
- */
-export function normalizeImplementationMetaToAppItem(
-  implementationMeta: ImplementationMeta,
-): AppItem {
-  const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
-
-  const { id, name, ...restOfImplementationMeta } = implementationMeta;
-
-  return {
-    ...restOfImplementationMeta,
-    title: name,
-    key: selectedApi,
-    implementation_id: id,
-    version: appVersion,
-  };
-}
-
-/**
- * Converts an API Authentication to an AuthenticationItem with normalized field names
- *
- * @param auth - Raw Authentication from API
- * @param options - Additional fields to include
- * @param options.app_key - selected_api from implementations endpoint
- * @param options.app_version - Version extracted from selected_api
- * @returns Normalized AuthenticationItem
- */
-export function normalizeAuthenticationItem(
-  auth: Authentication,
-  options: { app_key?: string; app_version?: string } = {},
-): AuthenticationItem {
-  // Extract app key and version from selected_api if not provided
-  let appKey = options.app_key;
-  let appVersion = options.app_version;
-
-  if (auth.selected_api) {
-    const [extractedAppKey, extractedVersion] = splitVersionedKey(
-      auth.selected_api,
-    );
-
-    // Use extracted app key if not provided in options
-    if (!appKey) {
-      appKey = extractedAppKey;
-    }
-
-    // Use extracted version if not provided in options
-    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 as any).label || undefined, // 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
-  };
-}
-
-export function normalizeActionItem(action: Action): ActionItem {
-  const { name, type, selected_api: selectedApi } = action;
-
-  // Split version from selected_api
-  const [appKey, appVersion] = selectedApi
-    ? splitVersionedKey(selectedApi)
-    : ["", undefined];
-
-  return {
-    // Only include the fields we want - explicitly list them
-    id: action.id,
-    key: action.key,
-    description: action.description,
-    is_important: action.is_important,
-    is_hidden: action.is_hidden,
-    // Transformed fields
-    app_key: appKey,
-    app_version: appVersion,
-    action_type: type,
-    title: name, // Map name to title
-    type: "action",
-  };
-}
-
-/**
- * Groups app keys by their type based on format patterns
- *
- * @param appKeys Array of app key strings to categorize
- * @returns Object with arrays of keys grouped by type: selectedApi (CLI APIs), slug (everything else)
- *
- * @example
- * groupVersionedAppKeysByType([
- *   'FormatterCLIAPI@1.0.0',
- *   'slack',
- *   'AnotherAPI'
- * ])
- * // Returns: {
- * //   selectedApi: ['FormatterCLIAPI@1.0.0', 'AnotherAPI'],
- * //   slug: ['slack']
- * // }
- */
-export function groupVersionedAppKeysByType(appKeys: string[]): {
-  selectedApi: string[];
-  slug: string[];
-} {
-  const result = {
-    selectedApi: [] as string[],
-    slug: [] as string[],
-  };
-
-  // Use Sets to track seen keys for deduplication
-  const seenSelectedApi = new Set<string>();
-  const seenSlugs = new Set<string>();
-
-  for (const key of appKeys) {
-    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);
-      }
-    }
-  }
-
-  return result;
-}
-
-export function groupAppKeysByType(appKeys: string[]): {
-  selectedApi: string[];
-  slug: string[];
-} {
-  const grouped = groupVersionedAppKeysByType(appKeys);
-
-  // Extract base keys and dedupe by using Set
-  return {
-    selectedApi: [
-      ...new Set(grouped.selectedApi.map((key) => key.split("@")[0])),
-    ],
-    slug: [...new Set(grouped.slug.map((key) => key.split("@")[0]))],
-  };
-}
-
-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);
-  }
-
-  return !!slug.match(/^[a-z0-9]+(?:_[a-z0-9]+)*$/);
-}
-
-export function dashifySnakeCasedSlug(slug: string): string {
-  // Only dashify if it's a valid snake_cased slug.
-  if (!isSnakeCasedSlug(slug)) {
-    return slug;
-  }
-
-  // Allow one leading underscore for slugs starting with a number.
-  if (slug.startsWith("_")) {
-    slug = slug.slice(1);
-  }
-
-  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

@@ -1,73 +0,0 @@
-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

@@ -1,94 +0,0 @@
-// 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}`);
-}

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

@@ -1,141 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createFunction, createPaginatedFunction } from "./function-utils";
-import { ZapierValidationError, ZapierUnknownError } from "../types/errors";
-import { ALL_ITEMS, listTestItems } from "./pagination-utils.test";
-
-describe("createFunction", () => {
-  it("should return result from core function", async () => {
-    const mockCoreFn = async (options: { name: string }) => {
-      return `Hello, ${options.name}!`;
-    };
-
-    const wrappedFn = createFunction(mockCoreFn);
-    const result = await wrappedFn({ name: "World" });
-
-    expect(result).toBe("Hello, World!");
-  });
-});
-
-describe.each([
-  { name: "createFunction", createFn: createFunction },
-  { name: "createPaginatedFunction", createFn: createPaginatedFunction },
-])("$name", ({ createFn }) => {
-  it("should preserve function name", async () => {
-    async function testCoreFn(options: { value: number }) {
-      return options.value * 2;
-    }
-
-    const wrappedFn = createFn(testCoreFn);
-
-    expect(wrappedFn.name).toBe("testCoreFn");
-  });
-
-  it("should normalize and rethrow ZapierError instances", async () => {
-    const mockError = new ZapierValidationError("Validation failed", {
-      details: { field: "name" },
-    });
-    const mockCoreFn = async () => {
-      throw mockError;
-    };
-
-    const wrappedFn = createFn(mockCoreFn);
-
-    await expect(wrappedFn({})).rejects.toBe(mockError);
-  });
-
-  it("should normalize generic Error to ZapierUnknownError", async () => {
-    const mockCoreFn = async () => {
-      throw new Error("Something went wrong");
-    };
-
-    const wrappedFn = createFn(mockCoreFn);
-
-    await expect(wrappedFn({})).rejects.toThrow(ZapierUnknownError);
-  });
-
-  it("should normalize non-Error values to ZapierUnknownError", async () => {
-    const mockCoreFn = async () => {
-      throw "String error";
-    };
-
-    const wrappedFn = createFn(mockCoreFn);
-
-    await expect(wrappedFn({})).rejects.toThrow(ZapierUnknownError);
-  });
-});
-
-describe("createPaginatedFunction", () => {
-  it("should wrap non-array result in {data: [result]}", async () => {
-    const mockCoreFn = async (options: { name: string }) => {
-      return `Hello, ${options.name}!`;
-    };
-
-    const wrappedFn = createPaginatedFunction(mockCoreFn);
-    const result = await wrappedFn({ name: "World" });
-
-    expect(result).toEqual({ data: ["Hello, World!"] });
-  });
-
-  it("should wrap array result in {data: result}", async () => {
-    const mockCoreFn = async (options: { count: number }) => {
-      return Array.from({ length: options.count }, (_, i) => `Item ${i + 1}`);
-    };
-
-    const wrappedFn = createPaginatedFunction(mockCoreFn);
-    const result = await wrappedFn({ count: 3 });
-
-    expect(result).toEqual({ data: ["Item 1", "Item 2", "Item 3"] });
-  });
-
-  it("should return {data} object unchanged", async () => {
-    const mockCoreFn = async (options: { items: string[] }) => {
-      return { data: options.items };
-    };
-
-    const wrappedFn = createPaginatedFunction(mockCoreFn);
-    const result = await wrappedFn({ items: ["A", "B", "C"] });
-
-    expect(result).toEqual({ data: ["A", "B", "C"] });
-  });
-
-  it("should allow for await iteration over pages", async () => {
-    const listItems = createPaginatedFunction(listTestItems);
-
-    const pages = [];
-    for await (const page of listItems({ pageSize: 3 })) {
-      pages.push(page);
-      if (pages.length >= 3) break;
-    }
-
-    // Should have collected 3 pages
-    expect(pages).toHaveLength(3);
-
-    // Check first page structure
-    expect(pages[0]).toEqual({
-      data: ALL_ITEMS.slice(0, 3),
-      nextCursor: "cursor-3",
-    });
-
-    // Check second page
-    expect(pages[1]).toEqual({
-      data: ALL_ITEMS.slice(3, 6),
-      nextCursor: "cursor-6",
-    });
-  });
-
-  it("should allow for await iteration over individual items", async () => {
-    const listItems = createPaginatedFunction(listTestItems);
-
-    const items = [];
-    for await (const item of listItems({ pageSize: 3 }).items()) {
-      items.push(item);
-      if (items.length >= 7) break; // Get first 7 items across pages
-    }
-
-    // Should have collected 7 individual items
-    expect(items).toHaveLength(7);
-
-    // Should be the first 7 items from ALL_ITEMS (flattened from pages)
-    expect(items).toEqual(ALL_ITEMS.slice(0, 7));
-  });
-});