@geekmidas/cli 0.0.11 → 0.0.13

package/dist/{build-C-UDqpkV.cjs → build-CTKUZTHx.cjs}

@@ -1,6 +1,6 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
 const require_config = require('./config-D8AyiwBU.cjs');
-const require_loadEndpoints = require('./loadEndpoints-CYFwuPZr.cjs');
+const require_loadEndpoints = require('./loadEndpoints-Dh-dSqZX.cjs');
 const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
 const path = require_chunk.__toESM(require("path"));
 

package/dist/{build-DCAjSjA0.mjs → build-DgeiXkH-.mjs}

@@ -1,5 +1,5 @@
 import { loadConfig } from "./config-DV1Lwdkx.mjs";
-import { loadEndpoints } from "./loadEndpoints-BL8q2rTO.mjs";
+import { loadEndpoints } from "./loadEndpoints-DKaw6Eqm.mjs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join, relative } from "path";
 

package/dist/build.cjs

@@ -1,5 +1,5 @@
 require('./config-D8AyiwBU.cjs');
-require('./loadEndpoints-CYFwuPZr.cjs');
-const require_build = require('./build-C-UDqpkV.cjs');
+require('./loadEndpoints-Dh-dSqZX.cjs');
+const require_build = require('./build-CTKUZTHx.cjs');
 
 exports.buildCommand = require_build.buildCommand;

package/dist/build.mjs

@@ -1,5 +1,5 @@
 import "./config-DV1Lwdkx.mjs";
-import "./loadEndpoints-BL8q2rTO.mjs";
-import { buildCommand } from "./build-DCAjSjA0.mjs";
+import "./loadEndpoints-DKaw6Eqm.mjs";
+import { buildCommand } from "./build-DgeiXkH-.mjs";
 
 export { buildCommand };

package/dist/{cli-NvCqdZtD.cjs → cli-CNAOwWIn.cjs}

@@ -1,11 +1,12 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_build = require('./build-C-UDqpkV.cjs');
-const require_openapi = require('./openapi-BX7ba0w0.cjs');
+const require_build = require('./build-CTKUZTHx.cjs');
+const require_openapi = require('./openapi-DrPYAlJ_.cjs');
+const require_openapi_react_query = require('./openapi-react-query-BWpdwBix.cjs');
 const commander = require_chunk.__toESM(require("commander"));
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "0.0.11";
+var version = "0.0.13";
 var private$1 = false;
 var type = "module";
 var bin = { "gkm": "./src/index.ts" };
@@ -82,6 +83,16 @@ program.command("openapi").description("Generate OpenAPI 3.0 specification from
 		process.exit(1);
 	}
 });
+program.command("generate:react-query").description("Generate React Query hooks from OpenAPI specification").option("--input <path>", "Input OpenAPI spec file path", "openapi.json").option("--output <path>", "Output file path for generated hooks", "src/api/hooks.ts").option("--name <name>", "API name prefix for generated code", "API").action(async (options) => {
+	try {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		await require_openapi_react_query.generateReactQueryCommand(options);
+	} catch (error) {
+		console.error("React Query generation failed:", error.message);
+		process.exit(1);
+	}
+});
 program.parse();
 
 //#endregion

package/dist/{cli-DPcRbYh5.mjs → cli-jxBvJiFq.mjs}

@@ -1,10 +1,11 @@
-import { buildCommand } from "./build-DCAjSjA0.mjs";
-import { openapiCommand } from "./openapi-BxI6zE0N.mjs";
+import { buildCommand } from "./build-DgeiXkH-.mjs";
+import { openapiCommand } from "./openapi-DgLItZw-.mjs";
+import { generateReactQueryCommand } from "./openapi-react-query-DuNQ8DwF.mjs";
 import { Command } from "commander";
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "0.0.11";
+var version = "0.0.13";
 var private$1 = false;
 var type = "module";
 var bin = { "gkm": "./src/index.ts" };
@@ -81,6 +82,16 @@ program.command("openapi").description("Generate OpenAPI 3.0 specification from
 		process.exit(1);
 	}
 });
+program.command("generate:react-query").description("Generate React Query hooks from OpenAPI specification").option("--input <path>", "Input OpenAPI spec file path", "openapi.json").option("--output <path>", "Output file path for generated hooks", "src/api/hooks.ts").option("--name <name>", "API name prefix for generated code", "API").action(async (options) => {
+	try {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		await generateReactQueryCommand(options);
+	} catch (error) {
+		console.error("React Query generation failed:", error.message);
+		process.exit(1);
+	}
+});
 program.parse();
 
 //#endregion

