@cushin/api-codegen 1.1.1 → 2.0.1

package/dist/index.js

@@ -1,10 +1,3 @@
-import { cosmiconfig } from 'cosmiconfig';
-import path6 from 'path';
-import ky, { HTTPError } from 'ky';
-import { createJiti } from 'jiti';
-import fs5 from 'fs/promises';
-import { fileURLToPath } from 'url';
-
 // src/config/schema.ts
 function defineConfig(config) {
   return config;
@@ -15,6 +8,10 @@ function defineEndpoint(config) {
 function defineEndpoints(endpoints) {
   return endpoints;
 }
+
+// src/config/index.ts
+import { cosmiconfig } from "cosmiconfig";
+import path from "path";
 var explorer = cosmiconfig("api-codegen", {
   searchPlaces: [
     "api-codegen.config.js",
@@ -33,9 +30,9 @@ async function loadConfig(configPath) {
       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 rootDir = path.dirname(result.filepath);
+    const endpointsPath = path.resolve(rootDir, userConfig.endpoints);
+    const outputDir = path.resolve(rootDir, userConfig.output);
     const generateHooks = userConfig.generateHooks ?? true;
     const generateServerActions = userConfig.generateServerActions ?? userConfig.provider === "nextjs";
     const generateServerQueries = userConfig.generateServerQueries ?? userConfig.provider === "nextjs";
@@ -76,6 +73,9 @@ function validateConfig(config) {
     throw new Error('Config error: "output" directory is required');
   }
 }
+
+// src/runtime/client.ts
+import ky, { HTTPError } from "ky";
 var APIError = class extends Error {
   constructor(message, status, response) {
     super(message);
@@ -185,9 +185,9 @@ var APIClient = class {
     })();
     return this.refreshPromise;
   }
-  buildPath(path12, params) {
-    if (!params) return path12;
-    let finalPath = path12;
+  buildPath(path10, params) {
+    if (!params) return path10;
+    let finalPath = path10;
     Object.entries(params).forEach(([key, value]) => {
       finalPath = finalPath.replace(
         `:${key}`,
@@ -219,7 +219,7 @@ var APIClient = class {
   }
   async request(endpoint, params, query, body) {
     try {
-      const path12 = this.buildPath(endpoint.path, params);
+      const path10 = this.buildPath(endpoint.path, params);
       const client = this.getClientForEndpoint(endpoint);
       const options = {
         method: endpoint.method
@@ -243,7 +243,7 @@ var APIClient = class {
           options.json = body;
         }
       }
-      const response = await client(path12, options);
+      const response = await client(path10, options);
       const data = await response.json();
       if (endpoint.response) {
         return endpoint.response.parse(data);
@@ -330,6 +330,13 @@ function createAPIClient(config, authCallbacks) {
   };
 }
 
+// src/core/codegen.ts
+import { createJiti } from "jiti";
+
+// src/generators/hooks.ts
+import fs from "fs/promises";
+import path2 from "path";
+
 // src/generators/base.ts
 var BaseGenerator = class {
   constructor(context) {
@@ -434,15 +441,15 @@ var BaseGenerator = class {
 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");
+    const outputPath = path2.join(this.context.config.outputDir, "hooks.ts");
+    await fs.mkdir(path2.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
     const useClientDirective = this.context.config.options?.useClientDirective ?? true;
-    const outputPath = path6.join(this.context.config.outputDir, "types.ts");
-    const endpointsPath = path6.join(this.context.config.endpointsPath);
-    const relativePath = path6.relative(path6.dirname(outputPath), endpointsPath).replace(/\\/g, "/");
+    const outputPath = path2.join(this.context.config.outputDir, "types.ts");
+    const endpointsPath = path2.join(this.context.config.endpointsPath);
+    const relativePath = path2.relative(path2.dirname(outputPath), endpointsPath).replace(/\\/g, "/");
     const content = `${useClientDirective ? "'use client';\n" : ""}
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { apiClient } from "./client";
@@ -568,12 +575,16 @@ export function ${hookName}(${params.join(",\n  ")}) {
     }`;
   }
 };
+
+// src/generators/actions.ts
+import fs2 from "fs/promises";
+import path3 from "path";
 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");
+    const outputPath = path3.join(this.context.config.outputDir, "actions.ts");
+    await fs2.mkdir(path3.dirname(outputPath), { recursive: true });
+    await fs2.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
     const imports = `'use server';
@@ -641,12 +652,16 @@ ${revalidateStatements}
 }`;
   }
 };
+
+// src/generators/queries.ts
+import fs3 from "fs/promises";
+import path4 from "path";
 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");
+    const outputPath = path4.join(this.context.config.outputDir, "queries.ts");
+    await fs3.mkdir(path4.dirname(outputPath), { recursive: true });
+    await fs3.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
     const imports = `import { cache } from 'react';
@@ -700,17 +715,21 @@ export const ${queryName} = cache(async (
 });`;
   }
 };
+
+// src/generators/types.ts
+import fs4 from "fs/promises";
+import path5 from "path";
 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");
+    const outputPath = path5.join(this.context.config.outputDir, "types.ts");
+    await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
+    await fs4.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
-    const outputPath = path6.join(this.context.config.outputDir, "types.ts");
-    const endpointsPath = path6.join(this.context.config.endpointsPath);
-    const relativePath = path6.relative(path6.dirname(outputPath), endpointsPath).replace(/\\/g, "/");
+    const outputPath = path5.join(this.context.config.outputDir, "types.ts");
+    const endpointsPath = path5.join(this.context.config.endpointsPath);
+    const relativePath = path5.relative(path5.dirname(outputPath), endpointsPath).replace(/\\/g, "/");
     return `// Auto-generated type definitions
 // Do not edit this file manually
 
@@ -784,6 +803,10 @@ ${this.generateEndpointTypes()}
     return types.join("\n");
   }
 };
+
+// src/generators/client.ts
+import fs5 from "fs/promises";
+import path6 from "path";
 var ClientGenerator = class extends BaseGenerator {
   async generate() {
     await this.generateClientFile();
@@ -969,20 +992,24 @@ export const serverClient = createAPIClient(apiConfig) as APIClientMethods;
     return methods.join("\n");
   }
 };
+
+// src/generators/query-keys.ts
+import fs6 from "fs/promises";
+import path7 from "path";
 var QueryKeysGenerator = class extends BaseGenerator {
   async generate() {
     const content = this.generateContent();
-    const outputPath = path6.join(
+    const outputPath = path7.join(
       this.context.config.outputDir,
       "query-keys.ts"
     );
-    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
-    await fs5.writeFile(outputPath, content, "utf-8");
+    await fs6.mkdir(path7.dirname(outputPath), { recursive: true });
+    await fs6.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
-    const outputPath = path6.join(this.context.config.outputDir, "types.ts");
-    const endpointsPath = path6.join(this.context.config.endpointsPath);
-    const relativePath = path6.relative(path6.dirname(outputPath), endpointsPath).replace(/\\/g, "/");
+    const outputPath = path7.join(this.context.config.outputDir, "types.ts");
+    const endpointsPath = path7.join(this.context.config.endpointsPath);
+    const relativePath = path7.relative(path7.dirname(outputPath), endpointsPath).replace(/\\/g, "/");
     const content = `// Auto-generated query keys
 import { z } from 'zod';
 import { apiConfig } from '${relativePath}';
@@ -1032,20 +1059,24 @@ ${resourceKeys.join("\n")}
     return keys.join("\n");
   }
 };
+
+// src/generators/query-options.ts
+import fs7 from "fs/promises";
+import path8 from "path";
 var QueryOptionsGenerator = class extends BaseGenerator {
   async generate() {
     const content = this.generateContent();
-    const outputPath = path6.join(
+    const outputPath = path8.join(
       this.context.config.outputDir,
       "query-options.ts"
     );
-    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
-    await fs5.writeFile(outputPath, content, "utf-8");
+    await fs7.mkdir(path8.dirname(outputPath), { recursive: true });
+    await fs7.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
-    const outputPath = path6.join(this.context.config.outputDir, "types.ts");
-    const endpointsPath = path6.join(this.context.config.endpointsPath);
-    const relativePath = path6.relative(path6.dirname(outputPath), endpointsPath).replace(/\\/g, "/");
+    const outputPath = path8.join(this.context.config.outputDir, "types.ts");
+    const endpointsPath = path8.join(this.context.config.endpointsPath);
+    const relativePath = path8.relative(path8.dirname(outputPath), endpointsPath).replace(/\\/g, "/");
     const content = `// Auto-generated query options
 import { queryOptions } from '@tanstack/react-query';
 import { apiClient } from './client';
@@ -1114,22 +1145,26 @@ ${resourceOptions.join("\n")}
   }
   generateQueryOptionsExports() {
     const groups = this.groupEndpointsByResource();
-    const exports$1 = [];
+    const exports = [];
     Object.keys(groups).forEach((resource) => {
       const hasQueries = groups[resource].some(
         ({ endpoint }) => endpoint.method === "GET"
       );
-      if (hasQueries) exports$1.push(`  ${resource}: ${resource}QueryOptions,`);
+      if (hasQueries) exports.push(`  ${resource}: ${resource}QueryOptions,`);
     });
-    return exports$1.join("\n");
+    return exports.join("\n");
   }
 };
+
+// src/generators/prefetch.ts
+import fs8 from "fs/promises";
+import path9 from "path";
 var PrefetchGenerator = class extends BaseGenerator {
   async generate() {
     const content = this.generateContent();
-    const outputPath = path6.join(this.context.config.outputDir, "prefetchs.ts");
-    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
-    await fs5.writeFile(outputPath, content, "utf-8");
+    const outputPath = path9.join(this.context.config.outputDir, "prefetchs.ts");
+    await fs8.mkdir(path9.dirname(outputPath), { recursive: true });
+    await fs8.writeFile(outputPath, content, "utf-8");
   }
   generateContent() {
     const content = `// Auto-generated prefetch utilities
@@ -1177,419 +1212,6 @@ ${this.generatePrefetchFunctions()}
 };`;
   }
 };
-var SchemaGenerator = class extends BaseGenerator {
-  async generate() {
-    const content = this.generateContent();
-    const outputPath = path6.join(this.context.config.outputDir, "schema.ts");
-    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
-    await fs5.writeFile(outputPath, content, "utf-8");
-  }
-  generateContent() {
-    const content = `// Auto-generated schema definitions
-
-import type { z } from 'zod';
-
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-
-export interface APIEndpoint {
-  path: string;
-  method: HTTPMethod;
-  baseUrl?: string;
-  params?: z.ZodType<any>;
-  query?: z.ZodType<any>;
-  body?: z.ZodType<any>;
-  response: z.ZodType<any>;
-  tags?: string[];
-  description?: string;
-}
-
-export interface APIConfig {
-  baseUrl?: string;
-  endpoints: Record<string, APIEndpoint>;
-}
-
-export type EndpointConfig<
-  TPath extends string = string,
-  TMethod extends HTTPMethod = HTTPMethod,
-  TParams = undefined,
-  TQuery = undefined,
-  TBody = undefined,
-  TResponse = any,
-> = {
-  path: TPath;
-  method: TMethod;
-  baseUrl?: string;
-  params?: z.ZodType<TParams>;
-  query?: z.ZodType<TQuery>;
-  body?: z.ZodType<TBody>;
-  response: z.ZodType<TResponse>;
-  tags?: string[];
-  description?: string;
-};
-
-/**
- * Helper function to define API configuration with type safety
- */
-export function defineConfig<T extends APIConfig>(config: T): T {
-  return config;
-}
-
-/**
- * Helper function to define a single endpoint with type inference
- */
-export function defineEndpoint<
-  TPath extends string,
-  TMethod extends HTTPMethod,
-  TParams = undefined,
-  TQuery = undefined,
-  TBody = undefined,
-  TResponse = any,
->(
-  config: EndpointConfig<TPath, TMethod, TParams, TQuery, TBody, TResponse>,
-): EndpointConfig<TPath, TMethod, TParams, TQuery, TBody, TResponse> {
-  return config;
-}
-
-/**
- * Helper to define multiple endpoints
- */
-export function defineEndpoints<
-  T extends Record<string, APIEndpoint>,
->(endpoints: T): T {
-  return endpoints;
-}
-  }
-  `;
-    return content;
-  }
-};
-var CoreGenerator = class extends BaseGenerator {
-  async generate() {
-    const content = this.generateContent();
-    const outputPath = path6.join(this.context.config.outputDir, "core.ts");
-    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
-    await fs5.writeFile(outputPath, content, "utf-8");
-  }
-  generateContent() {
-    const content = `// Auto-generated schema definitions
-
-import ky, { HTTPError } from "ky";
-import type { APIConfig, APIEndpoint } from "../config/schema.js";
-
-export interface AuthTokens {
-  accessToken: string;
-  refreshToken?: string;
-}
-
-export interface AuthCallbacks {
-  getTokens: () => Promise<AuthTokens | null>;
-  onAuthError?: () => void;
-  onRefreshToken?: () => Promise<void>;
-}
-
-export class APIError extends Error {
-  constructor(
-    message: string,
-    public status: number,
-    public response?: any,
-  ) {
-    super(message);
-    this.name = "APIError";
-  }
-}
-
-export class AuthError extends APIError {
-  constructor(message: string = "Authentication failed") {
-    super(message, 401);
-    this.name = "AuthError";
-  }
-}
-
-export class APIClient {
-  private client: typeof ky;
-  private isRefreshing = false;
-  private refreshPromise: Promise<void> | null = null;
-  private hooks: any;
-
-  constructor(
-    private config: APIConfig,
-    private authCallbacks?: AuthCallbacks,
-  ) {
-    this.hooks = {
-      beforeRequest: [
-        async (request: Request) => {
-          const tokens = await this.authCallbacks?.getTokens();
-          if (tokens?.accessToken) {
-            request.headers.set(
-              "Authorization",
-              \`Bearer \${tokens.accessToken}\`,
-            );
-          }
-        },
-      ],
-      beforeRetry: [
-        async ({ request, error, retryCount }: any) => {
-          if (error instanceof HTTPError && error.response.status === 401) {
-            if (retryCount === 1 && this.authCallbacks) {
-              try {
-                await this.refreshTokens();
-                const tokens = await this.authCallbacks.getTokens();
-                if (tokens?.accessToken) {
-                  request.headers.set(
-                    "Authorization",
-                    \`Bearer \${tokens.accessToken}\`,
-                  );
-                }
-              } catch (refreshError) {
-                this.authCallbacks.onAuthError?.();
-                throw new AuthError();
-              }
-            } else {
-              this.authCallbacks?.onAuthError?.();
-              throw new AuthError();
-            }
-          }
-        },
-      ],
-      beforeError: [
-        async (error: any) => {
-          const { response } = error;
-          if (response?.body) {
-            try {
-              const body = await response.json();
-              error.message =
-                (body as Error).message || \`HTTP \${response.status}\`;
-            } catch {
-              // Keep original message
-            }
-          }
-          return error;
-        },
-      ],
-    };
-
-    this.client = ky.create({
-      prefixUrl: this.config.baseUrl,
-      headers: {
-        "Content-Type": "application/json",
-      },
-      retry: {
-        limit: 2,
-        methods: ["get", "post", "put", "delete", "patch"],
-        statusCodes: [401],
-      },
-      hooks: this.hooks,
-    });
-  }
-
-  private async refreshTokens(): Promise<void> {
-    if (!this.authCallbacks) {
-      throw new AuthError("No auth callbacks provided");
-    }
-
-    if (this.isRefreshing && this.refreshPromise) {
-      return this.refreshPromise;
-    }
-
-    this.isRefreshing = true;
-
-    this.refreshPromise = (async () => {
-      try {
-        if (this.authCallbacks?.onRefreshToken) {
-          await this.authCallbacks.onRefreshToken();
-        } else {
-          throw new AuthError("No refresh token handler provided");
-        }
-      } catch (error) {
-        throw error;
-      } finally {
-        this.isRefreshing = false;
-        this.refreshPromise = null;
-      }
-    })();
-
-    return this.refreshPromise;
-  }
-
-  private buildPath(path: string, params?: Record<string, any>): string {
-    if (!params) return path;
-
-    let finalPath = path;
-    Object.entries(params).forEach(([key, value]) => {
-      finalPath = finalPath.replace(
-        \`:\${key}\`,
-        encodeURIComponent(String(value)),
-      );
-    });
-
-    return finalPath;
-  }
-
-  private getEndpointBaseUrl(endpoint: APIEndpoint): string {
-    return endpoint.baseUrl || this.config.baseUrl!;
-  }
-
-  private getClientForEndpoint(endpoint: APIEndpoint): typeof ky {
-    const endpointBaseUrl = this.getEndpointBaseUrl(endpoint);
-
-    if (endpointBaseUrl === this.config.baseUrl) {
-      return this.client;
-    }
-
-    return ky.create({
-      prefixUrl: endpointBaseUrl,
-      headers: {
-        "Content-Type": "application/json",
-      },
-      retry: {
-        limit: 2,
-        methods: ["get", "post", "put", "delete", "patch"],
-        statusCodes: [401],
-      },
-      hooks: this.hooks,
-    });
-  }
-
-  async request<T>(
-    endpoint: APIEndpoint,
-    params?: Record<string, any>,
-    query?: Record<string, any>,
-    body?: any,
-  ): Promise<T> {
-    try {
-      const path = this.buildPath(endpoint.path, params);
-      const client = this.getClientForEndpoint(endpoint);
-
-      const options: Record<string, any> = {
-        method: endpoint.method,
-      };
-
-      if (query && Object.keys(query).length > 0) {
-        const searchParams = new URLSearchParams();
-        Object.entries(query).forEach(([key, value]) => {
-          if (value !== undefined && value !== null) {
-            searchParams.append(key, String(value));
-          }
-        });
-        if (searchParams.toString()) {
-          options.searchParams = searchParams;
-        }
-      }
-
-      if (body && endpoint.method !== "GET") {
-        if (endpoint.body) {
-          const validatedBody = endpoint.body.parse(body);
-          options.json = validatedBody;
-        } else {
-          options.json = body;
-        }
-      }
-
-      const response = await client(path, options);
-      const data = await response.json();
-
-      if (endpoint.response) {
-        return endpoint.response.parse(data);
-      }
-
-      return data as T;
-    } catch (error) {
-      if (error instanceof HTTPError) {
-        const errorData = await error.response.json().catch(() => ({}));
-        throw new APIError(
-          errorData.message || error.message,
-          error.response.status,
-          errorData,
-        );
-      }
-
-      if (error instanceof AuthError) {
-        throw error;
-      }
-
-      throw new APIError(
-        error instanceof Error ? error.message : "Network error",
-        0,
-      );
-    }
-  }
-
-  updateAuthCallbacks(authCallbacks: AuthCallbacks) {
-    this.authCallbacks = authCallbacks;
-  }
-
-  async refreshAuth(): Promise<void> {
-    if (!this.authCallbacks) {
-      throw new AuthError("No auth callbacks provided");
-    }
-    await this.refreshTokens();
-  }
-
-  generateMethods() {
-    const methods: any = {};
-
-    Object.entries(this.config.endpoints).forEach(([name, endpoint]) => {
-      if (endpoint.method === "GET") {
-        if (endpoint.params && endpoint.query) {
-          methods[name] = (params: any, query?: any): Promise<any> => {
-            return this.request(endpoint, params, query);
-          };
-        } else if (endpoint.params) {
-          methods[name] = (params: any): Promise<any> => {
-            return this.request(endpoint, params);
-          };
-        } else if (endpoint.query) {
-          methods[name] = (query?: any): Promise<any> => {
-            return this.request(endpoint, undefined, query);
-          };
-        } else {
-          methods[name] = (): Promise<any> => {
-            return this.request(endpoint);
-          };
-        }
-      } else {
-        if (endpoint.params && endpoint.body) {
-          methods[name] = (params: any, body: any): Promise<any> => {
-            return this.request(endpoint, params, undefined, body);
-          };
-        } else if (endpoint.params) {
-          methods[name] = (params: any): Promise<any> => {
-            return this.request(endpoint, params);
-          };
-        } else if (endpoint.body) {
-          methods[name] = (body: any): Promise<any> => {
-            return this.request(endpoint, undefined, undefined, body);
-          };
-        } else {
-          methods[name] = (): Promise<any> => {
-            return this.request(endpoint);
-          };
-        }
-      }
-    });
-
-    return methods;
-  }
-}
-
-export function createAPIClient(
-  config: APIConfig,
-  authCallbacks?: AuthCallbacks,
-) {
-  const instance = new APIClient(config, authCallbacks);
-  const methods = instance.generateMethods();
-
-  return {
-    ...methods,
-    refreshAuth: () => instance.refreshAuth(),
-    updateAuthCallbacks: (newCallbacks: AuthCallbacks) =>
-      instance.updateAuthCallbacks(newCallbacks),
-  };
-}
-`;
-    return content;
-  }
-};
 
 // src/generators/index.ts
 var CodeGenerator = class {
@@ -1605,8 +1227,6 @@ var CodeGenerator = class {
   getGenerators() {
     const generators = [];
     generators.push(new TypesGenerator(this.context));
-    generators.push(new SchemaGenerator(this.context));
-    generators.push(new CoreGenerator(this.context));
     if (this.context.config.generateClient) {
       generators.push(new ClientGenerator(this.context));
     }
@@ -1627,6 +1247,9 @@ var CodeGenerator = class {
     return generators;
   }
 };
+
+// src/core/codegen.ts
+import { fileURLToPath } from "url";
 var CodegenCore = class {
   constructor(config) {
     this.config = config;
@@ -1660,7 +1283,16 @@ var CodegenCore = class {
     }
   }
 };
-
-export { APIError, AuthError, CodeGenerator, CodegenCore, createAPIClient, defineConfig, defineEndpoint, defineEndpoints, loadConfig, validateConfig };
-//# sourceMappingURL=index.js.map
+export {
+  APIError,
+  AuthError,
+  CodeGenerator,
+  CodegenCore,
+  createAPIClient,
+  defineConfig,
+  defineEndpoint,
+  defineEndpoints,
+  loadConfig,
+  validateConfig
+};
 //# sourceMappingURL=index.js.map