@zapier/zapier-sdk 0.13.6 → 0.13.8

package/src/plugins/manifest/index.ts

@@ -1,461 +0,0 @@
-import { readFile, writeFile, resolve } from "../../utils/file-utils";
-import type {
-  GetVersionedImplementationId,
-  Manifest,
-  ManifestEntry,
-  ManifestPluginOptionsSchema,
-  ResolveAppKeys,
-} from "./schemas";
-import { ManifestSchema, DEFAULT_CONFIG_PATH } from "./schemas";
-import type { Plugin } from "../../types/plugin";
-import type { z } from "zod";
-import type { ApiClient } from "../../api";
-import type { ImplementationsMetaResponse } from "../../api/types";
-import {
-  normalizeImplementationMetaToAppItem,
-  splitVersionedKey,
-  isSnakeCasedSlug,
-  dashifySnakeCasedSlug,
-  toAppLocator,
-  type ResolvedAppLocator,
-  isResolvedAppLocator,
-} from "../../utils/domain-utils";
-import type { AppItem } from "../../types/domain";
-import { extractCursor } from "../../utils/function-utils";
-import { paginate } from "../../utils/pagination-utils";
-import { toArrayFromAsync } from "../../utils/array-utils";
-
-export type ManifestPluginOptions = z.infer<typeof ManifestPluginOptionsSchema>;
-
-export interface UpdateManifestEntryOptions {
-  appKey: string;
-  entry: ManifestEntry;
-  configPath?: string;
-  skipWrite?: boolean;
-  manifest?: Manifest;
-}
-
-export interface ManifestPluginProvides {
-  context: {
-    getVersionedImplementationId: GetVersionedImplementationId;
-    resolveAppKeys: ResolveAppKeys;
-    updateManifestEntry: (
-      options: UpdateManifestEntryOptions,
-    ) => Promise<[string, ManifestEntry, Manifest]>;
-  };
-}
-
-/**
- * Parse manifest content from a string
- */
-function parseManifestContent(
-  content: string,
-  source: string,
-): Manifest | null {
-  try {
-    const parsed = JSON.parse(content);
-
-    if (parsed?.apps && typeof parsed?.apps === "object") {
-      const result = ManifestSchema.safeParse(parsed);
-      if (result.success) {
-        return result.data;
-      }
-      console.warn(`⚠️ Invalid manifest format in ${source}: ${result.error}`);
-    }
-
-    return null;
-  } catch (error) {
-    console.warn(`⚠️ Failed to parse manifest from ${source}:`, error);
-    return null;
-  }
-}
-
-/**
- * Read manifest from a file path asynchronously
- * Supports local files (Node.js) and browser environments (fallback to global filesystem)
- */
-export async function readManifestFromFile(
-  filePath: string,
-): Promise<Manifest | null> {
-  try {
-    // Resolve relative paths relative to current working directory
-    const resolvedPath = await resolve(filePath);
-    const content = await readFile(resolvedPath);
-    return parseManifestContent(content, resolvedPath);
-  } catch {
-    console.warn(`⚠️ Failed to read manifest from ${filePath}`);
-    return null;
-  }
-}
-
-/**
- * Write manifest to a file path asynchronously
- * Supports local files (Node.js) and browser environments (fallback to global filesystem)
- */
-async function writeManifestToFile(
-  manifest: Manifest,
-  filePath: string,
-): Promise<void> {
-  const resolvedPath = await resolve(filePath);
-  await writeFile(resolvedPath, JSON.stringify(manifest, null, 2));
-}
-
-/**
- * Get the preferred key for storing an app in the manifest
- * Extracted from plugin to make it easier to test
- */
-export async function getPreferredManifestEntryKey({
-  appKey,
-  api,
-}: {
-  appKey: string;
-  api: ApiClient;
-}): Promise<string> {
-  const locator = toAppLocator(appKey);
-
-  // If we have a slug, prefer it
-  if (locator.slug) {
-    return locator.slug;
-  }
-
-  // If we have implementation name, look up the latest to get the slug
-  if (locator.implementationName) {
-    try {
-      // API call to get app metadata by implementation name using selected_apis parameter
-      const implementationsEnvelope: ImplementationsMetaResponse =
-        await api.get(`/api/v4/implementations-meta/lookup/`, {
-          searchParams: {
-            selected_apis: locator.implementationName,
-          },
-        });
-
-      if (
-        implementationsEnvelope.results.length > 0 &&
-        implementationsEnvelope.results[0].slug
-      ) {
-        return implementationsEnvelope.results[0].slug;
-      }
-    } catch {
-      // Fall back to implementation name if lookup fails
-    }
-
-    return locator.implementationName;
-  }
-
-  // Fall back to original key if we can't determine anything better
-  return locator.lookupAppKey;
-}
-
-async function listAppsForSlugsPage({
-  slugs,
-  cursor,
-  api,
-}: {
-  slugs: string[];
-  cursor?: string;
-  api: ApiClient;
-}) {
-  const searchParams: Record<string, string> = {};
-
-  if (slugs.length > 0) {
-    searchParams.slugs = slugs.join(",");
-  }
-
-  if (cursor) {
-    searchParams.offset = cursor;
-  }
-
-  const implementationsEnvelope: ImplementationsMetaResponse = await api.get(
-    "/api/v4/implementations-meta/lookup/",
-    {
-      searchParams,
-    },
-  );
-
-  return {
-    data: implementationsEnvelope.results.map(
-      normalizeImplementationMetaToAppItem,
-    ),
-    nextCursor: extractCursor(implementationsEnvelope),
-  };
-}
-
-/**
- * Find a manifest entry by any app key (implementation name, slug, etc.).
- */
-export function findManifestEntry({
-  appKey,
-  manifest,
-}: {
-  appKey: string;
-  manifest: Manifest;
-}): [string, ManifestEntry] | null {
-  const [appKeyWithoutVersion] = splitVersionedKey(appKey);
-
-  // Direct match by key
-  if (manifest.apps[appKeyWithoutVersion]) {
-    return [appKeyWithoutVersion, manifest.apps[appKeyWithoutVersion]];
-  }
-
-  // Handle snake-cased slugs (convert to dashed)
-  if (isSnakeCasedSlug(appKey)) {
-    const slug = dashifySnakeCasedSlug(appKey);
-    if (manifest.apps[slug]) {
-      return [slug, manifest.apps[slug]];
-    }
-  }
-
-  // Search by implementation name in manifest values
-  for (const [key, entry] of Object.entries(manifest.apps)) {
-    if (entry.implementationName === appKeyWithoutVersion) {
-      return [key, entry];
-    }
-  }
-
-  // No match found
-  return null;
-}
-
-/**
- * Turn any app keys (slugs, implementation names, etc.) into app locators, which are objects that will be guaranteed to
- * have implementation names. Note that this function will not actually guarantee that implementation names are valid!
- * It will attempt to find the app key in the manifest, or if it's a slug, actually do an API call, or otherwise just
- * assume it's an implementation name that will be used for an API call.
- */
-async function resolveAppKeys({
-  appKeys,
-  api,
-  manifest,
-}: {
-  appKeys: string[];
-  api: ApiClient;
-  manifest: Manifest;
-}): Promise<ResolvedAppLocator[]> {
-  // Step 1: Convert all app keys to locators
-  const locators = appKeys.map(toAppLocator);
-
-  // Step 2: Map to resolved/unresolved via manifest
-  const locatorsWithManifest = locators.map((locator) => {
-    const manifestEntryResult = findManifestEntry({
-      appKey: locator.lookupAppKey,
-      manifest,
-    });
-
-    if (manifestEntryResult) {
-      const [, manifestEntry] = manifestEntryResult;
-      // Use manifest entry to resolve implementation name
-      const resolvedVersion = locator.version || manifestEntry.version;
-
-      const resolvedLocator: ResolvedAppLocator = {
-        ...locator,
-        implementationName: manifestEntry.implementationName,
-        version: resolvedVersion,
-      };
-
-      return resolvedLocator;
-    }
-
-    // If these have an implementationName, they're already resolved.
-    return locator;
-  });
-
-  // Step 3: Separate resolved from unresolved
-  const unresolvedLocators = locatorsWithManifest.filter(
-    (locator) => !isResolvedAppLocator(locator),
-  );
-
-  // Step 4: Resolve slugs via API
-  const slugsToResolve = unresolvedLocators
-    .map((locator) => locator.slug)
-    .filter((slug): slug is string => !!slug)
-    .filter((slug, index, array) => array.indexOf(slug) === index); // dedupe
-
-  if (slugsToResolve.length === 0) {
-    return locatorsWithManifest.filter(isResolvedAppLocator);
-  }
-
-  const iterator = paginate(listAppsForSlugsPage, {
-    slugs: slugsToResolve,
-    api,
-  });
-
-  const pages = await toArrayFromAsync(iterator);
-  const apps = pages.flatMap((page) => page.data);
-
-  const slugToAppData = new Map<string, AppItem>();
-  for (const app of apps) {
-    if (app.slug) {
-      slugToAppData.set(app.slug, app);
-    }
-  }
-
-  const slugResolvedLocators = locatorsWithManifest.map((locator) => {
-    if (isResolvedAppLocator(locator)) {
-      return locator;
-    }
-    if (locator.slug) {
-      const appData = slugToAppData.get(locator.slug);
-      if (appData) {
-        // After resolving from API, check if we have a manifest entry for this implementation name
-        const manifestEntryByImplementationName = findManifestEntry({
-          appKey: appData.key, // appData.key is the implementation name
-          manifest,
-        });
-
-        let version = locator.version;
-        if (!version) {
-          // Prefer manifest version if available, otherwise use API version
-          version = manifestEntryByImplementationName
-            ? manifestEntryByImplementationName[1].version || appData.version
-            : appData.version;
-        }
-
-        return {
-          ...locator,
-          implementationName: appData.key,
-          version,
-        };
-      }
-    }
-    return locator;
-  });
-
-  // Return all resolved locators.
-  return slugResolvedLocators.filter(isResolvedAppLocator);
-}
-
-export { DEFAULT_CONFIG_PATH } from "./schemas";
-export type { ManifestEntry, Manifest } from "./schemas";
-
-export const manifestPlugin: Plugin<
-  {}, // no SDK dependencies
-  { api: ApiClient },
-  ManifestPluginProvides
-> = (params) => {
-  const { context } = params;
-  const { api, options } = context;
-  const { manifestPath = DEFAULT_CONFIG_PATH, manifest } = options || {};
-
-  let resolvedManifest: Manifest | undefined | null;
-
-  async function resolveManifest(): Promise<Manifest | null> {
-    // If manifest is provided directly, use it
-    if (manifest) {
-      return manifest;
-    }
-    // If manifestPath is provided, load from file
-    if (manifestPath) {
-      return await readManifestFromFile(manifestPath);
-    }
-    return null;
-  }
-
-  const getResolvedManifest = async (): Promise<Manifest | null> => {
-    if (typeof resolvedManifest === "undefined") {
-      resolvedManifest = (await resolveManifest()) ?? null;
-    }
-
-    return resolvedManifest;
-  };
-
-  const getVersionedImplementationId = async (appKey: string) => {
-    const resolvedApps = await resolveAppKeys({
-      appKeys: [appKey],
-      api,
-      manifest: (await getResolvedManifest()) ?? { apps: {} },
-    });
-
-    const resolvedApp = resolvedApps[0];
-    if (!resolvedApp) return null;
-
-    return `${resolvedApp.implementationName}@${resolvedApp.version || "latest"}`;
-  };
-
-  const updateManifestEntry = async (
-    options: UpdateManifestEntryOptions,
-  ): Promise<[string, ManifestEntry, Manifest]> => {
-    const {
-      appKey,
-      entry,
-      configPath = DEFAULT_CONFIG_PATH,
-      skipWrite = false,
-      manifest: inputManifest,
-    } = options;
-
-    // Use provided manifest or read from file
-    const manifest = inputManifest ||
-      (await readManifestFromFile(configPath)) || { apps: {} };
-
-    // Try to find existing entry by direct key first
-    let existingEntry = findManifestEntry({
-      appKey,
-      manifest,
-    });
-
-    // If not found directly, try to resolve the app key and search by implementation name
-    if (!existingEntry) {
-      try {
-        const resolvedApps = await resolveAppKeys({
-          appKeys: [appKey],
-          api,
-          manifest,
-        });
-
-        if (resolvedApps.length > 0) {
-          const resolvedImplementationName = resolvedApps[0].implementationName;
-          // Try to find entry using the resolved implementation name
-          existingEntry = findManifestEntry({
-            appKey: resolvedImplementationName,
-            manifest,
-          });
-        }
-      } catch {
-        // If resolution fails, continue with original logic
-      }
-    }
-
-    let manifestKey: string;
-
-    if (existingEntry) {
-      // Use existing key to maintain consistency with types files
-      manifestKey = existingEntry[0];
-    } else {
-      // Get preferred key for new entries
-      manifestKey = await getPreferredManifestEntryKey({
-        appKey,
-        api,
-      });
-    }
-
-    const updatedManifest = {
-      ...manifest,
-      apps: {
-        ...manifest.apps,
-        [manifestKey]: entry,
-      },
-    };
-
-    // Conditionally write to file
-    if (!skipWrite) {
-      await writeManifestToFile(updatedManifest, configPath);
-
-      // Clear the cached manifest so it gets reloaded with the new data
-      resolvedManifest = undefined;
-    }
-
-    return [manifestKey, entry, updatedManifest];
-  };
-
-  return {
-    context: {
-      getVersionedImplementationId,
-      resolveAppKeys: async ({ appKeys }: { appKeys: string[] }) =>
-        resolveAppKeys({
-          appKeys,
-          api,
-          manifest: (await getResolvedManifest()) ?? { apps: {} },
-        }),
-      updateManifestEntry,
-    },
-  };
-};