package/dist/cli.cjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 require('./config-D8AyiwBU.cjs');
-require('./loadEndpoints-CYFwuPZr.cjs');
-require('./build-C-UDqpkV.cjs');
-require('./cli-NvCqdZtD.cjs');
-require('./openapi-BX7ba0w0.cjs');
+require('./loadEndpoints-Dh-dSqZX.cjs');
+require('./build-CTKUZTHx.cjs');
+require('./cli-CNAOwWIn.cjs');
+require('./openapi-DrPYAlJ_.cjs');
+require('./openapi-react-query-BWpdwBix.cjs');

package/dist/cli.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import "./config-DV1Lwdkx.mjs";
-import "./loadEndpoints-BL8q2rTO.mjs";
-import "./build-DCAjSjA0.mjs";
-import "./cli-DPcRbYh5.mjs";
-import "./openapi-BxI6zE0N.mjs";
+import "./loadEndpoints-DKaw6Eqm.mjs";
+import "./build-DgeiXkH-.mjs";
+import "./cli-jxBvJiFq.mjs";
+import "./openapi-DgLItZw-.mjs";
+import "./openapi-react-query-DuNQ8DwF.mjs";

package/dist/index.cjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env -S npx tsx
 require('./config-D8AyiwBU.cjs');
-require('./loadEndpoints-CYFwuPZr.cjs');
-require('./build-C-UDqpkV.cjs');
-require('./cli-NvCqdZtD.cjs');
-require('./openapi-BX7ba0w0.cjs');
+require('./loadEndpoints-Dh-dSqZX.cjs');
+require('./build-CTKUZTHx.cjs');
+require('./cli-CNAOwWIn.cjs');
+require('./openapi-DrPYAlJ_.cjs');
+require('./openapi-react-query-BWpdwBix.cjs');

package/dist/index.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env -S npx tsx
 import "./config-DV1Lwdkx.mjs";
-import "./loadEndpoints-BL8q2rTO.mjs";
-import "./build-DCAjSjA0.mjs";
-import "./cli-DPcRbYh5.mjs";
-import "./openapi-BxI6zE0N.mjs";
+import "./loadEndpoints-DKaw6Eqm.mjs";
+import "./build-DgeiXkH-.mjs";
+import "./cli-jxBvJiFq.mjs";
+import "./openapi-DgLItZw-.mjs";
+import "./openapi-react-query-DuNQ8DwF.mjs";

package/dist/{loadEndpoints-BL8q2rTO.mjs → loadEndpoints-DKaw6Eqm.mjs}

