@zapier/zapier-sdk 0.8.3 → 0.10.0

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}`);
+}

package/src/utils/schema-utils.ts

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import type { ZapierSdk } from "../types/sdk";
+import type { InputFieldItem } from "../schemas/Field";
 
 // ============================================================================
 // Format Metadata Types
@@ -6,92 +8,121 @@ import { z } from "zod";
 
 export interface FormattedItem {
   title: string;
-  subtitle?: string;
+  id?: string;
+  key?: 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 {
-  format: (item: any) => FormattedItem;
+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,
+  formatMeta: FormatMetadata<z.infer<T>>,
 ): T {
   // Store format metadata on the schema definition
-  (schema._def as any).formatMeta = formatMeta;
-  return schema;
+  Object.assign(schema._def, {
+    formatMeta: formatMeta,
+  });
+  return schema as T & {
+    _def: T["_def"] & { formatMeta: FormatMetadata<z.infer<T>> };
+  };
 }
 
-// Helper function to get format metadata from a schema
-export function getFormatMetadata(
-  schema: z.ZodType,
-): FormatMetadata | undefined {
-  return (schema._def as any).formatMeta;
+// 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 {
+): T & {
+  _def: T["_def"] & { outputSchema: z.ZodType };
+} {
   // Store output schema reference on the input schema
-  (inputSchema._def as any).outputSchema = outputSchema;
-  return inputSchema;
-}
-
-// Helper function to get output schema from an input schema
-export function getOutputSchema(inputSchema: z.ZodType): z.ZodType | undefined {
-  return (inputSchema._def as any).outputSchema;
+  Object.assign(inputSchema._def, {
+    outputSchema,
+  });
+  return inputSchema as T & {
+    _def: T["_def"] & { outputSchema: z.ZodType };
+  };
 }
 
 // ============================================================================
 // Resolution Metadata Types
 // ============================================================================
 
-export interface StaticResolver {
+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 {
+export interface DynamicResolver<
+  TItem = unknown,
+  TParams = Record<string, unknown>,
+> extends Resolver {
   type: "dynamic";
-  fetch: (sdk: any, resolvedParams: any) => Promise<any[]>; // Function to fetch data using SDK
-  prompt: (items: any[], params: any) => any;
-  depends?: string[]; // Parameters this resolver depends on
+  fetch: (sdk: ZapierSdk, resolvedParams: TParams) => Promise<TItem[]>; // Function to fetch data using SDK
+  prompt: (items: TItem[], params: TParams) => PromptConfig;
 }
 
-export interface FieldsResolver {
+export interface FieldsResolver<TParams = Record<string, unknown>>
+  extends Resolver {
   type: "fields";
-  fetch: (sdk: any, resolvedParams: any) => Promise<any[]>; // Function to fetch fields using SDK
-  depends?: string[]; // Parameters this resolver depends on
+  fetch: (sdk: ZapierSdk, resolvedParams: TParams) => Promise<InputFieldItem[]>; // Function to fetch fields using SDK
 }
 
-export type ResolverMetadata =
-  | StaticResolver
-  | DynamicResolver
-  | FieldsResolver;
+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 {
-  resolver: ResolverMetadata;
+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>(
-  schema: T,
-  config: ResolverConfig,
-): T {
+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 any).resolverMeta = config;
+  (
+    schema._def as { resolverMeta?: ResolverConfig<TItem, TParams> }
+  ).resolverMeta = config;
   return schema;
 }
 
@@ -104,7 +135,7 @@ export function getSchemaDescription(schema: z.ZodSchema): string | undefined {
 }
 
 export function getFieldDescriptions(
-  schema: z.ZodObject<any>,
+  schema: z.ZodObject<z.ZodRawShape>,
 ): Record<string, string> {
   const descriptions: Record<string, string> = {};
   const shape = schema.shape;
@@ -123,20 +154,41 @@ export function getFieldDescriptions(
 // ============================================================================
 
 export interface PositionalMetadata {
-  positional: true;
+  positionalMeta: {
+    positional: true;
+  };
 }
 
 // Helper function to mark a parameter as positional for CLI
-export function withPositional<T extends z.ZodType>(schema: T): T {
+export function withPositional<T extends z.ZodType>(
+  schema: T,
+): T & {
+  _def: T["_def"] & PositionalMetadata;
+} {
   // Store positional metadata on the schema definition
-  (schema._def as any).positionalMeta = { positional: true };
-  return schema;
+  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 ((schema._def as any).positionalMeta?.positional) {
+  if (
+    schemaHasPositionalMeta(schema) &&
+    schema._def.positionalMeta?.positional
+  ) {
     return true;
   }