@geekmidas/cli 0.0.12 → 0.0.14

package/dist/cli.cjs

@@ -1,6 +1,95 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S npx tsx
+const require_chunk = require('./chunk-CUT6urMc.cjs');
 require('./config-D8AyiwBU.cjs');
 require('./loadEndpoints-Dh-dSqZX.cjs');
-require('./build-CTKUZTHx.cjs');
-require('./cli-DLypHuNF.cjs');
-require('./openapi-DrPYAlJ_.cjs');
+const require_build = require('./build-CTKUZTHx.cjs');
+const require_openapi_react_query = require('./openapi-react-query-C1JLYUOs.cjs');
+const require_openapi = require('./openapi-DrPYAlJ_.cjs');
+const commander = require_chunk.__toESM(require("commander"));
+
+//#region package.json
+var name = "@geekmidas/cli";
+var version = "0.0.14";
+var private$1 = false;
+var type = "module";
+var bin = { "gkm": "./dist/cli.cjs" };
+var publishConfig = {
+	"registry": "https://registry.npmjs.org/",
+	"access": "public"
+};
+var dependencies = {
+	"commander": "~14.0.0",
+	"lodash.get": "~4.4.2",
+	"lodash.set": "~4.3.2",
+	"zod": "~3.25.67",
+	"fast-glob": "~3.3.3",
+	"@geekmidas/api": "workspace:*"
+};
+var devDependencies = {
+	"@types/lodash.get": "~4.4.9",
+	"@types/lodash.set": "~4.3.9"
+};
+var package_default = {
+	name,
+	version,
+	private: private$1,
+	type,
+	bin,
+	publishConfig,
+	dependencies,
+	devDependencies
+};
+
+//#endregion
+//#region src/cli.ts
+const program = new commander.Command();
+program.name("gkm").description("GeekMidas backend framework CLI").version(package_default.version).option("--cwd <path>", "Change working directory");
+program.command("build").description("Build API handlers from endpoints").option("--providers <providers>", "Target providers for generated handlers (comma-separated)", "aws-apigatewayv1").action(async (options) => {
+	try {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		const providerList = [...new Set(options.providers.split(",").map((p) => p.trim()))];
+		await require_build.buildCommand({ providers: providerList });
+	} catch (error) {
+		console.error("Build failed:", error.message);
+		process.exit(1);
+	}
+});
+program.command("cron").description("Manage cron jobs").action(() => {
+	const globalOptions = program.opts();
+	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+	process.stdout.write("Cron management - coming soon\n");
+});
+program.command("function").description("Manage serverless functions").action(() => {
+	const globalOptions = program.opts();
+	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+	process.stdout.write("Serverless function management - coming soon\n");
+});
+program.command("api").description("Manage REST API endpoints").action(() => {
+	const globalOptions = program.opts();
+	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+	process.stdout.write("REST API management - coming soon\n");
+});
+program.command("openapi").description("Generate OpenAPI 3.0 specification from endpoints").option("--output <path>", "Output file path for the OpenAPI spec", "openapi.json").action(async (options) => {
+	try {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		await require_openapi.openapiCommand(options);
+	} catch (error) {
+		console.error("OpenAPI generation failed:", error.message);
+		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.mjs

@@ -1,6 +1,94 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S npx tsx
 import "./config-DV1Lwdkx.mjs";
 import "./loadEndpoints-DKaw6Eqm.mjs";
-import "./build-DgeiXkH-.mjs";
-import "./cli-BuIVmCrJ.mjs";
-import "./openapi-DgLItZw-.mjs";
+import { buildCommand } from "./build-DgeiXkH-.mjs";
+import { generateReactQueryCommand } from "./openapi-react-query-DpT3XHFC.mjs";
+import { openapiCommand } from "./openapi-DgLItZw-.mjs";
+import { Command } from "commander";
+
+//#region package.json
+var name = "@geekmidas/cli";
+var version = "0.0.14";
+var private$1 = false;
+var type = "module";
+var bin = { "gkm": "./dist/cli.cjs" };
+var publishConfig = {
+	"registry": "https://registry.npmjs.org/",
+	"access": "public"
+};
+var dependencies = {
+	"commander": "~14.0.0",
+	"lodash.get": "~4.4.2",
+	"lodash.set": "~4.3.2",
+	"zod": "~3.25.67",
+	"fast-glob": "~3.3.3",
+	"@geekmidas/api": "workspace:*"
+};
+var devDependencies = {
+	"@types/lodash.get": "~4.4.9",
+	"@types/lodash.set": "~4.3.9"
+};
+var package_default = {
+	name,
+	version,
+	private: private$1,
+	type,
+	bin,
+	publishConfig,
+	dependencies,
+	devDependencies
+};
+
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+program.name("gkm").description("GeekMidas backend framework CLI").version(package_default.version).option("--cwd <path>", "Change working directory");
+program.command("build").description("Build API handlers from endpoints").option("--providers <providers>", "Target providers for generated handlers (comma-separated)", "aws-apigatewayv1").action(async (options) => {
+	try {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		const providerList = [...new Set(options.providers.split(",").map((p) => p.trim()))];
+		await buildCommand({ providers: providerList });
+	} catch (error) {
+		console.error("Build failed:", error.message);
+		process.exit(1);
+	}
+});
+program.command("cron").description("Manage cron jobs").action(() => {
+	const globalOptions = program.opts();
+	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+	process.stdout.write("Cron management - coming soon\n");
+});
+program.command("function").description("Manage serverless functions").action(() => {
+	const globalOptions = program.opts();
+	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+	process.stdout.write("Serverless function management - coming soon\n");
+});
+program.command("api").description("Manage REST API endpoints").action(() => {
+	const globalOptions = program.opts();
+	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+	process.stdout.write("REST API management - coming soon\n");
+});
+program.command("openapi").description("Generate OpenAPI 3.0 specification from endpoints").option("--output <path>", "Output file path for the OpenAPI spec", "openapi.json").action(async (options) => {
+	try {
+		const globalOptions = program.opts();
+		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
+		await openapiCommand(options);
+	} catch (error) {
+		console.error("OpenAPI generation failed:", error.message);
+		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/openapi-react-query-C1JLYUOs.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_child_process = require_chunk.__toESM(require("node:child_process"));
+const node_fs = require_chunk.__toESM(require("node:fs"));
+const node_path = require_chunk.__toESM(require("node:path"));
+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-DpT3XHFC.mjs

@@ -0,0 +1,165 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { exec } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+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-C1JLYUOs.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-DpT3XHFC.mjs";
+
+export { generateReactQueryCommand };

package/package.json

@@ -1,17 +1,10 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "private": false,
   "type": "module",
   "bin": {
-    "gkm": "./src/index.ts"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs",
-      "types": "./src/index.ts"
-    }
+    "gkm": "./dist/cli.cjs"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
@@ -23,7 +16,7 @@
     "lodash.set": "~4.3.2",
     "zod": "~3.25.67",
     "fast-glob": "~3.3.3",
-    "@geekmidas/api": "0.0.26"
+    "@geekmidas/api": "0.0.31"
   },
   "devDependencies": {
     "@types/lodash.get": "~4.4.9",

package/src/cli.ts

@@ -1,10 +1,11 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S npx tsx
 
 import { Command } from 'commander';
 import pkg from '../package.json' assert { type: 'json' };
-import { buildCommand } from './build.js';
-import { openapiCommand } from './openapi.js';
-import type { Provider } from './types.js';
+import { buildCommand } from './build.ts';
+import { generateReactQueryCommand } from './openapi-react-query.ts';
+import { openapiCommand } from './openapi.ts';
+import type { Provider } from './types.ts';
 
 const program = new Command();
 
@@ -92,4 +93,32 @@ 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/openapi-react-query.ts

@@ -0,0 +1,287 @@
+#!/usr/bin/env -S npx tsx
+
+import { exec } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+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);
+}

package/tsdown.config.ts

@@ -1,3 +1,5 @@
 import { defineConfig } from 'tsdown';
 
-export default defineConfig({});
+export default defineConfig({
+  dts: false,
+});

package/dist/cli-BuIVmCrJ.mjs

@@ -1,86 +0,0 @@
-import { buildCommand } from "./build-DgeiXkH-.mjs";
-import { openapiCommand } from "./openapi-DgLItZw-.mjs";
-import { Command } from "commander";
-
-//#region package.json
-var name = "@geekmidas/cli";
-var version = "0.0.12";
-var private$1 = false;
-var type = "module";
-var bin = { "gkm": "./src/index.ts" };
-var exports = { ".": {
-	"import": "./dist/index.mjs",
-	"require": "./dist/index.cjs",
-	"types": "./src/index.ts"
-} };
-var publishConfig = {
-	"registry": "https://registry.npmjs.org/",
-	"access": "public"
-};
-var dependencies = {
-	"commander": "~14.0.0",
-	"lodash.get": "~4.4.2",
-	"lodash.set": "~4.3.2",
-	"zod": "~3.25.67",
-	"fast-glob": "~3.3.3",
-	"@geekmidas/api": "workspace:*"
-};
-var devDependencies = {
-	"@types/lodash.get": "~4.4.9",
-	"@types/lodash.set": "~4.3.9"
-};
-var package_default = {
-	name,
-	version,
-	private: private$1,
-	type,
-	bin,
-	exports,
-	publishConfig,
-	dependencies,
-	devDependencies
-};
-
-//#endregion
-//#region src/cli.ts
-const program = new Command();
-program.name("gkm").description("GeekMidas backend framework CLI").version(package_default.version).option("--cwd <path>", "Change working directory");
-program.command("build").description("Build API handlers from endpoints").option("--providers <providers>", "Target providers for generated handlers (comma-separated)", "aws-apigatewayv1").action(async (options) => {
-	try {
-		const globalOptions = program.opts();
-		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-		const providerList = [...new Set(options.providers.split(",").map((p) => p.trim()))];
-		await buildCommand({ providers: providerList });
-	} catch (error) {
-		console.error("Build failed:", error.message);
-		process.exit(1);
-	}
-});
-program.command("cron").description("Manage cron jobs").action(() => {
-	const globalOptions = program.opts();
-	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-	process.stdout.write("Cron management - coming soon\n");
-});
-program.command("function").description("Manage serverless functions").action(() => {
-	const globalOptions = program.opts();
-	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-	process.stdout.write("Serverless function management - coming soon\n");
-});
-program.command("api").description("Manage REST API endpoints").action(() => {
-	const globalOptions = program.opts();
-	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-	process.stdout.write("REST API management - coming soon\n");
-});
-program.command("openapi").description("Generate OpenAPI 3.0 specification from endpoints").option("--output <path>", "Output file path for the OpenAPI spec", "openapi.json").action(async (options) => {
-	try {
-		const globalOptions = program.opts();
-		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-		await openapiCommand(options);
-	} catch (error) {
-		console.error("OpenAPI generation failed:", error.message);
-		process.exit(1);
-	}
-});
-program.parse();
-
-//#endregion

package/dist/cli-DLypHuNF.cjs

@@ -1,87 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_build = require('./build-CTKUZTHx.cjs');
-const require_openapi = require('./openapi-DrPYAlJ_.cjs');
-const commander = require_chunk.__toESM(require("commander"));
-
-//#region package.json
-var name = "@geekmidas/cli";
-var version = "0.0.12";
-var private$1 = false;
-var type = "module";
-var bin = { "gkm": "./src/index.ts" };
-var exports$1 = { ".": {
-	"import": "./dist/index.mjs",
-	"require": "./dist/index.cjs",
-	"types": "./src/index.ts"
-} };
-var publishConfig = {
-	"registry": "https://registry.npmjs.org/",
-	"access": "public"
-};
-var dependencies = {
-	"commander": "~14.0.0",
-	"lodash.get": "~4.4.2",
-	"lodash.set": "~4.3.2",
-	"zod": "~3.25.67",
-	"fast-glob": "~3.3.3",
-	"@geekmidas/api": "workspace:*"
-};
-var devDependencies = {
-	"@types/lodash.get": "~4.4.9",
-	"@types/lodash.set": "~4.3.9"
-};
-var package_default = {
-	name,
-	version,
-	private: private$1,
-	type,
-	bin,
-	exports: exports$1,
-	publishConfig,
-	dependencies,
-	devDependencies
-};
-
-//#endregion
-//#region src/cli.ts
-const program = new commander.Command();
-program.name("gkm").description("GeekMidas backend framework CLI").version(package_default.version).option("--cwd <path>", "Change working directory");
-program.command("build").description("Build API handlers from endpoints").option("--providers <providers>", "Target providers for generated handlers (comma-separated)", "aws-apigatewayv1").action(async (options) => {
-	try {
-		const globalOptions = program.opts();
-		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-		const providerList = [...new Set(options.providers.split(",").map((p) => p.trim()))];
-		await require_build.buildCommand({ providers: providerList });
-	} catch (error) {
-		console.error("Build failed:", error.message);
-		process.exit(1);
-	}
-});
-program.command("cron").description("Manage cron jobs").action(() => {
-	const globalOptions = program.opts();
-	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-	process.stdout.write("Cron management - coming soon\n");
-});
-program.command("function").description("Manage serverless functions").action(() => {
-	const globalOptions = program.opts();
-	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-	process.stdout.write("Serverless function management - coming soon\n");
-});
-program.command("api").description("Manage REST API endpoints").action(() => {
-	const globalOptions = program.opts();
-	if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-	process.stdout.write("REST API management - coming soon\n");
-});
-program.command("openapi").description("Generate OpenAPI 3.0 specification from endpoints").option("--output <path>", "Output file path for the OpenAPI spec", "openapi.json").action(async (options) => {
-	try {
-		const globalOptions = program.opts();
-		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
-		await require_openapi.openapiCommand(options);
-	} catch (error) {
-		console.error("OpenAPI generation failed:", error.message);
-		process.exit(1);
-	}
-});
-program.parse();
-
-//#endregion

package/dist/index.cjs

@@ -1,6 +0,0 @@
-#!/usr/bin/env -S npx tsx
-require('./config-D8AyiwBU.cjs');
-require('./loadEndpoints-Dh-dSqZX.cjs');
-require('./build-CTKUZTHx.cjs');
-require('./cli-DLypHuNF.cjs');
-require('./openapi-DrPYAlJ_.cjs');

package/dist/index.mjs

@@ -1,6 +0,0 @@
-#!/usr/bin/env -S npx tsx
-import "./config-DV1Lwdkx.mjs";
-import "./loadEndpoints-DKaw6Eqm.mjs";
-import "./build-DgeiXkH-.mjs";
-import "./cli-BuIVmCrJ.mjs";
-import "./openapi-DgLItZw-.mjs";

package/src/index.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env -S npx tsx
-
-import './cli.ts';
-
-// Export types for user configuration
-export type { GkmConfig, Provider, BuildOptions } from './types.ts';