@cushin/api-codegen 1.0.0

package/dist/cli.js

@@ -0,0 +1,756 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { cosmiconfig } from 'cosmiconfig';
+import path6 from 'path';
+import { pathToFileURL } from 'url';
+import fs5 from 'fs/promises';
+
+var explorer = cosmiconfig("api-codegen", {
+  searchPlaces: [
+    "api-codegen.config.js",
+    "api-codegen.config.mjs",
+    "api-codegen.config.ts",
+    "api-codegen.config.json",
+    ".api-codegenrc",
+    ".api-codegenrc.json",
+    ".api-codegenrc.js"
+  ]
+});
+async function loadConfig(configPath) {
+  try {
+    const result = configPath ? await explorer.load(configPath) : await explorer.search();
+    if (!result || !result.config) {
+      return null;
+    }
+    const userConfig = result.config;
+    const rootDir = path6.dirname(result.filepath);
+    const endpointsPath = path6.resolve(rootDir, userConfig.endpoints);
+    const outputDir = path6.resolve(rootDir, userConfig.output);
+    const generateHooks = userConfig.generateHooks ?? true;
+    const generateServerActions = userConfig.generateServerActions ?? userConfig.provider === "nextjs";
+    const generateServerQueries = userConfig.generateServerQueries ?? userConfig.provider === "nextjs";
+    const generateClient = userConfig.generateClient ?? true;
+    return {
+      ...userConfig,
+      rootDir,
+      endpointsPath,
+      outputDir,
+      generateHooks,
+      generateServerActions,
+      generateServerQueries,
+      generateClient
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function validateConfig(config) {
+  if (!config.endpoints) {
+    throw new Error('Config error: "endpoints" path is required');
+  }
+  if (!config.provider) {
+    throw new Error('Config error: "provider" must be specified (vite or nextjs)');
+  }
+  if (!["vite", "nextjs"].includes(config.provider)) {
+    throw new Error('Config error: "provider" must be either "vite" or "nextjs"');
+  }
+  if (!config.output) {
+    throw new Error('Config error: "output" directory is required');
+  }
+}
+
+// src/generators/base.ts
+var BaseGenerator = class {
+  constructor(context) {
+    this.context = context;
+  }
+  isQueryEndpoint(endpoint) {
+    return endpoint.method === "GET";
+  }
+  isMutationEndpoint(endpoint) {
+    return !this.isQueryEndpoint(endpoint);
+  }
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  getQueryTags(endpoint) {
+    return endpoint.tags || [];
+  }
+  getInvalidationTags(endpoint) {
+    const tags = endpoint.tags || [];
+    return tags.filter((tag) => tag !== "query" && tag !== "mutation");
+  }
+  hasParams(endpoint) {
+    return !!endpoint.params;
+  }
+  hasQuery(endpoint) {
+    return !!endpoint.query;
+  }
+  hasBody(endpoint) {
+    return !!endpoint.body;
+  }
+  getEndpointSignature(name, endpoint) {
+    const hasParams = this.hasParams(endpoint);
+    const hasQuery = this.hasQuery(endpoint);
+    const hasBody = this.hasBody(endpoint);
+    return {
+      hasParams,
+      hasQuery,
+      hasBody,
+      paramType: hasParams ? `ExtractParams<APIEndpoints['${name}']>` : "never",
+      queryType: hasQuery ? `ExtractQuery<APIEndpoints['${name}']>` : "never",
+      bodyType: hasBody ? `ExtractBody<APIEndpoints['${name}']>` : "never",
+      responseType: `ExtractResponse<APIEndpoints['${name}']>`
+    };
+  }
+  generateMutationCall(name, hasParams, hasBody) {
+    if (hasParams && hasBody) {
+      return `return apiClient.${name}(input.params, input.body);`;
+    } else if (hasParams) {
+      return `return apiClient.${name}(input);`;
+    } else if (hasBody) {
+      return `return apiClient.${name}(input);`;
+    } else {
+      return `return apiClient.${name}();`;
+    }
+  }
+};
+
+// src/generators/hooks.ts
+var HooksGenerator = class extends BaseGenerator {
+  async generate() {
+    const content = this.generateContent();
+    const outputPath = path6.join(this.context.config.outputDir, "hooks.ts");
+    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+    await fs5.writeFile(outputPath, content, "utf-8");
+  }
+  generateContent() {
+    const useClientDirective = this.context.config.options?.useClientDirective ?? true;
+    const imports = `${useClientDirective ? "'use client';\n" : ""}
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import type { 
+  UseQueryOptions, 
+  UseMutationOptions,
+  QueryKey 
+} from '@tanstack/react-query';
+import { apiClient } from './client';
+import type { 
+  APIEndpoints, 
+  ExtractBody, 
+  ExtractParams, 
+  ExtractQuery, 
+  ExtractResponse 
+} from './types';
+`;
+    const hooks = [];
+    Object.entries(this.context.apiConfig.endpoints).forEach(([name, endpoint]) => {
+      if (this.isQueryEndpoint(endpoint)) {
+        hooks.push(this.generateQueryHook(name, endpoint));
+      } else {
+        hooks.push(this.generateMutationHook(name, endpoint));
+      }
+    });
+    return imports + "\n" + hooks.join("\n\n");
+  }
+  generateQueryHook(name, endpoint) {
+    const hookPrefix = this.context.config.options?.hookPrefix || "use";
+    const hookName = `${hookPrefix}${this.capitalize(name)}`;
+    const signature = this.getEndpointSignature(name, endpoint);
+    const queryTags = this.getQueryTags(endpoint);
+    const paramDef = signature.hasParams ? `params: ${signature.paramType}` : "";
+    const queryDef = signature.hasQuery ? `query?: ${signature.queryType}` : "";
+    const optionsDef = `options?: Omit<UseQueryOptions<${signature.responseType}, Error, ${signature.responseType}, QueryKey>, 'queryKey' | 'queryFn'>`;
+    const paramsList = [paramDef, queryDef, optionsDef].filter(Boolean).join(",\n  ");
+    const queryKeyParts = [
+      ...queryTags.map((tag) => `'${tag}'`),
+      signature.hasParams ? "params" : "undefined",
+      signature.hasQuery ? "query" : "undefined"
+    ];
+    const clientCallArgs = [];
+    if (signature.hasParams) clientCallArgs.push("params");
+    if (signature.hasQuery) clientCallArgs.push("query");
+    return `/**
+ * ${endpoint.description || `Query hook for ${name}`}
+ * @tags ${queryTags.join(", ") || "none"}
+ */
+export function ${hookName}(
+  ${paramsList}
+) {
+  return useQuery({
+    queryKey: [${queryKeyParts.join(", ")}] as const,
+    queryFn: () => apiClient.${name}(${clientCallArgs.join(", ")}),
+    ...options,
+  });
+}`;
+  }
+  generateMutationHook(name, endpoint) {
+    const hookPrefix = this.context.config.options?.hookPrefix || "use";
+    const hookName = `${hookPrefix}${this.capitalize(name)}`;
+    const signature = this.getEndpointSignature(name, endpoint);
+    const invalidationTags = this.getInvalidationTags(endpoint);
+    let inputType = "void";
+    if (signature.hasParams && signature.hasBody) {
+      inputType = `{ params: ${signature.paramType}; body: ${signature.bodyType} }`;
+    } else if (signature.hasParams) {
+      inputType = signature.paramType;
+    } else if (signature.hasBody) {
+      inputType = signature.bodyType;
+    }
+    const invalidationQueries = invalidationTags.length > 0 ? invalidationTags.map((tag) => `      queryClient.invalidateQueries({ queryKey: ['${tag}'] });`).join("\n") : "      // No automatic invalidations";
+    return `/**
+ * ${endpoint.description || `Mutation hook for ${name}`}
+ * @tags ${endpoint.tags?.join(", ") || "none"}
+ */
+export function ${hookName}(
+  options?: Omit<UseMutationOptions<${signature.responseType}, Error, ${inputType}>, 'mutationFn'>
+) {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: ${inputType === "void" ? "() => {" : "(input) => {"}
+      ${this.generateMutationCall(name, signature.hasParams, signature.hasBody)}
+    },
+    onSuccess: (data, variables, context) => {
+      // Invalidate related queries
+${invalidationQueries}
+      
+      // Call user's onSuccess if provided
+      options?.onSuccess?.(data, variables, context);
+    },
+    ...options,
+  });
+}`;
+  }
+};
+var ServerActionsGenerator = class extends BaseGenerator {
+  async generate() {
+    const content = this.generateContent();
+    const outputPath = path6.join(this.context.config.outputDir, "actions.ts");
+    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+    await fs5.writeFile(outputPath, content, "utf-8");
+  }
+  generateContent() {
+    const imports = `'use server';
+
+import { revalidateTag, revalidatePath } from 'next/cache';
+import { serverClient } from './server-client';
+import type { 
+  APIEndpoints, 
+  ExtractBody, 
+  ExtractParams, 
+  ExtractResponse 
+} from './types';
+
+export type ActionResult<T> = 
+  | { success: true; data: T }
+  | { success: false; error: string };
+`;
+    const actions = [];
+    Object.entries(this.context.apiConfig.endpoints).forEach(([name, endpoint]) => {
+      if (this.isMutationEndpoint(endpoint)) {
+        actions.push(this.generateServerAction(name, endpoint));
+      }
+    });
+    return imports + "\n" + actions.join("\n\n");
+  }
+  generateServerAction(name, endpoint) {
+    const actionSuffix = this.context.config.options?.actionSuffix || "Action";
+    const actionName = `${name}${actionSuffix}`;
+    const signature = this.getEndpointSignature(name, endpoint);
+    const invalidationTags = this.getInvalidationTags(endpoint);
+    let inputType = "";
+    let inputParam = "";
+    if (signature.hasParams && signature.hasBody) {
+      inputType = `input: { params: ${signature.paramType}; body: ${signature.bodyType} }`;
+      inputParam = "input";
+    } else if (signature.hasParams) {
+      inputType = `params: ${signature.paramType}`;
+      inputParam = "params";
+    } else if (signature.hasBody) {
+      inputType = `body: ${signature.bodyType}`;
+      inputParam = "body";
+    }
+    const revalidateStatements = invalidationTags.length > 0 ? invalidationTags.map((tag) => `    revalidateTag('${tag}');`).join("\n") : "    // No automatic revalidations";
+    return `/**
+ * ${endpoint.description || `Server action for ${name}`}
+ * @tags ${endpoint.tags?.join(", ") || "none"}
+ */
+export async function ${actionName}(
+  ${inputType}
+): Promise<ActionResult<${signature.responseType}>> {
+  try {
+    const result = await serverClient.${name}(${inputParam ? inputParam : ""});
+    
+    // Revalidate related data
+${revalidateStatements}
+    
+    return { success: true, data: result };
+  } catch (error) {
+    console.error('[Server Action Error]:', error);
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Unknown error' 
+    };
+  }
+}`;
+  }
+};
+var ServerQueriesGenerator = class extends BaseGenerator {
+  async generate() {
+    const content = this.generateContent();
+    const outputPath = path6.join(this.context.config.outputDir, "queries.ts");
+    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+    await fs5.writeFile(outputPath, content, "utf-8");
+  }
+  generateContent() {
+    const imports = `import { cache } from 'react';
+import { unstable_cache } from 'next/cache';
+import { serverClient } from './server-client';
+import type { 
+  APIEndpoints, 
+  ExtractParams, 
+  ExtractQuery, 
+  ExtractResponse 
+} from './types';
+`;
+    const queries = [];
+    Object.entries(this.context.apiConfig.endpoints).forEach(([name, endpoint]) => {
+      if (this.isQueryEndpoint(endpoint)) {
+        queries.push(this.generateServerQuery(name, endpoint));
+      }
+    });
+    return imports + "\n" + queries.join("\n\n");
+  }
+  generateServerQuery(name, endpoint) {
+    const queryName = `${name}Query`;
+    const signature = this.getEndpointSignature(name, endpoint);
+    const queryTags = this.getQueryTags(endpoint);
+    const paramDef = signature.hasParams ? `params: ${signature.paramType}` : "";
+    const queryDef = signature.hasQuery ? `query?: ${signature.queryType}` : "";
+    const paramsList = [paramDef, queryDef].filter(Boolean).join(",\n  ");
+    const clientCallArgs = [];
+    if (signature.hasParams) clientCallArgs.push("params");
+    if (signature.hasQuery) clientCallArgs.push("query");
+    const cacheKeyParts = [
+      `'${name}'`
+    ];
+    if (signature.hasParams) cacheKeyParts.push("JSON.stringify(params)");
+    if (signature.hasQuery) cacheKeyParts.push("JSON.stringify(query)");
+    return `/**
+ * ${endpoint.description || `Server query for ${name}`}
+ * @tags ${queryTags.join(", ") || "none"}
+ */
+export const ${queryName} = cache(async (
+  ${paramsList}
+): Promise<${signature.responseType}> => {
+  return unstable_cache(
+    async () => serverClient.${name}(${clientCallArgs.join(", ")}),
+    [${cacheKeyParts.join(", ")}],
+    {
+      tags: [${queryTags.map((tag) => `'${tag}'`).join(", ")}],
+      revalidate: 3600, // 1 hour default, can be overridden
+    }
+  )();
+});`;
+  }
+};
+var TypesGenerator = class extends BaseGenerator {
+  async generate() {
+    const content = this.generateContent();
+    const outputPath = path6.join(this.context.config.outputDir, "types.ts");
+    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+    await fs5.writeFile(outputPath, content, "utf-8");
+  }
+  generateContent() {
+    return `// Auto-generated type definitions
+// Do not edit this file manually
+
+import type { z } from 'zod';
+
+// Re-export endpoint configuration types
+export type { APIConfig, APIEndpoint, HTTPMethod } from '@vietbus/api-codegen/config';
+
+/**
+ * Type helper to extract params schema from an endpoint
+ */
+export type ExtractParams<T> = T extends { params: infer P extends z.ZodType }
+  ? z.infer<P>
+  : never;
+
+/**
+ * Type helper to extract query schema from an endpoint
+ */
+export type ExtractQuery<T> = T extends { query: infer Q extends z.ZodType }
+  ? z.infer<Q>
+  : never;
+
+/**
+ * Type helper to extract body schema from an endpoint
+ */
+export type ExtractBody<T> = T extends { body: infer B extends z.ZodType }
+  ? z.infer<B>
+  : never;
+
+/**
+ * Type helper to extract response schema from an endpoint
+ */
+export type ExtractResponse<T> = T extends { response: infer R extends z.ZodType }
+  ? z.infer<R>
+  : never;
+
+/**
+ * Import your API config to get typed endpoints
+ * 
+ * @example
+ * import { apiConfig } from './config/endpoints';
+ * export type APIEndpoints = typeof apiConfig.endpoints;
+ */
+export type APIEndpoints = Record<string, any>;
+`;
+  }
+};
+var ClientGenerator = class extends BaseGenerator {
+  async generate() {
+    await this.generateClientFile();
+    if (this.context.config.provider === "nextjs") {
+      await this.generateServerClientFile();
+    }
+  }
+  async generateClientFile() {
+    const content = this.generateClientContent();
+    const outputPath = path6.join(this.context.config.outputDir, "client.ts");
+    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+    await fs5.writeFile(outputPath, content, "utf-8");
+  }
+  async generateServerClientFile() {
+    const content = this.generateServerClientContent();
+    const outputPath = path6.join(this.context.config.outputDir, "server-client.ts");
+    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+    await fs5.writeFile(outputPath, content, "utf-8");
+  }
+  generateClientContent() {
+    const useClientDirective = this.context.config.options?.useClientDirective ?? true;
+    return `${useClientDirective ? "'use client';\n" : ""}
+import { createAPIClient } from '@cushin/api-codegen/client';
+import type { AuthCallbacks } from '@cushin/api-codegen/client';
+import { apiConfig } from '../config/endpoints';
+import type { APIEndpoints } from './types';
+
+// Type-safe API client methods
+type APIClientMethods = {
+  [K in keyof APIEndpoints]: APIEndpoints[K] extends {
+    method: infer M;
+    params?: infer P;
+    query?: infer Q;
+    body?: infer B;
+    response: infer R;
+  }
+    ? M extends 'GET'
+      ? P extends { _type: any }
+        ? Q extends { _type: any }
+          ? (params: P['_type'], query?: Q['_type']) => Promise<R['_type']>
+          : (params: P['_type']) => Promise<R['_type']>
+        : Q extends { _type: any }
+          ? (query?: Q['_type']) => Promise<R['_type']>
+          : () => Promise<R['_type']>
+      : P extends { _type: any }
+        ? B extends { _type: any }
+          ? (params: P['_type'], body: B['_type']) => Promise<R['_type']>
+          : (params: P['_type']) => Promise<R['_type']>
+        : B extends { _type: any }
+          ? (body: B['_type']) => Promise<R['_type']>
+          : () => Promise<R['_type']>
+    : never;
+};
+
+// Export singleton instance (will be initialized later)
+export let apiClient: APIClientMethods & {
+  refreshAuth: () => Promise<void>;
+  updateAuthCallbacks: (callbacks: AuthCallbacks) => void;
+};
+
+/**
+ * Initialize API client with auth callbacks
+ * Call this function in your auth provider setup
+ * 
+ * @example
+ * const authCallbacks = {
+ *   getTokens: () => getStoredTokens(),
+ *   setTokens: (tokens) => storeTokens(tokens),
+ *   clearTokens: () => clearStoredTokens(),
+ *   onAuthError: () => router.push('/login'),
+ *   onRefreshToken: async () => {
+ *     const newToken = await refreshAccessToken();
+ *     return newToken;
+ *   },
+ * };
+ * 
+ * initializeAPIClient(authCallbacks);
+ */
+export const initializeAPIClient = (authCallbacks: AuthCallbacks) => {
+  apiClient = createAPIClient(apiConfig, authCallbacks) as any;
+  return apiClient;
+};
+
+// Export for custom usage
+export { createAPIClient };
+export type { AuthCallbacks };
+`;
+  }
+  generateServerClientContent() {
+    return `import { createAPIClient } from '@cushin/api-codegen/client';
+import { apiConfig } from '../config/endpoints';
+import type { APIEndpoints } from './types';
+
+// Type-safe API client methods for server-side
+type APIClientMethods = {
+  [K in keyof APIEndpoints]: APIEndpoints[K] extends {
+    method: infer M;
+    params?: infer P;
+    query?: infer Q;
+    body?: infer B;
+    response: infer R;
+  }
+    ? M extends 'GET'
+      ? P extends { _type: any }
+        ? Q extends { _type: any }
+          ? (params: P['_type'], query?: Q['_type']) => Promise<R['_type']>
+          : (params: P['_type']) => Promise<R['_type']>
+        : Q extends { _type: any }
+          ? (query?: Q['_type']) => Promise<R['_type']>
+          : () => Promise<R['_type']>
+      : P extends { _type: any }
+        ? B extends { _type: any }
+          ? (params: P['_type'], body: B['_type']) => Promise<R['_type']>
+          : (params: P['_type']) => Promise<R['_type']>
+        : B extends { _type: any }
+          ? (body: B['_type']) => Promise<R['_type']>
+          : () => Promise<R['_type']>
+    : never;
+};
+
+/**
+ * Server-side API client (no auth, direct API calls)
+ * Use this in Server Components, Server Actions, and Route Handlers
+ */
+export const serverClient = createAPIClient(apiConfig) as APIClientMethods;
+`;
+  }
+};
+
+// src/generators/index.ts
+var CodeGenerator = class {
+  constructor(context) {
+    this.context = context;
+  }
+  async generate() {
+    const generators = this.getGenerators();
+    for (const generator of generators) {
+      await generator.generate();
+    }
+  }
+  getGenerators() {
+    const generators = [];
+    generators.push(new TypesGenerator(this.context));
+    if (this.context.config.generateClient) {
+      generators.push(new ClientGenerator(this.context));
+    }
+    if (this.context.config.generateHooks) {
+      generators.push(new HooksGenerator(this.context));
+    }
+    if (this.context.config.generateServerActions && this.context.config.provider === "nextjs") {
+      generators.push(new ServerActionsGenerator(this.context));
+    }
+    if (this.context.config.generateServerQueries && this.context.config.provider === "nextjs") {
+      generators.push(new ServerQueriesGenerator(this.context));
+    }
+    return generators;
+  }
+};
+
+// src/core/codegen.ts
+var CodegenCore = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async execute() {
+    const apiConfig = await this.loadAPIConfig();
+    this.config.apiConfig = apiConfig;
+    const generator = new CodeGenerator({
+      config: this.config,
+      apiConfig
+    });
+    await generator.generate();
+  }
+  async loadAPIConfig() {
+    try {
+      const fileUrl = pathToFileURL(this.config.endpointsPath).href;
+      const module = await import(fileUrl);
+      const apiConfig = module.apiConfig || module.default?.apiConfig || module.default || module;
+      if (!apiConfig || !apiConfig.endpoints) {
+        throw new Error(
+          'Invalid API config: must export an object with "endpoints" property'
+        );
+      }
+      return apiConfig;
+    } catch (error) {
+      throw new Error(
+        `Failed to load endpoints from "${this.config.endpointsPath}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+var program = new Command();
+program.name("api-codegen").description("Generate type-safe API client code from endpoint definitions").version("1.0.0");
+program.command("generate").alias("gen").description("Generate API client code from configuration").option("-c, --config <path>", "Path to configuration file").option("-w, --watch", "Watch for changes and regenerate").action(async (options) => {
+  const spinner = ora("Loading configuration...").start();
+  try {
+    const config = await loadConfig(options.config);
+    if (!config) {
+      spinner.fail(
+        chalk.red(
+          "No configuration file found. Please create an api-codegen.config.js file."
+        )
+      );
+      process.exit(1);
+    }
+    spinner.text = "Validating configuration...";
+    validateConfig(config);
+    spinner.text = "Loading API endpoints...";
+    const codegen = new CodegenCore(config);
+    spinner.text = "Generating code...";
+    await codegen.execute();
+    spinner.succeed(
+      chalk.green(
+        `\u2728 Code generated successfully in ${chalk.cyan(config.outputDir)}`
+      )
+    );
+    console.log(chalk.dim("\nGenerated files:"));
+    const files = await fs5.readdir(config.outputDir);
+    files.forEach((file) => {
+      console.log(chalk.dim(`  \u2022 ${file}`));
+    });
+    if (options.watch) {
+      console.log(chalk.yellow("\n\u{1F440} Watching for changes..."));
+      spinner.info(chalk.dim("Watch mode not yet implemented"));
+    }
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to generate code"));
+    console.error(
+      chalk.red("\n" + (error instanceof Error ? error.message : String(error)))
+    );
+    if (error instanceof Error && error.stack) {
+      console.error(chalk.dim(error.stack));
+    }
+    process.exit(1);
+  }
+});
+program.command("init").description("Initialize a new api-codegen configuration").option("-p, --provider <provider>", "Provider type (vite or nextjs)", "vite").action(async (options) => {
+  const spinner = ora("Creating configuration file...").start();
+  try {
+    const configContent = generateConfigTemplate(options.provider);
+    const configPath = path6.join(process.cwd(), "api-codegen.config.js");
+    try {
+      await fs5.access(configPath);
+      spinner.warn(
+        chalk.yellow(
+          "Configuration file already exists at api-codegen.config.js"
+        )
+      );
+      return;
+    } catch {
+    }
+    await fs5.writeFile(configPath, configContent, "utf-8");
+    spinner.succeed(
+      chalk.green("\u2728 Configuration file created: api-codegen.config.js")
+    );
+    console.log(chalk.dim("\nNext steps:"));
+    console.log(chalk.dim("  1. Update the endpoints path in the config"));
+    console.log(chalk.dim("  2. Run: npx api-codegen generate"));
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to create configuration file"));
+    console.error(
+      chalk.red("\n" + (error instanceof Error ? error.message : String(error)))
+    );
+    process.exit(1);
+  }
+});
+program.command("validate").description("Validate your API endpoints configuration").option("-c, --config <path>", "Path to configuration file").action(async (options) => {
+  const spinner = ora("Loading configuration...").start();
+  try {
+    const config = await loadConfig(options.config);
+    if (!config) {
+      spinner.fail(chalk.red("No configuration file found"));
+      process.exit(1);
+    }
+    spinner.text = "Validating configuration...";
+    validateConfig(config);
+    spinner.text = "Loading API endpoints...";
+    new CodegenCore(config);
+    const apiConfigModule = await import(pathToFileURL2(config.endpointsPath).href);
+    const apiConfig = apiConfigModule.apiConfig || apiConfigModule.default?.apiConfig || apiConfigModule.default;
+    if (!apiConfig || !apiConfig.endpoints) {
+      throw new Error("Invalid endpoints configuration");
+    }
+    const endpointCount = Object.keys(apiConfig.endpoints).length;
+    spinner.succeed(
+      chalk.green(
+        `\u2728 Configuration is valid! Found ${endpointCount} endpoint${endpointCount === 1 ? "" : "s"}`
+      )
+    );
+    console.log(chalk.dim("\nEndpoints:"));
+    Object.entries(apiConfig.endpoints).forEach(([name, endpoint]) => {
+      console.log(
+        chalk.dim(
+          `  \u2022 ${chalk.cyan(name)}: ${endpoint.method} ${endpoint.path}`
+        )
+      );
+    });
+  } catch (error) {
+    spinner.fail(chalk.red("Validation failed"));
+    console.error(
+      chalk.red("\n" + (error instanceof Error ? error.message : String(error)))
+    );
+    process.exit(1);
+  }
+});
+function generateConfigTemplate(provider) {
+  return `/** @type {import('@cushin/api-codegen').UserConfig} */
+export default {
+  // Provider: 'vite' or 'nextjs'
+  provider: '${provider}',
+
+  // Path to your API endpoints configuration
+  endpoints: './lib/api/config/endpoints.ts',
+
+  // Output directory for generated files
+  output: './lib/api/generated',
+
+  // Base URL for API requests (optional, can be set at runtime)
+  baseUrl: process.env.VITE_API_URL || process.env.NEXT_PUBLIC_API_URL,
+
+  // Generation options
+  generateHooks: true,
+  generateClient: true,
+  ${provider === "nextjs" ? `generateServerActions: true,
+  generateServerQueries: true,` : ""}
+
+  // Advanced options
+  options: {
+    useClientDirective: true,
+    hookPrefix: 'use',
+    actionSuffix: 'Action',
+  },
+};
+`;
+}
+function pathToFileURL2(filePath) {
+  return new URL(`file://${path6.resolve(filePath)}`);
+}
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map