@zapier/zapier-sdk 0.13.6 → 0.13.8

package/src/utils/pagination-utils.ts

@@ -1,242 +0,0 @@
-const offsetCursorMarker = "$$offset$$";
-
-type TPageOptions<TOptions> = TOptions extends undefined
-  ? { cursor?: string; maxItems?: number; pageSize?: number }
-  : TOptions & { cursor?: string; maxItems?: number; pageSize?: number };
-
-function splitOffsetCursor(cursor?: string): [number, string | undefined] {
-  if (!cursor) {
-    return [0, cursor];
-  }
-
-  try {
-    const parsedCursor = JSON.parse(cursor);
-    if (!Array.isArray(parsedCursor)) {
-      return [0, cursor];
-    }
-
-    const [marker, offset, currentCursor] = parsedCursor;
-
-    if (marker !== offsetCursorMarker) {
-      return [0, cursor];
-    }
-
-    if (typeof offset !== "number") {
-      return [0, cursor];
-    }
-
-    return [offset, currentCursor];
-  } catch {
-    return [0, cursor];
-  }
-}
-
-function createOffsetCursor(
-  offset: number,
-  currentCursor: string | undefined,
-): string {
-  return JSON.stringify([offsetCursorMarker, offset, currentCursor]);
-}
-
-export function createPrefixedCursor(
-  prefix: string,
-  cursor: string | undefined,
-): string {
-  if (!cursor) {
-    return `${prefix}::`;
-  }
-  return `${prefix}::${cursor}`;
-}
-
-export function splitPrefixedCursor(
-  cursor: string | undefined,
-  prefixes?: string[],
-): [string | undefined, string | undefined] {
-  if (!cursor) {
-    return [undefined, undefined];
-  }
-
-  const [prefix, ...rest] = cursor.split("::");
-
-  if (prefixes && !prefixes.includes(prefix)) {
-    return [undefined, cursor];
-  }
-
-  cursor = rest.join("::");
-
-  if (!cursor) {
-    return [prefix, undefined];
-  }
-
-  return [prefix, cursor];
-}
-
-/**
- * Utility for paginating through API endpoints that return cursor-based pages
- *
- * @param pageFunction - Function that fetches a single page with {data, nextCursor} structure
- * @param pageOptions - Options to pass to the page function (cursor will be managed automatically)
- * @returns Async iterator that yields pages
- */
-export async function* paginateMaxItems<
-  TOptions,
-  TPage extends { data: any[]; nextCursor?: string },
->(
-  pageFunction: (
-    options: TOptions & {
-      cursor?: string;
-      maxItems?: number;
-      pageSize?: number;
-    },
-  ) => Promise<TPage>,
-  pageOptions?: TPageOptions<TOptions>,
-): AsyncIterableIterator<TPage> {
-  let cursor = pageOptions?.cursor;
-  let totalItemsYielded = 0;
-  const maxItems = pageOptions?.maxItems;
-  const pageSize = pageOptions?.pageSize;
-
-  do {
-    const options = {
-      ...(pageOptions || {}),
-      cursor,
-      pageSize:
-        maxItems !== undefined && pageSize !== undefined
-          ? Math.min(pageSize, maxItems)
-          : pageSize,
-    } as TOptions & { cursor?: string; maxItems?: number; pageSize?: number };
-
-    const page = await pageFunction(options);
-
-    if (maxItems !== undefined) {
-      const remainingItems = maxItems - totalItemsYielded;
-      if (page.data.length >= remainingItems) {
-        const yieldedPage = {
-          ...page,
-          data: page.data.slice(0, remainingItems),
-          nextCursor: undefined,
-        };
-        yield yieldedPage;
-        break;
-      }
-    }
-
-    yield page;
-    totalItemsYielded += page.data.length;
-
-    cursor = page.nextCursor;
-  } while (cursor);
-}
-
-export async function* paginateBuffered<
-  TOptions,
-  TPage extends { data: any[]; nextCursor?: string },
->(
-  pageFunction: (
-    options: TOptions & {
-      cursor?: string;
-      maxItems?: number;
-      pageSize?: number;
-    },
-  ) => Promise<TPage>,
-  pageOptions?: TPageOptions<TOptions>,
-): AsyncIterableIterator<TPage> {
-  const pageSize = pageOptions?.pageSize;
-  const [cursorOffset, currentCursor] = splitOffsetCursor(pageOptions?.cursor);
-  const options = {
-    ...(pageOptions || {}),
-    cursor: currentCursor,
-  } as TPageOptions<TOptions>;
-  const iterator = paginateMaxItems(pageFunction, options);
-  let bufferedPages: TPage[] = [];
-  let isFirstPage = true;
-  let cursor: string | undefined;
-  for await (let page of iterator) {
-    if (isFirstPage) {
-      isFirstPage = false;
-      if (cursorOffset) {
-        page = {
-          ...page,
-          data: page.data.slice(cursorOffset),
-        };
-      }
-    }
-    if (!pageSize) {
-      yield page;
-      cursor = page.nextCursor;
-      continue;
-    }
-
-    const bufferedLength = bufferedPages.reduce(
-      (acc, page) => acc + page.data.length,
-      0,
-    );
-
-    // If we don't have enough to fill a page, buffer this page.
-    if (bufferedLength + page.data.length < pageSize) {
-      bufferedPages.push(page);
-      cursor = page.nextCursor;
-      continue;
-    }
-
-    // Let's yield a page from our buffered pages.
-    const bufferedItems = bufferedPages.map((p) => p.data).flat();
-    const allItems = [...bufferedItems, ...page.data];
-    const pageItems = allItems.slice(0, pageSize);
-    const remainingItems = allItems.slice(pageItems.length);
-
-    // No extra items to buffer, so we can just yield a normal page with a cursor to the next one.
-    if (remainingItems.length === 0) {
-      yield {
-        ...page,
-        data: pageItems,
-        nextCursor: page.nextCursor,
-      };
-      bufferedPages = [];
-      cursor = page.nextCursor;
-      continue;
-    }
-
-    // Yield our items with a cursor to offset into this page.
-    yield {
-      ...page,
-      data: pageItems,
-      nextCursor: createOffsetCursor(
-        page.data.length - remainingItems.length,
-        cursor,
-      ),
-    };
-
-    while (remainingItems.length > pageSize) {
-      const pageItems = remainingItems.splice(0, pageSize);
-      yield {
-        ...page,
-        data: pageItems,
-        nextCursor: createOffsetCursor(
-          page.data.length - remainingItems.length,
-          cursor,
-        ),
-      };
-    }
-
-    bufferedPages = [
-      {
-        ...page,
-        data: remainingItems,
-      },
-    ];
-
-    cursor = page.nextCursor;
-  }
-
-  if (bufferedPages.length > 0) {
-    const lastBufferedPage = bufferedPages.slice(-1)[0];
-    const bufferedItems = bufferedPages.map((p) => p.data).flat();
-    yield {
-      ...lastBufferedPage,
-      data: bufferedItems,
-    };
-  }
-}
-
-export const paginate = paginateBuffered;

