@geekmidas/cli 1.2.1 → 1.2.3

package/dist/openapi.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S npx tsx
 require('./workspace-BMJE18LV.cjs');
 require('./config-Bayob8pB.cjs');
-const require_openapi = require('./openapi-BZP8jkI4.cjs');
+const require_openapi = require('./openapi-ZhO7wwya.cjs');
 
 exports.OPENAPI_OUTPUT_PATH = require_openapi.OPENAPI_OUTPUT_PATH;
 exports.generateOpenApi = require_openapi.generateOpenApi;

package/dist/openapi.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi.d.cts","names":[],"sources":["../src/openapi.ts"],"sourcesContent":[],"mappings":";;;;UASU,cAAA;;AAFiD;AAS3D;AAKA;;AACS,cANI,mBAAA,GAMJ,mBAAA;;AACO;AA4BhB;AAAqC,iBA9BrB,oBAAA,CA8BqB,MAAA,EA7B5B,SA6B4B,CAAA,EA5BlC,aA4BkC,GAAA;EAAA,OAC5B,EAAA,OAAA;CAAS;AAER;AAkCV;;;AAEG,iBAvCmB,eAAA,CAuCnB,MAAA,EAtCM,SAsCN,EAAA,QAAA,EAAA;EAAO,MAAA,CAAA,EAAA,OAAA;IApCP;;;;iBAkCmB,cAAA,WACZ,iBACP"}
+{"version":3,"file":"openapi.d.cts","names":[],"sources":["../src/openapi.ts"],"sourcesContent":[],"mappings":";;;;UASU,cAAA;;AAFiD;AAS3D;AAKA;;AACS,cANI,mBAAA,GAMJ,mBAAA;;AACO;AA6BhB;AAAqC,iBA/BrB,oBAAA,CA+BqB,MAAA,EA9B5B,SA8B4B,CAAA,EA7BlC,aA6BkC,GAAA;EAAA,OAC5B,EAAA,OAAA;CAAS;AAER;AAkCV;;;AAEG,iBAvCmB,eAAA,CAuCnB,MAAA,EAtCM,SAsCN,EAAA,QAAA,EAAA;EAAO,MAAA,CAAA,EAAA,OAAA;IApCP;;;;iBAkCmB,cAAA,WACZ,iBACP"}

package/dist/openapi.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi.d.mts","names":[],"sources":["../src/openapi.ts"],"sourcesContent":[],"mappings":";;;;UASU,cAAA;;AAFiD;AAS3D;AAKA;;AACS,cANI,mBAAA,GAMJ,mBAAA;;AACO;AA4BhB;AAAqC,iBA9BrB,oBAAA,CA8BqB,MAAA,EA7B5B,SA6B4B,CAAA,EA5BlC,aA4BkC,GAAA;EAAA,OAC5B,EAAA,OAAA;CAAS;AAER;AAkCV;;;AAEG,iBAvCmB,eAAA,CAuCnB,MAAA,EAtCM,SAsCN,EAAA,QAAA,EAAA;EAAO,MAAA,CAAA,EAAA,OAAA;IApCP;;;;iBAkCmB,cAAA,WACZ,iBACP"}
+{"version":3,"file":"openapi.d.mts","names":[],"sources":["../src/openapi.ts"],"sourcesContent":[],"mappings":";;;;UASU,cAAA;;AAFiD;AAS3D;AAKA;;AACS,cANI,mBAAA,GAMJ,mBAAA;;AACO;AA6BhB;AAAqC,iBA/BrB,oBAAA,CA+BqB,MAAA,EA9B5B,SA8B4B,CAAA,EA7BlC,aA6BkC,GAAA;EAAA,OAC5B,EAAA,OAAA;CAAS;AAER;AAkCV;;;AAEG,iBAvCmB,eAAA,CAuCnB,MAAA,EAtCM,SAsCN,EAAA,QAAA,EAAA;EAAO,MAAA,CAAA,EAAA,OAAA;IApCP;;;;iBAkCmB,cAAA,WACZ,iBACP"}

