@geekmidas/cli 10.0.0-alpha.63 → 10.0.0-alpha.64

package/dist/config-BEJYKd4s.cjs

@@ -1,648 +0,0 @@
-const require_schemas = require("./schemas-Ckm_aBnF.cjs");
-const require_discover = require("./discover-C_6COHEv.cjs");
-const require_workspace = require("./workspace-Kl4NG9IH.cjs");
-let node_path = require("node:path");
-let node_fs = require("node:fs");
-let _geekmidas_manifest = require("@geekmidas/manifest");
-//#region src/workspace/derive.ts
-/**
-* The apps a manifest implies.
-*
-* `gkm.config.ts` used to carry an `apps` block naming every app: its type, its
-* path, its port, its framework, which other apps it depended on. Every one of
-* those facts was already declared. A `StaticSite('Web', { path: 'apps/web' })`
-* and an `apps.web = { type: 'web', path: 'apps/web', framework: 'vite',
-* dependencies: ['api'] }` are the same statement written twice, and only one of
-* them was checked against anything — so the copy in config was free to drift,
-* and a surface config had no entry for simply never deployed.
-*
-* So the list comes from the graph. A `site` is an app, and so is every
-* `rest-api` — one surface, one container, at the `path` it declared.
-*
-* What config still supplies is what no graph can answer: the backends a cache
-* and a mailer resolve to, the deploy endpoint, the stage's domain.
-*/
-/** Which frontend framework builds each site variant. */
-const FRAMEWORKS = {
-	static: "vite",
-	next: "nextjs",
-	tanstack: "tanstack-start"
-};
-/**
-* The app key a construct id becomes.
-*
-* The same kebab form every physical name is built from, so `Api` is `api` in
-* the config, `production-kitchen-sink-api` on Dokploy, and `API_URL` in an
-* environment — one id, three renderings, no second list.
-*/
-function appKey(id) {
-	return (0, _geekmidas_manifest.kebabCase)(id);
-}
-/**
-* The app serving a surface: its own, always.
-*
-* Every surface gets a container. There is no arrangement in which one runs
-* inside another — two surfaces in a process share a filesystem, an
-* environment, and every credential either was granted, so an auth server
-* beside an API is one bug in the API away from being read by it.
-*/
-function hostOf(manifest, id) {
-	const declaration = manifest[id];
-	if (!declaration || declaration.kind !== "rest-api") return void 0;
-	return id;
-}
-/**
-* Local ports, assigned so that adding a site does not renumber the others.
-*
-* Backends first, then the site holding the base domain, then the rest
-* alphabetically. The ordering is arbitrary but it is *fixed*, which is the
-* property that matters: a port that moves when an unrelated app is added is a
-* port nobody can put in a bookmark. A construct that names its own port keeps
-* it, and is skipped here.
-*/
-function assignPorts(apps) {
-	const rank = (name, app) => [
-		app.type === "backend" ? 0 : app.type === "web" ? 1 : 2,
-		app.root ? 0 : 1,
-		name
-	];
-	const ordered = Object.entries(apps).sort(([aName, a], [bName, b]) => {
-		const [at, ar, an] = rank(aName, a);
-		const [bt, br, bn] = rank(bName, b);
-		return at - bt || ar - br || an.localeCompare(bn);
-	});
-	const taken = new Set(ordered.map(([, app]) => app.port).filter((p) => !!p));
-	let next = 3e3;
-	for (const [, app] of ordered) {
-		if (app.port) continue;
-		while (taken.has(next)) next += 1;
-		app.port = next;
-		taken.add(next);
-	}
-}
-/**
-* Whichever site holds the base domain.
-*
-* The convention first — a site named `web` — because it is one people already
-* rely on. Then an explicit `root: true`. A project with one site needs neither.
-*/
-function markRoot(apps) {
-	const sites = Object.entries(apps).filter(([, a]) => a.type === "web");
-	if (sites.length === 0) return;
-	if (sites.some(([, a]) => a.root)) return;
-	const chosen = sites.find(([name]) => name === "web") ?? (sites.length === 1 ? sites[0] : void 0);
-	if (chosen) chosen[1].root = true;
-}
-function derivedApps(manifest, workspace) {
-	const apps = {};
-	const defaultTarget = workspace.deploy?.default ?? "dokploy";
-	for (const [id, declaration] of Object.entries(manifest)) {
-		if (declaration.kind !== "site" && declaration.kind !== "mobile-app" && declaration.kind !== "rest-api") continue;
-		const spec = declaration.kind === "site" || declaration.kind === "mobile-app" ? declaration.app : {
-			path: declaration.path,
-			...declaration.telescope ? { telescope: true } : {}
-		};
-		const name = appKey(id);
-		const configured = workspace.apps[name];
-		apps[name] = {
-			...configured,
-			type: declaration.kind === "site" ? "web" : declaration.kind === "mobile-app" ? "mobile" : "backend",
-			path: spec.path,
-			port: spec.port ?? configured?.port ?? 0,
-			...(declaration.kind === "rest-api" || declaration.kind === "site") && declaration.subdomain ? { subdomain: declaration.subdomain } : {},
-			dependencies: [],
-			resolvedDeployTarget: configured?.resolvedDeployTarget ?? defaultTarget,
-			...declaration.kind === "site" ? {
-				framework: configured?.framework ?? FRAMEWORKS[declaration.variant],
-				...declaration.root ? { root: true } : {},
-				...spec.config ? { config: spec.config } : {}
-			} : {},
-			...declaration.kind === "mobile-app" ? {
-				framework: configured?.framework ?? declaration.variant,
-				...spec.config ? { config: spec.config } : {}
-			} : {},
-			...spec.telescope !== void 0 ? { telescope: spec.telescope } : {},
-			...spec.openapi !== void 0 ? { openapi: spec.openapi } : {},
-			...spec.runtime !== void 0 ? { runtime: spec.runtime } : {},
-			...spec.env !== void 0 ? { env: spec.env } : {},
-			...spec.entry !== void 0 ? { entry: spec.entry } : {},
-			...configured?.domain ? { domain: configured.domain } : {}
-		};
-	}
-	for (const [id, declaration] of Object.entries(manifest)) {
-		if (declaration.kind !== "site" && declaration.kind !== "mobile-app" && declaration.kind !== "rest-api") continue;
-		const app = apps[appKey(id)];
-		if (!app) continue;
-		const edges = declaration.kind === "rest-api" ? declaration.calls ?? [] : declaration.dependencies ?? [];
-		const names = /* @__PURE__ */ new Set();
-		for (const edge of edges) {
-			if (edge.kind !== "rest-api") continue;
-			const host = hostOf(manifest, edge.target);
-			if (!host) continue;
-			const key = appKey(host);
-			if (key !== appKey(id) && apps[key]) names.add(key);
-		}
-		app.dependencies = [...names].sort();
-	}
-	markRoot(apps);
-	assignPorts(apps);
-	for (const [name, app] of Object.entries(workspace.apps)) if (!apps[name]) apps[name] = app;
-	return apps;
-}
-//#endregion
-//#region src/config.ts
-/**
-* Define GKM configuration with full TypeScript support.
-* This is an identity function that provides type safety and autocomplete.
-*
-* @example
-* ```ts
-* // gkm.config.ts
-* import { defineConfig } from '@geekmidas/cli/config';
-*
-* export default defineConfig({
-*   routes: './src/endpoints/**\/*.ts',
-*   envParser: './src/config/env',
-*   logger: './src/config/logger',
-*   telescope: true,
-* });
-* ```
-*/
-function defineConfig(config) {
-	return config;
-}
-/**
-* Parse a module config string into path and import pattern.
-*
-* @param configString - Config string in format "./path/to/module" or "./path/to/module#exportName"
-* @param defaultAlias - The default alias name to use if no export name specified
-* @returns Object with path and import pattern
-*
-* @example
-* parseModuleConfig('./src/config/env', 'envParser')
-* // { path: './src/config/env', importPattern: 'envParser' }
-*
-* parseModuleConfig('./src/config/env#envParser', 'envParser')
-* // { path: './src/config/env', importPattern: '{ envParser }' }
-*
-* parseModuleConfig('./src/config/env#myEnv', 'envParser')
-* // { path: './src/config/env', importPattern: '{ myEnv as envParser }' }
-*/
-function parseModuleConfig(configString, defaultAlias) {
-	const parts = configString.split("#");
-	const path = parts[0] ?? configString;
-	const exportName = parts[1];
-	return {
-		path,
-		importPattern: !exportName ? defaultAlias : exportName === defaultAlias ? `{ ${defaultAlias} }` : `{ ${exportName} as ${defaultAlias} }`
-	};
-}
-/**
-* Find and return the path to the config file.
-*
-* Resolution order:
-* 1. GKM_CONFIG_PATH env var (set by workspace dev command)
-* 2. Walk up directory tree from cwd
-*/
-function findConfigPath(cwd) {
-	const files = [
-		"gkm.config.json",
-		"gkm.config.ts",
-		"gkm.config.js"
-	];
-	const envConfigPath = process.env.GKM_CONFIG_PATH;
-	if (envConfigPath && (0, node_fs.existsSync)(envConfigPath)) return {
-		configPath: envConfigPath,
-		workspaceRoot: (0, node_path.dirname)(envConfigPath)
-	};
-	let currentDir = cwd;
-	const { root } = (0, node_path.parse)(currentDir);
-	while (currentDir !== root) {
-		for (const file of files) {
-			const configPath = (0, node_path.join)(currentDir, file);
-			if ((0, node_fs.existsSync)(configPath)) return {
-				configPath,
-				workspaceRoot: currentDir
-			};
-		}
-		currentDir = (0, node_path.dirname)(currentDir);
-	}
-	throw new ConfigNotFound(cwd);
-}
-/**
-* The directory holding the gkm config that `cwd` belongs to — the project a
-* sandbox for it is confined to.
-*
-* @throws {ConfigNotFound} when neither `cwd` nor any parent has one.
-*/
-function findWorkspaceRoot(cwd) {
-	return findConfigPath(cwd).workspaceRoot;
-}
-/** No gkm config in a directory or any of its parents. */
-var ConfigNotFound = class extends Error {
-	cwd;
-	constructor(cwd) {
-		super("Configuration file not found. Please create gkm.config.json, gkm.config.ts, or gkm.config.js in the project root.");
-		this.cwd = cwd;
-		this.name = "ConfigNotFound";
-	}
-};
-/**
-* How long loading a config, or discovering its constructs, may take in a
-* sandbox: room for tsx to compile a large project cold, and not a deploy
-* held open by a config that never finishes importing.
-*/
-const CONFIG_LOAD_TIMEOUT_MS = 6e4;
-/** The config failed to import, or threw while it ran. */
-var ConfigLoadFailed = class extends Error {
-	configPath;
-	detail;
-	constructor(configPath, detail) {
-		super(`Failed to load config: ${detail}`);
-		this.configPath = configPath;
-		this.detail = detail;
-		this.name = "ConfigLoadFailed";
-	}
-};
-/**
-* The config holds something that is not data — a custom state store, an
-* inline deploy target, a function — and the sandbox it was loaded in hands
-* the deploy nothing but data.
-*/
-var ConfigObjectNotSerializable = class extends Error {
-	configPath;
-	paths;
-	constructor(configPath, paths) {
-		super(`${configPath} holds values that are not plain data at: ${paths.join(", ")}. It was loaded in an isolating sandbox, which hands the deploy the config as JSON, so a live object — a custom store, an inline target, a function — cannot reach it. Configure these with plain values instead, or deploy this project with a sandbox that is not isolating (the default) if the host trusts it.`);
-		this.configPath = configPath;
-		this.paths = paths;
-		this.name = "ConfigObjectNotSerializable";
-	}
-};
-/** What the config worker answers. Checked: the worker ran project code. */
-const ConfigAnswer = require_schemas.discriminatedUnion("reason", [
-	require_schemas.object({
-		reason: require_schemas.literal("loaded"),
-		config: require_schemas.record(require_schemas.string(), require_schemas.unknown())
-	}),
-	require_schemas.object({
-		reason: require_schemas.literal("live"),
-		paths: require_schemas.array(require_schemas.string())
-	}),
-	require_schemas.object({
-		reason: require_schemas.literal("failed"),
-		error: require_schemas.object({
-			name: require_schemas.string(),
-			message: require_schemas.string()
-		})
-	})
-]);
-/** Import the config in this process — live objects and all. */
-async function importConfig(configPath) {
-	try {
-		return (await import(configPath)).default;
-	} catch (error) {
-		throw new ConfigLoadFailed(configPath, error.message);
-	}
-}
-/**
-* The config, loaded in `sandbox` and handed back as JSON.
-*
-* A config holding live objects cannot come back that way. An isolating
-* sandbox refuses it with {@link ConfigObjectNotSerializable}; any other
-* imports it here as well, as before, since the host already runs this
-* project's code as its own.
-*/
-async function loadConfigInSandbox(sandbox, configPath, workspaceRoot, timeoutMs = CONFIG_LOAD_TIMEOUT_MS) {
-	const { value } = await require_discover.runWorker(sandbox, "config load", {
-		name: "config-worker",
-		args: [configPath],
-		cwd: workspaceRoot,
-		timeoutMs,
-		schema: ConfigAnswer
-	});
-	switch (value.reason) {
-		case "loaded": return value.config;
-		case "failed": throw new ConfigLoadFailed(configPath, value.error.message);
-		case "live":
-			if (sandbox.isolating) throw new ConfigObjectNotSerializable(configPath, value.paths);
-			return importConfig(configPath);
-	}
-}
-/**
-* Load raw configuration from file.
-*/
-async function loadRawConfig(cwd, options = {}) {
-	const { configPath, workspaceRoot } = findConfigPath(cwd);
-	const sandbox = options.sandbox ?? require_discover.activeSandbox();
-	return {
-		config: sandbox ? await loadConfigInSandbox(sandbox, configPath, workspaceRoot, options.timeoutMs) : await importConfig(configPath),
-		workspaceRoot
-	};
-}
-/**
-* Load configuration file (single-app format).
-* For backwards compatibility with existing code.
-*
-* @deprecated Use loadWorkspaceConfig for new code
-*/
-async function loadConfig(cwd = process.cwd()) {
-	const { config } = await loadRawConfig(cwd);
-	if (require_workspace.isWorkspaceConfig(config)) throw new Error("Workspace configuration detected. Use loadWorkspaceConfig() instead.");
-	return config;
-}
-/**
-* Load configuration file and process it as a workspace.
-* Works with both single-app and workspace configurations.
-*
-* Single-app configs are automatically wrapped as a workspace with one app.
-*
-* @example
-* ```ts
-* const { type, workspace } = await loadWorkspaceConfig();
-*
-* if (type === 'workspace') {
-*   console.log('Multi-app workspace:', workspace.apps);
-* } else {
-*   console.log('Single app wrapped as workspace');
-* }
-* ```
-*/
-/**
-* The workspace a directory belongs to, as its config states it — without
-* discovering its constructs.
-*
-* For callers that need a fact the config holds (where a stage's secrets are
-* stored) and nothing the graph adds. `loadWorkspaceConfig` imports every
-* construct module to derive the apps, which is a cost a secrets read should
-* not pay.
-*/
-async function loadWorkspaceSettings(cwd = process.cwd(), options = {}) {
-	const { config, workspaceRoot } = await loadRawConfig(cwd, options);
-	return require_workspace.processConfig(config, workspaceRoot).workspace;
-}
-async function loadWorkspaceConfig(cwd = process.cwd(), options = {}) {
-	const { config, workspaceRoot } = await loadRawConfig(cwd, options);
-	return withDerivedApps(require_workspace.processConfig(config, workspaceRoot), options.sandbox);
-}
-/**
-* The loaded config, with its apps read off the graph.
-*
-* Here rather than at each call site because every command needs the same
-* answer, and the ones that forgot to ask were exactly the bugs: a site that
-* never deployed, a surface that could not be its own process. `gkm dev`,
-* `gkm build`, `gkm docker` and `gkm deploy` now all see the same apps without
-* any of them knowing a derivation happened.
-*
-* Discovery imports the construct modules — declarations only, not endpoints —
-* which is the same import the reconciler and the build already do. A workspace
-* with no `constructs` glob discovers nothing and keeps whatever its config
-* said, so nothing that worked before changes.
-*
-* A construct file that throws is reported and skipped rather than taking the
-* command down: `gkm dev` failing to start because a half-written declaration
-* cannot be imported is a worse failure than starting with the app it does not
-* describe yet.
-*/
-async function withDerivedApps(loaded, sandbox) {
-	const globs = require_workspace.allConstructGlobs(loaded.workspace);
-	if (globs.length === 0) throw new WorkspaceDeclaresNoConstructs(loaded.workspace.root);
-	try {
-		const manifest = await require_discover.discover({
-			patterns: globs,
-			cwd: loaded.workspace.root,
-			...sandbox ? { sandbox } : {}
-		});
-		return {
-			...loaded,
-			manifest,
-			workspace: {
-				...loaded.workspace,
-				apps: derivedApps(manifest, loaded.workspace)
-			}
-		};
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		require_discover.output.warn(`⚠️  Could not read constructs, so apps come from config alone: ${message}`);
-		return loaded;
-	}
-}
-/**
-* A workspace with no `constructs` glob.
-*
-* In v10 every address, container and app comes from what the workspace
-* declares — there is no second path that reads a hand-written compose file or
-* an `apps` block's ports. A config that declares nothing has nothing to run.
-*/
-var WorkspaceDeclaresNoConstructs = class extends Error {
-	root;
-	constructor(root) {
-		super(`The workspace at ${root} declares no constructs. Every workspace names where its constructs live — \`constructs: ['./constructs/**/*.ts', './apps/*/endpoints/**/*.ts']\` in gkm.config.ts — and its apps, containers and URLs are derived from them.`);
-		this.root = root;
-		this.name = "WorkspaceDeclaresNoConstructs";
-	}
-};
-/**
-* The app a directory is part of: the one whose `path` contains it.
-*
-* An app's path is the one its construct declares — `new RestApi('Api',
-* { path: 'apps/api' })` — read off the workspace the constructs were derived
-* into, never off the filesystem's package names. The deepest match wins, so
-* an app inside another app's folder is its own; the workspace root belongs to
-* no app unless one lives there.
-*/
-function resolveWorkspaceApp(loadedConfig, cwd) {
-	const here = real(cwd);
-	let found;
-	for (const [key, app] of Object.entries(loadedConfig.workspace.apps)) {
-		const dir = real((0, node_path.join)(loadedConfig.workspace.root, app.path));
-		if ((here === dir || here.startsWith(`${dir}${node_path.sep}`)) && (!found || dir.length > found.dir.length)) found = {
-			key,
-			app,
-			dir
-		};
-	}
-	return found && {
-		key: found.key,
-		app: found.app
-	};
-}
-/** A path with its symlinks resolved, where it exists — `/tmp` is `/private/tmp`. */
-function real(path) {
-	const absolute = (0, node_path.resolve)(path);
-	return (0, node_fs.existsSync)(absolute) ? (0, node_fs.realpathSync)(absolute) : absolute;
-}
-/** A directory that no app in the workspace lives in. */
-var NotInAnApp = class extends Error {
-	cwd;
-	apps;
-	constructor(cwd, apps) {
-		super(`${cwd} is not inside any app's path. Apps: ` + Object.entries(apps).map(([key, path]) => `${key} (${path})`).join(", ") + ".");
-		this.cwd = cwd;
-		this.apps = apps;
-		this.name = "NotInAnApp";
-	}
-};
-/** Every app's path, by key — what `NotInAnApp` lists. */
-function appPaths(loadedConfig) {
-	return Object.fromEntries(Object.entries(loadedConfig.workspace.apps).map(([key, app]) => [key, app.path]));
-}
-/**
-* The backend app a directory is part of, with its gkm config — found by the
-* `path` its construct declares.
-*
-* @example
-* ```ts
-* // From apps/api, where a construct declares `path: 'apps/api'`
-* const { app, workspace, workspaceRoot } = await loadAppConfig();
-* ```
-*
-* @throws {NotInAnApp} when no app's path contains the directory.
-* @throws {NotABackendApp} when the app it is in has no gkm config to run.
-*/
-async function loadAppConfig(cwd = process.cwd()) {
-	const { appName, app, workspace, workspaceRoot } = await loadWorkspaceAppInfo(cwd);
-	const gkmConfig = require_workspace.getAppGkmConfig(workspace, appName);
-	if (!gkmConfig) throw new NotABackendApp(appName);
-	return {
-		appName,
-		app,
-		gkmConfig,
-		workspace,
-		workspaceRoot,
-		appRoot: (0, node_path.join)(workspaceRoot, app.path)
-	};
-}
-/** The app a directory is in has no gkm config — a site, or an entry app. */
-var NotABackendApp = class extends Error {
-	appName;
-	constructor(appName) {
-		super(`App "${appName}" is not a backend app and cannot be run with gkm dev.`);
-		this.appName = appName;
-		this.name = "NotABackendApp";
-	}
-};
-/**
-* The app a directory is part of, frontend or backend — found by the `path`
-* its construct declares. Unlike `loadAppConfig`, the app need not have a
-* gkm config, which is what `gkm exec` and `gkm test` from a site need.
-*
-* @throws {NotInAnApp} when no app's path contains the directory.
-*/
-async function loadWorkspaceAppInfo(cwd = process.cwd()) {
-	const { config, workspaceRoot } = await loadRawConfig(cwd);
-	const loadedConfig = await withDerivedApps(require_workspace.processConfig(config, workspaceRoot));
-	const resolved = resolveWorkspaceApp(loadedConfig, cwd);
-	if (!resolved) throw new NotInAnApp(cwd, appPaths(loadedConfig));
-	return {
-		appName: resolved.key,
-		app: resolved.app,
-		workspace: loadedConfig.workspace,
-		workspaceRoot
-	};
-}
-//#endregion
-Object.defineProperty(exports, "CONFIG_LOAD_TIMEOUT_MS", {
-	enumerable: true,
-	get: function() {
-		return CONFIG_LOAD_TIMEOUT_MS;
-	}
-});
-Object.defineProperty(exports, "ConfigLoadFailed", {
-	enumerable: true,
-	get: function() {
-		return ConfigLoadFailed;
-	}
-});
-Object.defineProperty(exports, "ConfigNotFound", {
-	enumerable: true,
-	get: function() {
-		return ConfigNotFound;
-	}
-});
-Object.defineProperty(exports, "ConfigObjectNotSerializable", {
-	enumerable: true,
-	get: function() {
-		return ConfigObjectNotSerializable;
-	}
-});
-Object.defineProperty(exports, "NotABackendApp", {
-	enumerable: true,
-	get: function() {
-		return NotABackendApp;
-	}
-});
-Object.defineProperty(exports, "NotInAnApp", {
-	enumerable: true,
-	get: function() {
-		return NotInAnApp;
-	}
-});
-Object.defineProperty(exports, "WorkspaceDeclaresNoConstructs", {
-	enumerable: true,
-	get: function() {
-		return WorkspaceDeclaresNoConstructs;
-	}
-});
-Object.defineProperty(exports, "appKey", {
-	enumerable: true,
-	get: function() {
-		return appKey;
-	}
-});
-Object.defineProperty(exports, "defineConfig", {
-	enumerable: true,
-	get: function() {
-		return defineConfig;
-	}
-});
-Object.defineProperty(exports, "derivedApps", {
-	enumerable: true,
-	get: function() {
-		return derivedApps;
-	}
-});
-Object.defineProperty(exports, "findWorkspaceRoot", {
-	enumerable: true,
-	get: function() {
-		return findWorkspaceRoot;
-	}
-});
-Object.defineProperty(exports, "loadAppConfig", {
-	enumerable: true,
-	get: function() {
-		return loadAppConfig;
-	}
-});
-Object.defineProperty(exports, "loadConfig", {
-	enumerable: true,
-	get: function() {
-		return loadConfig;
-	}
-});
-Object.defineProperty(exports, "loadWorkspaceAppInfo", {
-	enumerable: true,
-	get: function() {
-		return loadWorkspaceAppInfo;
-	}
-});
-Object.defineProperty(exports, "loadWorkspaceConfig", {
-	enumerable: true,
-	get: function() {
-		return loadWorkspaceConfig;
-	}
-});
-Object.defineProperty(exports, "loadWorkspaceSettings", {
-	enumerable: true,
-	get: function() {
-		return loadWorkspaceSettings;
-	}
-});
-Object.defineProperty(exports, "parseModuleConfig", {
-	enumerable: true,
-	get: function() {
-		return parseModuleConfig;
-	}
-});
-
-//# sourceMappingURL=config-BEJYKd4s.cjs.map