package/src/utils/schema-utils.ts

@@ -1,207 +0,0 @@
-import { z } from "zod";
-import type { ZapierSdk } from "../types/sdk";
-import type { InputFieldItem } from "../schemas/Field";
-
-// ============================================================================
-// Format Metadata Types
-// ============================================================================
-
-export interface FormattedItem {
-  title: string;
-  id?: string;
-  key?: string;
-  keys?: string[];
-  description?: string;
-  data?: unknown; // Optional: if provided, CLI will use formatJsonOutput instead of details
-  details: Array<{
-    text: string;
-    style: "normal" | "dim" | "accent" | "warning" | "success";
-  }>;
-}
-
-export interface FormatMetadata<TItem = unknown> {
-  format: (item: TItem) => FormattedItem;
-}
-
-// Helper function to add format metadata to schemas
-export function withFormatter<T extends z.ZodType>(
-  schema: T,
-  formatMeta: FormatMetadata<z.infer<T>>,
-): T {
-  // Store format metadata on the schema definition
-  Object.assign(schema._def, {
-    formatMeta: formatMeta,
-  });
-  return schema as T & {
-    _def: T["_def"] & { formatMeta: FormatMetadata<z.infer<T>> };
-  };
-}
-
-// Helper function to get output schema from an input schema
-export function getOutputSchema(inputSchema: z.ZodType): z.ZodType | undefined {
-  return (inputSchema._def as { outputSchema?: z.ZodType }).outputSchema;
-}
-
-// Helper function to link input schemas to output schemas
-export function withOutputSchema<T extends z.ZodType>(
-  inputSchema: T,
-  outputSchema: z.ZodType,
-): T & {
-  _def: T["_def"] & { outputSchema: z.ZodType };
-} {
-  // Store output schema reference on the input schema
-  Object.assign(inputSchema._def, {
-    outputSchema,
-  });
-  return inputSchema as T & {
-    _def: T["_def"] & { outputSchema: z.ZodType };
-  };
-}
-
-// ============================================================================
-// Resolution Metadata Types
-// ============================================================================
-
-export interface PromptConfig {
-  type: "list";
-  name: string;
-  message: string;
-  choices: Array<{
-    name: string;
-    value: unknown;
-  }>;
-}
-
-export interface Resolver {
-  type: string;
-  depends?: readonly string[] | string[]; // Parameters this resolver depends on
-}
-
-export interface StaticResolver extends Resolver {
-  type: "static";
-  inputType?: "text" | "password" | "email";
-  placeholder?: string;
-}
-
-export interface DynamicResolver<
-  TItem = unknown,
-  TParams = Record<string, unknown>,
-> extends Resolver {
-  type: "dynamic";
-  fetch: (sdk: ZapierSdk, resolvedParams: TParams) => Promise<TItem[]>; // Function to fetch data using SDK
-  prompt: (items: TItem[], params: TParams) => PromptConfig;
-}
-
-export interface FieldsResolver<TParams = Record<string, unknown>>
-  extends Resolver {
-  type: "fields";
-  fetch: (sdk: ZapierSdk, resolvedParams: TParams) => Promise<InputFieldItem[]>; // Function to fetch fields using SDK
-}
-
-export type ResolverMetadata<
-  TItem = unknown,
-  TParams = Record<string, unknown>,
-> = StaticResolver | DynamicResolver<TItem, TParams> | FieldsResolver<TParams>;
-
-// Wrapper interface for resolver metadata to allow future extensibility
-export interface ResolverConfig<
-  TItem = unknown,
-  TParams = Record<string, unknown>,
-> {
-  resolver: ResolverMetadata<TItem, TParams>;
-  // Future metadata types can be added here:
-  // validation?: ValidationMetadata;
-  // display?: DisplayMetadata;
-}
-
-// Helper function to add resolver metadata to schemas
-export function withResolver<
-  T extends z.ZodType,
-  TItem = unknown,
-  TParams = Record<string, unknown>,
->(schema: T, config: ResolverConfig<TItem, TParams>): T {
-  // Store resolver metadata on the schema definition
-  (
-    schema._def as { resolverMeta?: ResolverConfig<TItem, TParams> }
-  ).resolverMeta = config;
-  return schema;
-}
-
-// ============================================================================
-// Schema Description Utilities
-// ============================================================================
-
-export function getSchemaDescription(schema: z.ZodSchema): string | undefined {
-  return schema.description;
-}
-
-export function getFieldDescriptions(
-  schema: z.ZodObject<z.ZodRawShape>,
-): Record<string, string> {
-  const descriptions: Record<string, string> = {};
-  const shape = schema.shape;
-
-  for (const [key, fieldSchema] of Object.entries(shape)) {
-    if (fieldSchema instanceof z.ZodType && fieldSchema.description) {
-      descriptions[key] = fieldSchema.description;
-    }
-  }
-
-  return descriptions;
-}
-
-// ============================================================================
-// Positional Parameter Metadata
-// ============================================================================
-
-export interface PositionalMetadata {
-  positionalMeta: {
-    positional: true;
-  };
-}
-
-// Helper function to mark a parameter as positional for CLI
-export function withPositional<T extends z.ZodType>(
-  schema: T,
-): T & {
-  _def: T["_def"] & PositionalMetadata;
-} {
-  // Store positional metadata on the schema definition
-  Object.assign(schema._def, {
-    positionalMeta: { positional: true },
-  } satisfies PositionalMetadata);
-  return schema as T & {
-    _def: T["_def"] & PositionalMetadata;
-  };
-}
-
-function schemaHasPositionalMeta<T extends z.ZodType>(
-  schema: T,
-): schema is T & {
-  _def: T["_def"] & PositionalMetadata;
-} {
-  return "positionalMeta" in schema._def;
-}
-
-// Helper function to check if a parameter should be positional
-export function isPositional(schema: z.ZodType): boolean {
-  // Check the current schema first
-  if (
-    schemaHasPositionalMeta(schema) &&
-    schema._def.positionalMeta?.positional
-  ) {
-    return true;
-  }
-
-  // If this is a ZodOptional, check the inner type
-  if (schema instanceof z.ZodOptional) {
-    return isPositional(schema._def.innerType);
-  }
-
-  // If this is a ZodDefault, check the inner type
-  if (schema instanceof z.ZodDefault) {
-    return isPositional(schema._def.innerType);
-  }
-
-  return false;
-}

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

