@geekmidas/cli 0.0.14 → 0.0.15

package/dist/cli.cjs

@@ -11,7 +11,7 @@ const commander = require_chunk.__toESM(require("commander"));
 var name = "@geekmidas/cli";
 var version = "0.0.14";
 var private$1 = false;
-var type = "module";
+var type = "commonjs";
 var bin = { "gkm": "./dist/cli.cjs" };
 var publishConfig = {
 	"registry": "https://registry.npmjs.org/",

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "private": false,
-  "type": "module",
+  "type": "commonjs",
   "bin": {
     "gkm": "./dist/cli.cjs"
   },

package/tsdown.config.ts

@@ -2,4 +2,5 @@ import { defineConfig } from 'tsdown';
 
 export default defineConfig({
   dts: false,
+  format: 'cjs',
 });

package/dist/build-DgeiXkH-.mjs

@@ -1,160 +0,0 @@
-import { loadConfig } from "./config-DV1Lwdkx.mjs";
-import { loadEndpoints } from "./loadEndpoints-DKaw6Eqm.mjs";
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join, relative } from "path";
-
-//#region src/build.ts
-const logger = console;
-async function buildCommand(options) {
-	logger.log(`Building with providers: ${options.providers.join(", ")}`);
-	const config = await loadConfig();
-	logger.log(`Loading routes from: ${config.routes}`);
-	logger.log(`Using envParser: ${config.envParser}`);
-	const [envParserPath, envParserName] = config.envParser.split("#");
-	const envParserImportPattern = !envParserName ? "envParser" : envParserName === "envParser" ? "{ envParser }" : `{ ${envParserName} as envParser }`;
-	const [loggerPath, loggerName] = config.logger.split("#");
-	const loggerImportPattern = !loggerName ? "logger" : loggerName === "logger" ? "{ logger }" : `{ ${loggerName} as logger }`;
-	const loadedEndpoints = await loadEndpoints(config.routes);
-	if (loadedEndpoints.length === 0) {
-		logger.log("No endpoints found to process");
-		return;
-	}
-	const allEndpoints = loadedEndpoints.map(({ name, endpoint, file }) => {
-		const routeInfo = {
-			path: endpoint._path,
-			method: endpoint.method,
-			handler: ""
-		};
-		logger.log(`Found endpoint: ${name} - ${routeInfo.method} ${routeInfo.path}`);
-		return {
-			file: relative(process.cwd(), file),
-			exportName: name,
-			endpoint,
-			routeInfo
-		};
-	});
-	for (const provider of options.providers) {
-		const routes = [];
-		const outputDir = join(process.cwd(), ".gkm", provider);
-		await mkdir(outputDir, { recursive: true });
-		logger.log(`\nGenerating handlers for provider: ${provider}`);
-		if (provider === "server") {
-			const serverFile = await generateServerFile(outputDir, allEndpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern);
-			routes.push({
-				path: "*",
-				method: "ALL",
-				handler: relative(process.cwd(), serverFile)
-			});
-			logger.log(`Generated server app with ${allEndpoints.length} endpoints`);
-		} else for (const { file, exportName, routeInfo } of allEndpoints) {
-			const handlerFile = await generateHandlerFile(outputDir, file, exportName, provider, routeInfo, envParserPath, envParserImportPattern);
-			routes.push({
-				...routeInfo,
-				handler: relative(process.cwd(), handlerFile).replace(/\.ts$/, ".handler")
-			});
-			logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
-		}
-		const manifest = { routes };
-		const manifestPath = join(outputDir, "routes.json");
-		await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
-		logger.log(`Generated ${routes.length} handlers in ${relative(process.cwd(), outputDir)}`);
-		logger.log(`Routes manifest: ${relative(process.cwd(), manifestPath)}`);
-	}
-}
-async function generateServerFile(outputDir, endpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern) {
-	const serverFileName = "app.ts";
-	const serverPath = join(outputDir, serverFileName);
-	const importsByFile = /* @__PURE__ */ new Map();
-	for (const { file, exportName } of endpoints) {
-		const relativePath = relative(dirname(serverPath), file);
-		const importPath = relativePath.replace(/\.ts$/, ".js");
-		if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
-		importsByFile.get(importPath).push(exportName);
-	}
-	const relativeEnvParserPath = relative(dirname(serverPath), envParserPath);
-	const relativeLoggerPath = relative(dirname(serverPath), loggerPath);
-	const imports = Array.from(importsByFile.entries()).map(([importPath, exports]) => `import { ${exports.join(", ")} } from '${importPath}';`).join("\n");
-	const allExportNames = endpoints.map(({ exportName }) => exportName);
-	const content = `import { HonoEndpoint } from '@geekmidas/api/hono';
-import { Endpoint } from '@geekmidas/api/server';
-import { ServiceDiscovery } from '@geekmidas/api/services';
-import { Hono } from 'hono';
-import ${envParserImportPattern} from '${relativeEnvParserPath}';
-import ${loggerImportPattern} from '${relativeLoggerPath}';
-${imports}
-
-export function createApp(app?: Hono): Hono {
-  const honoApp = app || new Hono();
-  
-  const endpoints: Endpoint<any, any, any, any, any, any>[] = [
-    ${allExportNames.join(",\n    ")}
-  ];
-
-  const serviceDiscovery = ServiceDiscovery.getInstance(
-    logger,
-    envParser
-  );
-
-  HonoEndpoint.addRoutes(endpoints, serviceDiscovery, honoApp);
-
-  return honoApp;
-}
-
-// Default export for convenience
-export default createApp;
-`;
-	await writeFile(serverPath, content);
-	return serverPath;
-}
-async function generateHandlerFile(outputDir, sourceFile, exportName, provider, _routeInfo, envParserPath, envParserImportPattern) {
-	const handlerFileName = `${exportName}.ts`;
-	const handlerPath = join(outputDir, handlerFileName);
-	const relativePath = relative(dirname(handlerPath), sourceFile);
-	const importPath = relativePath.replace(/\.ts$/, ".js");
-	const relativeEnvParserPath = relative(dirname(handlerPath), envParserPath);
-	let content;
-	switch (provider) {
-		case "aws-apigatewayv1":
-			content = generateAWSApiGatewayV1Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
-			break;
-		case "aws-apigatewayv2":
-			content = generateAWSApiGatewayV2Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
-			break;
-		case "server":
-			content = generateServerHandler(importPath, exportName);
-			break;
-		default: throw new Error(`Unsupported provider: ${provider}`);
-	}
-	await writeFile(handlerPath, content);
-	return handlerPath;
-}
-function generateAWSApiGatewayV1Handler(importPath, exportName, envParserPath, envParserImportPattern) {
-	return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/api/aws-apigateway';
-import { ${exportName} } from '${importPath}';
-import ${envParserImportPattern} from '${envParserPath}';
-
-const adapter = new AmazonApiGatewayV1Endpoint(envParser, ${exportName});
-
-export const handler = adapter.handler;
-`;
-}
-function generateAWSApiGatewayV2Handler(importPath, exportName, envParserPath, envParserImportPattern) {
-	return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/api/aws-apigateway';
-import { ${exportName} } from '${importPath}';
-import ${envParserImportPattern} from '${envParserPath}';
-
-const adapter = new AmazonApiGatewayV2Endpoint(envParser, ${exportName});
-
-export const handler = adapter.handler;
-`;
-}
-function generateServerHandler(importPath, exportName) {
-	return `import { ${exportName} } from '${importPath}';
-
-// Server handler - implement based on your server framework
-export const handler = ${exportName};
-`;
-}
-
-//#endregion
-export { buildCommand };

