@contractspec/lib.contracts 0.0.0-canary-20260113162409

package/dist/app-config/runtime.js

@@ -0,0 +1,617 @@
+//#region src/app-config/runtime.ts
+function resolveAppConfig(blueprint, tenant, deps = {}) {
+	const capabilities = mergeCapabilities(blueprint.capabilities, tenant.capabilities);
+	const features = mergeFeatures(blueprint.features, tenant.features);
+	const dataViews = mergeMappings(blueprint.dataViews ?? {}, tenant.dataViewOverrides);
+	const workflows = mergeMappings(blueprint.workflows ?? {}, tenant.workflowOverrides);
+	const policies = mergePolicies(blueprint.policies ?? [], tenant.additionalPolicies ?? []);
+	const theme = mergeTheme(blueprint.theme, tenant.themeOverride);
+	const telemetry = mergeTelemetry(blueprint.telemetry, tenant.telemetryOverride);
+	const experiments = mergeExperiments(blueprint.experiments, tenant.experiments);
+	const featureFlags = mergeFeatureFlags(blueprint.featureFlags ?? [], tenant.featureFlags ?? []);
+	const routes = mergeRoutes(blueprint.routes ?? [], tenant.routeOverrides ?? []);
+	const { resolved: integrations } = evaluateIntegrationSlots(blueprint.integrationSlots, tenant.integrations, deps.integrationConnections, deps.integrationSpecs);
+	const knowledge = resolveKnowledgeBindings(tenant.knowledge, deps.knowledgeSpaces, deps.knowledgeSources);
+	const branding = resolveBranding(blueprint.branding, tenant);
+	const translation = resolveTranslation(blueprint.translationCatalog, tenant.locales, tenant.translationOverrides);
+	return {
+		appId: blueprint.meta.appId,
+		tenantId: tenant.meta.tenantId,
+		environment: tenant.meta.environment,
+		blueprintName: blueprint.meta.key,
+		blueprintVersion: blueprint.meta.version,
+		configVersion: tenant.meta.version,
+		capabilities,
+		features,
+		dataViews,
+		workflows,
+		policies,
+		theme,
+		telemetry,
+		experiments,
+		featureFlags,
+		routes,
+		integrations,
+		knowledge,
+		translation,
+		branding,
+		notes: tenant.notes ?? blueprint.notes
+	};
+}
+function composeAppConfig(blueprint, tenant, deps, options = {}) {
+	const resolved = resolveAppConfig(blueprint, tenant, deps);
+	const missing = [];
+	const integrationEvaluation = evaluateIntegrationSlots(blueprint.integrationSlots, tenant.integrations, deps.integrationConnections, deps.integrationSpecs);
+	resolved.integrations = integrationEvaluation.resolved;
+	missing.push(...integrationEvaluation.missing);
+	missing.push(...collectMissingKnowledge(tenant.knowledge ?? [], deps.knowledgeSpaces, deps.knowledgeSources));
+	const capabilities = resolveCapabilityRefs(resolved.capabilities.enabled, deps.capabilities, missing);
+	const features = resolveFeatureRefs(resolved.features.include, deps.features, missing);
+	const dataViews = resolvePointerRecord(resolved.dataViews, deps.dataViews, "dataView", missing);
+	const workflows = resolvePointerRecord(resolved.workflows, deps.workflows, "workflow", missing);
+	const policies = resolvePolicies(resolved.policies, deps.policies, missing);
+	const { theme, fallbacks, themeMissing } = resolveThemeBinding(resolved.theme, deps.themes);
+	missing.push(...themeMissing);
+	const { telemetry, telemetryMissing } = resolveTelemetryBinding(resolved.telemetry, deps.telemetry);
+	missing.push(...telemetryMissing);
+	const experiments = resolveExperimentsSpecs(resolved.experiments, deps.experiments, missing);
+	if (options.strict && missing.length > 0) {
+		const reasons = missing.map((item) => `${item.type}:${item.identifier}`).join(", ");
+		throw new Error(`composeAppConfig: missing references -> ${reasons}`);
+	}
+	return {
+		resolved,
+		capabilities,
+		features,
+		dataViews,
+		workflows,
+		policies,
+		theme,
+		themeFallbacks: fallbacks,
+		telemetry,
+		experiments,
+		integrations: resolved.integrations,
+		knowledge: resolved.knowledge,
+		missing
+	};
+}
+function mergeCapabilities(blueprint, tenant) {
+	const enabled = dedupeRefs([...blueprint?.enabled ?? [], ...tenant?.enable ?? []], capabilityKey);
+	const disabled = dedupeRefs([...blueprint?.disabled ?? [], ...tenant?.disable ?? []], capabilityKey);
+	const disabledKeys = new Set(disabled.map(capabilityKey));
+	return {
+		enabled: enabled.filter((ref) => !disabledKeys.has(capabilityKey(ref))),
+		disabled
+	};
+}
+function mergeFeatures(blueprint, tenant) {
+	const include = dedupeRefs([...blueprint?.include ?? [], ...tenant?.include ?? []], featureKey);
+	const exclude = dedupeRefs([...blueprint?.exclude ?? [], ...tenant?.exclude ?? []], featureKey);
+	const excludeSet = new Set(exclude.map(featureKey));
+	return {
+		include: include.filter((ref) => !excludeSet.has(featureKey(ref))),
+		exclude
+	};
+}
+function mergeMappings(blueprint, overrides) {
+	const merged = { ...blueprint };
+	if (!overrides) return merged;
+	for (const override of overrides) {
+		if (!override) continue;
+		if (!override.pointer) delete merged[override.slot];
+		else merged[override.slot] = override.pointer;
+	}
+	return merged;
+}
+function mergePolicies(blueprint, additional) {
+	return dedupeRefs([...blueprint, ...additional], policyKey);
+}
+function mergeTheme(blueprint, override) {
+	if (!blueprint && !override) return void 0;
+	const primary = override?.primary ?? blueprint?.primary;
+	if (!primary) return void 0;
+	return {
+		primary,
+		fallbacks: override?.fallbacks ?? blueprint?.fallbacks ?? []
+	};
+}
+function mergeTelemetry(blueprint, override) {
+	if (!blueprint && !override) return void 0;
+	const binding = {
+		spec: blueprint?.spec,
+		disabledEvents: blueprint?.disabledEvents ? [...blueprint.disabledEvents] : void 0,
+		samplingOverrides: blueprint?.samplingOverrides ? { ...blueprint.samplingOverrides } : void 0
+	};
+	if (override?.spec !== void 0) binding.spec = override.spec ?? void 0;
+	if (override?.disabledEvents) binding.disabledEvents = dedupeStrings([...binding.disabledEvents ?? [], ...override.disabledEvents]);
+	if (override?.samplingOverrides) binding.samplingOverrides = {
+		...binding.samplingOverrides ?? {},
+		...override.samplingOverrides
+	};
+	if (!binding.spec && !binding.disabledEvents?.length) return;
+	return binding;
+}
+function mergeExperiments(blueprint, tenant) {
+	const defaultActive = blueprint?.active ?? [];
+	const defaultPaused = blueprint?.paused ?? [];
+	const tenantActive = tenant?.active;
+	const tenantPaused = tenant?.paused;
+	const activeSource = tenantActive && tenantActive.length > 0 ? tenantActive : defaultActive;
+	const pausedSource = tenantPaused && tenantPaused.length > 0 ? tenantPaused : defaultPaused;
+	const active = dedupeRefs(activeSource, experimentKey);
+	let paused = dedupeRefs(pausedSource, experimentKey);
+	const activeKeys = new Set(active.map(experimentKey));
+	paused = paused.filter((ref) => !activeKeys.has(experimentKey(ref)));
+	return {
+		catalog: dedupeRefs([
+			...defaultActive,
+			...defaultPaused,
+			...tenantActive ?? [],
+			...tenantPaused ?? []
+		], experimentKey),
+		active,
+		paused
+	};
+}
+function resolveBranding(defaults, tenant) {
+	const override = tenant.branding;
+	const tenantMeta = tenant.meta;
+	const baseDomain = "app.localhost";
+	const domain = override?.customDomain ?? (override?.subdomain ? `${override.subdomain}.${baseDomain}` : `${tenantMeta.tenantId}.${baseDomain}`);
+	const localePreferenceOrder = [];
+	if (tenant.locales?.defaultLocale) localePreferenceOrder.push(tenant.locales.defaultLocale);
+	if (override?.appName) localePreferenceOrder.push("default", "en");
+	let appName;
+	if (override?.appName) {
+		for (const key of localePreferenceOrder) {
+			const candidate = override.appName[key];
+			if (candidate) {
+				appName = candidate;
+				break;
+			}
+		}
+		if (!appName) {
+			const [, firstValue] = Object.entries(override.appName)[0] ?? [];
+			if (typeof firstValue === "string") appName = firstValue;
+		}
+	}
+	if (!appName) appName = defaults?.appNameKey ?? tenantMeta.appId;
+	const assetEntries = /* @__PURE__ */ new Map();
+	const applyAssets = (assets$1) => {
+		if (!assets$1) return;
+		for (const asset of assets$1) {
+			if (!asset?.type) continue;
+			if ("url" in asset && asset.url) assetEntries.set(asset.type, asset.url);
+		}
+	};
+	applyAssets(defaults?.assets);
+	applyAssets(override?.assets);
+	const assets = {
+		logo: assetEntries.get("logo"),
+		logoDark: assetEntries.get("logo-dark"),
+		favicon: assetEntries.get("favicon"),
+		ogImage: assetEntries.get("og-image")
+	};
+	const colors = {
+		primary: override?.colors?.primary ?? defaults?.colorTokens?.primary ?? "#1f2937",
+		secondary: override?.colors?.secondary ?? defaults?.colorTokens?.secondary ?? "#4b5563"
+	};
+	return {
+		appName,
+		assets,
+		colors,
+		domain
+	};
+}
+function resolveTranslation(catalogPointer, locales, overrides) {
+	const defaultLocale = locales?.defaultLocale ?? "en";
+	return {
+		defaultLocale,
+		supportedLocales: dedupeStrings([defaultLocale, ...locales?.enabledLocales ?? []]),
+		blueprintCatalog: catalogPointer,
+		tenantOverrides: overrides?.entries ?? []
+	};
+}
+function mergeFeatureFlags(blueprint, overrides) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const flag of blueprint) merged.set(flag.key, { ...flag });
+	for (const override of overrides) merged.set(override.key, { ...override });
+	return [...merged.values()];
+}
+function mergeRoutes(blueprint, overrides) {
+	const routes = /* @__PURE__ */ new Map();
+	for (const route of blueprint) routes.set(route.path, { ...route });
+	for (const override of overrides) {
+		const existing = routes.get(override.path) ?? { path: override.path };
+		if (override.label !== void 0) if (override.label === null) delete existing.label;
+		else existing.label = override.label;
+		if (override.dataView !== void 0) if (override.dataView === null) delete existing.dataView;
+		else existing.dataView = override.dataView;
+		if (override.workflow !== void 0) if (override.workflow === null) delete existing.workflow;
+		else existing.workflow = override.workflow;
+		if (override.guard !== void 0) if (override.guard === null) delete existing.guard;
+		else existing.guard = override.guard;
+		if (override.featureFlag !== void 0) if (override.featureFlag === null) delete existing.featureFlag;
+		else existing.featureFlag = override.featureFlag;
+		if (override.experiment !== void 0) if (override.experiment === null) delete existing.experiment;
+		else existing.experiment = override.experiment;
+		routes.set(existing.path, existing);
+	}
+	return [...routes.values()];
+}
+function evaluateIntegrationSlots(slots, bindings, connections, specs) {
+	const resolved = [];
+	const missing = [];
+	const missingKeys = /* @__PURE__ */ new Set();
+	const recordMissing = (entry) => {
+		const key = `${entry.type}:${entry.identifier}`;
+		if (missingKeys.has(key)) return;
+		missingKeys.add(key);
+		missing.push(entry);
+	};
+	const slotList = slots ?? [];
+	const slotById = /* @__PURE__ */ new Map();
+	for (const slot of slotList) slotById.set(slot.slotId, slot);
+	const bindingsBySlot = /* @__PURE__ */ new Map();
+	for (const binding of bindings ?? []) {
+		if (!slotById.get(binding.slotId)) {
+			recordMissing({
+				type: "integrationSlot",
+				identifier: `slot:${binding.slotId}`
+			});
+			continue;
+		}
+		const entries = bindingsBySlot.get(binding.slotId);
+		if (entries) entries.push(binding);
+		else bindingsBySlot.set(binding.slotId, [binding]);
+	}
+	for (const slot of slotList) {
+		const slotBindings = bindingsBySlot.get(slot.slotId) ?? [];
+		if (slot.required && slotBindings.length === 0) recordMissing({
+			type: "integrationSlot",
+			identifier: `slot:${slot.slotId}`
+		});
+	}
+	if (!connections || !specs) return {
+		resolved,
+		missing
+	};
+	const connectionById = /* @__PURE__ */ new Map();
+	for (const connection of connections) connectionById.set(connection.meta.id, connection);
+	for (const slot of slotList) {
+		const slotBindings = bindingsBySlot.get(slot.slotId) ?? [];
+		if (slotBindings.length === 0) continue;
+		const orderedBindings = [...slotBindings].sort((a, b) => {
+			const aPriority = a.priority ?? Number.MAX_SAFE_INTEGER;
+			const bPriority = b.priority ?? Number.MAX_SAFE_INTEGER;
+			if (aPriority === bPriority) return 0;
+			return aPriority < bPriority ? -1 : 1;
+		});
+		let slotResolved = false;
+		for (const binding of orderedBindings) {
+			const connection = connectionById.get(binding.connectionId);
+			if (!connection) {
+				recordMissing({
+					type: "integrationConnection",
+					identifier: `connection:${binding.connectionId}`
+				});
+				continue;
+			}
+			const spec = specs.get(connection.meta.integrationKey, connection.meta.integrationVersion);
+			if (!spec) {
+				recordMissing({
+					type: "integrationSpec",
+					identifier: `spec:${connection.meta.integrationKey}.v${connection.meta.integrationVersion}`
+				});
+				continue;
+			}
+			if (spec.meta.category !== slot.requiredCategory) {
+				recordMissing({
+					type: "integrationSpec",
+					identifier: `spec:${spec.meta.key}.category`
+				});
+				continue;
+			}
+			if (!spec.supportedModes.includes(connection.ownershipMode)) {
+				recordMissing({
+					type: "integrationSpec",
+					identifier: `spec:${spec.meta.key}.mode:${connection.ownershipMode}`
+				});
+				continue;
+			}
+			if (slot.allowedModes && slot.allowedModes.length > 0 && !slot.allowedModes.includes(connection.ownershipMode)) {
+				recordMissing({
+					type: "integrationConnection",
+					identifier: `connection:${connection.meta.id}:mode`
+				});
+				continue;
+			}
+			if (slot.requiredCapabilities && !slot.requiredCapabilities.every((requirement) => integrationProvidesCapability(spec, requirement))) {
+				recordMissing({
+					type: "integrationSpec",
+					identifier: `spec:${spec.meta.key}.capabilities`
+				});
+				continue;
+			}
+			resolved.push({
+				slot,
+				binding,
+				connection,
+				spec
+			});
+			slotResolved = true;
+			break;
+		}
+		if (!slotResolved && slot.required) recordMissing({
+			type: "integrationSlot",
+			identifier: `slot:${slot.slotId}`
+		});
+	}
+	return {
+		resolved,
+		missing
+	};
+}
+function integrationProvidesCapability(spec, required) {
+	return spec.capabilities.provides.some((capability) => {
+		if (capability.key !== required.key) return false;
+		if (required.version == null) return true;
+		return capability.version === required.version;
+	});
+}
+function resolveKnowledgeBindings(bindings, spaces, sources) {
+	if (!bindings?.length || !spaces) return [];
+	const sourceList = sources ?? [];
+	return bindings.map((binding) => {
+		const space = spaces.get(binding.spaceKey, binding.spaceVersion);
+		if (!space) return null;
+		return {
+			binding,
+			space,
+			sources: sourceList.filter((source) => {
+				if (source.meta.spaceKey !== binding.spaceKey) return false;
+				if (binding.spaceVersion != null) return source.meta.spaceVersion === binding.spaceVersion;
+				return true;
+			})
+		};
+	}).filter((entry) => entry !== null);
+}
+function collectMissingKnowledge(bindings, spaces, sources) {
+	if (!bindings.length || !spaces) return [];
+	const missing = [];
+	const sourceList = sources ?? [];
+	for (const binding of bindings) {
+		if (!spaces.get(binding.spaceKey, binding.spaceVersion)) {
+			missing.push({
+				type: "knowledgeSpace",
+				identifier: binding.spaceVersion ? `${binding.spaceKey}@${binding.spaceVersion}` : binding.spaceKey
+			});
+			continue;
+		}
+		if (sources) {
+			if (sourceList.filter((source) => {
+				if (source.meta.spaceKey !== binding.spaceKey) return false;
+				if (binding.spaceVersion != null) return source.meta.spaceVersion === binding.spaceVersion;
+				return true;
+			}).length === 0) missing.push({
+				type: "knowledgeSource",
+				identifier: binding.spaceVersion ? `${binding.spaceKey}@${binding.spaceVersion}` : binding.spaceKey
+			});
+		}
+	}
+	return missing;
+}
+function resolveCapabilityRefs(refs, registry, missing) {
+	if (!registry) {
+		if (refs.length > 0) for (const ref of refs) missing.push({
+			type: "capability",
+			identifier: capabilityKey(ref)
+		});
+		return [];
+	}
+	const resolved = [];
+	for (const ref of refs) {
+		const spec = registry.get(ref.key, ref.version);
+		if (!spec) {
+			missing.push({
+				type: "capability",
+				identifier: capabilityKey(ref)
+			});
+			continue;
+		}
+		resolved.push(spec);
+	}
+	return resolved;
+}
+function resolveFeatureRefs(refs, registry, missing) {
+	if (!registry) {
+		if (refs.length > 0) for (const ref of refs) missing.push({
+			type: "feature",
+			identifier: ref.key
+		});
+		return [];
+	}
+	const resolved = [];
+	for (const ref of refs) {
+		const spec = registry.get(ref.key);
+		if (!spec) {
+			missing.push({
+				type: "feature",
+				identifier: ref.key
+			});
+			continue;
+		}
+		resolved.push(spec);
+	}
+	return resolved;
+}
+function resolvePointerRecord(record, registry, type, missing) {
+	if (!registry) {
+		if (Object.keys(record).length > 0) for (const [slot, pointer] of Object.entries(record)) missing.push({
+			type,
+			identifier: `${slot} -> ${specPointerKey(pointer)}`
+		});
+		return {};
+	}
+	const resolved = {};
+	for (const [slot, pointer] of Object.entries(record)) {
+		const spec = registry.get(pointer.key, pointer.version);
+		if (!spec) {
+			missing.push({
+				type,
+				identifier: `${slot} -> ${specPointerKey(pointer)}`
+			});
+			continue;
+		}
+		resolved[slot] = spec;
+	}
+	return resolved;
+}
+function resolvePolicies(policies, registry, missing) {
+	if (!registry) {
+		if (policies.length > 0) for (const policy of policies) missing.push({
+			type: "policy",
+			identifier: policyKey(policy)
+		});
+		return [];
+	}
+	const resolved = [];
+	for (const policy of policies) {
+		const spec = registry.get(policy.key, policy.version);
+		if (!spec) {
+			missing.push({
+				type: "policy",
+				identifier: policyKey(policy)
+			});
+			continue;
+		}
+		resolved.push(spec);
+	}
+	return resolved;
+}
+function resolveThemeBinding(binding, registry) {
+	const themeMissing = [];
+	if (!binding) return {
+		theme: void 0,
+		fallbacks: [],
+		themeMissing
+	};
+	if (!registry) {
+		themeMissing.push({
+			type: "theme",
+			identifier: `${binding.primary.key}.v${binding.primary.version}`
+		});
+		for (const fallback of binding.fallbacks ?? []) themeMissing.push({
+			type: "theme",
+			identifier: `${fallback.key}.v${fallback.version}`
+		});
+		return {
+			theme: void 0,
+			fallbacks: [],
+			themeMissing
+		};
+	}
+	const theme = registry.get(binding.primary.key, binding.primary.version);
+	if (!theme) themeMissing.push({
+		type: "theme",
+		identifier: `${binding.primary.key}.v${binding.primary.version}`
+	});
+	const fallbacks = [];
+	for (const fallback of binding.fallbacks ?? []) {
+		const spec = registry.get(fallback.key, fallback.version);
+		if (!spec) {
+			themeMissing.push({
+				type: "theme",
+				identifier: `${fallback.key}.v${fallback.version}`
+			});
+			continue;
+		}
+		fallbacks.push(spec);
+	}
+	return {
+		theme: theme ?? void 0,
+		fallbacks,
+		themeMissing
+	};
+}
+function resolveTelemetryBinding(binding, registry) {
+	const telemetryMissing = [];
+	if (!binding?.spec) return {
+		telemetry: void 0,
+		telemetryMissing
+	};
+	if (!registry) {
+		telemetryMissing.push({
+			type: "telemetry",
+			identifier: specPointerKey(binding.spec)
+		});
+		return {
+			telemetry: void 0,
+			telemetryMissing
+		};
+	}
+	const telemetry = registry.get(binding.spec.key, binding.spec.version);
+	if (!telemetry) telemetryMissing.push({
+		type: "telemetry",
+		identifier: specPointerKey(binding.spec)
+	});
+	return {
+		telemetry: telemetry ?? void 0,
+		telemetryMissing
+	};
+}
+function resolveExperimentsSpecs(experiments, registry, missing) {
+	const resolveList = (refs) => {
+		if (refs.length === 0) return [];
+		if (!registry) {
+			for (const ref of refs) missing.push({
+				type: "experiment",
+				identifier: experimentKey(ref)
+			});
+			return [];
+		}
+		const resolved = [];
+		for (const ref of refs) {
+			const spec = registry.get(ref.key, ref.version);
+			if (!spec) {
+				missing.push({
+					type: "experiment",
+					identifier: experimentKey(ref)
+				});
+				continue;
+			}
+			resolved.push(spec);
+		}
+		return resolved;
+	};
+	return {
+		active: resolveList(experiments.active),
+		paused: resolveList(experiments.paused)
+	};
+}
+function capabilityKey(ref) {
+	return `${ref.key}${ref.version ? `.v${ref.version}` : ""}`;
+}
+function featureKey(ref) {
+	return ref.key;
+}
+function specPointerKey(pointer) {
+	return `${pointer.key}${pointer.version ? `.v${pointer.version}` : ""}`;
+}
+function policyKey(ref) {
+	return `${ref.key}${ref.version ? `.v${ref.version}` : ""}`;
+}
+function experimentKey(ref) {
+	return `${ref.key}${ref.version ? `.v${ref.version}` : ""}`;
+}
+function dedupeRefs(refs, keyFn) {
+	const map = /* @__PURE__ */ new Map();
+	for (const ref of refs) map.set(keyFn(ref), ref);
+	return [...map.values()];
+}
+function dedupeStrings(values) {
+	return [...new Set(values)];
+}
+
+//#endregion
+export { composeAppConfig, resolveAppConfig };