@happyvertical/smrt-config 0.43.5 → 0.43.7

package/dist/index.js

@@ -76,6 +76,447 @@ function clearConfigCache() {
 	}
 }
 //#endregion
+//#region src/runtime-profile.ts
+function isApplicationRuntimeProfile(value) {
+	return value === "local" || value === "self-hosted" || value === "cloud";
+}
+function invalidProfileIssue() {
+	return {
+		code: "invalid_config",
+		path: "profile",
+		message: "must be local, self-hosted, or cloud.",
+		recovery: "Select one documented runtime profile."
+	};
+}
+var RuntimeProfileValidationError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(`Invalid application runtime profile:
+${issues.map((issue) => `- ${issue.path}: ${issue.message} Recovery: ${issue.recovery}`).join("\n")}`);
+		this.name = "RuntimeProfileValidationError";
+		this.issues = Object.freeze(issues.map((issue) => Object.freeze({ ...issue })));
+	}
+};
+var PROFILE_DEFAULTS = {
+	local: {
+		database: {
+			engine: "sqlite",
+			connectionOwnership: "user"
+		},
+		authentication: {
+			provider: "owner-bootstrap",
+			ownerBootstrap: "single-use"
+		},
+		tenancy: {
+			mode: "default-tenant",
+			context: "defaulted",
+			isolation: "application"
+		},
+		assets: {
+			provider: "local-files",
+			ownership: "user"
+		},
+		secrets: {
+			provider: "local-file",
+			ownership: "user"
+		},
+		jobs: { topology: "embedded" },
+		network: {
+			exposure: "loopback",
+			tls: false
+		},
+		portability: {
+			backup: "file-snapshot",
+			logicalExport: true,
+			logicalImport: true
+		}
+	},
+	"self-hosted": {
+		database: {
+			engine: "postgres",
+			connectionOwnership: "operator"
+		},
+		authentication: {
+			provider: "oidc",
+			ownerBootstrap: "disabled"
+		},
+		tenancy: {
+			mode: "single-tenant",
+			context: "defaulted",
+			isolation: "application"
+		},
+		assets: {
+			provider: "s3-compatible",
+			ownership: "operator"
+		},
+		secrets: {
+			provider: "environment",
+			ownership: "operator"
+		},
+		jobs: { topology: "external" },
+		network: {
+			exposure: "public",
+			tls: true
+		},
+		portability: {
+			backup: "operator",
+			logicalExport: true,
+			logicalImport: true
+		}
+	},
+	cloud: {
+		database: {
+			engine: "postgres",
+			connectionOwnership: "managed"
+		},
+		authentication: {
+			provider: "hosted-identity",
+			ownerBootstrap: "disabled"
+		},
+		tenancy: {
+			mode: "multi-tenant",
+			context: "required",
+			isolation: "database-rls"
+		},
+		assets: {
+			provider: "managed-object-storage",
+			ownership: "managed"
+		},
+		secrets: {
+			provider: "managed",
+			ownership: "managed"
+		},
+		jobs: { topology: "scalable" },
+		network: {
+			exposure: "public",
+			tls: true
+		},
+		portability: {
+			backup: "managed",
+			logicalExport: true,
+			logicalImport: true
+		}
+	}
+};
+var INVARIANTS = {
+	domainModels: "identical",
+	generatedRest: "identical",
+	generatedCli: "identical",
+	generatedMcp: "identical",
+	generatedWebMcp: "identical",
+	mcpExposurePolicy: "identical",
+	webMcpExposurePolicy: "identical",
+	actionEffects: "identical",
+	approvalPolicy: "identical",
+	authorizationRecords: "required",
+	jobInvocation: "identical",
+	portability: "logical-export-import"
+};
+var PROVIDER_FIELDS = {
+	database: ["engine", "connectionOwnership"],
+	authentication: ["provider", "ownerBootstrap"],
+	tenancy: [
+		"mode",
+		"context",
+		"isolation"
+	],
+	assets: ["provider", "ownership"],
+	secrets: ["provider", "ownership"],
+	jobs: ["topology"],
+	network: ["exposure", "tls"]
+};
+var PROVIDER_VALUE_DOMAINS = {
+	database: {
+		engine: ["sqlite", "postgres"],
+		connectionOwnership: [
+			"user",
+			"operator",
+			"managed"
+		]
+	},
+	authentication: {
+		provider: [
+			"owner-bootstrap",
+			"oidc",
+			"magic-link",
+			"hosted-identity"
+		],
+		ownerBootstrap: ["single-use", "disabled"]
+	},
+	tenancy: {
+		mode: [
+			"default-tenant",
+			"single-tenant",
+			"multi-tenant"
+		],
+		context: ["defaulted", "required"],
+		isolation: ["application", "database-rls"]
+	},
+	assets: {
+		provider: [
+			"local-files",
+			"s3-compatible",
+			"managed-object-storage"
+		],
+		ownership: [
+			"user",
+			"operator",
+			"managed"
+		]
+	},
+	secrets: {
+		provider: [
+			"local-file",
+			"environment",
+			"external",
+			"managed"
+		],
+		ownership: [
+			"user",
+			"operator",
+			"managed"
+		]
+	},
+	jobs: { topology: [
+		"inline",
+		"embedded",
+		"external",
+		"scalable"
+	] },
+	network: {
+		exposure: ["loopback", "public"],
+		tls: [false, true]
+	}
+};
+function isPlainRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function cloneDefaults(profile) {
+	const defaults = PROFILE_DEFAULTS[profile];
+	return {
+		database: { ...defaults.database },
+		authentication: { ...defaults.authentication },
+		tenancy: { ...defaults.tenancy },
+		assets: { ...defaults.assets },
+		secrets: { ...defaults.secrets },
+		jobs: { ...defaults.jobs },
+		network: { ...defaults.network },
+		portability: { ...defaults.portability }
+	};
+}
+function rejectUnknownFields(input) {
+	const issues = [];
+	for (const key of Object.keys(input).sort()) if (key !== "profile" && key !== "providers") issues.push({
+		code: "unsupported_field",
+		path: key,
+		message: "is not part of the runtime-profile contract.",
+		recovery: "Move provider selection under providers or remove this field."
+	});
+	if (Object.hasOwn(input, "profile") && !isApplicationRuntimeProfile(input.profile)) issues.push(invalidProfileIssue());
+	const providers = Object.hasOwn(input, "providers") ? input.providers : void 0;
+	if (providers === void 0) return issues;
+	if (!isPlainRecord(providers)) {
+		issues.push({
+			code: "invalid_config",
+			path: "providers",
+			message: "must be an object with Object.prototype or null.",
+			recovery: "Use providers: { database: { ... } } or omit providers."
+		});
+		return issues;
+	}
+	for (const providerName of Object.keys(providers).sort()) {
+		if (!Object.hasOwn(PROVIDER_FIELDS, providerName)) {
+			issues.push({
+				code: "unsupported_field",
+				path: `providers.${providerName}`,
+				message: "is not an overridable infrastructure provider.",
+				recovery: "Use database, authentication, tenancy, assets, secrets, jobs, or network."
+			});
+			continue;
+		}
+		const value = providers[providerName];
+		if (!isPlainRecord(value)) {
+			issues.push({
+				code: "invalid_config",
+				path: `providers.${providerName}`,
+				message: "must be an object with Object.prototype or null.",
+				recovery: `Provide a partial ${providerName} provider object or omit it.`
+			});
+			continue;
+		}
+		const allowed = PROVIDER_FIELDS[providerName];
+		const valueDomains = PROVIDER_VALUE_DOMAINS[providerName];
+		for (const field of Object.keys(value).sort()) {
+			if (!allowed.includes(field)) {
+				issues.push({
+					code: "unsupported_field",
+					path: `providers.${providerName}.${field}`,
+					message: "is not a supported provider override.",
+					recovery: "Remove secret values and application-policy fields; configure only documented provider selectors."
+				});
+				continue;
+			}
+			const suppliedValue = Object.hasOwn(value, field) ? value[field] : void 0;
+			const allowedValues = valueDomains[field];
+			if (suppliedValue !== void 0 && !allowedValues.includes(suppliedValue)) issues.push({
+				code: "invalid_config",
+				path: `providers.${providerName}.${field}`,
+				message: `must be one of ${allowedValues.map(String).join(", ")}.`,
+				recovery: "Choose a documented provider selector value; supplied values are omitted from diagnostics."
+			});
+		}
+	}
+	return issues;
+}
+function validateApplicationRuntimeConfigShape(config) {
+	if (!isPlainRecord(config)) return [{
+		code: "invalid_config",
+		path: "runtime",
+		message: "must be an object with Object.prototype or null.",
+		recovery: "Provide runtime: { profile: \"local\" | \"self-hosted\" | \"cloud\" }."
+	}];
+	return rejectUnknownFields(config);
+}
+function applyOverrides(providers, input) {
+	const overrideRoot = Object.hasOwn(input, "providers") && isPlainRecord(input.providers) ? input.providers : {};
+	const report = [];
+	for (const providerName of Object.keys(PROVIDER_FIELDS)) {
+		if (!Object.hasOwn(overrideRoot, providerName)) continue;
+		const supplied = overrideRoot[providerName];
+		if (!isPlainRecord(supplied)) continue;
+		const target = providers[providerName];
+		for (const field of PROVIDER_FIELDS[providerName]) {
+			if (!Object.hasOwn(supplied, field)) continue;
+			const value = supplied[field];
+			if (value === void 0) continue;
+			const previous = target[field];
+			target[field] = value;
+			if (value !== previous) report.push({
+				path: `providers.${providerName}.${field}`,
+				from: previous,
+				to: value
+			});
+		}
+	}
+	return report;
+}
+function incompatible(issues, path, expected, recovery) {
+	issues.push({
+		code: "incompatible_provider",
+		path,
+		message: `is incompatible; ${expected}.`,
+		recovery
+	});
+}
+function requireAllowed(issues, path, actual, allowed, profile) {
+	if (!allowed.includes(actual)) incompatible(issues, path, `${profile} requires one of ${allowed.map(String).join(", ")}`, `Choose a supported ${profile} provider or select a different profile.`);
+}
+function validateComposition(profile, providers) {
+	const issues = [];
+	const allow = (path, actual, values) => requireAllowed(issues, path, actual, values, profile);
+	if (profile === "local") {
+		allow("providers.database.engine", providers.database.engine, ["sqlite"]);
+		allow("providers.database.connectionOwnership", providers.database.connectionOwnership, ["user"]);
+		allow("providers.authentication.provider", providers.authentication.provider, ["owner-bootstrap"]);
+		allow("providers.authentication.ownerBootstrap", providers.authentication.ownerBootstrap, ["single-use"]);
+		allow("providers.tenancy.mode", providers.tenancy.mode, ["default-tenant"]);
+		allow("providers.tenancy.context", providers.tenancy.context, ["defaulted"]);
+		allow("providers.tenancy.isolation", providers.tenancy.isolation, ["application"]);
+		allow("providers.assets.provider", providers.assets.provider, ["local-files"]);
+		allow("providers.assets.ownership", providers.assets.ownership, ["user"]);
+		allow("providers.secrets.provider", providers.secrets.provider, ["local-file"]);
+		allow("providers.secrets.ownership", providers.secrets.ownership, ["user"]);
+		allow("providers.jobs.topology", providers.jobs.topology, ["inline", "embedded"]);
+		allow("providers.network.exposure", providers.network.exposure, ["loopback"]);
+		allow("providers.network.tls", providers.network.tls, [false, true]);
+	} else if (profile === "self-hosted") {
+		allow("providers.database.engine", providers.database.engine, ["postgres"]);
+		allow("providers.database.connectionOwnership", providers.database.connectionOwnership, ["operator"]);
+		allow("providers.authentication.provider", providers.authentication.provider, ["oidc", "magic-link"]);
+		allow("providers.authentication.ownerBootstrap", providers.authentication.ownerBootstrap, ["disabled"]);
+		allow("providers.tenancy.mode", providers.tenancy.mode, ["single-tenant", "multi-tenant"]);
+		allow("providers.tenancy.context", providers.tenancy.context, providers.tenancy.mode === "multi-tenant" ? ["required"] : ["defaulted"]);
+		allow("providers.tenancy.isolation", providers.tenancy.isolation, ["application", "database-rls"]);
+		allow("providers.assets.provider", providers.assets.provider, ["local-files", "s3-compatible"]);
+		allow("providers.assets.ownership", providers.assets.ownership, ["operator"]);
+		allow("providers.secrets.provider", providers.secrets.provider, [
+			"environment",
+			"local-file",
+			"external"
+		]);
+		allow("providers.secrets.ownership", providers.secrets.ownership, ["operator"]);
+		allow("providers.jobs.topology", providers.jobs.topology, ["external"]);
+		allow("providers.network.exposure", providers.network.exposure, ["public"]);
+		allow("providers.network.tls", providers.network.tls, [true]);
+	} else {
+		allow("providers.database.engine", providers.database.engine, ["postgres"]);
+		allow("providers.database.connectionOwnership", providers.database.connectionOwnership, ["managed"]);
+		allow("providers.authentication.provider", providers.authentication.provider, ["hosted-identity"]);
+		allow("providers.authentication.ownerBootstrap", providers.authentication.ownerBootstrap, ["disabled"]);
+		allow("providers.tenancy.mode", providers.tenancy.mode, ["multi-tenant"]);
+		allow("providers.tenancy.context", providers.tenancy.context, ["required"]);
+		allow("providers.tenancy.isolation", providers.tenancy.isolation, ["application", "database-rls"]);
+		allow("providers.assets.provider", providers.assets.provider, ["managed-object-storage", "s3-compatible"]);
+		allow("providers.assets.ownership", providers.assets.ownership, ["managed"]);
+		allow("providers.secrets.provider", providers.secrets.provider, ["managed", "external"]);
+		allow("providers.secrets.ownership", providers.secrets.ownership, ["managed"]);
+		allow("providers.jobs.topology", providers.jobs.topology, ["scalable"]);
+		allow("providers.network.exposure", providers.network.exposure, ["public"]);
+		allow("providers.network.tls", providers.network.tls, [true]);
+	}
+	return issues;
+}
+function deriveCapabilities(profile, providers) {
+	return {
+		ownerBootstrap: providers.authentication.ownerBootstrap === "single-use",
+		publicAuthentication: providers.authentication.provider !== "owner-bootstrap",
+		defaultTenant: providers.tenancy.context === "defaulted",
+		multiTenant: providers.tenancy.mode === "multi-tenant",
+		localAssets: providers.assets.provider === "local-files",
+		externalWorkers: providers.jobs.topology === "external" || providers.jobs.topology === "scalable",
+		backup: true,
+		logicalExport: true,
+		logicalImport: true,
+		diagnostics: true,
+		orchestrationHealth: profile !== "local"
+	};
+}
+function deepFreeze(value) {
+	if (value && typeof value === "object" && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const child of Object.values(value)) deepFreeze(child);
+	}
+	return value;
+}
+function resolveApplicationRuntime(config) {
+	if (!isPlainRecord(config)) throw new RuntimeProfileValidationError([...validateApplicationRuntimeConfigShape(config)]);
+	const unknownIssues = validateApplicationRuntimeConfigShape(config);
+	const profile = Object.hasOwn(config, "profile") ? config.profile : void 0;
+	if (!isApplicationRuntimeProfile(profile)) throw new RuntimeProfileValidationError([...unknownIssues, ...Object.hasOwn(config, "profile") ? [] : [invalidProfileIssue()]]);
+	const providers = cloneDefaults(profile);
+	const overrides = applyOverrides(providers, config);
+	const issues = [...unknownIssues, ...validateComposition(profile, providers)];
+	if (issues.length > 0) throw new RuntimeProfileValidationError(issues);
+	return deepFreeze({
+		schemaVersion: 1,
+		profile,
+		providers,
+		capabilities: deriveCapabilities(profile, providers),
+		invariants: { ...INVARIANTS },
+		diagnostics: {
+			secretValuesIncluded: false,
+			overrides,
+			unsafeOverrides: []
+		}
+	});
+}
+function getApplicationRuntimePreset(profile) {
+	if (!isApplicationRuntimeProfile(profile)) throw new RuntimeProfileValidationError([invalidProfileIssue()]);
+	return deepFreeze(cloneDefaults(profile));
+}
+//#endregion
 //#region src/merge.ts
 globalThis.__smrtRuntimeConfig ??= {};
 var UNSAFE_KEYS = /* @__PURE__ */ new Set([
@@ -83,6 +524,14 @@ var UNSAFE_KEYS = /* @__PURE__ */ new Set([
 	"constructor",
 	"prototype"
 ]);
+function defineOwn(target, key, value) {
+	Object.defineProperty(target, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
 function isPlainObject(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
 	const proto = Object.getPrototypeOf(value);
@@ -94,7 +543,7 @@ function deepClone(value) {
 		const out = {};
 		for (const key of Object.keys(value)) {
 			if (UNSAFE_KEYS.has(key)) continue;
-			out[key] = deepClone(value[key]);
+			defineOwn(out, key, deepClone(value[key]));
 		}
 		return out;
 	}
@@ -105,21 +554,34 @@ function deepMerge(target, source) {
 	const tgt = target;
 	const src = source;
 	for (const key of Object.keys(tgt)) {
-		if (UNSAFE_KEYS.has(key) || key in src) continue;
-		result[key] = deepClone(tgt[key]);
+		if (UNSAFE_KEYS.has(key) || Object.hasOwn(src, key)) continue;
+		defineOwn(result, key, deepClone(tgt[key]));
 	}
 	for (const key of Object.keys(src)) {
 		if (UNSAFE_KEYS.has(key)) continue;
 		const sourceValue = src[key];
-		const targetValue = tgt[key];
-		if (isPlainObject(sourceValue) && isPlainObject(targetValue)) result[key] = deepMerge(targetValue, sourceValue);
-		else if (sourceValue !== void 0 && sourceValue !== null) result[key] = deepClone(sourceValue);
-		else if (targetValue !== void 0) result[key] = deepClone(targetValue);
+		const targetValue = Object.hasOwn(tgt, key) ? tgt[key] : void 0;
+		if (isPlainObject(sourceValue) && isPlainObject(targetValue)) defineOwn(result, key, deepMerge(targetValue, sourceValue));
+		else if (sourceValue !== void 0 && sourceValue !== null) defineOwn(result, key, deepClone(sourceValue));
+		else if (targetValue !== void 0) defineOwn(result, key, deepClone(targetValue));
 	}
 	return result;
 }
 function setConfig$1(config) {
-	globalThis.__smrtRuntimeConfig = deepMerge(globalThis.__smrtRuntimeConfig || {}, config);
+	const incomingRuntime = Object.hasOwn(config, "runtime") ? config.runtime : void 0;
+	if (incomingRuntime !== null && (typeof incomingRuntime === "object" || typeof incomingRuntime === "function") && Object.hasOwn(incomingRuntime, "profile")) {
+		const profileIssues = validateApplicationRuntimeConfigShape(incomingRuntime).filter((issue) => issue.path === "runtime" || issue.path === "profile");
+		if (profileIssues.length > 0) throw new RuntimeProfileValidationError([...profileIssues]);
+	}
+	let current = globalThis.__smrtRuntimeConfig || {};
+	const currentRuntime = Object.hasOwn(current, "runtime") && isPlainObject(current.runtime) ? current.runtime : void 0;
+	const incomingRuntimeMap = Object.hasOwn(config, "runtime") && isPlainObject(config.runtime) ? config.runtime : void 0;
+	if (currentRuntime !== void 0 && incomingRuntimeMap !== void 0 && Object.hasOwn(currentRuntime, "profile") && Object.hasOwn(incomingRuntimeMap, "profile") && currentRuntime.profile !== incomingRuntimeMap.profile) {
+		current = deepClone(current);
+		const resetRuntime = current.runtime;
+		delete resetRuntime.providers;
+	}
+	globalThis.__smrtRuntimeConfig = deepMerge(current, config);
 }
 function getRuntimeConfig() {
 	return globalThis.__smrtRuntimeConfig || {};
@@ -274,6 +736,23 @@ async function loadConfig(options) {
 function getConfig() {
 	return getLoadedConfig();
 }
+function resolveConfiguredApplicationRuntime() {
+	const loadedConfig = getLoadedConfig();
+	const runtimeConfig = getRuntimeConfig();
+	const fileRuntime = loadedConfig && Object.hasOwn(loadedConfig, "runtime") ? loadedConfig.runtime : void 0;
+	const runtimeOverride = Object.hasOwn(runtimeConfig, "runtime") ? runtimeConfig.runtime : void 0;
+	for (const layer of [fileRuntime, runtimeOverride]) {
+		if (layer === void 0) continue;
+		const shapeIssues = validateApplicationRuntimeConfigShape(layer);
+		if (shapeIssues.length > 0) throw new RuntimeProfileValidationError([...shapeIssues]);
+	}
+	const fileHasProfile = fileRuntime !== void 0 && Object.hasOwn(fileRuntime, "profile");
+	const profileChanged = runtimeOverride !== void 0 && Object.hasOwn(runtimeOverride, "profile") && runtimeOverride.profile !== (fileHasProfile ? fileRuntime.profile : void 0);
+	if (profileChanged && fileHasProfile) resolveApplicationRuntime(fileRuntime);
+	const fileRuntimeWithoutProviders = { ...fileRuntime ?? {} };
+	delete fileRuntimeWithoutProviders.providers;
+	return resolveApplicationRuntime(mergeConfigs({}, profileChanged ? fileRuntimeWithoutProviders : fileRuntime ?? {}, runtimeOverride ?? {}));
+}
 function getSiteConfig() {
 	return (getLoadedConfig() || {}).site || null;
 }
@@ -305,6 +784,6 @@ function defineConfig(config) {
 	return config;
 }
 //#endregion
-export { clearCache, clearRuntimeConfig, defineConfig, exportConfig, getConfig, getModuleConfig, getPackageConfig, getRuntimeConfig, getSiteConfig, loadConfig, mergeConfigs, mergeExportedConfig, parseExportedConfig, sanitizeConfig, setConfig };
+export { RuntimeProfileValidationError, clearCache, clearRuntimeConfig, defineConfig, exportConfig, getApplicationRuntimePreset, getConfig, getModuleConfig, getPackageConfig, getRuntimeConfig, getSiteConfig, loadConfig, mergeConfigs, mergeExportedConfig, parseExportedConfig, resolveApplicationRuntime, resolveConfiguredApplicationRuntime, sanitizeConfig, setConfig };
 
 //# sourceMappingURL=index.js.map