@fakeware/core 0.0.5 → 0.0.7

package/dist/index.mjs

@@ -0,0 +1,610 @@
+import { l as LoadModuleError, s as ConfigError, u as loadModule } from "./config-DGneBZWH.mjs";
+import { r as estimateSyncBytes } from "./shopware-CIZF8Nuo.mjs";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+//#region src/define/errors.ts
+var RefError = class extends Error {};
+//#endregion
+//#region src/define/is-plain-object.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+//#endregion
+//#region src/define/ids.ts
+const FAKEWARE_NAMESPACE = "b1e0a3f4-6c2d-5a8b-9e7f-0d1c2b3a4e5f";
+function uuidBytes(uuid) {
+	const hex = uuid.replace(/-/g, "");
+	const bytes = new Uint8Array(16);
+	for (let i = 0; i < 16; i++) bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+const NAMESPACE_BYTES = uuidBytes(FAKEWARE_NAMESPACE);
+function uuidv5(name) {
+	const hash = createHash("sha1");
+	hash.update(NAMESPACE_BYTES);
+	hash.update(name, "utf8");
+	const bytes = hash.digest().subarray(0, 16);
+	bytes[6] = bytes[6] & 15 | 80;
+	bytes[8] = bytes[8] & 63 | 128;
+	return bytes.toString("hex");
+}
+function deterministicId(entity, key) {
+	return uuidv5(`${entity}:${key}`);
+}
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (isPlainObject(value)) {
+		const sorted = {};
+		for (const k of Object.keys(value).sort()) sorted[k] = canonicalize(value[k]);
+		return sorted;
+	}
+	return value;
+}
+function recordHash(payload) {
+	return createHash("sha256").update(JSON.stringify(canonicalize(payload))).digest("hex");
+}
+//#endregion
+//#region src/define/registry.ts
+let entries = [];
+function resetRegistry() {
+	entries = [];
+}
+function staticKey(value) {
+	if (typeof value !== "function") {
+		const k = value.$key;
+		if (typeof k === "string") return k;
+	}
+}
+function defineRecords(entity, recordOrRecords) {
+	const list = Array.isArray(recordOrRecords) ? recordOrRecords : [recordOrRecords];
+	for (const value of list) entries.push({
+		entity,
+		key: staticKey(value),
+		value
+	});
+}
+function drain() {
+	const order = [];
+	const byEntity = /* @__PURE__ */ new Map();
+	for (const e of entries) {
+		let bucket = byEntity.get(e.entity);
+		if (!bucket) {
+			bucket = [];
+			byEntity.set(e.entity, bucket);
+			order.push(e.entity);
+		}
+		bucket.push(e);
+	}
+	return order.map((entity) => ({
+		entity,
+		entries: byEntity.get(entity)
+	}));
+}
+function buildRefIndex(drained) {
+	const refIndex = { byEntity: /* @__PURE__ */ new Map() };
+	const ids = /* @__PURE__ */ new Map();
+	for (const { entity, entries: bucket } of drained) {
+		const slot = {
+			byKey: /* @__PURE__ */ new Map(),
+			all: []
+		};
+		refIndex.byEntity.set(entity, slot);
+		bucket.forEach((entry, i) => {
+			const id = deterministicId(entity, entry.key ?? String(i));
+			ids.set(entry, id);
+			slot.all.push(id);
+			if (entry.key) slot.byKey.set(entry.key, id);
+		});
+	}
+	return {
+		refIndex,
+		ids
+	};
+}
+//#endregion
+//#region src/define/define.ts
+function define(entity, records) {
+	defineRecords(entity, records);
+}
+function many(n, fn) {
+	return Array.from({ length: n }, () => fn);
+}
+let active;
+function setActiveRefIndex(refIndex) {
+	active = refIndex;
+}
+function requireActive() {
+	if (!active) throw new RefError("ref()/refs() may only be called while resolving definitions.");
+	return active;
+}
+function ref(path) {
+	const slash = path.indexOf("/");
+	if (slash === -1) throw new RefError(`ref('${path}') must be of the form 'entity/key'.`);
+	const entity = path.slice(0, slash);
+	const key = path.slice(slash + 1);
+	const id = requireActive().byEntity.get(entity)?.byKey.get(key);
+	if (!id) throw new RefError(`ref('${path}') does not match any defined record.`);
+	return id;
+}
+function refs(entity) {
+	const slot = requireActive().byEntity.get(entity);
+	if (!slot) throw new RefError(`refs('${entity}') does not match any defined entity.`);
+	return [...slot.all];
+}
+//#endregion
+//#region src/define/resolve.ts
+function resolveValue(value, ctx) {
+	if (typeof value === "function") return resolveValue(value(ctx), ctx);
+	if (Array.isArray(value)) return value.map((item) => resolveValue(item, ctx));
+	if (isPlainObject(value)) {
+		const out = {};
+		for (const [key, v] of Object.entries(value)) {
+			if (key === "$key") continue;
+			out[key] = resolveValue(v, ctx);
+		}
+		return out;
+	}
+	return value;
+}
+//#endregion
+//#region src/engine/errors.ts
+var GraphError = class extends Error {};
+var TransactionError = class extends Error {
+	rolledBack;
+	failedEntity;
+	unrevertableUpdates;
+	compensationErrors;
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "TransactionError";
+		this.rolledBack = options.rolledBack;
+		this.failedEntity = options.failedEntity;
+		this.unrevertableUpdates = options.unrevertableUpdates ?? false;
+		this.compensationErrors = options.compensationErrors ?? [];
+	}
+};
+//#endregion
+//#region src/engine/build-graph.ts
+function ownerByIdOf(refIndex) {
+	const owner = /* @__PURE__ */ new Map();
+	for (const [entity, slot] of refIndex.byEntity) for (const id of slot.all) owner.set(id, entity);
+	return owner;
+}
+function collectIdRefs(value, ownerById, into) {
+	if (typeof value === "string") {
+		const owner = ownerById.get(value);
+		if (owner) into.add(owner);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) collectIdRefs(item, ownerById, into);
+		return;
+	}
+	if (isPlainObject(value)) for (const v of Object.values(value)) collectIdRefs(v, ownerById, into);
+}
+function topoSort(entities, edges) {
+	const indegree = new Map(entities.map((e) => [e, 0]));
+	const dependents = new Map(entities.map((e) => [e, []]));
+	for (const [entity, deps] of edges) for (const dep of deps) {
+		indegree.set(entity, (indegree.get(entity) ?? 0) + 1);
+		dependents.get(dep)?.push(entity);
+	}
+	const queue = entities.filter((e) => (indegree.get(e) ?? 0) === 0);
+	const ordered = [];
+	while (queue.length > 0) {
+		const entity = queue.shift();
+		ordered.push(entity);
+		for (const dependent of dependents.get(entity) ?? []) {
+			const next = (indegree.get(dependent) ?? 0) - 1;
+			indegree.set(dependent, next);
+			if (next === 0) queue.push(dependent);
+		}
+	}
+	if (ordered.length !== entities.length) throw new GraphError(`Reference cycle between entities: ${entities.filter((e) => !ordered.includes(e)).join(", ")}.`);
+	return ordered;
+}
+function buildWritePlan(drained) {
+	const { refIndex, ids } = buildRefIndex(drained);
+	const ownerById = ownerByIdOf(refIndex);
+	const entities = drained.map((d) => d.entity);
+	const records = /* @__PURE__ */ new Map();
+	const edges = new Map(entities.map((e) => [e, /* @__PURE__ */ new Set()]));
+	setActiveRefIndex(refIndex);
+	try {
+		for (const { entity, entries } of drained) {
+			const out = [];
+			entries.forEach((entry, i) => {
+				const ctx = {
+					index: i,
+					count: entries.length,
+					ref,
+					refs
+				};
+				const payload = resolveValue(entry.value, ctx);
+				const id = ids.get(entry);
+				const referenced = /* @__PURE__ */ new Set();
+				collectIdRefs(payload, ownerById, referenced);
+				for (const dep of referenced) if (dep !== entity) edges.get(entity)?.add(dep);
+				out.push({
+					...payload,
+					id
+				});
+			});
+			records.set(entity, out);
+		}
+	} finally {
+		setActiveRefIndex(void 0);
+	}
+	return {
+		order: topoSort(entities, edges),
+		records
+	};
+}
+//#endregion
+//#region src/engine/discover.ts
+const DATA_DIR = "data";
+function isDataFile(name) {
+	return name.endsWith(".ts") && !name.endsWith(".test.ts") && !name.endsWith(".d.ts");
+}
+async function discoverDataFiles(projectRoot) {
+	const root = join(projectRoot, DATA_DIR);
+	let names;
+	try {
+		names = await readdir(root, { recursive: true });
+	} catch {
+		return [];
+	}
+	return names.filter(isDataFile).sort().map((name) => join(root, name));
+}
+//#endregion
+//#region src/engine/evaluate.ts
+async function evaluateDataFiles(files) {
+	resetRegistry();
+	for (const file of files) await loadModule(file);
+	return drain();
+}
+//#endregion
+//#region src/engine/manifest.ts
+const MANIFEST_DIR = ".fakeware";
+const CURRENT_VERSION = 1;
+function shopKey(shopwareUrl) {
+	return createHash("sha256").update(shopwareUrl).digest("hex").slice(0, 16);
+}
+function manifestPath(projectRoot, shopwareUrl) {
+	return join(projectRoot, MANIFEST_DIR, `${shopKey(shopwareUrl)}.json`);
+}
+function checksumOf(entities) {
+	const canonical = entities.map((e) => ({
+		entity: e.entity,
+		records: [...e.records].sort((a, b) => a.id.localeCompare(b.id))
+	})).sort((a, b) => a.entity.localeCompare(b.entity));
+	return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+function buildManifest(input) {
+	return {
+		version: CURRENT_VERSION,
+		fakewareVersion: input.fakewareVersion,
+		createdAt: input.createdAt,
+		shopwareUrl: input.shopwareUrl,
+		entities: input.entities,
+		checksum: checksumOf(input.entities)
+	};
+}
+async function readManifest(projectRoot, shopwareUrl) {
+	const path = manifestPath(projectRoot, shopwareUrl);
+	let contents;
+	try {
+		contents = await readFile(path, "utf8");
+	} catch {
+		return null;
+	}
+	const parsed = JSON.parse(contents);
+	switch (parsed.version) {
+		case CURRENT_VERSION: {
+			const manifest = parsed;
+			if (checksumOf(manifest.entities) !== manifest.checksum) throw new ConfigError(`Manifest at ${path} is corrupt (checksum mismatch). Re-run \`fakeware up\`.`);
+			return manifest;
+		}
+		default: throw new ConfigError(`Unsupported manifest version ${parsed.version} (this CLI understands up to ${CURRENT_VERSION}). Upgrade fakeware.`);
+	}
+}
+async function writeManifest(projectRoot, manifest) {
+	const path = manifestPath(projectRoot, manifest.shopwareUrl);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+async function removeManifest(projectRoot, shopwareUrl) {
+	await rm(manifestPath(projectRoot, shopwareUrl), { force: true });
+}
+//#endregion
+//#region src/engine/run.ts
+function priorHashes(manifest) {
+	const map = /* @__PURE__ */ new Map();
+	for (const e of manifest?.entities ?? []) map.set(e.entity, new Map(e.records.map((r) => [r.id, r.hash])));
+	return map;
+}
+function resolveTransaction(opts) {
+	return opts.transaction ?? opts.loaded.config.transaction;
+}
+function diffEntity(entity, records, prior) {
+	const toWrite = [];
+	const createdIds = [];
+	let created = 0;
+	let updated = 0;
+	let unchanged = 0;
+	return {
+		entity,
+		toWrite,
+		createdIds,
+		manifestRecords: records.map((record) => {
+			const hash = recordHash(record);
+			const previous = prior.get(record.id);
+			if (previous === void 0) {
+				created++;
+				createdIds.push(record.id);
+			} else if (previous === hash) unchanged++;
+			else updated++;
+			if (previous !== hash) toWrite.push(record);
+			return {
+				id: record.id,
+				hash
+			};
+		}),
+		step: {
+			entity,
+			created,
+			updated,
+			unchanged,
+			deleted: 0
+		}
+	};
+}
+function partialWrite(w, committed) {
+	if (committed <= 0) return null;
+	const createdSet = new Set(w.createdIds);
+	const prefix = w.toWrite.slice(0, committed);
+	const createdIds = prefix.map((r) => r.id).filter((id) => createdSet.has(id));
+	const updated = prefix.length - createdIds.length;
+	if (createdIds.length === 0 && updated === 0) return null;
+	return {
+		entity: w.entity,
+		toWrite: [],
+		createdIds,
+		manifestRecords: [],
+		step: {
+			entity: w.entity,
+			created: 0,
+			updated,
+			unchanged: 0,
+			deleted: 0
+		}
+	};
+}
+async function runUp(opts) {
+	const { loaded, sink, dryRun, reporter } = opts;
+	const tx = resolveTransaction(opts);
+	const plan = buildWritePlan(await evaluateDataFiles(await discoverDataFiles(loaded.projectRoot)));
+	const prior = priorHashes(await readManifest(loaded.projectRoot, loaded.connection.url));
+	const writes = plan.order.map((entity) => diffEntity(entity, plan.records.get(entity) ?? [], prior.get(entity) ?? /* @__PURE__ */ new Map()));
+	const steps = writes.map((w) => w.step);
+	const manifestEntities = writes.map((w) => ({
+		entity: w.entity,
+		records: w.manifestRecords
+	}));
+	const committed = steps.reduce((n, s) => n + s.created + s.updated, 0);
+	const pending = writes.filter((w) => w.toWrite.length > 0);
+	if (dryRun || pending.length === 0) {
+		for (const w of writes) {
+			reporter?.onStart?.(w.entity);
+			reporter?.onStep?.(w.step);
+		}
+		return {
+			steps,
+			manifestWritten: false,
+			mode: dryRun ? "dry-run" : "noop",
+			committed: 0,
+			rolledBack: 0
+		};
+	}
+	const writeManifestNow = (entities) => writeManifest(loaded.projectRoot, buildManifest({
+		fakewareVersion: opts.fakewareVersion ?? "0.0.0",
+		createdAt: opts.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+		shopwareUrl: loaded.connection.url,
+		entities
+	}));
+	const operations = pending.map((w) => ({
+		entity: w.entity,
+		action: "upsert",
+		records: w.toWrite
+	}));
+	if (tx.atomic && estimateSyncBytes(operations) <= 5242880) {
+		reporter?.onTransactionStart?.({ mode: "atomic" });
+		try {
+			await sink.applyAtomic(operations);
+		} catch (error) {
+			const message = "Apply failed — Shopware rolled back all changes.";
+			reporter?.onStop?.({
+				failedEntity: "",
+				error,
+				message
+			});
+			throw new TransactionError(message, {
+				cause: error,
+				rolledBack: [],
+				failedEntity: ""
+			});
+		}
+		await writeManifestNow(manifestEntities);
+		reporter?.onCommit?.({ committed });
+		return {
+			steps,
+			manifestWritten: true,
+			mode: "atomic",
+			committed,
+			rolledBack: 0
+		};
+	}
+	reporter?.onTransactionStart?.({ mode: "saga" });
+	const written = [];
+	const skipped = [];
+	for (const w of pending) {
+		reporter?.onStart?.(w.entity, w.toWrite.length);
+		let committedRecords = 0;
+		try {
+			await sink.upsert(w.entity, w.toWrite, (progress) => {
+				committedRecords = progress.records;
+				reporter?.onBatch?.(progress);
+			});
+			written.push(w);
+			reporter?.onStep?.(w.step);
+		} catch (error) {
+			if (tx.onError === "stop") {
+				const message = `Writing ${w.entity} failed — stopped.`;
+				reporter?.onStop?.({
+					failedEntity: w.entity,
+					error,
+					message
+				});
+				throw new TransactionError(message, {
+					cause: error,
+					rolledBack: [],
+					failedEntity: w.entity
+				});
+			}
+			if (tx.onError === "continue") {
+				skipped.push({
+					entity: w.entity,
+					error
+				});
+				reporter?.onSkip?.({
+					entity: w.entity,
+					error
+				});
+				continue;
+			}
+			const message = `Could not apply ${w.entity}.`;
+			reporter?.onStop?.({
+				failedEntity: w.entity,
+				error,
+				message
+			});
+			const partial = partialWrite(w, committedRecords);
+			const { rolledBack, unrevertableUpdates, compensationErrors } = await compensate(sink, partial ? [...written, partial] : written, reporter);
+			throw new TransactionError(message, {
+				cause: error,
+				rolledBack,
+				failedEntity: w.entity,
+				unrevertableUpdates,
+				compensationErrors
+			});
+		}
+	}
+	for (const w of writes) if (!written.includes(w) && !skipped.some((s) => s.entity === w.entity)) {
+		reporter?.onStart?.(w.entity);
+		reporter?.onStep?.(w.step);
+	}
+	if (skipped.length > 0) {
+		await writeManifestNow(restrictManifest(manifestEntities, prior, new Set(written.map((w) => w.entity))));
+		const first = skipped[0];
+		throw new TransactionError(`Applied with ${skipped.length} skipped entit${skipped.length === 1 ? "y" : "ies"}.`, {
+			cause: skipped,
+			rolledBack: [],
+			failedEntity: first.entity
+		});
+	}
+	await writeManifestNow(manifestEntities);
+	reporter?.onCommit?.({ committed });
+	return {
+		steps,
+		manifestWritten: true,
+		mode: "saga",
+		committed,
+		rolledBack: 0
+	};
+}
+async function compensate(sink, written, reporter) {
+	const rolledBack = [];
+	const compensationErrors = [];
+	for (const w of [...written].reverse()) {
+		if (w.createdIds.length === 0) continue;
+		try {
+			await sink.delete(w.entity, w.createdIds);
+			rolledBack.push({
+				entity: w.entity,
+				created: 0,
+				updated: 0,
+				unchanged: 0,
+				deleted: w.createdIds.length
+			});
+			reporter?.onCompensate?.(w.entity, w.createdIds.length);
+		} catch (error) {
+			compensationErrors.push(error);
+			reporter?.onCompensateFail?.(w.entity);
+		}
+	}
+	return {
+		rolledBack,
+		unrevertableUpdates: written.some((w) => w.step.updated > 0),
+		compensationErrors
+	};
+}
+function restrictManifest(desired, prior, writtenEntities) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const e of desired) {
+		seen.add(e.entity);
+		if (writtenEntities.has(e.entity)) out.push(e);
+		else {
+			const priorRecords = prior.get(e.entity);
+			if (priorRecords && priorRecords.size > 0) out.push({
+				entity: e.entity,
+				records: [...priorRecords].map(([id, hash]) => ({
+					id,
+					hash
+				}))
+			});
+		}
+	}
+	for (const [entity, records] of prior) if (!seen.has(entity) && records.size > 0) out.push({
+		entity,
+		records: [...records].map(([id, hash]) => ({
+			id,
+			hash
+		}))
+	});
+	return out;
+}
+async function runDown(opts) {
+	const { loaded, sink, dryRun, reporter } = opts;
+	const manifest = await readManifest(loaded.projectRoot, loaded.connection.url);
+	if (!manifest) return {
+		steps: [],
+		reverted: false
+	};
+	reporter?.onTransactionStart?.({ mode: "saga" });
+	const steps = [];
+	for (const entity of [...manifest.entities].reverse()) {
+		const ids = entity.records.map((r) => r.id);
+		reporter?.onStart?.(entity.entity, ids.length);
+		if (!dryRun && ids.length > 0) await sink.delete(entity.entity, ids, (progress) => reporter?.onBatch?.(progress));
+		const step = {
+			entity: entity.entity,
+			created: 0,
+			updated: 0,
+			unchanged: 0,
+			deleted: ids.length
+		};
+		steps.push(step);
+		reporter?.onStep?.(step);
+	}
+	if (!dryRun) await removeManifest(loaded.projectRoot, loaded.connection.url);
+	return {
+		steps,
+		reverted: !dryRun
+	};
+}
+//#endregion
+export { GraphError, LoadModuleError, RefError, TransactionError, define, many, readManifest, ref, refs, runDown, runUp };
+
+//# sourceMappingURL=index.mjs.map