package/dist/openapi.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S npx tsx
 import "./workspace-CASoZOjs.mjs";
 import "./config-BQ4a36Rq.mjs";
-import { OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-DrbBWq0s.mjs";
+import { OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-NthphEWK.mjs";
 
 export { OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -54,10 +54,10 @@
     "prompts": "~2.4.2",
     "tsx": "~4.20.3",
     "@geekmidas/constructs": "~1.0.0",
-    "@geekmidas/errors": "~1.0.0",
     "@geekmidas/envkit": "~1.0.0",
-    "@geekmidas/schema": "~1.0.0",
-    "@geekmidas/logger": "~1.0.0"
+    "@geekmidas/errors": "~1.0.0",
+    "@geekmidas/logger": "~1.0.0",
+    "@geekmidas/schema": "~1.0.0"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

package/src/__tests__/openapi.spec.ts

@@ -1,5 +1,5 @@
 import { existsSync, realpathSync } from 'node:fs';
-import { readFile, rm } from 'node:fs/promises';
+import { mkdir, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
@@ -38,9 +38,9 @@ describe('resolveOpenApiConfig', () => {
 		});
 	});
 
-	it('should return disabled when openapi is undefined', () => {
+	it('should return enabled by default when openapi is undefined', () => {
 		const result = resolveOpenApiConfig({ ...baseConfig });
-		expect(result.enabled).toBe(false);
+		expect(result.enabled).toBe(true);
 	});
 
 	it('should use custom config values when provided', () => {
@@ -111,9 +111,9 @@ describe('generateOpenApi', () => {
 		expect(result).toBeNull();
 	});
 
-	it('should return null when openapi is undefined', async () => {
+	it('should return null when no endpoints are found', async () => {
 		const config: GkmConfig = {
-			routes: './src/endpoints/**/*.ts',
+			routes: './src/endpoints/**/*.ts', // Path doesn't exist
 			envParser: './src/config/env#envParser',
 			logger: './src/config/logger#logger',
 		};
@@ -468,3 +468,383 @@ export const complexEndpoint = e
 		expect(content).toContain('export interface paths');
 	});
 });
+
+describe('openapiCommand - workspace mode', () => {
+	let tempDir: string;
+	const originalCwd = process.cwd();
+
+	beforeEach(async () => {
+		tempDir = realpathSync(await createTempDir('openapi-workspace-'));
+	});
+
+	afterEach(async () => {
+		process.chdir(originalCwd);
+		await cleanupDir(tempDir);
+		vi.restoreAllMocks();
+	});
+
+	it('should generate OpenAPI for backend app in workspace', async () => {
+		// Create workspace structure
+		const apiDir = join(tempDir, 'apps/api');
+		await mkdir(apiDir, { recursive: true });
+
+		// Create endpoint in backend app
+		await createMockEndpointFile(
+			apiDir,
+			'src/endpoints/users.ts',
+			'getUsers',
+			'/users',
+			'GET',
+		);
+
+		// Create workspace config (gkm.config.json)
+		await createTestFile(
+			tempDir,
+			'gkm.config.json',
+			JSON.stringify({
+				name: 'test-workspace',
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+				},
+			}),
+		);
+
+		process.chdir(tempDir);
+		const consoleSpy = vi.spyOn(console, 'log');
+
+		await openapiCommand({ cwd: tempDir });
+
+		// Should generate OpenAPI in the backend app's .gkm folder
+		const outputPath = join(apiDir, OPENAPI_OUTPUT_PATH);
+		expect(existsSync(outputPath)).toBe(true);
+
+		const content = await readFile(outputPath, 'utf-8');
+		expect(content).toContain('export interface paths');
+		expect(content).toContain("'/users'");
+
+		expect(consoleSpy).toHaveBeenCalledWith(
+			expect.stringContaining('[api] Generated OpenAPI'),
+		);
+	});
+
+	it('should copy OpenAPI to frontend app with client.output', async () => {
+		// Create workspace structure
+		const apiDir = join(tempDir, 'apps/api');
+		const webDir = join(tempDir, 'apps/web');
+		await mkdir(apiDir, { recursive: true });
+		await mkdir(webDir, { recursive: true });
+
+		// Create endpoint in backend app
+		await createMockEndpointFile(
+			apiDir,
+			'src/endpoints/users.ts',
+			'getUsers',
+			'/users',
+			'GET',
+		);
+
+		// Create workspace config with frontend that depends on backend
+		await createTestFile(
+			tempDir,
+			'gkm.config.json',
+			JSON.stringify({
+				name: 'test-workspace',
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+					web: {
+						type: 'frontend',
+						framework: 'nextjs',
+						path: 'apps/web',
+						port: 3001,
+						dependencies: ['api'],
+						client: {
+							output: './src/api',
+						},
+					},
+				},
+			}),
+		);
+
+		process.chdir(tempDir);
+		const consoleSpy = vi.spyOn(console, 'log');
+
+		await openapiCommand({ cwd: tempDir });
+
+		// Should generate OpenAPI in backend app
+		const backendOutput = join(apiDir, OPENAPI_OUTPUT_PATH);
+		expect(existsSync(backendOutput)).toBe(true);
+
+		// Should copy to frontend app's client output path
+		const frontendOutput = join(webDir, 'src/api/openapi.ts');
+		expect(existsSync(frontendOutput)).toBe(true);
+
+		// Content should be the same
+		const backendContent = await readFile(backendOutput, 'utf-8');
+		const frontendContent = await readFile(frontendOutput, 'utf-8');
+		expect(frontendContent).toBe(backendContent);
+
+		expect(consoleSpy).toHaveBeenCalledWith(
+			expect.stringContaining('[web] ./src/api/openapi.ts'),
+		);
+	});
+
+	it('should only copy to frontend apps that depend on the backend', async () => {
+		// Create workspace structure with multiple apps
+		const apiDir = join(tempDir, 'apps/api');
+		const authDir = join(tempDir, 'apps/auth');
+		const webDir = join(tempDir, 'apps/web');
+		const adminDir = join(tempDir, 'apps/admin');
+		await mkdir(apiDir, { recursive: true });
+		await mkdir(authDir, { recursive: true });
+		await mkdir(webDir, { recursive: true });
+		await mkdir(adminDir, { recursive: true });
+
+		// Create endpoints
+		await createMockEndpointFile(
+			apiDir,
+			'src/endpoints/users.ts',
+			'getUsers',
+			'/users',
+			'GET',
+		);
+		await createMockEndpointFile(
+			authDir,
+			'src/endpoints/login.ts',
+			'login',
+			'/login',
+			'POST',
+		);
+
+		// Create workspace config
+		await createTestFile(
+			tempDir,
+			'gkm.config.json',
+			JSON.stringify({
+				name: 'test-workspace',
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+					auth: {
+						type: 'backend',
+						path: 'apps/auth',
+						port: 3001,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+					web: {
+						type: 'frontend',
+						framework: 'nextjs',
+						path: 'apps/web',
+						port: 3002,
+						dependencies: ['api'], // Only depends on api
+						client: {
+							output: './src/api',
+						},
+					},
+					admin: {
+						type: 'frontend',
+						framework: 'nextjs',
+						path: 'apps/admin',
+						port: 3003,
+						dependencies: ['auth'], // Only depends on auth
+						client: {
+							output: './src/client',
+						},
+					},
+				},
+			}),
+		);
+
+		process.chdir(tempDir);
+
+		await openapiCommand({ cwd: tempDir });
+
+		// Web should have api's OpenAPI (not auth's)
+		const webApiOutput = join(webDir, 'src/api/openapi.ts');
+		expect(existsSync(webApiOutput)).toBe(true);
+		const webContent = await readFile(webApiOutput, 'utf-8');
+		expect(webContent).toContain("'/users'");
+		expect(webContent).not.toContain("'/login'");
+
+		// Admin should have auth's OpenAPI (not api's)
+		const adminClientOutput = join(adminDir, 'src/client/openapi.ts');
+		expect(existsSync(adminClientOutput)).toBe(true);
+		const adminContent = await readFile(adminClientOutput, 'utf-8');
+		expect(adminContent).toContain("'/login'");
+		expect(adminContent).not.toContain("'/users'");
+	});
+
+	it('should not copy to frontend with empty dependencies array', async () => {
+		// Create workspace structure
+		const apiDir = join(tempDir, 'apps/api');
+		const webDir = join(tempDir, 'apps/web');
+		await mkdir(apiDir, { recursive: true });
+		await mkdir(webDir, { recursive: true });
+
+		await createMockEndpointFile(
+			apiDir,
+			'src/endpoints/users.ts',
+			'getUsers',
+			'/users',
+			'GET',
+		);
+
+		// Frontend with empty dependencies array (depends on nothing)
+		await createTestFile(
+			tempDir,
+			'gkm.config.json',
+			JSON.stringify({
+				name: 'test-workspace',
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+					web: {
+						type: 'frontend',
+						framework: 'nextjs',
+						path: 'apps/web',
+						port: 3001,
+						dependencies: [], // Empty array means depends on nothing
+						client: {
+							output: './src/api',
+						},
+					},
+				},
+			}),
+		);
+
+		process.chdir(tempDir);
+
+		await openapiCommand({ cwd: tempDir });
+
+		// Should NOT copy to frontend since it has no dependencies
+		const frontendOutput = join(webDir, 'src/api/openapi.ts');
+		expect(existsSync(frontendOutput)).toBe(false);
+	});
+
+	it('should skip frontend apps without client.output', async () => {
+		const apiDir = join(tempDir, 'apps/api');
+		const webDir = join(tempDir, 'apps/web');
+		await mkdir(apiDir, { recursive: true });
+		await mkdir(webDir, { recursive: true });
+
+		await createMockEndpointFile(
+			apiDir,
+			'src/endpoints/users.ts',
+			'getUsers',
+			'/users',
+			'GET',
+		);
+
+		// Frontend without client.output
+		await createTestFile(
+			tempDir,
+			'gkm.config.json',
+			JSON.stringify({
+				name: 'test-workspace',
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+					web: {
+						type: 'frontend',
+						framework: 'nextjs',
+						path: 'apps/web',
+						port: 3001,
+						dependencies: ['api'],
+						// No client.output configured
+					},
+				},
+			}),
+		);
+
+		process.chdir(tempDir);
+
+		await openapiCommand({ cwd: tempDir });
+
+		// Backend should still have OpenAPI generated
+		expect(existsSync(join(apiDir, OPENAPI_OUTPUT_PATH))).toBe(true);
+
+		// But no files should be created in frontend
+		expect(existsSync(join(webDir, 'src/api/openapi.ts'))).toBe(false);
+	});
+
+	it('should handle nested client.output paths', async () => {
+		const apiDir = join(tempDir, 'apps/api');
+		const webDir = join(tempDir, 'apps/web');
+		await mkdir(apiDir, { recursive: true });
+		await mkdir(webDir, { recursive: true });
+
+		await createMockEndpointFile(
+			apiDir,
+			'src/endpoints/users.ts',
+			'getUsers',
+			'/users',
+			'GET',
+		);
+
+		// Deeply nested client output path
+		await createTestFile(
+			tempDir,
+			'gkm.config.json',
+			JSON.stringify({
+				name: 'test-workspace',
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+					web: {
+						type: 'frontend',
+						framework: 'nextjs',
+						path: 'apps/web',
+						port: 3001,
+						dependencies: ['api'],
+						client: {
+							output: './src/lib/api/generated',
+						},
+					},
+				},
+			}),
+		);
+
+		process.chdir(tempDir);
+
+		await openapiCommand({ cwd: tempDir });
+
+		// Should create nested directories and file
+		const frontendOutput = join(webDir, 'src/lib/api/generated/openapi.ts');
+		expect(existsSync(frontendOutput)).toBe(true);
+
+		const content = await readFile(frontendOutput, 'utf-8');
+		expect(content).toContain('export interface paths');
+	});
+});