@geekmidas/cli 0.10.0 → 0.13.0

package/src/openapi-react-query.ts

@@ -9,64 +9,64 @@ import { promisify } from 'node:util';
 const execAsync = promisify(exec);
 
 interface ReactQueryOptions {
-  input?: string;
-  output?: string;
-  name?: string;
+	input?: string;
+	output?: string;
+	name?: string;
 }
 
 interface OpenAPISpec {
-  openapi: string;
-  info?: {
-    title?: string;
-    version?: string;
-  };
-  paths: Record<string, Record<string, any>>;
+	openapi: string;
+	info?: {
+		title?: string;
+		version?: string;
+	};
+	paths: Record<string, Record<string, any>>;
 }
 
 export async function generateReactQueryCommand(
-  options: ReactQueryOptions = {},
+	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 mkdir(dirname(typesPath), { recursive: true });
-      await writeFile(
-        typesPath,
-        `// Auto-generated placeholder types
+	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 mkdir(dirname(typesPath), { recursive: true });
+			await writeFile(
+				typesPath,
+				`// Auto-generated placeholder types
 export interface paths {
   [path: string]: {
     [method: string]: {
@@ -78,115 +78,115 @@ export interface paths {
   };
 }
 `,
-      );
-    }
-
-    // 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}`,
-    );
-  }
+			);
+		}
+
+		// 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;
+	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;
+	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 responses = operation.responses;
+	if (!responses) return 'unknown';
 
