@cushin/api-codegen 1.0.2 → 1.0.4

package/dist/index.js

@@ -1,8 +1,9 @@
 import { cosmiconfig } from 'cosmiconfig';
 import path6 from 'path';
 import ky, { HTTPError } from 'ky';
-import { pathToFileURL } from 'url';
+import { createJiti } from 'jiti';
 import fs5 from 'fs/promises';
+import { fileURLToPath } from 'url';
 
 // src/config/schema.ts
 function defineConfig(config) {
@@ -183,9 +184,9 @@ var APIClient = class {
     })();
     return this.refreshPromise;
   }
-  buildPath(path7, params) {
-    if (!params) return path7;
-    let finalPath = path7;
+  buildPath(path9, params) {
+    if (!params) return path9;
+    let finalPath = path9;
     Object.entries(params).forEach(([key, value]) => {
       finalPath = finalPath.replace(
         `:${key}`,
@@ -217,7 +218,7 @@ var APIClient = class {
   }
   async request(endpoint, params, query, body) {
     try {
-      const path7 = this.buildPath(endpoint.path, params);
+      const path9 = this.buildPath(endpoint.path, params);
       const client = this.getClientForEndpoint(endpoint);
       const options = {
         method: endpoint.method
@@ -241,7 +242,7 @@ var APIClient = class {
           options.json = body;
         }
       }
-      const response = await client(path7, options);
+      const response = await client(path9, options);
       const data = await response.json();
       if (endpoint.response) {
         return endpoint.response.parse(data);
@@ -383,6 +384,49 @@ var BaseGenerator = class {
       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
@@ -395,7 +439,10 @@ var HooksGenerator = class extends BaseGenerator {
   }
   generateContent() {
     const useClientDirective = this.context.config.options?.useClientDirective ?? true;
-    const imports = `${useClientDirective ? "'use client';\n" : ""}
+    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 content = `${useClientDirective ? "'use client';\n" : ""}
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
 import type { 
   UseQueryOptions, 
@@ -410,85 +457,126 @@ import type {
   ExtractQuery, 
   ExtractResponse 
 } from './types';
+import { queryKeys } from './query-keys';
+${this.hasQueryOptions() ? "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 (this.isQueryEndpoint(endpoint)) {
-        hooks.push(this.generateQueryHook(name, endpoint));
-      } else {
-        hooks.push(this.generateMutationHook(name, endpoint));
+    Object.entries(this.context.apiConfig.endpoints).forEach(
+      ([name, endpoint]) => {
+        if (endpoint.method === "GET")
+          hooks.push(this.generateQueryHook(name, endpoint));
       }
-    });
-    return imports + "\n" + hooks.join("\n\n");
+    );
+    return 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 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);
-    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");
+    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}(
-  ${paramsList}
-) {
+export function ${hookName}(${params.join(",\n  ")}) {
   return useQuery({
-    queryKey: [${queryKeyParts.join(", ")}] as const,
-    queryFn: () => apiClient.${name}(${clientCallArgs.join(", ")}),
+    ...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 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 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 invalidationQueries = invalidationTags.length > 0 ? invalidationTags.map((tag) => `      queryClient.invalidateQueries({ queryKey: ['${tag}'] });`).join("\n") : "      // No automatic invalidations";
+    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?: 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,
-  });
-}`;
+    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,
+      });
+    }`;
   }
 };
 var ServerActionsGenerator = class extends BaseGenerator {
@@ -583,11 +671,13 @@ import type {
 } from './types';
 `;
     const queries = [];
-    Object.entries(this.context.apiConfig.endpoints).forEach(([name, endpoint]) => {
-      if (this.isQueryEndpoint(endpoint)) {
-        queries.push(this.generateServerQuery(name, endpoint));
+    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) {
@@ -600,9 +690,7 @@ import type {
     const clientCallArgs = [];
     if (signature.hasParams) clientCallArgs.push("params");
     if (signature.hasQuery) clientCallArgs.push("query");
-    const cacheKeyParts = [
-      `'${name}'`
-    ];
+    const cacheKeyParts = [`'${name}'`];
     if (signature.hasParams) cacheKeyParts.push("JSON.stringify(params)");
     if (signature.hasQuery) cacheKeyParts.push("JSON.stringify(query)");
     return `/**
@@ -631,13 +719,18 @@ var TypesGenerator = class extends BaseGenerator {
     await fs5.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, "/");
     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 '@vietbus/api-codegen/config';
+export type { APIConfig, APIEndpoint, HTTPMethod } from '@cushin/api-codegen/schema';
 
 /**
  * Type helper to extract params schema from an endpoint
@@ -670,13 +763,35 @@ export type ExtractResponse<T> = T extends { response: infer R extends z.ZodType
 /**
  * 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>;
+export type APIEndpoints = typeof apiConfig.endpoints;
+
+${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");
+  }
 };
 var ClientGenerator = class extends BaseGenerator {
   async generate() {
@@ -699,11 +814,15 @@ var ClientGenerator = class extends BaseGenerator {
   }
   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, "/");
     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 { apiConfig } from '${relativePath}';
 import type { APIEndpoints } from './types';
+import { z } from 'zod';
 
 // Type-safe API client methods
 type APIClientMethods = {
@@ -733,11 +852,15 @@ type APIClientMethods = {
 };
 
 // Export singleton instance (will be initialized later)
-export let apiClient: APIClientMethods & {
+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
@@ -757,8 +880,8 @@ export let apiClient: APIClientMethods & {
  * initializeAPIClient(authCallbacks);
  */
 export const initializeAPIClient = (authCallbacks: AuthCallbacks) => {
-  apiClient = createAPIClient(apiConfig, authCallbacks) as any;
-  return apiClient;
+  baseClient = createAPIClient(apiConfig, authCallbacks) as any;
+  return baseClient;
 };
 
 // Export for custom usage
@@ -805,6 +928,202 @@ type APIClientMethods = {
 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");
+  }
+};
+var QueryKeysGenerator = class extends BaseGenerator {
+  async generate() {
+    const content = this.generateContent();
+    const outputPath = path6.join(
+      this.context.config.outputDir,
+      "query-keys.ts"
+    );
+    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+    await fs5.writeFile(outputPath, content, "utf-8");
+  }
+  generateContent() {
+    const content = `// Auto-generated query keys
+import { z } from 'zod';
+import { apiConfig } from '../config/endpoints';
+
+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");
+  }
+};
+var QueryOptionsGenerator = class extends BaseGenerator {
+  async generate() {
+    const content = this.generateContent();
+    const outputPath = path6.join(
+      this.context.config.outputDir,
+      "query-options.ts"
+    );
+    await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+    await fs5.writeFile(outputPath, content, "utf-8");
+  }
+  generateContent() {
+    const content = `// Auto-generated query options
+import { queryOptions } from '@tanstack/react-query';
+import { apiClient } from './api-client';
+import { queryKeys } from './query-keys';
+import { z } from 'zod';
+import { apiConfig } from '../config/endpoints';
+
+${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$1 = [];
+    Object.keys(groups).forEach((resource) => {
+      const hasQueries = groups[resource].some(
+        ({ endpoint }) => endpoint.method === "GET"
+      );
+      if (hasQueries) exports$1.push(`  ${resource}: ${resource}QueryOptions,`);
+    });
+    return exports$1.join("\n");
+  }
 };
 
 // src/generators/index.ts
@@ -825,6 +1144,8 @@ var CodeGenerator = class {
       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.generateServerActions && this.context.config.provider === "nextjs") {
@@ -836,8 +1157,6 @@ var CodeGenerator = class {
     return generators;
   }
 };
-
-// src/core/codegen.ts
 var CodegenCore = class {
   constructor(config) {
     this.config = config;
@@ -853,8 +1172,10 @@ var CodegenCore = class {
   }
   async loadAPIConfig() {
     try {
-      const fileUrl = pathToFileURL(this.config.endpointsPath).href;
-      const module = await import(fileUrl);
+      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(