@@ -12,11 +12,14 @@ async function loadEndpoints(routes) {
 	for await (const f of files) try {
 		const file = f.toString();
 		const module = await import(file);
-		for (const [exportName, exportValue] of Object.entries(module)) if (Endpoint.isEndpoint(exportValue)) endpoints.push({
-			name: exportName,
-			endpoint: exportValue,
-			file
-		});
+		for (const [exportName, exportValue] of Object.entries(module)) if (Endpoint.isEndpoint(exportValue)) {
+			exportValue.operationId = exportName;
+			endpoints.push({
+				name: exportName,
+				endpoint: exportValue,
+				file
+			});
+		}
 	} catch (error) {
 		logger.warn(`Failed to load ${f}:`, error.message);
 	}

package/dist/{loadEndpoints-CYFwuPZr.cjs → loadEndpoints-Dh-dSqZX.cjs}

@@ -13,11 +13,14 @@ async function loadEndpoints(routes) {
 	for await (const f of files) try {
 		const file = f.toString();
 		const module$1 = await import(file);
-		for (const [exportName, exportValue] of Object.entries(module$1)) if (__geekmidas_api_server.Endpoint.isEndpoint(exportValue)) endpoints.push({
-			name: exportName,
-			endpoint: exportValue,
-			file
-		});
+		for (const [exportName, exportValue] of Object.entries(module$1)) if (__geekmidas_api_server.Endpoint.isEndpoint(exportValue)) {
+			exportValue.operationId = exportName;
+			endpoints.push({
+				name: exportName,
+				endpoint: exportValue,
+				file
+			});
+		}
 	} catch (error) {
 		logger.warn(`Failed to load ${f}:`, error.message);
 	}

package/dist/loadEndpoints.cjs

@@ -1,3 +1,3 @@
-const require_loadEndpoints = require('./loadEndpoints-CYFwuPZr.cjs');
+const require_loadEndpoints = require('./loadEndpoints-Dh-dSqZX.cjs');
 
 exports.loadEndpoints = require_loadEndpoints.loadEndpoints;

package/dist/loadEndpoints.mjs

@@ -1,3 +1,3 @@
-import { loadEndpoints } from "./loadEndpoints-BL8q2rTO.mjs";
+import { loadEndpoints } from "./loadEndpoints-DKaw6Eqm.mjs";
 
 export { loadEndpoints };

package/dist/{openapi-BxI6zE0N.mjs → openapi-DgLItZw-.mjs}

@@ -1,5 +1,5 @@
 import { loadConfig } from "./config-DV1Lwdkx.mjs";
-import { loadEndpoints } from "./loadEndpoints-BL8q2rTO.mjs";
+import { loadEndpoints } from "./loadEndpoints-DKaw6Eqm.mjs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { Endpoint } from "@geekmidas/api/server";
 import { join } from "node:path";

package/dist/{openapi-BX7ba0w0.cjs → openapi-DrPYAlJ_.cjs}

@@ -1,6 +1,6 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
 const require_config = require('./config-D8AyiwBU.cjs');
-const require_loadEndpoints = require('./loadEndpoints-CYFwuPZr.cjs');
+const require_loadEndpoints = require('./loadEndpoints-Dh-dSqZX.cjs');
 const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
 const __geekmidas_api_server = require_chunk.__toESM(require("@geekmidas/api/server"));
 const node_path = require_chunk.__toESM(require("node:path"));

package/dist/openapi-react-query-BWpdwBix.cjs

@@ -0,0 +1,171 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
+const node_path = require_chunk.__toESM(require("node:path"));
+const node_fs = require_chunk.__toESM(require("node:fs"));
+const node_child_process = require_chunk.__toESM(require("node:child_process"));
+const node_util = require_chunk.__toESM(require("node:util"));
+
+//#region src/openapi-react-query.ts
+const execAsync = (0, node_util.promisify)(node_child_process.exec);
+async function generateReactQueryCommand(options = {}) {
+	const logger = console;
+	try {
+		const inputPath = options.input || (0, node_path.join)(process.cwd(), "openapi.json");
+		if (!(0, node_fs.existsSync)(inputPath)) throw new Error(`OpenAPI spec not found at ${inputPath}. Run 'npx @geekmidas/cli openapi' first.`);
+		const specContent = await (0, node_fs_promises.readFile)(inputPath, "utf-8");
+		const spec = JSON.parse(specContent);
+		const outputDir = (0, node_path.dirname)(options.output || (0, node_path.join)(process.cwd(), "src", "api", "hooks.ts"));
+		const typesPath = (0, node_path.join)(outputDir, "openapi-types.d.ts");
+		logger.log("Generating TypeScript types from OpenAPI spec...");
+		try {
+			await execAsync(`npx openapi-typescript "${inputPath}" -o "${typesPath}"`, { cwd: process.cwd() });
+			logger.log(`TypeScript types generated: ${typesPath}`);
+		} catch (error) {
+			logger.warn("Could not generate types with openapi-typescript. Install it for better type inference.");
+			logger.warn("Run: npm install -D openapi-typescript");
+			await (0, node_fs_promises.writeFile)(typesPath, `// Auto-generated placeholder types
+export interface paths {
+  [path: string]: {
+    [method: string]: {
+      operationId?: string;
+      parameters?: any;
+      requestBody?: any;
+      responses?: any;
+    };
+  };
+}
+`);
+		}
+		const operations = extractOperations(spec);
+		const code = generateReactQueryCode(spec, operations, options.name || "API");
+		const outputPath = options.output || (0, node_path.join)(process.cwd(), "src", "api", "hooks.ts");
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+		await (0, node_fs_promises.writeFile)(outputPath, code);
+		logger.log(`React Query hooks generated: ${outputPath}`);
+		logger.log(`Generated ${operations.length} hooks`);
+	} catch (error) {
+		throw new Error(`React Query generation failed: ${error.message}`);
+	}
+}
+function extractOperations(spec) {
+	const operations = [];
+	Object.entries(spec.paths).forEach(([path, methods]) => {
+		Object.entries(methods).forEach(([method, operation]) => {
+			if (operation.operationId) operations.push({
+				operationId: operation.operationId,
+				path,
+				method: method.toUpperCase(),
+				endpoint: `${method.toUpperCase()} ${path}`,
+				parameters: operation.parameters,
+				requestBody: !!operation.requestBody,
+				responseType: extractResponseType(operation)
+			});
+		});
+	});
+	return operations;
+}
+function extractResponseType(operation) {
+	const responses = operation.responses;
+	if (!responses) return "unknown";
+	const successResponse = responses["200"] || responses["201"];
+	if (!successResponse?.content?.["application/json"]?.schema) return "unknown";
+	const schema = successResponse.content["application/json"].schema;
+	return schemaToTypeString(schema);
+}
+function schemaToTypeString(schema) {
+	if (!schema) return "unknown";
+	switch (schema.type) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "array": return `Array<${schemaToTypeString(schema.items)}>`;
+		case "object":
+			if (schema.properties) {
+				const props = Object.entries(schema.properties).map(([key, value]) => `${key}: ${schemaToTypeString(value)}`).join("; ");
+				return `{ ${props} }`;
+			}
+			return "Record<string, unknown>";
+		default: return "unknown";
+	}
+}
+function generateReactQueryCode(spec, operations, apiName) {
+	const imports = `import { createTypedQueryClient } from '@geekmidas/api/client';
+import type { paths } from './openapi-types';
+
+// Create typed query client
+export const ${apiName.toLowerCase()} = createTypedQueryClient<paths>({
+  baseURL: process.env.NEXT_PUBLIC_API_URL || '/api',
+});
+
+// Export individual hooks for better DX
+`;
+	const queryHooks = operations.filter((op) => op.method === "GET").map((op) => generateQueryHook(op, apiName)).join("\n\n");
+	const mutationHooks = operations.filter((op) => op.method !== "GET").map((op) => generateMutationHook(op, apiName)).join("\n\n");
+	const typeExports = generateTypeExports(operations);
+	return `${imports}
+// Query Hooks
+${queryHooks}
+
+// Mutation Hooks
+${mutationHooks}
+
+// Type exports for convenience
+${typeExports}
+
+// Re-export the api for advanced usage
+export { ${apiName.toLowerCase()} };
+`;
+}
+function generateQueryHook(op, apiName) {
+	const hookName = `use${capitalize(op.operationId)}`;
+	const endpoint = op.endpoint;
+	const hasParams = op.parameters?.some((p) => p.in === "path");
+	const hasQuery = op.parameters?.some((p) => p.in === "query");
+	let params = "";
+	let args = "";
+	if (hasParams || hasQuery) {
+		const paramParts = [];
+		if (hasParams) {
+			const pathParams = op.parameters?.filter((p) => p.in === "path").map((p) => p.name) || [];
+			paramParts.push(`params: { ${pathParams.map((p) => `${p}: string`).join("; ")} }`);
+		}
+		if (hasQuery) paramParts.push(`query?: Record<string, any>`);
+		params = `config: { ${paramParts.join("; ")} }, `;
+		args = ", config";
+	}
+	return `export const ${hookName} = (
+  ${params}options?: Parameters<typeof ${apiName.toLowerCase()}.useQuery>[2]
+) => {
+  return ${apiName.toLowerCase()}.useQuery('${endpoint}' as any${args}, options);
+};`;
+}
+function generateMutationHook(op, apiName) {
+	const hookName = `use${capitalize(op.operationId)}`;
+	const endpoint = op.endpoint;
+	return `export const ${hookName} = (
+  options?: Parameters<typeof ${apiName.toLowerCase()}.useMutation>[1]
+) => {
+  return ${apiName.toLowerCase()}.useMutation('${endpoint}' as any, options);
+};`;
+}
+function generateTypeExports(operations) {
+	const exports$1 = operations.map((op) => {
+		const typeName = capitalize(op.operationId);
+		const isQuery = op.method === "GET";
+		if (isQuery) return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['data']>>;`;
+		else return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['mutateAsync']>>;`;
+	});
+	return exports$1.join("\n");
+}
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+//#endregion
+Object.defineProperty(exports, 'generateReactQueryCommand', {
+  enumerable: true,
+  get: function () {
+    return generateReactQueryCommand;
+  }
+});

package/dist/openapi-react-query-DuNQ8DwF.mjs

@@ -0,0 +1,165 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+//#region src/openapi-react-query.ts
+const execAsync = promisify(exec);
+async function generateReactQueryCommand(options = {}) {
+	const logger = console;
+	try {
+		const inputPath = options.input || join(process.cwd(), "openapi.json");
+		if (!existsSync(inputPath)) throw new Error(`OpenAPI spec not found at ${inputPath}. Run 'npx @geekmidas/cli openapi' first.`);
+		const specContent = await readFile(inputPath, "utf-8");
+		const spec = JSON.parse(specContent);
+		const outputDir = dirname(options.output || join(process.cwd(), "src", "api", "hooks.ts"));
+		const typesPath = join(outputDir, "openapi-types.d.ts");
+		logger.log("Generating TypeScript types from OpenAPI spec...");
+		try {
+			await execAsync(`npx openapi-typescript "${inputPath}" -o "${typesPath}"`, { cwd: process.cwd() });
+			logger.log(`TypeScript types generated: ${typesPath}`);
+		} catch (error) {
+			logger.warn("Could not generate types with openapi-typescript. Install it for better type inference.");
+			logger.warn("Run: npm install -D openapi-typescript");
+			await writeFile(typesPath, `// Auto-generated placeholder types
+export interface paths {
+  [path: string]: {
+    [method: string]: {
+      operationId?: string;
+      parameters?: any;
+      requestBody?: any;
+      responses?: any;
+    };
+  };
+}
+`);
+		}
+		const operations = extractOperations(spec);
+		const code = generateReactQueryCode(spec, operations, options.name || "API");
+		const outputPath = options.output || join(process.cwd(), "src", "api", "hooks.ts");
+		await mkdir(dirname(outputPath), { recursive: true });
+		await writeFile(outputPath, code);
+		logger.log(`React Query hooks generated: ${outputPath}`);
+		logger.log(`Generated ${operations.length} hooks`);
+	} catch (error) {
+		throw new Error(`React Query generation failed: ${error.message}`);
+	}
+}
+function extractOperations(spec) {
+	const operations = [];
+	Object.entries(spec.paths).forEach(([path, methods]) => {
+		Object.entries(methods).forEach(([method, operation]) => {
+			if (operation.operationId) operations.push({
+				operationId: operation.operationId,
+				path,
+				method: method.toUpperCase(),
+				endpoint: `${method.toUpperCase()} ${path}`,
+				parameters: operation.parameters,
+				requestBody: !!operation.requestBody,
+				responseType: extractResponseType(operation)
+			});
+		});
+	});
+	return operations;
+}
+function extractResponseType(operation) {
+	const responses = operation.responses;
+	if (!responses) return "unknown";
+	const successResponse = responses["200"] || responses["201"];
+	if (!successResponse?.content?.["application/json"]?.schema) return "unknown";
+	const schema = successResponse.content["application/json"].schema;
+	return schemaToTypeString(schema);
+}
+function schemaToTypeString(schema) {
+	if (!schema) return "unknown";
+	switch (schema.type) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "array": return `Array<${schemaToTypeString(schema.items)}>`;
+		case "object":
+			if (schema.properties) {
+				const props = Object.entries(schema.properties).map(([key, value]) => `${key}: ${schemaToTypeString(value)}`).join("; ");
+				return `{ ${props} }`;
+			}
+			return "Record<string, unknown>";
+		default: return "unknown";
+	}
+}
+function generateReactQueryCode(spec, operations, apiName) {
+	const imports = `import { createTypedQueryClient } from '@geekmidas/api/client';
+import type { paths } from './openapi-types';
+
+// Create typed query client
+export const ${apiName.toLowerCase()} = createTypedQueryClient<paths>({
+  baseURL: process.env.NEXT_PUBLIC_API_URL || '/api',
+});
+
+// Export individual hooks for better DX
+`;
+	const queryHooks = operations.filter((op) => op.method === "GET").map((op) => generateQueryHook(op, apiName)).join("\n\n");
+	const mutationHooks = operations.filter((op) => op.method !== "GET").map((op) => generateMutationHook(op, apiName)).join("\n\n");
+	const typeExports = generateTypeExports(operations);
+	return `${imports}
+// Query Hooks
+${queryHooks}
+
+// Mutation Hooks
+${mutationHooks}
+
+// Type exports for convenience
+${typeExports}
+
+// Re-export the api for advanced usage
+export { ${apiName.toLowerCase()} };
+`;
+}
+function generateQueryHook(op, apiName) {
+	const hookName = `use${capitalize(op.operationId)}`;
+	const endpoint = op.endpoint;
+	const hasParams = op.parameters?.some((p) => p.in === "path");
+	const hasQuery = op.parameters?.some((p) => p.in === "query");
+	let params = "";
+	let args = "";
+	if (hasParams || hasQuery) {
+		const paramParts = [];
+		if (hasParams) {
+			const pathParams = op.parameters?.filter((p) => p.in === "path").map((p) => p.name) || [];
+			paramParts.push(`params: { ${pathParams.map((p) => `${p}: string`).join("; ")} }`);
+		}
+		if (hasQuery) paramParts.push(`query?: Record<string, any>`);
+		params = `config: { ${paramParts.join("; ")} }, `;
+		args = ", config";
+	}
+	return `export const ${hookName} = (
+  ${params}options?: Parameters<typeof ${apiName.toLowerCase()}.useQuery>[2]
+) => {
+  return ${apiName.toLowerCase()}.useQuery('${endpoint}' as any${args}, options);
+};`;
+}
+function generateMutationHook(op, apiName) {
+	const hookName = `use${capitalize(op.operationId)}`;
+	const endpoint = op.endpoint;
+	return `export const ${hookName} = (
+  options?: Parameters<typeof ${apiName.toLowerCase()}.useMutation>[1]
+) => {
+  return ${apiName.toLowerCase()}.useMutation('${endpoint}' as any, options);
+};`;
+}
+function generateTypeExports(operations) {
+	const exports = operations.map((op) => {
+		const typeName = capitalize(op.operationId);
+		const isQuery = op.method === "GET";
+		if (isQuery) return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['data']>>;`;
+		else return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['mutateAsync']>>;`;
+	});
+	return exports.join("\n");
+}
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+//#endregion
+export { generateReactQueryCommand };