@@ -1,45 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { toTitleCase } from "./string-utils";
-
-describe("toTitleCase", () => {
-  it("converts snake_case to title case", () => {
-    expect(toTitleCase("first_name")).toBe("First Name");
-    expect(toTitleCase("sender_settings")).toBe("Sender Settings");
-    expect(toTitleCase("api_key_config")).toBe("Api Key Config");
-  });
-
-  it("converts camelCase to title case", () => {
-    expect(toTitleCase("firstName")).toBe("First Name");
-    expect(toTitleCase("senderSettings")).toBe("Sender Settings");
-    expect(toTitleCase("apiKeyConfig")).toBe("Api Key Config");
-  });
-
-  it("converts kebab-case to title case", () => {
-    expect(toTitleCase("first-name")).toBe("First Name");
-    expect(toTitleCase("sender-settings")).toBe("Sender Settings");
-    expect(toTitleCase("api-key-config")).toBe("Api Key Config");
-  });
-
-  it("handles mixed formats", () => {
-    expect(toTitleCase("first_name-value")).toBe("First Name Value");
-    expect(toTitleCase("sender_settings-config")).toBe(
-      "Sender Settings Config",
-    );
-  });
-
-  it("handles single words", () => {
-    expect(toTitleCase("name")).toBe("Name");
-    expect(toTitleCase("settings")).toBe("Settings");
-  });
-
-  it("handles multiple spaces and trims", () => {
-    expect(toTitleCase("  first   name  ")).toBe("First Name");
-    expect(toTitleCase("sender__settings")).toBe("Sender Settings");
-  });
-
-  it("handles empty and edge cases", () => {
-    expect(toTitleCase("")).toBe("");
-    expect(toTitleCase("a")).toBe("A");
-    expect(toTitleCase("_")).toBe("");
-  });
-});