package/src/plugins/manifest/schemas.ts

@@ -1,60 +0,0 @@
-import { z } from "zod";
-import type { ResolvedAppLocator } from "../../utils/domain-utils";
-import type { AppItem } from "../../types/domain";
-
-export const DEFAULT_CONFIG_PATH = ".zapierrc" as const;
-
-export type ManifestEntry = {
-  implementationName: string;
-  version?: string;
-};
-
-export type GetVersionedImplementationId = (
-  appKey: string,
-) => Promise<string | null>;
-
-export type GetImplementation = (appKey: string) => Promise<AppItem | null>;
-
-export type Manifest = {
-  apps: Record<string, ManifestEntry>;
-};
-
-export type ResolveAppKeys = ({
-  appKeys,
-}: {
-  appKeys: string[];
-}) => Promise<ResolvedAppLocator[]>;
-
-/**
- * Manifest schema for version locking
- * Maps app keys to their locked version information
- */
-export const ManifestSchema = z
-  .object({
-    apps: z.record(
-      z.string(),
-      z.object({
-        implementationName: z
-          .string()
-          .describe(
-            "Base implementation name without version (e.g., 'SlackCLIAPI')",
-          ),
-        version: z.string().describe("Version string (e.g., '1.21.1')"),
-      }),
-    ),
-  })
-  .describe("Manifest mapping app keys to version information");
-
-export const ManifestPluginOptionsSchema = z.object({
-  manifestPath: z.string().optional().describe("Path to manifest file"),
-  manifest: z
-    .record(
-      z.string(),
-      z.object({
-        implementationName: z.string(),
-        version: z.string().optional(),
-      }),
-    )
-    .optional()
-    .describe("Direct manifest object"),
-});

