@codemation/host 0.0.4 → 0.0.7

package/README.md

@@ -1,6 +1,6 @@
 # `@codemation/host`
 
-The **framework host**: application composition (`CodemationApplication`), HTTP/WebSocket gateway (Hono), persistence (Prisma/Postgres), plugin and workflow discovery, shared React UI shell pieces, and server/client **subpath bundles** so Next.js and Node servers only import what they need.
+The **framework host**: app-config loading, app-container composition, HTTP/WebSocket gateway (Hono), persistence (Prisma/Postgres), plugin and workflow discovery, shared React UI shell pieces, and server/client **subpath bundles** so Next.js and Node servers only import what they need.
 
 ## Install
 
@@ -16,10 +16,10 @@ Depend on this package when you embed Codemation in a custom server, extend the
 
 ## Usage
 
-Root re-exports types and `CodemationApplication` for programmatic hosting:
+Root re-exports the container-oriented hosting surface:
 
 ```ts
-import { CodemationApplication, type CodemationApplicationConfig } from "@codemation/host";
+import { AppContainerFactory, AppConfigFactory } from "@codemation/host";
 ```
 
 Common subpaths (see `package.json` `exports`):

package/dist/{PrismaMigrationDeployer-B7cHGrXP.js → AppConfigFactory-DWIz2hy-.js}

@@ -1,10 +1,10 @@
 import { r as __require, t as __commonJS } from "./chunk-7V6ThxGB.js";
-import { t as __decorate } from "./decorate-B-N_5S4p.js";
+import { t as __decorate } from "./decorate-B0PP651O.js";
 import { createRequire } from "node:module";
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { injectable } from "@codemation/core";
+import { CoreTokens, injectable } from "@codemation/core";
 import { existsSync } from "node:fs";
 import { PGlite } from "@electric-sql/pglite";
 import { PGLiteSocketServer } from "@electric-sql/pglite-socket";
@@ -8014,60 +8014,6 @@ var require_client = /* @__PURE__ */ __commonJS({ "src/infrastructure/persistenc
 	module.exports = { ...require_prisma_client() };
 }) });
 