package/src/utils/string-utils.ts

@@ -1,54 +0,0 @@
-/**
- * String utility functions for the Zapier SDK
- */
-
-/**
- * Converts a string to title case, handling various input formats:
- * - camelCase: "firstName" → "First Name"
- * - snake_case: "first_name" → "First Name"
- * - kebab-case: "first-name" → "First Name"
- * - mixed formats: "first_name-value" → "First Name Value"
- */
-export function toTitleCase(input: string): string {
-  return (
-    input
-      // insert a space before capital letters (handles camelCase)
-      .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-      // replace delimiters (underscore, dash, multiple spaces) with single space
-      .replace(/[_\-]+/g, " ")
-      .replace(/\s+/g, " ")
-      .trim()
-      // split and capitalize each word
-      .split(" ")
-      .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-      .join(" ")
-  );
-}
-
-/**
- * Converts a string to snake_case, handling various input formats:
- * - camelCase: "firstName" → "first_name"
- * - kebab-case: "first-name" → "first_name"
- * - title case: "First Name" → "first_name"
- * - mixed formats: "first-Name Value" → "first_name_value"
- * - starts with number: "123abc" → "_123abc"
- */
-export function toSnakeCase(input: string): string {
-  let result = input
-    // insert underscore before capital letters (handles camelCase)
-    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-    // replace spaces and dashes with underscores
-    .replace(/[\s\-]+/g, "_")
-    // replace multiple underscores with single underscore
-    .replace(/_+/g, "_")
-    // remove leading/trailing underscores and convert to lowercase
-    .replace(/^_|_$/g, "")
-    .toLowerCase();
-
-  // If the result starts with a number, prefix with underscore
-  if (/^[0-9]/.test(result)) {
-    result = "_" + result;
-  }
-
-  return result;
-}