package/src/plugins/registry/index.ts

@@ -1,160 +0,0 @@
-import type { Plugin } from "../../types/plugin";
-import type { FunctionRegistryEntry } from "../../types/sdk";
-
-export interface RegisterPluginFunctionOptions {}
-
-export interface RegistryPluginProvides {
-  getRegistry: (options?: { package?: string }) => {
-    functions: FunctionRegistryEntry[];
-    categories: {
-      key: string;
-      title: string;
-      titlePlural: string;
-      functions: string[];
-    }[];
-  };
-}
-
-// Registry plugin requires no context but collects SDK metadata
-export const registryPlugin: Plugin<
-  {}, // accepts any SDK shape
-  {}, // requires no context
-  RegistryPluginProvides
-> = ({ sdk, context }) => {
-  const metaKeys = Object.keys(context.meta || {});
-
-  const categoryDefinitions: Record<
-    string,
-    { title: string; titlePlural?: string }
-  > = {
-    account: {
-      title: "Account",
-    },
-    app: {
-      title: "App",
-      titlePlural: "Apps",
-    },
-    authentication: {
-      title: "Authentication",
-    },
-    action: {
-      title: "Action",
-    },
-    http: {
-      title: "HTTP Request",
-    },
-    utility: {
-      title: "Utility",
-      titlePlural: "Utilities",
-    },
-    other: {
-      title: "Other",
-    },
-  };
-
-  const functions = metaKeys
-    .filter((key) => {
-      const property = sdk[key as keyof typeof sdk];
-      if (typeof property === "function") {
-        return true;
-      }
-      const [rootKey] = key.split(".");
-      const rootProperty = sdk[rootKey as keyof typeof sdk];
-      if (typeof rootProperty === "object" && rootProperty !== null) {
-        return true;
-      }
-      return false;
-    })
-    .map((key) => {
-      const meta = context.meta[key];
-      return {
-        name: key,
-        type: meta.type,
-        itemType: meta.itemType,
-        returnType: meta.returnType,
-        inputSchema: meta.inputSchema,
-        inputParameters: meta.inputParameters,
-        outputSchema: meta.outputSchema,
-        categories: meta.categories || [],
-        resolvers: meta.resolvers,
-        packages: meta.packages,
-      };
-    })
-    .sort((a, b) => a.name.localeCompare(b.name));
-
-  const knownCategories = Object.keys(categoryDefinitions);
-
-  // Cache the entire registry result for each package
-  const registryCache = new Map<
-    string,
-    { functions: FunctionRegistryEntry[]; categories: any[] }
-  >();
-
-  function getRegistry(options?: { package?: string }) {
-    const packageFilter = options?.package;
-    const cacheKey = packageFilter || "__all__";
-
-    // Return cached result if available
-    if (registryCache.has(cacheKey)) {
-      return registryCache.get(cacheKey)!;
-    }
-
-    // Filter functions by package if specified
-    const filteredFunctions = packageFilter
-      ? functions.filter(
-          (f) =>
-            // Include if packages is undefined (belongs to all packages) or includes the specified package
-            !f.packages || f.packages.includes(packageFilter),
-        )
-      : functions;
-
-    // Build categories with filtered functions
-    const filteredCategories = knownCategories
-      .sort((a, b) => {
-        // Keep "other" category last
-        if (a === "other") return 1;
-        if (b === "other") return -1;
-        // Alphabetize by title, not key
-        const titleA = categoryDefinitions[a].title;
-        const titleB = categoryDefinitions[b].title;
-        return titleA.localeCompare(titleB);
-      })
-      .map((categoryKey) => {
-        // Find the functions that are in this category and match the package filter
-        const categoryFunctions = filteredFunctions
-          .filter(
-            (f) =>
-              f.categories.includes(categoryKey) ||
-              // If the category is "other" and the function is not in any other category, include it
-              (categoryKey === "other" &&
-                !f.categories.some((c) => knownCategories.includes(c))),
-          )
-          .map((f) => f.name)
-          .sort(); // Alphabetize functions within each category
-
-        const definition = categoryDefinitions[categoryKey];
-        const title = definition.title;
-        return {
-          key: categoryKey,
-          title,
-          titlePlural: definition.titlePlural ?? `${title}s`,
-          functions: categoryFunctions,
-        };
-      })
-      .filter((category) => category.functions.length > 0); // Only include categories with functions
-
-    const result = {
-      functions: filteredFunctions,
-      categories: filteredCategories,
-    };
-
-    // Cache the result
-    registryCache.set(cacheKey, result);
-
-    return result;
-  }
-
-  return {
-    getRegistry,
-  };
-};