@geekmidas/cli 10.0.0-alpha.1 → 10.0.0-alpha.10

package/dist/{openapi-CljONd_M.cjs → openapi-SjsgARie.cjs}

@@ -1,7 +1,8 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
 const require_discover = require('./discover-DTmFeloL.cjs');
-const require_config = require('./config-DbPE1KXF.cjs');
+const require_config = require('./config-BZ1F0WuA.cjs');
 const node_path = require_chunk.__toESM(require("node:path"));
+const __geekmidas_manifest = require_chunk.__toESM(require("@geekmidas/manifest"));
 const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
 const node_child_process = require_chunk.__toESM(require("node:child_process"));
 const __geekmidas_constructs_endpoints = require_chunk.__toESM(require("@geekmidas/constructs/endpoints"));
@@ -603,24 +604,21 @@ export async function setupEndpoints(
 *
 * Falls back to the configured paths for an app that declares no surface.
 */
-function runtimeFor(context, fromDir) {
-	const module$1 = context.surface?.module;
+function runtimeFor(context, fromDir, owner) {
+	const module$1 = owner ? context.owners?.[owner] ?? context.surface?.module : context.surface?.module;
 	if (module$1) {
 		const specifier = importSpecifier(fromDir, module$1.specifier);
 		return {
 			imports: `import { ${module$1.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.",
+				"// What this construct was declared with. Objects, not module paths:",
+				"// the entry imports the owner, 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: ""
-	};
+	throw new Error(`No owner to take a logger and an environment parser from${owner ? ` for "${owner}"` : ""}. Build it from a \`RestApi\` or a \`Worker\`.`);
 }
 /** A relative specifier ESM will accept: always prefixed, never bare. */
 function importSpecifier(fromDir, target) {
@@ -993,6 +991,7 @@ import type { Hono as HonoType } from 'hono';
 import { setupEndpoints } from './endpoints.js';
 import { setupSubscribers } from './subscribers.js';
 import { setupQueues } from './queues.js';
+import { setupCrons } from './crons.js';
 ${runtime.imports}
 ${telescopeImports}
 ${studioImports}
@@ -1080,6 +1079,12 @@ ${afterSetupCall}
         logger.error({ error }, 'Failed to start queue workers');
       });
 
+      // Schedule this app's crons. Caught like the others: a scheduler that
+      // cannot start is not a reason for the HTTP server not to.
+      await setupCrons(envParser, logger).catch((error) => {
+        logger.error({ error }, 'Failed to schedule crons');
+      });
+
       logger.info({ port }, 'Starting server');
 
       // Start HTTP server using provided serve function
@@ -1150,8 +1155,7 @@ export const handler = ${exportName};
 	async generateProductionAppFile(outputDir, context) {
 		const appFileName = "app.ts";
 		const appPath = (0, node_path.join)(outputDir, appFileName);
-		const relativeLoggerPath = (0, node_path.relative)((0, node_path.dirname)(appPath), context.loggerPath);
-		const relativeEnvParserPath = (0, node_path.relative)((0, node_path.dirname)(appPath), context.envParserPath);
+		const runtime = runtimeFor(context, (0, node_path.dirname)(appPath));
 		const production = context.production;
 		const healthCheckPath = production.healthCheck;
 		const enableGracefulShutdown = production.gracefulShutdown;
@@ -1187,9 +1191,16 @@ export const handler = ${exportName};
       await setupQueues(envParser, logger).catch((error) => {
         logger.error({ error }, 'Failed to start queue workers');
       });
+
+      // Schedule this app's crons. Caught like the others: a scheduler that
+      // cannot start is not a reason for the HTTP server not to.
+      await setupCrons(envParser, logger).catch((error) => {
+        logger.error({ error }, 'Failed to schedule crons');
+      });
 ` : "";
 		const subscriberImport = includeSubscribers ? `import { setupSubscribers } from './subscribers.js';
-import { setupQueues } from './queues.js';` : "";
+import { setupQueues } from './queues.js';
+import { setupCrons } from './crons.js';` : "";
 		const gracefulShutdownCode = enableGracefulShutdown ? `
   // Graceful shutdown handling
   let isShuttingDown = false;
@@ -1219,8 +1230,8 @@ import { Hono } from 'hono';
 import type { Hono as HonoType } from 'hono';
 import { setupEndpoints } from '${endpointsImportPath}';
 ${subscriberImport}
-import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
-import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+${runtime.imports}
+${runtime.bindings}
 ${hooksImports}
 ${cors.imports}
 ${context.storageDrivers?.imports ?? ""}
@@ -1506,6 +1517,11 @@ var OpenApiTsGenerator = class {
 				}
 			}
 			const { $defs,...schemaWithoutDefs } = jsonSchema;
+			const ref = schemaWithoutDefs.$ref;
+			if (ref && Object.keys(schemaWithoutDefs).every((k) => k === "$ref" || k === "$schema")) {
+				const target = ref.split("/").pop();
+				return target === name ? null : `export type ${name} = ${target};`;
+			}
 			return this.jsonSchemaToInterface(schemaWithoutDefs, name);
 		} catch {
 			return null;
@@ -1823,6 +1839,16 @@ function normalizeRoutes(routes) {
 */
 const OPENAPI_OUTPUT_PATH = "./.gkm/openapi.ts";
 /**
+* Where a surface's generated client lands.
+*
+* Named from the surface, so `new RestApi('Webhooks')` writes
+* `.gkm/openapi/webhooks.ts` — the same kebab form that gives it its container
+* name and its `WEBHOOKS_URL`.
+*/
+function openApiPathFor(surfaceId) {
+	return `./.gkm/openapi/${(0, __geekmidas_manifest.kebabCase)(surfaceId)}.ts`;
+}
+/**
 * Resolve OpenAPI config from GkmConfig
 */
 function resolveOpenApiConfig(config) {
@@ -1841,33 +1867,66 @@ function resolveOpenApiConfig(config) {
 	};
 }
 /**
-* Generate OpenAPI spec from endpoints
-* @returns Object with output path and endpoint count, or null if disabled
+* Load endpoints from a glob, then generate.
+*
+* For the callers that have no endpoints in hand — `gkm openapi`, and `gkm dev`
+* regenerating on reload. The glob is the app's derived one — the conventional
+* directories under it — not a `routes` field anybody wrote.
+*/
+async function generateOpenApiFrom(routes, options = {}) {
+	const loaded = await new EndpointGenerator().load(routes, void 0, options.bustCache);
+	return generateOpenApi(loaded.map(({ construct }) => construct), options);
+}
+/**
+* Generate an OpenAPI spec for each surface these endpoints name.
+*
+* Takes the endpoints, not a glob to find them with. The build has already
+* loaded every one of them to generate handlers, so globbing again was a second
+* discovery pass over the same files — and the reason this function needed a
+* `routes` to be told where to look, which is how a retired config field stayed
+* load-bearing.
+*
+* @returns What was written, or null if disabled or there were none
 */
-async function generateOpenApi(config, options = {}) {
+async function generateOpenApi(endpoints, options = {}) {
 	const logger = options.silent ? { log: () => {} } : console;
-	const openApiConfig = resolveOpenApiConfig(config);
+	const openApiConfig = resolveOpenApiConfig({ openapi: options.openapi });
 	if (!openApiConfig.enabled) return null;
-	const endpointGenerator = new EndpointGenerator();
-	const loadedEndpoints = await endpointGenerator.load(config.routes, void 0, options.bustCache);
-	if (loadedEndpoints.length === 0) {
+	if (endpoints.length === 0) {
 		logger.log("No valid endpoints found for OpenAPI generation");
 		return null;
 	}
-	const endpoints = loadedEndpoints.map(({ construct }) => construct);
-	const outputPath = (0, node_path.join)(process.cwd(), OPENAPI_OUTPUT_PATH);
-	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	const bySurface = /* @__PURE__ */ new Map();
+	for (const endpoint of endpoints) {
+		const owner = endpoint.owner ?? endpoint.surface?.id;
+		if (!owner) continue;
+		const existing = bySurface.get(owner);
+		if (existing) existing.push(endpoint);
+		else bySurface.set(owner, [endpoint]);
+	}
+	if (bySurface.size === 0) {
+		logger.log("No endpoints named a surface, so no OpenAPI was generated");
+		return null;
+	}
 	const tsGenerator = new OpenApiTsGenerator();
-	const tsContent = await tsGenerator.generate(endpoints, {
-		title: openApiConfig.title,
-		version: openApiConfig.version,
-		description: openApiConfig.description
-	});
-	await (0, node_fs_promises.writeFile)(outputPath, tsContent);
-	logger.log(`📄 OpenAPI client generated: ${OPENAPI_OUTPUT_PATH}`);
+	const written = [];
+	for (const [surfaceId, surfaceEndpoints] of bySurface) {
+		const relative$1 = openApiPathFor(surfaceId);
+		const outputPath = (0, node_path.join)(process.cwd(), relative$1);
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+		const tsContent = await tsGenerator.generate(surfaceEndpoints, {
+			title: openApiConfig.title ?? surfaceId,
+			version: openApiConfig.version,
+			description: openApiConfig.description
+		});
+		await (0, node_fs_promises.writeFile)(outputPath, tsContent);
+		written.push(relative$1);
+		logger.log(`📄 OpenAPI client generated: ${relative$1} (${surfaceEndpoints.length} endpoints)`);
+	}
 	return {
-		outputPath,
-		endpointCount: loadedEndpoints.length
+		outputPath: (0, node_path.join)(process.cwd(), written[0]),
+		outputPaths: written.map((r) => (0, node_path.join)(process.cwd(), r)),
+		endpointCount: endpoints.length
 	};
 }
 async function openapiCommand(options = {}) {
@@ -1877,12 +1936,12 @@ async function openapiCommand(options = {}) {
 		if (loadedConfig.type === "single") {
 			const config = loadedConfig.raw;
 			if (!config.openapi) config.openapi = { enabled: true };
-			const result = await generateOpenApi(config);
+			const result = await generateOpenApiFrom(config.constructs, { openapi: config.openapi });
 			if (result) logger.log(`Found ${result.endpointCount} endpoints`);
 		} else {
 			const { workspace } = loadedConfig;
 			const workspaceRoot = workspace.root;
-			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));
+			const backendApps = Object.entries(workspace.apps).filter(([_, app]) => app.type === "backend" && 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;
@@ -1896,8 +1955,12 @@ async function openapiCommand(options = {}) {
 				return;
 			}
 			for (const [appName, app] of backendApps) {
-				if (app.type !== "backend" || !app.routes) continue;
 				const appPath = (0, node_path.join)(workspaceRoot, app.path);
+				if ((0, node_path.resolve)(appPath) === (0, node_path.resolve)(workspaceRoot)) {
+					const result = await generateOpenApiForApp(workspaceRoot, appName, app, false);
+					if (result) logger.log(`Found ${result.endpointCount} endpoints`);
+					continue;
+				}
 				await runOpenApiInSubprocess(appPath, appName);
 			}
 		}
@@ -1910,18 +1973,14 @@ async function openapiCommand(options = {}) {
 * Runs in-process. The caller is responsible for ensuring `process.cwd()`
 * is the app's directory so tsx loads the app's tsconfig path aliases.
 */
-async function generateOpenApiForApp(workspaceRoot, _appName, app) {
-	if (app.type !== "backend" || !app.routes) return null;
+async function generateOpenApiForApp(workspaceRoot, _appName, app, silent = true) {
+	if (app.type !== "backend") return null;
 	const appPath = (0, node_path.join)(workspaceRoot, app.path);
-	const routes = normalizeRoutes(app.routes);
-	const routesGlob = routes.map((r) => (0, node_path.join)(appPath, r));
-	const gkmConfig = {
-		routes: routesGlob,
-		envParser: app.envParser || "",
-		logger: app.logger || "",
-		openapi: app.openapi
-	};
-	return generateOpenApi(gkmConfig, { silent: true });
+	const globs = [(0, node_path.join)(appPath, "**/*.ts")];
+	return generateOpenApiFrom(globs, {
+		openapi: app.openapi ?? { enabled: true },
+		silent
+	});
 }
 /**
 * Resolve the gkm bin path. Tests can override via `GKM_BIN_PATH` env var
@@ -1939,7 +1998,7 @@ function resolveGkmBinPath() {
 */
 async function runOpenApiInSubprocess(appCwd, appName) {
 	const binPath = resolveGkmBinPath();
-	await new Promise((resolve, reject) => {
+	await new Promise((resolve$1, reject) => {
 		const child = (0, node_child_process.spawn)(process.execPath, [
 			binPath,
 			"openapi",
@@ -1952,7 +2011,7 @@ async function runOpenApiInSubprocess(appCwd, appName) {
 		});
 		child.on("error", reject);
 		child.on("close", (code) => {
-			if (code === 0) resolve();
+			if (code === 0) resolve$1();
 			else reject(new Error(`OpenAPI generation for app "${appName}" exited with code ${code}`));
 		});
 	});
@@ -1977,12 +2036,24 @@ Object.defineProperty(exports, 'generateOpenApi', {
     return generateOpenApi;
   }
 });
+Object.defineProperty(exports, 'generateOpenApiFrom', {
+  enumerable: true,
+  get: function () {
+    return generateOpenApiFrom;
+  }
+});
 Object.defineProperty(exports, 'normalizeRoutes', {
   enumerable: true,
   get: function () {
     return normalizeRoutes;
   }
 });
+Object.defineProperty(exports, 'openApiPathFor', {
+  enumerable: true,
+  get: function () {
+    return openApiPathFor;
+  }
+});
 Object.defineProperty(exports, 'openapiCommand', {
   enumerable: true,
   get: function () {
@@ -1995,4 +2066,10 @@ Object.defineProperty(exports, 'resolveOpenApiConfig', {
     return resolveOpenApiConfig;
   }
 });
-//# sourceMappingURL=openapi-CljONd_M.cjs.map
+Object.defineProperty(exports, 'runtimeFor', {
+  enumerable: true,
+  get: function () {
+    return runtimeFor;
+  }
+});
+//# sourceMappingURL=openapi-SjsgARie.cjs.map