@zodmire/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Vercel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/artifacts-CUzHfc15.mjs

@@ -0,0 +1,91 @@
+//#region packages/core/artifacts.ts
+function safeDataName(value) {
+	return value.replace(/[\\/]+/g, "__").replace(/[^A-Za-z0-9_.-]+/g, "_");
+}
+function createGeneratedArtifact(logicalPath, content, ownership) {
+	return {
+		logicalPath,
+		dataName: safeDataName(logicalPath),
+		content,
+		owned: true,
+		ownershipScope: ownership?.ownershipScope,
+		scopeKey: ownership?.scopeKey
+	};
+}
+function withArtifactOwnership(artifact, ownership) {
+	return {
+		...artifact,
+		ownershipScope: ownership.ownershipScope,
+		scopeKey: ownership.scopeKey
+	};
+}
+function mergeGeneratedArtifacts(...groups) {
+	const mergedArtifacts = [];
+	const artifactsByLogicalPath = /* @__PURE__ */ new Map();
+	for (const artifact of groups.flat()) {
+		const existingArtifact = artifactsByLogicalPath.get(artifact.logicalPath);
+		if (existingArtifact === void 0) {
+			artifactsByLogicalPath.set(artifact.logicalPath, artifact);
+			mergedArtifacts.push(artifact);
+			continue;
+		}
+		if (existingArtifact.dataName !== artifact.dataName || existingArtifact.content !== artifact.content || existingArtifact.ownershipScope !== artifact.ownershipScope || existingArtifact.scopeKey !== artifact.scopeKey) throw new Error(`Generated artifact logical path collision: ${artifact.logicalPath}`);
+	}
+	return mergedArtifacts;
+}
+function sharedArtifactOwnership(scopeKey = "shared") {
+	return {
+		ownershipScope: "shared-owned",
+		scopeKey
+	};
+}
+function sliceArtifactOwnership(scopeKey) {
+	return {
+		ownershipScope: "slice-owned",
+		scopeKey
+	};
+}
+function contextArtifactOwnership(scopeKey) {
+	return {
+		ownershipScope: "context-owned",
+		scopeKey
+	};
+}
+function applyOwnershipIfMissing(artifacts, ownership) {
+	return artifacts.map((artifact) => artifact.ownershipScope !== void 0 && artifact.scopeKey !== void 0 ? artifact : withArtifactOwnership(artifact, ownership));
+}
+function inferArtifactOwnership(logicalPath, defaultSliceScopeKey = "default") {
+	if (logicalPath.startsWith("lib/")) return sharedArtifactOwnership("lib");
+	if (logicalPath.startsWith("infrastructure/di/")) return sharedArtifactOwnership("composition");
+	if (logicalPath.startsWith("presentation/event-handlers/")) return sharedArtifactOwnership("composition");
+	if (logicalPath === "presentation/trpc/router.ts" || logicalPath === "presentation/trpc/context.ts") return sharedArtifactOwnership("composition");
+	if (logicalPath.startsWith("core/ports/messaging/")) return sharedArtifactOwnership("composition");
+	if (logicalPath.startsWith("infrastructure/unit-of-work/")) return sharedArtifactOwnership("composition");
+	if (logicalPath.startsWith("infrastructure/outbox/")) return sharedArtifactOwnership("composition");
+	if (logicalPath.startsWith("core/shared-kernel/") || logicalPath.startsWith("core/ports/")) return sharedArtifactOwnership();
+	const contextMatch = logicalPath.match(/^core\/contexts\/(.+?)\/(?:application|domain|tests)\//);
+	if (contextMatch) return sliceArtifactOwnership(contextMatch[1] ?? defaultSliceScopeKey);
+	if (logicalPath.match(/^infrastructure\/persistence\/[^/]+\/tables\.ts$/)) {
+		const ctx = logicalPath.split("/")[2];
+		return sliceArtifactOwnership(ctx ?? defaultSliceScopeKey);
+	}
+	if (logicalPath.match(/^infrastructure\/view-models\/[^/]+\/tables\.ts$/)) {
+		const ctx = logicalPath.split("/")[2];
+		return sliceArtifactOwnership(ctx ?? defaultSliceScopeKey);
+	}
+	const repositoryMatch = logicalPath.match(/^infrastructure\/.*\/repositories\/(.+)\/[^/]+$/);
+	if (repositoryMatch) return sliceArtifactOwnership(repositoryMatch[1] ?? defaultSliceScopeKey);
+	const routerMatch = logicalPath.match(/^presentation\/.*\/routers\/([^.]+)\.router\.ts$/);
+	if (routerMatch) return sliceArtifactOwnership(routerMatch[1] ?? defaultSliceScopeKey);
+	return sliceArtifactOwnership(defaultSliceScopeKey);
+}
+function resolveArtifactOwnership(artifact, defaultSliceScopeKey = "default") {
+	if (artifact.ownershipScope && artifact.scopeKey) return {
+		ownershipScope: artifact.ownershipScope,
+		scopeKey: artifact.scopeKey
+	};
+	return inferArtifactOwnership(artifact.logicalPath, defaultSliceScopeKey);
+}
+
+//#endregion
+export { mergeGeneratedArtifacts as a, sliceArtifactOwnership as c, inferArtifactOwnership as i, withArtifactOwnership as l, contextArtifactOwnership as n, resolveArtifactOwnership as o, createGeneratedArtifact as r, sharedArtifactOwnership as s, applyOwnershipIfMissing as t };

package/artifacts-QqCpfT50.d.mts

@@ -0,0 +1,25 @@
+//#region packages/core/artifacts.d.ts
+type OwnershipScope = "shared-owned" | "slice-owned" | "context-owned";
+type ArtifactOwnership = {
+  ownershipScope: OwnershipScope;
+  scopeKey: string;
+};
+type GeneratedArtifact = {
+  logicalPath: string;
+  dataName: string;
+  content: string;
+  owned: true;
+  ownershipScope?: OwnershipScope;
+  scopeKey?: string;
+};
+declare function createGeneratedArtifact(logicalPath: string, content: string, ownership?: ArtifactOwnership): GeneratedArtifact;
+declare function withArtifactOwnership(artifact: GeneratedArtifact, ownership: ArtifactOwnership): GeneratedArtifact;
+declare function mergeGeneratedArtifacts(...groups: GeneratedArtifact[][]): GeneratedArtifact[];
+declare function sharedArtifactOwnership(scopeKey?: string): ArtifactOwnership;
+declare function sliceArtifactOwnership(scopeKey: string): ArtifactOwnership;
+declare function contextArtifactOwnership(scopeKey: string): ArtifactOwnership;
+declare function applyOwnershipIfMissing(artifacts: GeneratedArtifact[], ownership: ArtifactOwnership): GeneratedArtifact[];
+declare function inferArtifactOwnership(logicalPath: string, defaultSliceScopeKey?: string): ArtifactOwnership;
+declare function resolveArtifactOwnership(artifact: Pick<GeneratedArtifact, "logicalPath" | "ownershipScope" | "scopeKey">, defaultSliceScopeKey?: string): ArtifactOwnership;
+//#endregion
+export { contextArtifactOwnership as a, mergeGeneratedArtifacts as c, sliceArtifactOwnership as d, withArtifactOwnership as f, applyOwnershipIfMissing as i, resolveArtifactOwnership as l, GeneratedArtifact as n, createGeneratedArtifact as o, OwnershipScope as r, inferArtifactOwnership as s, ArtifactOwnership as t, sharedArtifactOwnership as u };

package/materialize.d.mts

@@ -0,0 +1,68 @@
+import { n as GeneratedArtifact } from "./artifacts-QqCpfT50.mjs";
+import { z } from "zod";
+
+//#region packages/core/materialize.d.ts
+declare const OwnedManifestEntrySchema: z.ZodObject<{
+  logicalPath: z.ZodString;
+  ownershipScope: z.ZodEnum<{
+    "shared-owned": "shared-owned";
+    "slice-owned": "slice-owned";
+    "context-owned": "context-owned";
+  }>;
+  scopeKey: z.ZodString;
+  sourceArtifactId: z.ZodString;
+  contentSha256: z.ZodString;
+  generatorVersion: z.ZodString;
+}, z.core.$strict>;
+declare const MaterializationManifestSchema: z.ZodObject<{
+  targetRoot: z.ZodString;
+  files: z.ZodArray<z.ZodObject<{
+    logicalPath: z.ZodString;
+    ownershipScope: z.ZodEnum<{
+      "shared-owned": "shared-owned";
+      "slice-owned": "slice-owned";
+      "context-owned": "context-owned";
+    }>;
+    scopeKey: z.ZodString;
+    sourceArtifactId: z.ZodString;
+    contentSha256: z.ZodString;
+    generatorVersion: z.ZodString;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const LegacyMaterializationManifestSchema: z.ZodObject<{
+  targetRoot: z.ZodString;
+  files: z.ZodArray<z.ZodObject<{
+    logicalPath: z.ZodString;
+    owned: z.ZodLiteral<true>;
+    sourceArtifactId: z.ZodString;
+    contentSha256: z.ZodString;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type LegacyMaterializationManifest = z.output<typeof LegacyMaterializationManifestSchema>;
+type OwnedManifestEntry = z.output<typeof OwnedManifestEntrySchema>;
+type MaterializationManifest = z.output<typeof MaterializationManifestSchema>;
+type MaterializationAction = "write" | "overwrite" | "conflict";
+type MaterializedFile = {
+  logicalPath: string;
+  action: Exclude<MaterializationAction, "conflict"> | "delete";
+};
+type MaterializeResult = {
+  targetRoot: string;
+  files: MaterializedFile[];
+};
+type MaterializationScope = Pick<OwnedManifestEntry, "ownershipScope" | "scopeKey">;
+type MaterializeOptions = {
+  reconcileScopes?: MaterializationScope[];
+};
+type PreparedArtifact = {
+  artifact: GeneratedArtifact;
+  content: string;
+};
+declare function determineMaterializationAction(destinationExists: boolean, previousManifestSha256?: string, currentDestinationSha256?: string): MaterializationAction;
+declare function sha256Hex(content: string): Promise<string>;
+declare function buildMaterializationManifest(targetRoot: string, artifacts: GeneratedArtifact[] | PreparedArtifact[], generatorVersion: string): Promise<MaterializationManifest>;
+declare function upgradeLegacyMaterializationManifest(legacyManifest: LegacyMaterializationManifest): MaterializationManifest;
+declare function getPersistedMaterializationManifestPath(targetRoot: string): string;
+declare function materializeOwnedArtifacts(targetRoot: string, artifacts: GeneratedArtifact[], generatorVersion: string, options?: MaterializeOptions): Promise<MaterializeResult>;
+//#endregion
+export { LegacyMaterializationManifest, MaterializationAction, MaterializationManifest, MaterializationManifestSchema, MaterializationScope, MaterializeOptions, MaterializeResult, MaterializedFile, OwnedManifestEntry, OwnedManifestEntrySchema, buildMaterializationManifest, determineMaterializationAction, getPersistedMaterializationManifestPath, materializeOwnedArtifacts, sha256Hex, upgradeLegacyMaterializationManifest };

package/materialize.mjs

@@ -0,0 +1,240 @@
+import { c as sliceArtifactOwnership, i as inferArtifactOwnership, o as resolveArtifactOwnership } from "./artifacts-CUzHfc15.mjs";
+import { z } from "zod";
+import { dirname, join } from "node:path";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+
+//#region packages/core/materialize.ts
+let _oxfmt;
+async function loadOxfmt() {
+	if (!_oxfmt) _oxfmt = await import("oxfmt");
+	return _oxfmt;
+}
+const OwnershipScopeSchema = z.enum([
+	"shared-owned",
+	"slice-owned",
+	"context-owned"
+]);
+const OwnedManifestEntrySchema = z.strictObject({
+	logicalPath: z.string().min(1),
+	ownershipScope: OwnershipScopeSchema,
+	scopeKey: z.string().min(1),
+	sourceArtifactId: z.string().min(1),
+	contentSha256: z.string().length(64),
+	generatorVersion: z.string().min(1)
+});
+const MaterializationManifestSchema = z.strictObject({
+	targetRoot: z.string().min(1),
+	files: z.array(OwnedManifestEntrySchema)
+});
+const LegacyMaterializationManifestFileSchema = z.strictObject({
+	logicalPath: z.string().min(1),
+	owned: z.literal(true),
+	sourceArtifactId: z.string().min(1),
+	contentSha256: z.string().length(64)
+});
+const LegacyMaterializationManifestSchema = z.strictObject({
+	targetRoot: z.string().min(1),
+	files: z.array(LegacyMaterializationManifestFileSchema)
+});
+const persistedMaterializationManifestRelativePath = ".bounded-context-codegen/materialization-manifest.json";
+function determineMaterializationAction(destinationExists, previousManifestSha256, currentDestinationSha256) {
+	if (!destinationExists) return "write";
+	if (!previousManifestSha256 || !currentDestinationSha256) return "conflict";
+	return currentDestinationSha256 === previousManifestSha256 ? "overwrite" : "conflict";
+}
+async function sha256Hex(content) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function buildMaterializationManifest(targetRoot, artifacts, generatorVersion) {
+	return {
+		targetRoot,
+		files: await Promise.all(artifacts.map(async (entry) => {
+			const artifact = "artifact" in entry ? entry.artifact : entry;
+			const content = "content" in entry ? entry.content : await prepareArtifactContent(artifact);
+			const ownership = resolveArtifactOwnership(artifact);
+			return {
+				logicalPath: artifact.logicalPath,
+				ownershipScope: ownership.ownershipScope,
+				scopeKey: ownership.scopeKey,
+				sourceArtifactId: artifact.dataName,
+				contentSha256: await sha256Hex(content),
+				generatorVersion
+			};
+		}))
+	};
+}
+function inferLegacyManifestSliceScopeKey(legacyManifest) {
+	const unresolvedScopeKey = "__legacy-unresolved__";
+	const inferredScopeKeys = new Set(legacyManifest.files.flatMap((file) => {
+		if (!file.logicalPath.startsWith("core/contexts/") && !file.logicalPath.includes("/repositories/")) return [];
+		const ownership = inferArtifactOwnership(file.logicalPath, unresolvedScopeKey);
+		return ownership.ownershipScope === "slice-owned" && ownership.scopeKey !== unresolvedScopeKey ? [ownership.scopeKey] : [];
+	}));
+	return inferredScopeKeys.size === 1 ? [...inferredScopeKeys][0] : void 0;
+}
+function upgradeLegacyMaterializationManifest(legacyManifest) {
+	const defaultSliceScopeKey = inferLegacyManifestSliceScopeKey(legacyManifest) ?? "default";
+	return {
+		targetRoot: legacyManifest.targetRoot,
+		files: legacyManifest.files.map((file) => {
+			const ownership = file.logicalPath.startsWith("presentation/") || file.logicalPath.startsWith("routes/") ? sliceArtifactOwnership(defaultSliceScopeKey) : resolveArtifactOwnership(file, defaultSliceScopeKey);
+			return {
+				logicalPath: file.logicalPath,
+				ownershipScope: ownership.ownershipScope,
+				scopeKey: ownership.scopeKey,
+				sourceArtifactId: file.sourceArtifactId,
+				contentSha256: file.contentSha256,
+				generatorVersion: "legacy-v1"
+			};
+		})
+	};
+}
+function getPersistedMaterializationManifestPath(targetRoot) {
+	return join(targetRoot, persistedMaterializationManifestRelativePath);
+}
+function ownershipScopeKey(entry) {
+	return `${entry.ownershipScope}:${entry.scopeKey}`;
+}
+function scopedLogicalPathKey(entry) {
+	return `${ownershipScopeKey(entry)}:${entry.logicalPath}`;
+}
+function findScopedManifestEntry(entries, currentEntry) {
+	const currentOwnershipScopeKey = ownershipScopeKey(currentEntry);
+	return entries.find((entry) => ownershipScopeKey(entry) === currentOwnershipScopeKey && (entry.sourceArtifactId === currentEntry.sourceArtifactId || entry.logicalPath === currentEntry.logicalPath));
+}
+async function readDestinationSha256(destinationPath) {
+	try {
+		return await sha256Hex(await readFile(destinationPath, "utf-8"));
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+}
+async function readPersistedMaterializationManifest(targetRoot) {
+	try {
+		const persistedManifestText = await readFile(getPersistedMaterializationManifestPath(targetRoot), "utf-8");
+		const persistedManifest = JSON.parse(persistedManifestText);
+		const v2Manifest = MaterializationManifestSchema.safeParse(persistedManifest);
+		if (v2Manifest.success) return {
+			kind: "v2",
+			manifest: v2Manifest.data
+		};
+		const legacyManifest = LegacyMaterializationManifestSchema.safeParse(persistedManifest);
+		if (legacyManifest.success) return {
+			kind: "legacy-v1",
+			manifest: legacyManifest.data,
+			upgradedManifest: upgradeLegacyMaterializationManifest(legacyManifest.data)
+		};
+		return {
+			kind: "v2",
+			manifest: MaterializationManifestSchema.parse(persistedManifest)
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return { kind: "missing" };
+		throw error;
+	}
+}
+function indexLegacyManifestEntriesByLogicalPath(manifest) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const file of manifest.files) {
+		if (entries.has(file.logicalPath)) throw new Error(`Legacy materialization manifest is ambiguous for logical path: ${file.logicalPath}`);
+		entries.set(file.logicalPath, file);
+	}
+	return entries;
+}
+async function removePathIfExists(path) {
+	try {
+		await rm(path);
+	} catch (error) {
+		if (!(error.code === "ENOENT")) throw error;
+	}
+}
+function shouldFormatArtifact(logicalPath) {
+	return /\.(?:[cm]?tsx?|jsx?)$/.test(logicalPath);
+}
+async function prepareArtifactContent(artifact) {
+	if (!shouldFormatArtifact(artifact.logicalPath)) return artifact.content;
+	let currentContent = artifact.content;
+	for (let pass = 0; pass < 3; pass++) {
+		const result = await (await loadOxfmt()).format(artifact.logicalPath, currentContent, { singleQuote: true });
+		if (result.errors.length > 0) throw new Error(`Failed to format generated artifact ${artifact.logicalPath}: ${result.errors.join(", ")}`);
+		if (result.code === currentContent) return result.code;
+		currentContent = result.code;
+	}
+	return currentContent;
+}
+async function prepareArtifactsForMaterialization(artifacts) {
+	return await Promise.all(artifacts.map(async (artifact) => ({
+		artifact,
+		content: await prepareArtifactContent(artifact)
+	})));
+}
+async function materializeOwnedArtifacts(targetRoot, artifacts, generatorVersion, options = {}) {
+	const preparedArtifacts = await prepareArtifactsForMaterialization(artifacts);
+	const manifest = await buildMaterializationManifest(targetRoot, preparedArtifacts, generatorVersion);
+	const previousManifest = await readPersistedMaterializationManifest(targetRoot);
+	const previousOwnedEntries = previousManifest.kind === "missing" ? [] : previousManifest.kind === "legacy-v1" ? (() => {
+		indexLegacyManifestEntriesByLogicalPath(previousManifest.manifest);
+		return previousManifest.upgradedManifest.files;
+	})() : previousManifest.manifest.files;
+	const activeOwnershipScopes = new Set([...manifest.files, ...options.reconcileScopes ?? []].map((file) => ownershipScopeKey(file)));
+	const currentManifestEntriesBySourceArtifactId = new Map(manifest.files.map((file) => [file.sourceArtifactId, file]));
+	const currentManifestEntriesByScopedLogicalPath = new Set(manifest.files.map((file) => scopedLogicalPathKey(file)));
+	const plannedWrites = [];
+	const plannedDeletes = [];
+	for (const preparedArtifact of preparedArtifacts) {
+		const { artifact, content } = preparedArtifact;
+		const destinationPath = join(targetRoot, artifact.logicalPath);
+		const destinationSha256 = await readDestinationSha256(destinationPath);
+		const currentManifestEntry = currentManifestEntriesBySourceArtifactId.get(artifact.dataName);
+		if (currentManifestEntry === void 0) throw new Error(`Materialization manifest missing current entry for artifact: ${artifact.logicalPath}`);
+		const previousManifestEntry = findScopedManifestEntry(previousOwnedEntries, currentManifestEntry);
+		const action = determineMaterializationAction(destinationSha256 !== void 0, previousManifestEntry?.contentSha256, destinationSha256);
+		if (action === "conflict") throw new Error(`Materialization conflict for generator-owned file: ${artifact.logicalPath}`);
+		plannedWrites.push({
+			artifact: {
+				...artifact,
+				content
+			},
+			destinationPath,
+			action
+		});
+	}
+	for (const previousManifestEntry of previousOwnedEntries) {
+		if (!activeOwnershipScopes.has(ownershipScopeKey(previousManifestEntry))) continue;
+		if (currentManifestEntriesByScopedLogicalPath.has(scopedLogicalPathKey(previousManifestEntry))) continue;
+		const destinationPath = join(targetRoot, previousManifestEntry.logicalPath);
+		const destinationSha256 = await readDestinationSha256(destinationPath);
+		if (destinationSha256 !== void 0 && destinationSha256 !== previousManifestEntry.contentSha256) throw new Error(`Materialization conflict for stale generator-owned file: ${previousManifestEntry.logicalPath}`);
+		plannedDeletes.push({
+			logicalPath: previousManifestEntry.logicalPath,
+			destinationPath
+		});
+	}
+	for (const staleFile of plannedDeletes) await removePathIfExists(staleFile.destinationPath);
+	for (const write of plannedWrites) {
+		await mkdir(dirname(write.destinationPath), { recursive: true });
+		await writeFile(write.destinationPath, write.artifact.content, "utf-8");
+	}
+	const persistedManifestPath = getPersistedMaterializationManifestPath(targetRoot);
+	const persistedManifest = {
+		targetRoot,
+		files: [...previousOwnedEntries.filter((file) => !activeOwnershipScopes.has(ownershipScopeKey(file))), ...manifest.files]
+	};
+	await mkdir(dirname(persistedManifestPath), { recursive: true });
+	await writeFile(persistedManifestPath, `${JSON.stringify(persistedManifest, null, 2)}\n`, "utf-8");
+	return {
+		targetRoot,
+		files: [...plannedDeletes.map((staleFile) => ({
+			logicalPath: staleFile.logicalPath,
+			action: "delete"
+		})), ...plannedWrites.map((write) => ({
+			logicalPath: write.artifact.logicalPath,
+			action: write.action
+		}))]
+	};
+}
+
+//#endregion
+export { MaterializationManifestSchema, OwnedManifestEntrySchema, buildMaterializationManifest, determineMaterializationAction, getPersistedMaterializationManifestPath, materializeOwnedArtifacts, sha256Hex, upgradeLegacyMaterializationManifest };