package/src/utils/validation.test.ts

@@ -1,51 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createValidator } from "./validation";
-import { ZapierValidationError } from "../types/errors";
-
-describe("validation utilities", () => {
-  describe("createValidator", () => {
-    it("should validate valid input", () => {
-      const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-      });
-      const validator = createValidator(schema);
-
-      const result = validator({ name: "John", age: 30 });
-      expect(result).toEqual({ name: "John", age: 30 });
-    });
-
-    it("should throw ZapierValidationError for invalid input", () => {
-      const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-      });
-      const validator = createValidator(schema);
-
-      expect(() => {
-        validator({ name: "John", age: "not-a-number" });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should include helpful error messages", () => {
-      const schema = z.object({
-        name: z.string(),
-        age: z.number().min(0),
-      });
-      const validator = createValidator(schema);
-
-      try {
-        validator({ name: 123, age: -5 });
-      } catch (error) {
-        expect(error).toBeInstanceOf(ZapierValidationError);
-        expect((error as ZapierValidationError).message).toContain("name:");
-        expect((error as ZapierValidationError).message).toContain("age:");
-        expect(
-          ((error as ZapierValidationError).details as { zodErrors: unknown })
-            ?.zodErrors,
-        ).toBeDefined();
-      }
-    });
-  });
-});

package/src/utils/validation.ts

@@ -1,44 +0,0 @@
-import type { z } from "zod";
-import { ZapierValidationError } from "../types/errors";
-
-/**
- * Throws clean ZapierValidationError on validation failures
- */
-const validate = <TSchema extends z.ZodSchema>(
-  schema: TSchema,
-  input: unknown,
-) => {
-  const result = schema.safeParse(input);
-
-  if (!result.success) {
-    // Format Zod errors into a clean, user-friendly message
-    const errorMessages = result.error.errors.map((error) => {
-      const path = error.path.length > 0 ? error.path.join(".") : "input";
-      return `${path}: ${error.message}`;
-    });
-
-    const message = `Validation failed:\n  ${errorMessages.join("\n  ")}`;
-
-    throw new ZapierValidationError(message, {
-      details: {
-        zodErrors: result.error.errors,
-        input,
-      },
-    });
-  }
-
-  return result.data;
-};
-
-export function createValidator<TSchema extends z.ZodSchema>(schema: TSchema) {
-  return function validateFn(input: unknown): z.infer<TSchema> {
-    return validate(schema, input);
-  };
-}
-
-export const validateOptions = <TOptions, TSchemaOptions extends TOptions>(
-  schema: z.ZodSchema<TSchemaOptions>,
-  options: TOptions,
-) => {
-  return validate(schema, options);
-};

package/tsconfig.build.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ES2020",
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "bundler"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["dist", "node_modules", "src/**/*.test.ts", "src/**/*.spec.ts"]
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ES2020",
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "bundler",
-    "composite": true,
-    "declarationMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["dist", "node_modules"]
-}