package/dist/openapi-react-query.cjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env -S npx tsx
+const require_openapi_react_query = require('./openapi-react-query-BWpdwBix.cjs');
+
+exports.generateReactQueryCommand = require_openapi_react_query.generateReactQueryCommand;

package/dist/openapi-react-query.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env -S npx tsx
+import { generateReactQueryCommand } from "./openapi-react-query-DuNQ8DwF.mjs";
+
+export { generateReactQueryCommand };

package/dist/openapi.cjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S npx tsx
 require('./config-D8AyiwBU.cjs');
-require('./loadEndpoints-CYFwuPZr.cjs');
-const require_openapi = require('./openapi-BX7ba0w0.cjs');
+require('./loadEndpoints-Dh-dSqZX.cjs');
+const require_openapi = require('./openapi-DrPYAlJ_.cjs');
 
 exports.openapiCommand = require_openapi.openapiCommand;

package/dist/openapi.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S npx tsx
 import "./config-DV1Lwdkx.mjs";
-import "./loadEndpoints-BL8q2rTO.mjs";
-import { openapiCommand } from "./openapi-BxI6zE0N.mjs";
+import "./loadEndpoints-DKaw6Eqm.mjs";
+import { openapiCommand } from "./openapi-DgLItZw-.mjs";
 
 export { openapiCommand };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "private": false,
   "type": "module",
   "bin": {
@@ -23,7 +23,7 @@
     "lodash.set": "~4.3.2",
     "zod": "~3.25.67",
     "fast-glob": "~3.3.3",
-    "@geekmidas/api": "0.0.25"
+    "@geekmidas/api": "0.0.26"
   },
   "devDependencies": {
     "@types/lodash.get": "~4.4.9",

package/src/cli.ts

@@ -4,6 +4,7 @@ import { Command } from 'commander';
 import pkg from '../package.json' assert { type: 'json' };
 import { buildCommand } from './build.js';
 import { openapiCommand } from './openapi.js';
+import { generateReactQueryCommand } from './openapi-react-query.js';
 import type { Provider } from './types.js';
 
 const program = new Command();
@@ -92,4 +93,35 @@ program
     }
   });
 
