@cushin/api-codegen 1.1.0 → 1.1.1

package/dist/index.js

@@ -185,9 +185,9 @@ var APIClient = class {
     })();
     return this.refreshPromise;
   }
-  buildPath(path10, params) {
-    if (!params) return path10;
-    let finalPath = path10;
+  buildPath(path12, params) {
+    if (!params) return path12;
+    let finalPath = path12;
     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 path10 = this.buildPath(endpoint.path, params);
+      const path12 = 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(path10, options);
+      const response = await client(path12, options);
       const data = await response.json();
       if (endpoint.response) {
         return endpoint.response.parse(data);
@@ -719,7 +719,7 @@ import { apiConfig } from '${relativePath}';
 
 
 // Re-export endpoint configuration types
-export type { APIConfig, APIEndpoint, HTTPMethod } from '@cushin/api-codegen/schema';
+export type { APIConfig, APIEndpoint, HTTPMethod } from './schema';
 
 /**
  * Type helper to extract params schema from an endpoint
@@ -812,8 +812,8 @@ var ClientGenerator = class extends BaseGenerator {
     const endpointsPath = path6.join(this.context.config.endpointsPath);
     const relativePath = path6.relative(path6.dirname(outputPath), endpointsPath).replace(/\\/g, "/");
     return `${useClientDirective ? "'use client';\n" : ""}
-import { createAPIClient } from '@cushin/api-codegen/client';
-import type { AuthCallbacks } from '@cushin/api-codegen/client';
+import { createAPIClient } from './core';
+import type { AuthCallbacks } from './core';
 import { apiConfig } from '${relativePath}';
 import { z } from 'zod';
 
@@ -881,7 +881,7 @@ export type { AuthCallbacks };
 `;
   }
   generateServerClientContent() {
-    return `import { createAPIClient } from '@cushin/api-codegen/client';
+    return `import { createAPIClient } from './core';
 import { apiConfig } from '../config/endpoints';
 import type { APIEndpoints } from './types';
 
@@ -1177,6 +1177,419 @@ ${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 {
@@ -1192,6 +1605,8 @@ 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));
     }