-  const successResponse = responses['200'] || responses['201'];
-  if (!successResponse?.content?.['application/json']?.schema) {
-    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);
+	// 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';
-  }
+	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,
+	_spec: OpenAPISpec,
+	operations: OperationInfo[],
+	apiName: string,
 ): string {
-  const imports = `import { createTypedQueryClient } from '@geekmidas/client';
+	const imports = `import { createTypedQueryClient } from '@geekmidas/client';
 import type { paths } from './openapi-types';
 
 // Create typed query client
@@ -197,19 +197,19 @@ export const ${apiName.toLowerCase()} = createTypedQueryClient<paths>({
 // Export individual hooks for better DX
 `;
 
-  const queryHooks = operations
-    .filter((op) => op.method === 'GET')
-    .map((op) => generateQueryHook(op, apiName))
-    .join('\n\n');
+	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 mutationHooks = operations
+		.filter((op) => op.method !== 'GET')
+		.map((op) => generateMutationHook(op, apiName))
+		.join('\n\n');
 
-  const typeExports = generateTypeExports(operations);
+	const typeExports = generateTypeExports(operations);
 
-  return `${imports}
+	return `${imports}
 // Query Hooks
 ${queryHooks}
 
@@ -225,32 +225,32 @@ 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} = (
+	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);
@@ -258,10 +258,10 @@ function generateQueryHook(op: OperationInfo, apiName: string): string {
 }
 
 function generateMutationHook(op: OperationInfo, apiName: string): string {
-  const hookName = `use${capitalize(op.operationId)}`;
-  const endpoint = op.endpoint;
+	const hookName = `use${capitalize(op.operationId)}`;
+	const endpoint = op.endpoint;
 
-  return `export const ${hookName} = (
+	return `export const ${hookName} = (
   options?: Parameters<typeof ${apiName.toLowerCase()}.useMutation>[1]
 ) => {
   return ${apiName.toLowerCase()}.useMutation('${endpoint}' as any, options);
@@ -269,20 +269,20 @@ function generateMutationHook(op: OperationInfo, apiName: string): string {
 }
 
 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');
+	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);
+	return str.charAt(0).toUpperCase() + str.slice(1);
 }

package/src/openapi.ts

@@ -8,7 +8,7 @@ import { OpenApiTsGenerator } from './generators/OpenApiTsGenerator.js';
 import type { GkmConfig, OpenApiConfig } from './types.js';
 
 interface OpenAPIOptions {
-  cwd?: string;
+	cwd?: string;
 }
 
 /**
@@ -20,29 +20,29 @@ export const OPENAPI_OUTPUT_PATH = './.gkm/openapi.ts';
  * Resolve OpenAPI config from GkmConfig
  */
 export function resolveOpenApiConfig(
-  config: GkmConfig,
+	config: GkmConfig,
 ): OpenApiConfig & { enabled: boolean } {
-  if (config.openapi === false) {
-    return { enabled: false };
-  }
-
-  if (config.openapi === true || config.openapi === undefined) {
-    return {
-      enabled: config.openapi === true,
-      title: 'API Documentation',
-      version: '1.0.0',
-      description: 'Auto-generated API documentation from endpoints',
-    };
-  }
-
-  return {
-    enabled: config.openapi.enabled !== false,
-    title: config.openapi.title || 'API Documentation',
-    version: config.openapi.version || '1.0.0',
-    description:
-      config.openapi.description ||
-      'Auto-generated API documentation from endpoints',
-  };
+	if (config.openapi === false) {
+		return { enabled: false };
+	}
+
+	if (config.openapi === true || config.openapi === undefined) {
+		return {
+			enabled: config.openapi === true,
+			title: 'API Documentation',
+			version: '1.0.0',
+			description: 'Auto-generated API documentation from endpoints',
+		};
+	}
+
+	return {
+		enabled: config.openapi.enabled !== false,
+		title: config.openapi.title || 'API Documentation',
+		version: config.openapi.version || '1.0.0',
+		description:
+			config.openapi.description ||
+			'Auto-generated API documentation from endpoints',
+	};
 }
 
 /**
@@ -50,61 +50,61 @@ export function resolveOpenApiConfig(
  * @returns Object with output path and endpoint count, or null if disabled
  */
 export async function generateOpenApi(
-  config: GkmConfig,
-  options: { silent?: boolean } = {},
+	config: GkmConfig,
+	options: { silent?: boolean } = {},
 ): Promise<{ outputPath: string; endpointCount: number } | null> {
-  const logger = options.silent ? { log: () => {} } : console;
-  const openApiConfig = resolveOpenApiConfig(config);
+	const logger = options.silent ? { log: () => {} } : console;
+	const openApiConfig = resolveOpenApiConfig(config);
 
-  if (!openApiConfig.enabled) {
-    return null;
-  }
+	if (!openApiConfig.enabled) {
+		return null;
+	}
 
-  const endpointGenerator = new EndpointGenerator();
-  const loadedEndpoints = await endpointGenerator.load(config.routes);
+	const endpointGenerator = new EndpointGenerator();
+	const loadedEndpoints = await endpointGenerator.load(config.routes);
 
-  if (loadedEndpoints.length === 0) {
-    logger.log('No valid endpoints found for OpenAPI generation');
-    return null;
-  }
+	if (loadedEndpoints.length === 0) {
+		logger.log('No valid endpoints found for OpenAPI generation');
+		return null;
+	}
 
-  const endpoints = loadedEndpoints.map(({ construct }) => construct);
-  const outputPath = join(process.cwd(), OPENAPI_OUTPUT_PATH);
+	const endpoints = loadedEndpoints.map(({ construct }) => construct);
+	const outputPath = join(process.cwd(), OPENAPI_OUTPUT_PATH);
 
-  await mkdir(dirname(outputPath), { recursive: true });
+	await mkdir(dirname(outputPath), { recursive: true });
 
-  const tsGenerator = new OpenApiTsGenerator();
-  const tsContent = await tsGenerator.generate(endpoints, {
-    title: openApiConfig.title!,
-    version: openApiConfig.version!,
-    description: openApiConfig.description!,
-  });
+	const tsGenerator = new OpenApiTsGenerator();
+	const tsContent = await tsGenerator.generate(endpoints, {
+		title: openApiConfig.title!,
+		version: openApiConfig.version!,
+		description: openApiConfig.description!,
+	});
 
-  await writeFile(outputPath, tsContent);
-  logger.log(`📄 OpenAPI client generated: ${OPENAPI_OUTPUT_PATH}`);
+	await writeFile(outputPath, tsContent);
+	logger.log(`📄 OpenAPI client generated: ${OPENAPI_OUTPUT_PATH}`);
 
-  return { outputPath, endpointCount: loadedEndpoints.length };
+	return { outputPath, endpointCount: loadedEndpoints.length };
 }
 
 export async function openapiCommand(
-  options: OpenAPIOptions = {},
+	options: OpenAPIOptions = {},
 ): Promise<void> {
-  const logger = console;
+	const logger = console;
 
-  try {
-    const config = await loadConfig(options.cwd);
+	try {
+		const config = await loadConfig(options.cwd);
 
-    // Enable openapi if not configured
-    if (!config.openapi) {
-      config.openapi = { enabled: true };
-    }
+		// Enable openapi if not configured
+		if (!config.openapi) {
+			config.openapi = { enabled: true };
+		}
 
-    const result = await generateOpenApi(config);
+		const result = await generateOpenApi(config);
 
-    if (result) {
-      logger.log(`Found ${result.endpointCount} endpoints`);
-    }
-  } catch (error) {
-    throw new Error(`OpenAPI generation failed: ${(error as Error).message}`);
-  }
+		if (result) {
+			logger.log(`Found ${result.endpointCount} endpoints`);
+		}
+	} catch (error) {
+		throw new Error(`OpenAPI generation failed: ${(error as Error).message}`);
+	}
 }