+program
+  .command('generate:react-query')
+  .description('Generate React Query hooks from OpenAPI specification')
+  .option(
+    '--input <path>',
+    'Input OpenAPI spec file path',
+    'openapi.json',
+  )
+  .option(
+    '--output <path>',
+    'Output file path for generated hooks',
+    'src/api/hooks.ts',
+  )
+  .option(
+    '--name <name>',
+    'API name prefix for generated code',
+    'API',
+  )
+  .action(async (options: { input?: string; output?: string; name?: string }) => {
+    try {
+      const globalOptions = program.opts();
+      if (globalOptions.cwd) {
+        process.chdir(globalOptions.cwd);
+      }
+      await generateReactQueryCommand(options);
+    } catch (error) {
+      console.error('React Query generation failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/src/loadEndpoints.ts

@@ -27,7 +27,8 @@ export async function loadEndpoints(routes: Routes): Promise<LoadedEndpoint[]> {
 
       // Check all exports for endpoints
       for (const [exportName, exportValue] of Object.entries(module)) {
-        if (Endpoint.isEndpoint(exportValue as any)) {
+        if (Endpoint.isEndpoint(exportValue)) {
+          exportValue.operationId = exportName;
           endpoints.push({
             name: exportName,
             endpoint: exportValue as Endpoint<any, any, any, any, any, any>,

package/src/openapi-react-query.ts

@@ -0,0 +1,265 @@
+#!/usr/bin/env -S npx tsx
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+
+interface ReactQueryOptions {
+  input?: string;
+  output?: string;
+  name?: string;
+}
+
+interface OpenAPISpec {
+  openapi: string;
+  info?: {
+    title?: string;
+    version?: string;
+  };
+  paths: Record<string, Record<string, any>>;
+}
+
+export async function generateReactQueryCommand(
+  options: ReactQueryOptions = {},
+): Promise<void> {
+  const logger = console;
+
+  try {
+    // Read OpenAPI spec
+    const inputPath = options.input || join(process.cwd(), 'openapi.json');
+    
+    if (!existsSync(inputPath)) {
+      throw new Error(`OpenAPI spec not found at ${inputPath}. Run 'npx @geekmidas/cli openapi' first.`);
+    }
+
+    const specContent = await readFile(inputPath, 'utf-8');
+    const spec: OpenAPISpec = JSON.parse(specContent);
+
+    // Generate TypeScript types from OpenAPI spec
+    const outputDir = dirname(options.output || join(process.cwd(), 'src', 'api', 'hooks.ts'));
+    const typesPath = join(outputDir, 'openapi-types.d.ts');
+    
+    logger.log('Generating TypeScript types from OpenAPI spec...');
+    
+    try {
+      // Use npx to run openapi-typescript
+      await execAsync(
+        `npx openapi-typescript "${inputPath}" -o "${typesPath}"`,
+        { cwd: process.cwd() }
+      );
+      logger.log(`TypeScript types generated: ${typesPath}`);
+    } catch (error) {
+      logger.warn('Could not generate types with openapi-typescript. Install it for better type inference.');
+      logger.warn('Run: npm install -D openapi-typescript');
+      
+      // Generate basic types file
+      await writeFile(typesPath, `// Auto-generated placeholder types
+export interface paths {
+  [path: string]: {
+    [method: string]: {
+      operationId?: string;
+      parameters?: any;
+      requestBody?: any;
+      responses?: any;
+    };
+  };
+}
+`);
+    }
+
+    // Extract operation info
+    const operations = extractOperations(spec);
+    
+    // Generate TypeScript code
+    const code = generateReactQueryCode(spec, operations, options.name || 'API');
+
+    // Write output
+    const outputPath = options.output || join(process.cwd(), 'src', 'api', 'hooks.ts');
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, code);
+
+    logger.log(`React Query hooks generated: ${outputPath}`);
+    logger.log(`Generated ${operations.length} hooks`);
+  } catch (error) {
+    throw new Error(`React Query generation failed: ${(error as Error).message}`);
+  }
+}
+
+interface OperationInfo {
+  operationId: string;
+  path: string;
+  method: string;
+  endpoint: string; // Full endpoint like 'GET /users/{id}'
+  parameters?: Array<{ name: string; in: string; required?: boolean }>;
+  requestBody?: boolean;
+  responseType?: string;
+}
+
+function extractOperations(spec: OpenAPISpec): OperationInfo[] {
+  const operations: OperationInfo[] = [];
+
+  Object.entries(spec.paths).forEach(([path, methods]) => {
+    Object.entries(methods).forEach(([method, operation]) => {
+      if (operation.operationId) {
+        operations.push({
+          operationId: operation.operationId,
+          path,
+          method: method.toUpperCase(),
+          endpoint: `${method.toUpperCase()} ${path}`,
+          parameters: operation.parameters,
+          requestBody: !!operation.requestBody,
+          responseType: extractResponseType(operation),
+        });
+      }
+    });
+  });
+
+  return operations;
+}
+
+function extractResponseType(operation: any): string {
+  const responses = operation.responses;
+  if (!responses) return 'unknown';
+
+  const successResponse = responses['200'] || responses['201'];
+  if (!successResponse?.content?.['application/json']?.schema) {
+    return 'unknown';
+  }
+
+  // Basic type inference from schema
+  const schema = successResponse.content['application/json'].schema;
+  return schemaToTypeString(schema);
+}
+
+function schemaToTypeString(schema: any): string {
+  if (!schema) return 'unknown';
+  
+  switch (schema.type) {
+    case 'string':
+      return 'string';
+    case 'number':
+    case 'integer':
+      return 'number';
+    case 'boolean':
+      return 'boolean';
+    case 'array':
+      return `Array<${schemaToTypeString(schema.items)}>`;
+    case 'object':
+      if (schema.properties) {
+        const props = Object.entries(schema.properties)
+          .map(([key, value]: [string, any]) => `${key}: ${schemaToTypeString(value)}`)
+          .join('; ');
+        return `{ ${props} }`;
+      }
+      return 'Record<string, unknown>';
+    default:
+      return 'unknown';
+  }
+}
+
+function generateReactQueryCode(
+  spec: OpenAPISpec,
+  operations: OperationInfo[],
+  apiName: string,
+): string {
+  const imports = `import { createTypedQueryClient } from '@geekmidas/api/client';
+import type { paths } from './openapi-types';
+
+// Create typed query client
+export const ${apiName.toLowerCase()} = createTypedQueryClient<paths>({
+  baseURL: process.env.NEXT_PUBLIC_API_URL || '/api',
+});
+
+// Export individual hooks for better DX
+`;
+
+  const queryHooks = operations
+    .filter(op => op.method === 'GET')
+    .map(op => generateQueryHook(op, apiName))
+    .join('\n\n');
+
+  const mutationHooks = operations
+    .filter(op => op.method !== 'GET')
+    .map(op => generateMutationHook(op, apiName))
+    .join('\n\n');
+
+  const typeExports = generateTypeExports(operations);
+
+  return `${imports}
+// Query Hooks
+${queryHooks}
+
+// Mutation Hooks
+${mutationHooks}
+
+// Type exports for convenience
+${typeExports}
+
+// Re-export the api for advanced usage
+export { ${apiName.toLowerCase()} };
+`;
+}
+
+function generateQueryHook(op: OperationInfo, apiName: string): string {
+  const hookName = `use${capitalize(op.operationId)}`;
+  const endpoint = op.endpoint;
+  const hasParams = op.parameters?.some(p => p.in === 'path');
+  const hasQuery = op.parameters?.some(p => p.in === 'query');
+  
+  // Generate properly typed hook
+  let params = '';
+  let args = '';
+  
+  if (hasParams || hasQuery) {
+    const paramParts: string[] = [];
+    if (hasParams) {
+      const pathParams = op.parameters?.filter(p => p.in === 'path').map(p => p.name) || [];
+      paramParts.push(`params: { ${pathParams.map(p => `${p}: string`).join('; ')} }`);
+    }
+    if (hasQuery) {
+      paramParts.push(`query?: Record<string, any>`);
+    }
+    params = `config: { ${paramParts.join('; ')} }, `;
+    args = ', config';
+  }
+  
+  return `export const ${hookName} = (
+  ${params}options?: Parameters<typeof ${apiName.toLowerCase()}.useQuery>[2]
+) => {
+  return ${apiName.toLowerCase()}.useQuery('${endpoint}' as any${args}, options);
+};`;
+}
+
+function generateMutationHook(op: OperationInfo, apiName: string): string {
+  const hookName = `use${capitalize(op.operationId)}`;
+  const endpoint = op.endpoint;
+  
+  return `export const ${hookName} = (
+  options?: Parameters<typeof ${apiName.toLowerCase()}.useMutation>[1]
+) => {
+  return ${apiName.toLowerCase()}.useMutation('${endpoint}' as any, options);
+};`;
+}
+
+function generateTypeExports(operations: OperationInfo[]): string {
+  const exports = operations.map(op => {
+    const typeName = capitalize(op.operationId);
+    const isQuery = op.method === 'GET';
+    
+    if (isQuery) {
+      return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['data']>>;`;
+    } else {
+      return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['mutateAsync']>>;`;
+    }
+  });
+
+  return exports.join('\n');
+}
+
+function capitalize(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}