cushin-monorepo 3.0.1

package/packages/api-codegen/dist/index.js

@@ -0,0 +1,1026 @@
+// src/index.ts
+export * from "@cushin/api-runtime";
+
+// src/config/index.ts
+import { cosmiconfig } from "cosmiconfig";
+import path from "path";
+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 = 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";
+    const generateClient = userConfig.generateClient ?? true;
+    const generatePrefetch = userConfig.generatePrefetch ?? true;
+    return {
+      ...userConfig,
+      rootDir,
+      endpointsPath,
+      outputDir,
+      generateHooks,
+      generateServerActions,
+      generateServerQueries,
+      generateClient,
+      generatePrefetch
+    };
+  } 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/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) {
+    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 ? this.inferNonNull(`typeof apiConfig.endpoints.${name}.params`) : "never",
+      queryType: hasQuery ? this.inferNonNull(`typeof apiConfig.endpoints.${name}.query`) : "never",
+      bodyType: hasBody ? this.inferNonNull(`typeof apiConfig.endpoints.${name}.body`) : "never",
+      responseType: this.inferNonNull(`typeof apiConfig.endpoints.${name}.response`)
+    };
+  }
+  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}();`;
+    }
+  }
+  inferNonNull(expr) {
+    return `z.infer<NonNullable<${expr}>>`;
+  }
+  toCamelCase(str) {
+    return str.toLowerCase().replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (c) => c.toLowerCase());
+  }
+  getResourceFromEndpoint(_name, endpoint) {
+    const tag = endpoint.tags?.find((t) => t !== "query" && t !== "mutation");
+    if (tag) return this.toCamelCase(tag);
+    const match = endpoint.path.match(/^\/([^/]+)/);
+    return match ? this.toCamelCase(match[1]) : "general";
+  }
+  groupEndpointsByResource() {
+    const groups = {};
+    Object.entries(this.context.apiConfig.endpoints).forEach(
+      ([name, endpoint]) => {
+        const res = this.getResourceFromEndpoint(name, endpoint);
+        if (!groups[res]) groups[res] = [];
+        groups[res].push({ name, endpoint });
+      }
+    );
+    return groups;
+  }
+  resourceHasQueryEndpoints(resource) {
+    return this.groupEndpointsByResource()[resource]?.some(
+      ({ endpoint }) => endpoint.method === "GET"
+    ) ?? false;
+  }
+  getEndpointKeyName(name) {
+    return name.startsWith("get") ? name[3].toLowerCase() + name.slice(4) : name;
+  }
+  generateQueryKeyCall(resource, name, endpoint) {
+    const key = this.getEndpointKeyName(name);
+    const args = [];
+    if (endpoint.params) args.push("params");
+    if (endpoint.query) args.push("filters");
+    return args.length ? `queryKeys.${resource}.${key}(${args.join(", ")})` : `queryKeys.${resource}.${key}()`;
+  }
+  hasQueryOptions() {
+    return Object.values(this.context.apiConfig.endpoints).some(
+      (e) => e.method === "GET"
+    );
+  }
+};
+
+// src/generators/hooks.ts
+var HooksGenerator = class extends BaseGenerator {
+  async generate() {
+    const content = this.generateContent();
+    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 = 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, "/").replace(/\.ts$/, "");
+    const content = `${useClientDirective ? "'use client';\n" : ""}
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { apiClient } from "./client";
+import { queryKeys } from "./query-keys";
+import { apiQueryOptions } from "./query-options";
+import { z } from "zod";
+import { apiConfig } from "${relativePath}";
+
+${this.generateQueryHooks()}
+${this.generateMutationHooks()}
+`;
+    return content;
+  }
+  generateQueryHooks() {
+    const hooks = [];
+    Object.entries(this.context.apiConfig.endpoints).forEach(
+      ([name, endpoint]) => {
+        if (endpoint.method === "GET")
+          hooks.push(this.generateQueryHook(name, endpoint));
+      }
+    );
+    return hooks.join("\n\n");
+  }
+  generateQueryHook(name, endpoint) {
+    const hookName = `use${this.capitalize(name)}`;
+    const resource = this.getResourceFromEndpoint(name, endpoint);
+    const optionName = this.getEndpointKeyName(name);
+    const inferParams = this.inferNonNull(
+      `typeof apiConfig.endpoints.${name}.params`
+    );
+    const inferQuery = this.inferNonNull(
+      `typeof apiConfig.endpoints.${name}.query`
+    );
+    const inferResponse = this.inferNonNull(
+      `typeof apiConfig.endpoints.${name}.response`
+    );
+    const params = [];
+    const optionParams = [];
+    const queryTags = this.getQueryTags(endpoint);
+    if (endpoint.params) {
+      params.push(`params: ${inferParams}`);
+      optionParams.push("params");
+    }
+    if (endpoint.query) {
+      params.push(`filters?: ${inferQuery}`);
+      optionParams.push("filters");
+    }
+    params.push(`options?: {
+    enabled?: boolean;
+    select?: <TData = ${inferResponse}>(data: ${inferResponse}) => TData;
+  }`);
+    return `/**
+ * ${endpoint.description || `Query hook for ${name}`}
+ * @tags ${queryTags.join(", ") || "none"}
+ */
+export function ${hookName}(${params.join(",\n  ")}) {
+  return useQuery({
+    ...apiQueryOptions.${resource}.${optionName}(${optionParams.join(", ")}),
+    ...options,
+  });
+}`;
+  }
+  generateMutationHooks() {
+    const hooks = [];
+    Object.entries(this.context.apiConfig.endpoints).forEach(
+      ([name, endpoint]) => {
+        if (endpoint.method !== "GET")
+          hooks.push(this.generateMutationHook(name, endpoint));
+      }
+    );
+    return hooks.join("\n\n");
+  }
+  generateMutationHook(name, endpoint) {
+    const hookName = `use${this.capitalize(name)}`;
+    const resource = this.getResourceFromEndpoint(name, endpoint);
+    const inferParams = this.inferNonNull(
+      `typeof apiConfig.endpoints.${name}.params`
+    );
+    const inferBody = this.inferNonNull(
+      `typeof apiConfig.endpoints.${name}.body`
+    );
+    const inferResponse = this.inferNonNull(
+      `typeof apiConfig.endpoints.${name}.response`
+    );
+    const resourceHasQueries = this.resourceHasQueryEndpoints(resource);
+    let inputType;
+    let fnBody;
+    if (endpoint.params && endpoint.body) {
+      inputType = `{ params: ${inferParams}; body: ${inferBody}; }`;
+      fnBody = `({ params, body }: ${inputType}) => apiClient.${name}(params, body)`;
+    } else if (endpoint.params) {
+      inputType = `${inferParams}`;
+      fnBody = `(params: ${inputType}) => apiClient.${name}(params)`;
+    } else if (endpoint.body) {
+      inputType = `${inferBody}`;
+      fnBody = `(body: ${inputType}) => apiClient.${name}(body)`;
+    } else {
+      inputType = "void";
+      fnBody = `() => apiClient.${name}()`;
+    }
+    const invalidate = resourceHasQueries ? `queryClient.invalidateQueries({ queryKey: queryKeys.${resource}.all });` : "";
+    return `/**
+ * ${endpoint.description || `Mutation hook for ${name}`}
+ * @tags ${endpoint.tags?.join(", ") || "none"}
+ */
+    export function ${hookName}(options?: {
+      onSuccess?: (data: ${inferResponse}, variables: ${inputType}, context: unknown) => void;
+      onError?: (error: Error, variables: ${inputType}, context: unknown) => void;
+      onSettled?: (data: ${inferResponse} | undefined, error: Error | null, variables: ${inputType}, context: unknown) => void;
+      onMutate?: (variables: ${inputType}) => Promise<unknown> | unknown;
+    }) {
+      ${invalidate ? "const queryClient = useQueryClient();" : ""}
+      return useMutation({
+	mutationFn: ${fnBody},
+	onSuccess: (data, variables, context) => {
+	  ${invalidate}
+	  options?.onSuccess?.(data, variables, context);
+	},
+	onError: options?.onError,
+	onSettled: options?.onSettled,
+	onMutate: options?.onMutate,
+      });
+    }`;
+  }
+};
+
+// 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 = 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 outputPath = path3.join(this.context.config.outputDir, "types.ts");
+    const endpointsPath = path3.join(this.context.config.endpointsPath);
+    const relativePath = path3.relative(path3.dirname(outputPath), endpointsPath).replace(/\\/g, "/").replace(/\.ts$/, "");
+    const imports = `'use server';
+
+import { revalidateTag, revalidatePath } from 'next/cache';
+import { serverClient } from './server-client';
+import { z } from 'zod';
+import { apiConfig } from '${relativePath}';
+
+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 callArgs = "";
+    if (signature.hasParams && signature.hasBody) {
+      inputType = `input: { params: ${signature.paramType}; body: ${signature.bodyType} }`;
+      callArgs = "input.params, input.body";
+    } else if (signature.hasParams) {
+      inputType = `params: ${signature.paramType}`;
+      callArgs = "params";
+    } else if (signature.hasBody) {
+      inputType = `body: ${signature.bodyType}`;
+      callArgs = "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 as any).${name}(${callArgs});
+
+    // 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'
+    };
+  }
+}`;
+  }
+};
+
+// 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 = 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 outputPath = path4.join(this.context.config.outputDir, "types.ts");
+    const endpointsPath = path4.join(this.context.config.endpointsPath);
+    const relativePath = path4.relative(path4.dirname(outputPath), endpointsPath).replace(/\\/g, "/").replace(/\.ts$/, "");
+    const imports = `import { cache } from 'react';
+import { unstable_cache } from 'next/cache';
+import { serverClient } from './server-client';
+import { z } from 'zod';
+import { apiConfig } from '${relativePath}';
+`;
+    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  ");
+    let clientCall = "";
+    if (signature.hasParams && signature.hasQuery) {
+      clientCall = `(serverClient as any).${name}(params, query)`;
+    } else if (signature.hasParams) {
+      clientCall = `(serverClient as any).${name}(params)`;
+    } else if (signature.hasQuery) {
+      clientCall = `(serverClient as any).${name}(query)`;
+    } else {
+      clientCall = `(serverClient as any).${name}()`;
+    }
+    const cacheKeyParts = [`'${name}'`];
+    if (signature.hasParams) cacheKeyParts.push("JSON.stringify(params)");
+    if (signature.hasQuery)
+      cacheKeyParts.push("query ? JSON.stringify(query) : 'no-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 () => ${clientCall},
+    [${cacheKeyParts.join(", ")}],
+    {
+      tags: [${queryTags.map((tag) => `'${tag}'`).join(", ")}],
+      revalidate: 3600, // 1 hour default, can be overridden
+    }
+  )();
+});`;
+  }
+};
+
+// 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 = 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 = 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, "/").replace(/\.ts$/, "");
+    return `// Auto-generated type definitions
+// Do not edit this file manually
+
+import type { z } from 'zod';
+import { apiConfig } from '${relativePath}';
+
+
+// Re-export endpoint configuration types
+export type { APIConfig, APIEndpoint, HTTPMethod } from '@cushin/api-runtime';
+
+${this.generateEndpointTypes()}
+`;
+  }
+  generateEndpointTypes() {
+    const types = [];
+    Object.entries(this.context.apiConfig.endpoints).forEach(
+      ([name, endpoint]) => {
+        const cap = this.capitalize(name);
+        if (endpoint.response)
+          types.push(
+            `export type ${cap}Response = ${this.inferNonNull(`typeof apiConfig.endpoints.${name}.response`)};`
+          );
+        if (endpoint.body)
+          types.push(
+            `export type ${cap}Input = ${this.inferNonNull(`typeof apiConfig.endpoints.${name}.body`)};`
+          );
+        if (endpoint.query)
+          types.push(
+            `export type ${cap}Query = ${this.inferNonNull(`typeof apiConfig.endpoints.${name}.query`)};`
+          );
+        if (endpoint.params)
+          types.push(
+            `export type ${cap}Params = ${this.inferNonNull(`typeof apiConfig.endpoints.${name}.params`)};`
+          );
+      }
+    );
+    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();
+    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;
+    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, "/").replace(/\.ts$/, "");
+    return `${useClientDirective ? "'use client';\n" : ""}
+import { createAPIClient } from '@cushin/api-runtime';
+import type { AuthCallbacks } from '@cushin/api-runtime';
+import { apiConfig } from '${relativePath}';
+import { z } from 'zod';
+
+// Type the methods based on endpoints
+type APIClientMethods = {
+  [K in keyof typeof apiConfig.endpoints]: (typeof apiConfig.endpoints)[K] extends infer E
+    ? E extends { method: "GET"; params: infer P; query: infer Q; response: infer R }
+      ? (params: P extends z.ZodType ? z.infer<P> : never, query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+      : E extends { method: "GET"; params: infer P; response: infer R }
+        ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+        : E extends { method: "GET"; query: infer Q; response: infer R }
+          ? (query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+          : E extends { method: "GET"; response: infer R }
+            ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
+            : E extends { method: string; params: infer P; body: infer B; response: infer R }
+              ? (params: P extends z.ZodType ? z.infer<P> : never, body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+              : E extends { method: string; params: infer P; response: infer R }
+                ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+                : E extends { method: string; body: infer B; response: infer R }
+                  ? (body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+                  : E extends { method: string; response: infer R }
+                    ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
+                    : never
+    : never;
+};
+
+
+// Export singleton instance (will be initialized later)
+export let baseClient: APIClientMethods & {
+  refreshAuth: () => Promise<void>;
+  updateAuthCallbacks: (callbacks: AuthCallbacks) => void;
+};
+
+export const apiClient = {
+${this.generateApiClientMethods()}
+};
+
+/**
+ * Initialize API client with auth callbacks
+ * Call this function in your auth provider setup
+ * 
+ * @example
+ * const authCallbacks = {
+ *   getTokens: () => getStoredTokens(),
+ *   onAuthError: () => router.push('/login'),
+ *   onRefreshToken: async () => {
+ *     await refreshAccessToken();
+ *   },
+ * };
+ * 
+ * initializeAPIClient(authCallbacks);
+ */
+export const initializeAPIClient = (authCallbacks: AuthCallbacks) => {
+  baseClient = createAPIClient(apiConfig, authCallbacks) as any;
+  return baseClient;
+};
+
+// Export for custom usage
+export { createAPIClient };
+export type { AuthCallbacks };
+`;
+  }
+  generateServerClientContent() {
+    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, "/").replace(/\.ts$/, "");
+    return `import { createAPIClient } from '@cushin/api-runtime';
+import { apiConfig } from '${relativePath}';
+import { z } from 'zod';
+
+// Type the methods based on endpoints
+type APIClientMethods = {
+  [K in keyof typeof apiConfig.endpoints]: (typeof apiConfig.endpoints)[K] extends infer E
+    ? E extends { method: "GET"; params: infer P; query: infer Q; response: infer R }
+      ? (params: P extends z.ZodType ? z.infer<P> : never, query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+      : E extends { method: "GET"; params: infer P; response: infer R }
+        ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+        : E extends { method: "GET"; query: infer Q; response: infer R }
+          ? (query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+          : E extends { method: "GET"; response: infer R }
+            ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
+            : E extends { method: string; params: infer P; body: infer B; response: infer R }
+              ? (params: P extends z.ZodType ? z.infer<P> : never, body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+              : E extends { method: string; params: infer P; response: infer R }
+                ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+                : E extends { method: string; body: infer B; response: infer R }
+                  ? (body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+                  : E extends { method: string; response: infer R }
+                    ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
+                    : never
+    : 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;
+`;
+  }
+  generateApiClientMethods() {
+    const methods = [];
+    Object.entries(this.context.apiConfig.endpoints).forEach(
+      ([name, endpoint]) => {
+        const inferParams = this.inferNonNull(
+          `typeof apiConfig.endpoints.${name}.params`
+        );
+        const inferQuery = this.inferNonNull(
+          `typeof apiConfig.endpoints.${name}.query`
+        );
+        const inferBody = this.inferNonNull(
+          `typeof apiConfig.endpoints.${name}.body`
+        );
+        const inferResponse = this.inferNonNull(
+          `typeof apiConfig.endpoints.${name}.response`
+        );
+        if (endpoint.method === "GET") {
+          if (endpoint.params && endpoint.query) {
+            methods.push(`  ${name}: (params: ${inferParams}, query?: ${inferQuery}): Promise<${inferResponse}> => 
+    (baseClient as any).${name}(params, query),`);
+          } else if (endpoint.params) {
+            methods.push(`  ${name}: (params: ${inferParams}): Promise<${inferResponse}> => 
+    (baseClient as any).${name}(params),`);
+          } else if (endpoint.query) {
+            methods.push(`  ${name}: (query?: ${inferQuery}): Promise<${inferResponse}> => 
+    (baseClient as any).${name}(query),`);
+          } else {
+            methods.push(`  ${name}: (): Promise<${inferResponse}> => 
+    (baseClient as any).${name}(),`);
+          }
+        } else {
+          if (endpoint.params && endpoint.body) {
+            methods.push(`  ${name}: (params: ${inferParams}, body: ${inferBody}): Promise<${inferResponse}> => 
+    (baseClient as any).${name}(params, body),`);
+          } else if (endpoint.params) {
+            methods.push(`  ${name}: (params: ${inferParams}): Promise<${inferResponse}> => 
+    (baseClient as any).${name}(params),`);
+          } else if (endpoint.body) {
+            methods.push(`  ${name}: (body: ${inferBody}): Promise<${inferResponse}> => 
+    (baseClient as any).${name}(body),`);
+          } else {
+            methods.push(`  ${name}: (): Promise<${inferResponse}> => 
+    (baseClient as any).${name}(),`);
+          }
+        }
+      }
+    );
+    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 = path7.join(
+      this.context.config.outputDir,
+      "query-keys.ts"
+    );
+    await fs6.mkdir(path7.dirname(outputPath), { recursive: true });
+    await fs6.writeFile(outputPath, content, "utf-8");
+  }
+  generateContent() {
+    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, "/").replace(/\.ts$/, "");
+    const content = `// Auto-generated query keys
+import { z } from 'zod';
+import { apiConfig } from '${relativePath}';
+
+export const queryKeys = {
+${this.generateQueryKeysContent()}
+} as const;
+`;
+    return content;
+  }
+  generateQueryKeysContent() {
+    const resourceGroups = this.groupEndpointsByResource();
+    const keys = [];
+    Object.entries(resourceGroups).forEach(([resource, endpoints]) => {
+      const queryEndpoints = endpoints.filter(
+        ({ endpoint }) => endpoint.method === "GET"
+      );
+      if (queryEndpoints.length === 0) return;
+      const resourceKeys = [`    all: ['${resource}'] as const,`];
+      const added = /* @__PURE__ */ new Set();
+      queryEndpoints.forEach(({ name, endpoint }) => {
+        const keyName = this.getEndpointKeyName(name);
+        if (added.has(keyName)) return;
+        const inferParams = this.inferNonNull(
+          `typeof apiConfig.endpoints.${name}.params`
+        );
+        const inferQuery = this.inferNonNull(
+          `typeof apiConfig.endpoints.${name}.query`
+        );
+        if (endpoint.params || endpoint.query) {
+          const params = [];
+          if (endpoint.params) params.push(`params?: ${inferParams}`);
+          if (endpoint.query) params.push(`query?: ${inferQuery}`);
+          resourceKeys.push(`    ${keyName}: (${params.join(", ")}) =>
+      ['${resource}', '${keyName}', ${endpoint.params ? "params" : "undefined"}, ${endpoint.query ? "query" : "undefined"}] as const,`);
+        } else {
+          resourceKeys.push(
+            `    ${keyName}: () => ['${resource}', '${keyName}'] as const,`
+          );
+        }
+        added.add(keyName);
+      });
+      keys.push(`  ${resource}: {
+${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 = path8.join(
+      this.context.config.outputDir,
+      "query-options.ts"
+    );
+    await fs7.mkdir(path8.dirname(outputPath), { recursive: true });
+    await fs7.writeFile(outputPath, content, "utf-8");
+  }
+  generateContent() {
+    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, "/").replace(/\.ts$/, "");
+    const content = `// Auto-generated query options
+import { queryOptions } from '@tanstack/react-query';
+import { apiClient } from './client';
+import { queryKeys } from './query-keys';
+import { z } from 'zod';
+import { apiConfig } from '${relativePath}';
+
+${this.generateQueryOptionsContent()}
+
+export const apiQueryOptions = {
+${this.generateQueryOptionsExports()}
+} as const;
+`;
+    return content;
+  }
+  generateQueryOptionsContent() {
+    const groups = this.groupEndpointsByResource();
+    const options = [];
+    Object.entries(groups).forEach(([resource, endpoints]) => {
+      const queries = endpoints.filter(
+        ({ endpoint }) => endpoint.method === "GET"
+      );
+      if (queries.length === 0) return;
+      const resourceOptions = [];
+      queries.forEach(({ name, endpoint }) => {
+        const optionName = this.getEndpointKeyName(name);
+        const inferParams = this.inferNonNull(
+          `typeof apiConfig.endpoints.${name}.params`
+        );
+        const inferQuery = this.inferNonNull(
+          `typeof apiConfig.endpoints.${name}.query`
+        );
+        const inferResponse = this.inferNonNull(
+          `typeof apiConfig.endpoints.${name}.response`
+        );
+        const params = [];
+        let apiCall = "";
+        if (endpoint.params && endpoint.query) {
+          params.push(`params: ${inferParams}`, `filters?: ${inferQuery}`);
+          apiCall = `apiClient.${name}(params, filters)`;
+        } else if (endpoint.params) {
+          params.push(`params: ${inferParams}`);
+          apiCall = `apiClient.${name}(params)`;
+        } else if (endpoint.query) {
+          params.push(`filters?: ${inferQuery}`);
+          apiCall = `apiClient.${name}(filters)`;
+        } else {
+          apiCall = `apiClient.${name}()`;
+        }
+        const keyCall = this.generateQueryKeyCall(resource, name, endpoint);
+        resourceOptions.push(`  ${optionName}: (${params.join(", ")}) =>
+    queryOptions({
+      queryKey: ${keyCall},
+      queryFn: (): Promise<${inferResponse}> => ${apiCall},
+      staleTime: 1000 * 60 * 5,
+    }),`);
+      });
+      options.push(
+        `const ${resource}QueryOptions = {
+${resourceOptions.join("\n")}
+};
+`
+      );
+    });
+    return options.join("\n");
+  }
+  generateQueryOptionsExports() {
+    const groups = this.groupEndpointsByResource();
+    const exports = [];
+    Object.keys(groups).forEach((resource) => {
+      const hasQueries = groups[resource].some(
+        ({ endpoint }) => endpoint.method === "GET"
+      );
+      if (hasQueries) exports.push(`  ${resource}: ${resource}QueryOptions,`);
+    });
+    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 = 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
+import { type QueryClient } from '@tanstack/react-query';
+${this.hasQueryOptions() ? "import { apiQueryOptions } from './query-options';" : ""}
+import { z } from 'zod';
+import { apiConfig } from '../config/endpoints';
+
+${this.generatePrefetchFunctions()}
+`;
+    return content;
+  }
+  generatePrefetchFunctions() {
+    const funcs = [];
+    Object.entries(this.context.apiConfig.endpoints).forEach(
+      ([name, endpoint]) => {
+        if (endpoint.method === "GET")
+          funcs.push(this.generatePrefetchFunction(name, endpoint));
+      }
+    );
+    return funcs.join("\n\n");
+  }
+  generatePrefetchFunction(name, endpoint) {
+    const prefetchName = `prefetch${this.capitalize(name)}`;
+    const resource = this.getResourceFromEndpoint(name, endpoint);
+    const optionName = this.getEndpointKeyName(name);
+    const inferParams = this.inferNonNull(
+      `typeof apiConfig.endpoints.${name}.params`
+    );
+    const inferQuery = this.inferNonNull(
+      `typeof apiConfig.endpoints.${name}.query`
+    );
+    const params = ["queryClient: QueryClient"];
+    const optionParams = [];
+    if (endpoint.params) {
+      params.push(`params: ${inferParams}`);
+      optionParams.push("params");
+    }
+    if (endpoint.query) {
+      params.push(`filters?: ${inferQuery}`);
+      optionParams.push("filters");
+    }
+    return `export const ${prefetchName} = async (${params.join(",\n  ")}) => {
+  return await queryClient.ensureQueryData(apiQueryOptions.${resource}.${optionName}(${optionParams.join(", ")}));
+};`;
+  }
+};
+
+// src/generators/generate-index.ts
+import fs9 from "fs/promises";
+import path10 from "path";
+var IndexGenerator = class extends BaseGenerator {
+  async generate() {
+    const content = this.generateContent();
+    const outputPath = path10.join(this.context.config.outputDir, "index.ts");
+    await fs9.mkdir(path10.dirname(outputPath), { recursive: true });
+    await fs9.writeFile(outputPath, content, "utf-8");
+  }
+  generateContent() {
+    const outputPath = path10.join(this.context.config.outputDir, "types.ts");
+    const endpointsPath = path10.join(this.context.config.endpointsPath);
+    const relativePath = path10.relative(path10.dirname(outputPath), endpointsPath).replace(/\\/g, "/").replace(/\.ts$/, "");
+    const content = `// Auto-generated exports
+export * from './types';
+export * from './client';
+export * from './query-keys';
+${this.hasQueryOptions() ? "export * from './query-options';" : ""}
+export * from './hooks';
+export * from './prefetchs';
+export { z } from 'zod';
+export { apiConfig } from '${relativePath}';
+`;
+    return content;
+  }
+};
+
+// 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));
+    generators.push(new IndexGenerator(this.context));
+    if (this.context.config.generateClient) {
+      generators.push(new ClientGenerator(this.context));
+    }
+    if (this.context.config.generateHooks) {
+      generators.push(new QueryKeysGenerator(this.context));
+      generators.push(new QueryOptionsGenerator(this.context));
+      generators.push(new HooksGenerator(this.context));
+    }
+    if (this.context.config.generatePrefetch) {
+      generators.push(new PrefetchGenerator(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
+import { fileURLToPath } from "url";
+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 jiti = createJiti(fileURLToPath(import.meta.url), {
+        interopDefault: true
+      });
+      const module = await jiti.import(this.config.endpointsPath);
+      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)}`
+      );
+    }
+  }
+};
+export {
+  CodeGenerator,
+  CodegenCore,
+  loadConfig,
+  validateConfig
+};
+//# sourceMappingURL=index.js.map