@geekmidas/cli 9.0.2 → 10.0.0-alpha.0

package/dist/{openapi-Cfwi0fqF.mjs → openapi-CgpMWMmM.mjs}

@@ -1,80 +1,12 @@
-import { loadWorkspaceConfig } from "./config-Bbu1JKvf.mjs";
+import { ConstructGenerator, isPartitionedRoutes } from "./discover-CAlFgYec.mjs";
+import { loadWorkspaceConfig } from "./config-D8o6I_7Z.mjs";
 import { dirname, join, relative } from "node:path";
 import { mkdir, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
-import fg from "fast-glob";
-import kebabCase from "lodash.kebabcase";
 import { Endpoint } from "@geekmidas/constructs/endpoints";
 import { fileURLToPath } from "node:url";
 import { StandardSchemaJsonSchema, getRegisteredZodJsonSchemas, getSchemaMetadata } from "@geekmidas/schema/conversion";
 
-//#region src/types.ts
-function isPartitionedRoutes(routes) {
-	return typeof routes === "object" && routes !== null && !Array.isArray(routes) && "paths" in routes;
-}
-
-//#endregion
-//#region src/generators/Generator.ts
-/**
-* Zod v4 maintains a process-wide registry of schemas registered via
-* `.meta({ id })`. When we cache-bust user module imports (by appending a
-* `?t=timestamp` query), those modules re-execute and try to register the
-* same ids again, which throws `ID X already exists in the registry`.
-*
-* Clearing the registry in the CLI process is safe: the user's running
-* server lives in a subprocess and has its own isolated registry.
-*
-* Exported for tests.
-*/
-function clearZodGlobalRegistry() {
-	const registry = globalThis.__zod_globalRegistry;
-	if (registry && typeof registry.clear === "function") registry.clear();
-}
-var ConstructGenerator = class {
-	static async build(context, outputDir, generator, patterns, options) {
-		const constructs = await generator.load(patterns);
-		return generator.build(context, constructs, outputDir, options);
-	}
-	async load(patterns, cwd = process.cwd(), bustCache = false) {
-		const logger = console;
-		let globPatterns;
-		let partitionFn;
-		if (isPartitionedRoutes(patterns)) {
-			globPatterns = Array.isArray(patterns.paths) ? patterns.paths : [patterns.paths];
-			partitionFn = patterns.partition;
-		} else globPatterns = Array.isArray(patterns) ? patterns : patterns ? [patterns] : [];
-		const files = fg.stream(globPatterns, {
-			cwd,
-			absolute: true
-		});
-		if (bustCache) clearZodGlobalRegistry();
-		const constructs = [];
-		for await (const f of files) try {
-			const file = f.toString();
-			const importPath = bustCache ? `${file}?t=${Date.now()}` : file;
-			const module = await import(importPath);
-			const partition = partitionFn ? partitionFn(file) : void 0;
-			for (const [key, construct] of Object.entries(module)) if (this.isConstruct(construct)) constructs.push({
-				key,
-				name: kebabCase(key),
-				construct,
-				path: {
-					absolute: file,
-					relative: relative(process.cwd(), file)
-				},
-				partition
-			});
-		} catch (error) {
-			const err = error;
-			logger.error(`Failed to load ${f}: ${err.message}`);
-			if (err.stack) logger.error(err.stack);
-			throw error;
-		}
-		return constructs;
-	}
-};
-
-//#endregion
 //#region src/build/endpoint-analyzer.ts
 /**
 * Analyze an endpoint to extract its features
@@ -656,6 +588,94 @@ export async function setupEndpoints(
 
 //#endregion
 //#region src/generators/EndpointGenerator.ts
+/**
+* How a generated entry gets its logger and environment parser.
+*
+* From the surface it serves, when there is one: the surface holds both as
+* *objects*, and discovery already recorded which module declares it, so the
+* entry imports that module and reads them off it.
+*
+* The alternative — the shape this replaces — was naming both in config as
+* module paths, `envParser: './config/env#envParser'`, and printing an import
+* for each. Two strings per app, checked by nothing, describing files the
+* surface was already holding the contents of.
+*
+* Falls back to the configured paths for an app that declares no surface.
+*/
+function runtimeFor(context, fromDir) {
+	const module = context.surface?.module;
+	if (module) {
+		const specifier = importSpecifier(fromDir, module.specifier);
+		return {
+			imports: `import { ${module.exportName} as __surface } from '${specifier}';`,
+			bindings: [
+				"// What this surface was declared with. Objects, not module paths:",
+				"// the entry imports the surface, so there is nothing to print.",
+				"const envParser = __surface.envParser;",
+				"const logger = __surface.logger;"
+			].join("\n")
+		};
+	}
+	return {
+		imports: [`import ${context.envParserImportPattern} from '${importSpecifier(fromDir, context.envParserPath)}';`, `import ${context.loggerImportPattern} from '${importSpecifier(fromDir, context.loggerPath)}';`].join("\n"),
+		bindings: ""
+	};
+}
+/** A relative specifier ESM will accept: always prefixed, never bare. */
+function importSpecifier(fromDir, target) {
+	const rel = relative(fromDir, target).replace(/\.ts$/, ".js");
+	return rel.startsWith(".") ? rel : `./${rel}`;
+}
+/**
+* CORS for a surface, derived rather than hand-written.
+*
+* Who may call a surface is already in the graph — every construct that
+* declared an edge to it — and reaches the process as one comma-separated
+* value. An application that maintained this by hand maintained a list that was
+* wrong in two directions at once: it trusted origins nothing was serving, and
+* it could not name hosts a deploy had not chosen yet.
+*
+* Only the parts a graph cannot answer are configurable, and every one has a
+* default: a surface that says nothing about CORS still gets it.
+*/
+function corsFor(surface) {
+	if (!surface) return {
+		imports: "",
+		setup: ""
+	};
+	const cors = surface.cors ?? {};
+	const allowHeaders = [
+		"content-type",
+		"authorization",
+		...cors.allowHeaders ?? []
+	];
+	return {
+		imports: `import { cors } from 'hono/cors';`,
+		setup: `
+  // Who may call ${surface.id}, read off the graph rather than listed here.
+  {
+    const { origins } = envParser
+      .create((get) => ({
+        origins: get('${surface.trustedOriginsKey}')
+          .string()
+          .default('')
+          .transform((value: string) =>
+            value.split(',').map((origin) => origin.trim()).filter(Boolean),
+          ),
+      }))
+      .parse();
+
+    honoApp.use('*', cors({
+      origin: origins,
+      allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+      allowHeaders: ${JSON.stringify(allowHeaders)},${cors.exposeHeaders ? `\n      exposeHeaders: ${JSON.stringify(cors.exposeHeaders)},` : ""}
+      credentials: ${cors.credentials ?? true},
+      maxAge: ${cors.maxAge ?? 86400},
+    }));
+  }
+`
+	};
+}
 var EndpointGenerator = class extends ConstructGenerator {
 	isConstruct(value) {
 		return Endpoint.isEndpoint(value);
@@ -688,6 +708,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 					timeout: construct.timeout,
 					memorySize: construct.memorySize,
 					environment: await construct.getEnvironment({ markOptional: context.markOptional }),
+					dependencies: construct.constructs,
 					authorizer: construct.authorizer?.name ?? "none"
 				};
 				routes.push(routeInfo);
@@ -702,6 +723,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 				timeout: construct.timeout,
 				memorySize: construct.memorySize,
 				environment: await construct.getEnvironment({ markOptional: context.markOptional }),
+				dependencies: construct.constructs,
 				authorizer: construct.authorizer?.name ?? "none"
 			};
 			routes.push(routeInfo);
@@ -714,14 +736,13 @@ var EndpointGenerator = class extends ConstructGenerator {
 		const handlerPath = join(outputDir, handlerFileName);
 		const relativePath = relative(dirname(handlerPath), sourceFile);
 		const importPath = relativePath.replace(/\.ts$/, ".js");
-		const relativeEnvParserPath = relative(dirname(handlerPath), context.envParserPath);
 		let content;
 		switch (provider) {
 			case "aws-apigatewayv1":
-				content = this.generateAWSApiGatewayV1Handler(importPath, exportName, relativeEnvParserPath, context.envParserImportPattern);
+				content = this.generateAWSApiGatewayV1Handler(importPath, exportName, context.storageDrivers);
 				break;
 			case "aws-apigatewayv2":
-				content = this.generateAWSApiGatewayV2Handler(importPath, exportName, relativeEnvParserPath, context.envParserImportPattern);
+				content = this.generateAWSApiGatewayV2Handler(importPath, exportName, context.storageDrivers);
 				break;
 			case "server":
 				content = this.generateServerHandler(importPath, exportName);
@@ -831,15 +852,17 @@ export async function setupEndpoints(
 		if (context.production?.enabled) return this.generateProductionAppFile(outputDir, context);
 		const appFileName = "app.ts";
 		const appPath = join(outputDir, appFileName);
-		const relativeLoggerPath = relative(dirname(appPath), context.loggerPath);
-		const relativeEnvParserPath = relative(dirname(appPath), context.envParserPath);
+		const runtime = runtimeFor(context, dirname(appPath));
 		const telescopeEnabled = context.telescope?.enabled;
 		const telescopeWebSocketEnabled = context.telescope?.websocket;
 		const usesExternalTelescope = !!context.telescope?.telescopePath;
 		const studioEnabled = context.studio?.enabled;
 		const usesExternalStudio = !!context.studio?.studioPath;
+		const studioFromDatabase = !usesExternalStudio && !!context.studio?.database;
+		const telescopeFromSurface = !!context.surface?.module && !usesExternalTelescope;
 		let telescopeImports = "";
-		if (telescopeEnabled) if (usesExternalTelescope) {
+		if (telescopeEnabled) if (telescopeFromSurface) telescopeImports = "import { createMiddleware, createUI } from '@geekmidas/telescope/hono';";
+		else if (usesExternalTelescope) {
 			const relativeTelescopePath = relative(dirname(appPath), context.telescope?.telescopePath);
 			telescopeImports = `import ${context.telescope?.telescopeImportPattern} from '${relativeTelescopePath}';
 import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`;
@@ -850,8 +873,14 @@ import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`;
 			const relativeStudioPath = relative(dirname(appPath), context.studio?.studioPath);
 			studioImports = `import ${context.studio?.studioImportPattern} from '${relativeStudioPath}';
 import { createStudioApp } from '@geekmidas/studio/server/hono';`;
-		} else studioImports = `// Studio requires a configured instance - use studio config path
-// import { createStudioApp } from '@geekmidas/studio/server/hono';`;
+		} else if (studioFromDatabase) {
+			const dbSpecifier = importSpecifier(dirname(appPath), context.studio.database.specifier);
+			studioImports = `import { snifferContext } from '@geekmidas/constructs';
+import { Direction, InMemoryMonitoringStorage, Studio } from '@geekmidas/studio';
+import { ${context.studio.database.exportName} as __studioDb } from '${dbSpecifier}';
+import { createStudioApp } from '@geekmidas/studio/server/hono';`;
+		} else studioImports = "";
+		const cors = corsFor(context.surface);
 		let hooksImports = "";
 		let beforeSetupCall = "";
 		let afterSetupCall = "";
@@ -903,7 +932,7 @@ import { createStudioApp } from '@geekmidas/studio/server/hono';`;
   }
 ` : "";
 		let telescopeSetup = "";
-		if (telescopeEnabled) if (usesExternalTelescope) telescopeSetup = `
+		if (telescopeEnabled) if (telescopeFromSurface || usesExternalTelescope) telescopeSetup = `
 ${telescopeWebSocketSetupCode}
   // Add telescope middleware (before endpoints to capture all requests)
   honoApp.use('*', createMiddleware(telescope));
@@ -931,7 +960,22 @@ ${telescopeWebSocketSetupCode}
   honoApp.route('${context.telescope?.path}', telescopeUI);
 `;
 		let studioSetup = "";
-		if (studioEnabled && usesExternalStudio) studioSetup = `
+		if (studioEnabled && studioFromDatabase) studioSetup = `
+  // Studio, built from the declared database. The client comes from the
+  // construct, so what you inspect is by definition what the handlers write to.
+  const studio = new Studio({
+    monitoring: { storage: new InMemoryMonitoringStorage({ maxEntries: 100 }) },
+    data: {
+      db: await __studioDb.service.register({ envParser, context: snifferContext }),
+      cursor: { field: 'id', direction: Direction.Desc },
+    },
+    enabled: true,
+  });
+
+  const studioApp = createStudioApp(studio);
+  honoApp.route('${context.studio?.path}', studioApp);
+`;
+		else if (studioEnabled && usesExternalStudio) studioSetup = `
   // Mount Studio data browser UI
   const studioApp = createStudioApp(studio);
   honoApp.route('${context.studio?.path}', studioApp);
@@ -948,12 +992,21 @@ import type { Hono as HonoType } from 'hono';
 import { setupEndpoints } from './endpoints.js';
 import { setupSubscribers } from './subscribers.js';
 import { setupQueues } from './queues.js';
-import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
-import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+${runtime.imports}
 ${telescopeImports}
 ${studioImports}
 ${hooksImports}
+${cors.imports}
+${context.storageDrivers?.imports ?? ""}
+
+${runtime.bindings}
+${telescopeFromSurface ? "const telescope = __surface.telescope;" : ""}
 
+${context.storageDrivers?.setup ? `// Which storage drivers exist is the entry point's decision: the scheme in
+// each injected URL picks one, so no construct and no application module names
+// a provider.
+${context.storageDrivers.setup}
+` : ""}
 export interface ServerApp {
   app: HonoType;
   start: (options?: {
@@ -998,7 +1051,7 @@ export interface ServerApp {
  */
 export async function createApp(app?: HonoType, enableOpenApi: boolean = true): Promise<ServerApp> {
   const honoApp = app || new Hono();
-${telescopeSetup}${beforeSetupCall}${studioSetup}
+${telescopeSetup}${cors.setup}${beforeSetupCall}${studioSetup}
   // Setup HTTP endpoints
   await setupEndpoints(honoApp, envParser, logger, enableOpenApi);
 ${afterSetupCall}
@@ -1042,22 +1095,42 @@ export default createApp;
 		await writeFile(appPath, content);
 		return appPath;
 	}
-	generateAWSApiGatewayV1Handler(importPath, exportName, envParserPath, envParserImportPattern) {
+	/**
+	* One Lambda, one endpoint — and no environment import.
+	*
+	* The endpoint was built from its surface, so it carries the parser the
+	* adaptor needs. This used to read
+	* `import { envParser } from '../../config/env'`, a line the build wrote
+	* because a generator can print a module specifier and cannot print an
+	* object. Nothing has to be printed now, which is also why nothing has to be
+	* named in config.
+	*/
+	generateAWSApiGatewayV1Handler(importPath, exportName, drivers) {
 		return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/constructs/aws';
 import { ${exportName} } from '${importPath}';
-import ${envParserImportPattern} from '${envParserPath}';
-
-const adapter = new AmazonApiGatewayV1Endpoint(envParser, ${exportName});
+${drivers?.imports ?? ""}
+${drivers?.setup ? `\n// The handler registers the drivers its target needs.\n${drivers.setup}\n` : ""}
+const adapter = new AmazonApiGatewayV1Endpoint(${exportName});
 
 export const handler = adapter.handler;
 `;
 	}
-	generateAWSApiGatewayV2Handler(importPath, exportName, envParserPath, envParserImportPattern) {
+	/**
+	* One Lambda, one endpoint — and no environment import.
+	*
+	* The endpoint was built from its surface, so it carries the parser the
+	* adaptor needs. This used to read
+	* `import { envParser } from '../../config/env'`, a line the build wrote
+	* because a generator can print a module specifier and cannot print an
+	* object. Nothing has to be printed now, which is also why nothing has to be
+	* named in config.
+	*/
+	generateAWSApiGatewayV2Handler(importPath, exportName, drivers) {
 		return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/constructs/aws';
 import { ${exportName} } from '${importPath}';
-import ${envParserImportPattern} from '${envParserPath}';
-
-const adapter = new AmazonApiGatewayV2Endpoint(envParser, ${exportName});
+${drivers?.imports ?? ""}
+${drivers?.setup ? `\n// The handler registers the drivers its target needs.\n${drivers.setup}\n` : ""}
+const adapter = new AmazonApiGatewayV2Endpoint(${exportName});
 
 export const handler = adapter.handler;
 `;
@@ -1083,6 +1156,7 @@ export const handler = ${exportName};
 		const enableGracefulShutdown = production.gracefulShutdown;
 		const enableOpenApi = production.openapi;
 		const includeSubscribers = production.subscribers === "include";
+		const cors = corsFor(context.surface);
 		let hooksImports = "";
 		let beforeSetupCall = "";
 		let afterSetupCall = "";
@@ -1147,7 +1221,12 @@ ${subscriberImport}
 import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
 import ${context.loggerImportPattern} from '${relativeLoggerPath}';
 ${hooksImports}
+${cors.imports}
+${context.storageDrivers?.imports ?? ""}
 
+${context.storageDrivers?.setup ? `// The entry point registers the drivers its target needs.
+${context.storageDrivers.setup}
+` : ""}
 export interface ServerApp {
   app: HonoType;
   start: (options?: {
@@ -1165,7 +1244,7 @@ export async function createApp(app?: HonoType): Promise<ServerApp> {
   // Health check endpoint (always first)
   honoApp.get('${healthCheckPath}', (c) => c.json({ status: 'ok', timestamp: Date.now() }));
   honoApp.get('/ready', (c) => c.json({ ready: true }));
-${beforeSetupCall}
+${cors.setup}${beforeSetupCall}
   // Setup HTTP endpoints (OpenAPI: ${enableOpenApi})
   await setupEndpoints(honoApp, envParser, logger, ${enableOpenApi});
 ${afterSetupCall}
@@ -1802,7 +1881,7 @@ async function openapiCommand(options = {}) {
 		} else {
 			const { workspace } = loadedConfig;
 			const workspaceRoot = workspace.root;
-			const backendApps = Object.entries(workspace.apps).filter(([_, app]) => app.type === "backend" && (app.openapi === true || typeof app.openapi === "object" && app.openapi.enabled !== false));
+			const backendApps = Object.entries(workspace.apps).filter(([_, app]) => app.type === "backend" && app.routes !== void 0 && app.openapi !== false && (typeof app.openapi !== "object" || app.openapi.enabled !== false));
 			if (backendApps.length === 0) {
 				logger.log("No backend apps with OpenAPI enabled found");
 				return;
@@ -1879,5 +1958,5 @@ async function runOpenApiInSubprocess(appCwd, appName) {
 }
 
 //#endregion
-export { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, isPartitionedRoutes, normalizeRoutes, openapiCommand, resolveOpenApiConfig };
-//# sourceMappingURL=openapi-Cfwi0fqF.mjs.map
+export { EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, normalizeRoutes, openapiCommand, resolveOpenApiConfig };
+//# sourceMappingURL=openapi-CgpMWMmM.mjs.map