-//#endregion
-//#region src/infrastructure/persistence/DatabasePersistenceResolver.ts
-const DEFAULT_PGLITE_RELATIVE_DIR = ".codemation/pglite";
-/**
-* Resolves whether persistence uses TCP PostgreSQL, embedded PGlite, or in-memory stores.
-* Uses {@link CodemationConfig.runtime.database} as the source of truth; optional `CODEMATION_DATABASE_KIND`
-* and `CODEMATION_PGLITE_DATA_DIR` can override kind / PGlite directory. `DATABASE_URL` is not read here—put
-* connection strings in `runtime.database.url` (often sourced from `process.env` inside `codemation.config.ts`).
-*/
-var DatabasePersistenceResolver = class {
-	resolve(args) {
-		const db = args.runtimeConfig.database;
-		if (!db) return { kind: "none" };
-		if (this.resolveDatabaseKind(this.inferDatabaseKind(db), args.env) === "postgresql") {
-			const url = db.url?.trim() ?? "";
-			if (!url) throw new Error("runtime.database.kind is \"postgresql\" but no database URL was set (runtime.database.url).");
-			if (!this.isPostgresUrl(url)) throw new Error(`runtime.database.url must be a postgresql:// or postgres:// URL when kind is postgresql. Received: ${url}`);
-			return {
-				kind: "postgresql",
-				databaseUrl: url
-			};
-		}
-		return {
-			kind: "pglite",
-			dataDir: this.resolvePgliteDataDirFromConfig(db, args.env, args.consumerRoot)
-		};
-	}
-	resolveDatabaseKind(configured, env) {
-		const fromEnv = env.CODEMATION_DATABASE_KIND?.trim();
-		if (fromEnv === "postgresql" || fromEnv === "pglite") return fromEnv;
-		if (configured) return configured;
-		return "pglite";
-	}
-	inferDatabaseKind(db) {
-		if (db.kind) return db.kind;
-		const url = db.url?.trim();
-		if (url && this.isPostgresUrl(url)) return "postgresql";
-		return "pglite";
-	}
-	isPostgresUrl(value) {
-		return value.startsWith("postgresql://") || value.startsWith("postgres://");
-	}
-	isPgliteUrl(value) {
-		return value.startsWith("pglite:");
-	}
-	resolvePgliteDataDirFromConfig(db, env, consumerRoot) {
-		const fromEnv = env.CODEMATION_PGLITE_DATA_DIR?.trim();
-		if (fromEnv && fromEnv.length > 0) return path.isAbsolute(fromEnv) ? fromEnv : path.resolve(consumerRoot, fromEnv);
-		const configured = db.pgliteDataDir?.trim();
-		if (configured && configured.length > 0) return path.isAbsolute(configured) ? configured : path.resolve(consumerRoot, configured);
-		return path.resolve(consumerRoot, DEFAULT_PGLITE_RELATIVE_DIR);
-	}
-};
-
 //#endregion
 //#region src/infrastructure/persistence/PrismaMigrationDeployer.ts
 let PrismaMigrationDeployer = class PrismaMigrationDeployer$1 {
@@ -8221,5 +8167,105 @@ let PrismaMigrationDeployer = class PrismaMigrationDeployer$1 {
 PrismaMigrationDeployer = __decorate([injectable()], PrismaMigrationDeployer);
 
 //#endregion
-export { DatabasePersistenceResolver as n, require_client as r, PrismaMigrationDeployer as t };
-//# sourceMappingURL=PrismaMigrationDeployer-B7cHGrXP.js.map
+//#region src/bootstrap/runtime/AppConfigFactory.ts
+var AppConfigFactory = class {
+	create(args) {
+		const runtimeConfig = args.config.runtime ?? {};
+		const persistence = this.resolvePersistence(runtimeConfig, args.env, args.consumerRoot);
+		const redisUrl = runtimeConfig.eventBus?.redisUrl ?? args.env.REDIS_URL;
+		const schedulerKind = this.resolveSchedulerKind(runtimeConfig, args.env, redisUrl);
+		const eventBusKind = this.resolveEventBusKind(runtimeConfig, args.env, schedulerKind, redisUrl);
+		const workerQueues = runtimeConfig.scheduler?.workerQueues ?? [];
+		const queuePrefix = runtimeConfig.scheduler?.queuePrefix ?? runtimeConfig.eventBus?.queuePrefix ?? args.env.QUEUE_PREFIX;
+		const hasConfiguredCredentialSessionServiceRegistration = args.config.containerRegistrations.some((entry) => entry.token === CoreTokens.CredentialSessionService);
+		return {
+			consumerRoot: args.consumerRoot,
+			repoRoot: args.repoRoot,
+			env: args.env,
+			workflowSources: [...args.workflowSources],
+			workflows: [...args.config.workflows ?? []],
+			containerRegistrations: [...args.config.containerRegistrations],
+			credentialTypes: [...args.config.credentialTypes ?? []],
+			plugins: [...args.config.plugins ?? []],
+			hasConfiguredCredentialSessionServiceRegistration,
+			log: args.config.log,
+			engineExecutionLimits: runtimeConfig.engineExecutionLimits,
+			databaseUrl: persistence.kind === "postgresql" ? persistence.databaseUrl : runtimeConfig.database?.url?.trim() || void 0,
+			database: runtimeConfig.database,
+			persistence,
+			scheduler: {
+				kind: schedulerKind,
+				queuePrefix,
+				workerQueues,
+				redisUrl
+			},
+			eventing: {
+				kind: eventBusKind,
+				queuePrefix,
+				redisUrl
+			},
+			auth: args.config.auth,
+			whitelabel: args.config.whitelabel ?? {},
+			webSocketPort: this.resolveWebSocketPort(args.env),
+			webSocketBindHost: args.env.CODEMATION_WS_BIND_HOST ?? "0.0.0.0"
+		};
+	}
+	resolvePersistence(runtimeConfig, env, consumerRoot) {
+		const database = runtimeConfig.database;
+		if (!database) return { kind: "none" };
+		if (this.resolveDatabaseKind(database.kind, database.url, env) === "postgresql") {
+			const databaseUrl = database.url?.trim() ?? "";
+			if (!databaseUrl) throw new Error("runtime.database.kind is \"postgresql\" but no database URL was set (runtime.database.url).");
+			if (!databaseUrl.startsWith("postgresql://") && !databaseUrl.startsWith("postgres://")) throw new Error(`runtime.database.url must be a postgresql:// or postgres:// URL when kind is postgresql. Received: ${databaseUrl}`);
+			return {
+				kind: "postgresql",
+				databaseUrl
+			};
+		}
+		return {
+			kind: "pglite",
+			dataDir: this.resolvePgliteDataDir(database.pgliteDataDir, env, consumerRoot)
+		};
+	}
+	resolveDatabaseKind(configuredKind, databaseUrl, env) {
+		const kindFromEnv = env.CODEMATION_DATABASE_KIND?.trim();
+		if (kindFromEnv === "postgresql" || kindFromEnv === "pglite") return kindFromEnv;
+		if (configuredKind) return configuredKind;
+		const trimmedUrl = databaseUrl?.trim();
+		if (trimmedUrl && (trimmedUrl.startsWith("postgresql://") || trimmedUrl.startsWith("postgres://"))) return "postgresql";
+		return "pglite";
+	}
+	resolvePgliteDataDir(configuredPath, env, consumerRoot) {
+		const envPath = env.CODEMATION_PGLITE_DATA_DIR?.trim();
+		if (envPath && envPath.length > 0) return path.isAbsolute(envPath) ? envPath : path.resolve(consumerRoot, envPath);
+		const trimmedConfiguredPath = configuredPath?.trim();
+		if (trimmedConfiguredPath && trimmedConfiguredPath.length > 0) return path.isAbsolute(trimmedConfiguredPath) ? trimmedConfiguredPath : path.resolve(consumerRoot, trimmedConfiguredPath);
+		return path.resolve(consumerRoot, ".codemation", "pglite");
+	}
+	resolveSchedulerKind(runtimeConfig, env, redisUrl) {
+		const configuredKind = runtimeConfig.scheduler?.kind ?? this.readSchedulerKind(env.CODEMATION_SCHEDULER);
+		if (configuredKind) return configuredKind;
+		return redisUrl ? "bullmq" : "local";
+	}
+	resolveEventBusKind(runtimeConfig, env, schedulerKind, redisUrl) {
+		const configuredKind = runtimeConfig.eventBus?.kind ?? this.readEventBusKind(env.CODEMATION_EVENT_BUS);
+		if (configuredKind) return configuredKind;
+		if (schedulerKind === "bullmq") return "redis";
+		return redisUrl ? "redis" : "memory";
+	}
+	readSchedulerKind(value) {
+		if (value === "local" || value === "bullmq") return value;
+	}
+	readEventBusKind(value) {
+		if (value === "memory" || value === "redis") return value;
+	}
+	resolveWebSocketPort(env) {
+		const configuredPort = Number(env.CODEMATION_WS_PORT ?? 3001);
+		if (Number.isNaN(configuredPort) || configuredPort <= 0) return 3001;
+		return configuredPort;
+	}
+};
+
+//#endregion
+export { PrismaMigrationDeployer as n, require_client as r, AppConfigFactory as t };
+//# sourceMappingURL=AppConfigFactory-DWIz2hy-.js.map