package/dist/build.mjs

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

package/dist/cli.mjs

@@ -1,94 +0,0 @@
-#!/usr/bin/env -S npx tsx
-import "./config-DV1Lwdkx.mjs";
-import "./loadEndpoints-DKaw6Eqm.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/config-DV1Lwdkx.mjs

@@ -1,17 +0,0 @@
-import { join } from "path";
-import { existsSync } from "fs";
-
-//#region src/config.ts
-async function loadConfig() {
-	const configPath = join(process.cwd(), "gkm.config.json");
-	if (!existsSync(configPath)) throw new Error("gkm.config.json not found. Please create a configuration file.");
-	try {
-		const config = await import(configPath);
-		return config.default || config;
-	} catch (error) {
-		throw new Error(`Failed to load gkm.config.ts: ${error.message}`);
-	}
-}
-
-//#endregion
-export { loadConfig };

package/dist/config.mjs

@@ -1,3 +0,0 @@
-import { loadConfig } from "./config-DV1Lwdkx.mjs";
-
-export { loadConfig };

package/dist/loadEndpoints-DKaw6Eqm.mjs

@@ -1,30 +0,0 @@
-import { Endpoint } from "@geekmidas/api/server";
-import fg from "fast-glob";
-
-//#region src/loadEndpoints.ts
-async function loadEndpoints(routes) {
-	const logger = console;
-	const files = await fg.stream(routes, {
-		cwd: process.cwd(),
-		absolute: true
-	});
-	const endpoints = [];
-	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)) {
-			exportValue.operationId = exportName;
-			endpoints.push({
-				name: exportName,
-				endpoint: exportValue,
-				file
-			});
-		}
-	} catch (error) {
-		logger.warn(`Failed to load ${f}:`, error.message);
-	}
-	return endpoints;
-}
-
-//#endregion
-export { loadEndpoints };

package/dist/loadEndpoints.mjs

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

package/dist/openapi-DgLItZw-.mjs

@@ -1,34 +0,0 @@
-import { loadConfig } from "./config-DV1Lwdkx.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";
-
-//#region src/openapi.ts
-async function openapiCommand(options = {}) {
-	const logger = console;
-	try {
-		const config = await loadConfig();
-		const loadedEndpoints = await loadEndpoints(config.routes);
-		if (loadedEndpoints.length === 0) {
-			logger.log("No valid endpoints found");
-			return;
-		}
-		const endpoints = loadedEndpoints.map(({ endpoint }) => endpoint);
-		const spec = await Endpoint.buildOpenApiSchema(endpoints, {
-			title: "API Documentation",
-			version: "1.0.0",
-			description: "Auto-generated API documentation from endpoints"
-		});
-		const outputPath = options.output || join(process.cwd(), "openapi.json");
-		await mkdir(join(outputPath, ".."), { recursive: true });
-		await writeFile(outputPath, JSON.stringify(spec, null, 2));
-		logger.log(`OpenAPI spec generated: ${outputPath}`);
-		logger.log(`Found ${endpoints.length} endpoints`);
-	} catch (error) {
-		throw new Error(`OpenAPI generation failed: ${error.message}`);
-	}
-}
-
-//#endregion
-export { openapiCommand };

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

@@ -1,165 +0,0 @@
-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.mjs

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

package/dist/openapi.mjs

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