@yahoo/uds-create-config 2.45.0 → 3.0.1

package/dist/entities/system/copy-plan.js

@@ -0,0 +1,451 @@
+import { rejectData } from "../../framework/rejection.js";
+import { MINTED, collectRefs, isMintedRow, kindOf, pathOf, rewriteRefs, sourceOf, splitRef } from "../../framework/utils/refs.js";
+import { kindBorrowable } from "../../framework/registry.js";
+import { File } from "./File.js";
+import { componentModuleFilePaths, componentRegistryImports } from "./component-module.js";
+import { PIN_KIND, covers, declarationOf, narrowDeclaration } from "./link-declaration.js";
+//#region src/entities/system/copy-plan.ts
+/**
+* The source's entries one path names: every item of the kind for `'*'`, a folder's members for a
+* group path, the item itself otherwise. Rows keep the source's own names.
+*/
+function sourceEntries({ source, kind, path }) {
+	if (path === "*") return source.list(kind).map((item) => ({
+		from: item.path,
+		to: item.path
+	}));
+	if (source.resolve(kind, path)) return [{
+		from: path,
+		to: path
+	}];
+	return source.members(kind, path).map((member) => ({
+		from: member.path,
+		to: member.path
+	}));
+}
+/**
+* The source's components a code component's render imports by module.
+*
+* A render names a sibling component through an import rather than a ref, and the source's file edges
+* record which registered components those imports bind. Read off every file the component's module
+* reaches, so a helper that imports a component counts too.
+*/
+function renderImportedComponents({ source, path }) {
+	const { file } = source.resolve("component", path)?.body ?? {};
+	if (!file) return [];
+	const ref = splitRef(file.__ref);
+	if (ref.kind !== "file" || ref.source) return [];
+	const components = [];
+	for (const filePath of componentModuleFilePaths(source, ref.path)) for (const edge of componentRegistryImports(source, filePath)) for (const binding of edge.bindings) components.push(pathOf(binding.componentRef));
+	return components;
+}
+/**
+* The source's files a code component renders from: the file its `file` names and every local file
+* that module reaches through its imports. Stops at a sibling component's file, which comes along
+* with the sibling ({@link renderImportedComponents}). Empty for a component generated from config.
+*/
+function renderSourceFiles({ source, path }) {
+	const { file } = source.resolve("component", path)?.body ?? {};
+	if (!file) return [];
+	const ref = splitRef(file.__ref);
+	if (ref.kind !== "file" || ref.source) return [];
+	return componentModuleFilePaths(source, ref.path);
+}
+/** A folder's meta as this config would author it — without a pointer the source held, and without
+*  the build's mark, which no kind declares as a group field. */
+function ownMeta(meta) {
+	const { ref: _pointer, [MINTED]: _mark, ...own } = meta;
+	return own;
+}
+/**
+* What `copy` would do with this input, and the patches that do it.
+*
+* A copied row stands on its own: every ref into the source is followed and its target is taken too,
+* unless this config already holds that path — then the copy points at what is here. A code
+* component's files come along the same way, so the copy renders from its own rows. A ref through a
+* third system is theirs to resolve and is left as spelled, and a kind this config can't hold stays
+* qualified, since the pin survives to answer it.
+*
+* Refuses exactly what the op refuses, since the op is this plan applied.
+*/
+function planCopy({ config, input }) {
+	const { path: slug } = input;
+	const wholesale = input.data === "*";
+	const source = config.sourceFor(slug);
+	if (!source) rejectData(`Cannot copy through "${slug}" — nothing has resolved that link.`);
+	/** The kinds named, with what to take of each. An accessor this config has no kind for is refused
+	*  by name, since it is a typo rather than a source that offers nothing. */
+	const wanted = [];
+	if (input.data === "*") for (const kind of config.borrowableKinds(slug)) wanted.push({
+		kind,
+		paths: "*"
+	});
+	else {
+		const accessors = config.accessors();
+		for (const [accessor, paths] of Object.entries(input.data)) {
+			const cls = accessors[accessor];
+			if (!cls) rejectData(`Cannot copy through "${slug}" — this system has no "${accessor}".`, ["data", accessor]);
+			wanted.push({
+				kind: cls.kind,
+				paths
+			});
+		}
+	}
+	if (wanted.length === 0) rejectData(`Cannot copy through "${slug}" — name what to take in \`data\`.`);
+	/** One row landing: the source's path, the local path, and the delta a pointer there carried. */
+	const taking = [];
+	const folders = [];
+	const reused = [];
+	/** Every `kind:path` `take` has answered, whichever way, so the walk below visits each once. */
+	const seen = /* @__PURE__ */ new Set();
+	const folder = (kind, path) => {
+		if (!folders.some((f) => f.kind === kind && f.path === path)) folders.push({
+			kind,
+			path
+		});
+	};
+	/**
+	* Queue one entity of the source to land at `at`. Yours already — authored, a value you named over
+	* theirs, or borrowed through another pin — wins and is reused rather than copied, since copying is
+	* about this source's values and neither is one of them. `replace` writes theirs over a row of
+	* yours, and over a row held through another pin when the call named it; a row reached only through
+	* a ref stays that pin's, since the person pointed at what named it. A pointer through this pin is
+	* replaced by the literal it stood for.
+	*/
+	const take = ({ kind, theirs, at, named }) => {
+		const key = `${kind}:${at}`;
+		if (seen.has(key)) return { ok: true };
+		seen.add(key);
+		const held = config.resolve(kind, at);
+		if (held && held.borrowedFrom !== slug) {
+			const own = held.borrowedFrom === void 0;
+			if (input.onConflict !== "replace" || !own && !named) {
+				reused.push({
+					kind,
+					path: at
+				});
+				return { ok: true };
+			}
+			const fit = config.canBorrow({
+				kind,
+				path: theirs,
+				slug
+			});
+			if (!fit.ok) return fit;
+			const stored = config.storedBody(kind, at);
+			const minted = stored !== void 0 && isMintedRow(stored);
+			taking.push({
+				kind,
+				theirs,
+				at,
+				named,
+				...minted ? {} : { extend: {} },
+				overwrite: true
+			});
+			return { ok: true };
+		}
+		const fit = config.canBorrow({
+			kind,
+			path: theirs,
+			slug
+		});
+		if (!fit.ok) return fit;
+		const stored = held ? config.storedBody(kind, at) : void 0;
+		const extend = stored ? stored.extend : void 0;
+		taking.push({
+			kind,
+			theirs,
+			at,
+			named,
+			...stored ? { extend: extend ?? {} } : {}
+		});
+		return { ok: true };
+	};
+	/**
+	* Queue one of the source's files to land at the same path. A file is never linked, so one already
+	* here is this config's own: the same bytes are one file and are reused, different bytes are two
+	* files and the copy refuses rather than binding the copied render to code the source never wrote
+	* for it — unless the call asked to replace what is here.
+	*/
+	const takeFile = ({ path, component }) => {
+		const key = `file:${path}`;
+		if (seen.has(key)) return;
+		seen.add(key);
+		const mine = File.get(config, path);
+		if (!mine) {
+			taking.push({
+				kind: "file",
+				theirs: path,
+				at: path,
+				named: false
+			});
+			return;
+		}
+		if (mine.hash === File.get(source, path)?.hash) {
+			reused.push({
+				kind: "file",
+				path
+			});
+			return;
+		}
+		if (input.onConflict !== "replace") rejectData(`Cannot copy component "${component}" from "${slug}" — its code needs "${path}", and this system already holds a different file at that path. Pass \`onConflict: 'replace'\` to write the source's over it.`);
+		taking.push({
+			kind: "file",
+			theirs: path,
+			at: path,
+			named: false,
+			extend: {},
+			overwrite: true
+		});
+	};
+	for (const { kind, paths } of wanted) {
+		if (!kindBorrowable(config.entityOf(kind), {
+			config,
+			source
+		})) {
+			if (wholesale) continue;
+			rejectData(`Cannot copy ${kind} from "${slug}" — ${kind} is not borrowable. Its entries belong to the config that holds them, not to the system it draws on.`);
+		}
+		if (paths === "*") {
+			const entries = sourceEntries({
+				source,
+				kind,
+				path: "*"
+			});
+			if (entries.length === 0 && !wholesale) rejectData(`"${slug}" has no ${kind} entries to copy.`);
+			for (const { from: theirs, to: at } of entries) take({
+				kind,
+				theirs,
+				at,
+				named: true
+			});
+			for (const group of source.groups(kind)) folder(kind, group.path);
+			continue;
+		}
+		for (const from of paths) {
+			const isItem = source.resolve(kind, from) !== void 0;
+			if (!isItem && source.members(kind, from).length === 0) rejectData(`Cannot copy ${kind} "${from}" from "${slug}" — "${slug}" has no ${kind} "${from}".`);
+			for (const { from: theirs, to: at } of sourceEntries({
+				source,
+				kind,
+				path: from
+			})) {
+				const landed = take({
+					kind,
+					theirs,
+					at,
+					named: true
+				});
+				if (!landed.ok && isItem) rejectData(`Cannot copy ${kind} "${theirs}" from "${slug}" — ${landed.error}`);
+			}
+			if (!isItem) {
+				for (const group of source.groups(kind)) if (group.path === from || group.path.startsWith(`${from}/`)) folder(kind, group.path);
+			}
+		}
+	}
+	if (taking.length === 0 && wholesale) rejectData(`"${slug}" has nothing to copy.`);
+	for (let index = 0; index < taking.length; index++) {
+		const row = taking[index];
+		const body = source.resolve(row.kind, row.theirs)?.toJSON();
+		for (const target of collectRefs(body)) {
+			if (sourceOf(target) !== void 0) continue;
+			const depKind = kindOf(target);
+			const depPath = pathOf(target);
+			if (depPath === "" || !config.entityOf(depKind)) continue;
+			if (!kindBorrowable(config.entityOf(depKind), {
+				config,
+				source
+			})) continue;
+			if (source.resolve(depKind, depPath)) {
+				take({
+					kind: depKind,
+					theirs: depPath,
+					at: depPath,
+					named: false
+				});
+				continue;
+			}
+			const members = source.members(depKind, depPath);
+			if (members.length === 0) continue;
+			for (const member of members) take({
+				kind: depKind,
+				theirs: member.path,
+				at: member.path,
+				named: false
+			});
+			folder(depKind, depPath);
+		}
+		if (row.kind === "component") {
+			for (const sibling of renderImportedComponents({
+				source,
+				path: row.theirs
+			})) take({
+				kind: "component",
+				theirs: sibling,
+				at: sibling,
+				named: false
+			});
+			for (const path of renderSourceFiles({
+				source,
+				path: row.theirs
+			})) takeFile({
+				path,
+				component: row.theirs
+			});
+		}
+	}
+	const arriving = new Set([
+		...taking.map((row) => `${row.kind}:${row.at}`),
+		...reused.map((row) => `${row.kind}:${row.path}`),
+		...folders.map((folder) => `${folder.kind}:${folder.path}`)
+	]);
+	const patches = [];
+	for (const { kind, path } of folders) {
+		const meta = ownMeta(source.groups(kind).find((group) => group.path === path)?.meta ?? {});
+		const pointed = config.groupBorrowedFrom({
+			kind,
+			groupPath: path
+		}) === slug;
+		if (Object.keys(meta).length === 0 && !pointed) continue;
+		patches.push({
+			kind,
+			operation: "group-update",
+			path,
+			data: pointed ? {
+				...meta,
+				ref: null
+			} : meta
+		});
+	}
+	const rebound = [];
+	const landing = new Set(taking.map((row) => `${row.kind}:${row.at}`));
+	const respell = (from, to) => {
+		for (const referrer of config.refs.dependents(from)) {
+			const [kind, path] = splitRef(referrer).kind ? [kindOf(referrer), pathOf(referrer)] : [void 0, void 0];
+			if (!kind || !path || landing.has(referrer)) continue;
+			const body = config.storedBody(kind, path);
+			if (!body || isMintedRow(body)) continue;
+			const rewritten = rewriteRefs(body, from, to);
+			if (JSON.stringify(rewritten) === JSON.stringify(body)) continue;
+			rebound.push({
+				kind,
+				path
+			});
+			patches.push({
+				kind,
+				operation: "replace",
+				path,
+				data: rewritten
+			});
+		}
+	};
+	const ordered = dependenciesFirst({
+		taking,
+		source
+	});
+	for (const { kind, theirs, at, extend } of ordered) {
+		const body = config.copyOf({
+			slug,
+			kind,
+			path: theirs,
+			alongside: arriving,
+			extend
+		});
+		if (!body) continue;
+		const data = {
+			...body,
+			copiedFrom: `${theirs}@${slug}`
+		};
+		patches.push(extend === void 0 ? {
+			kind,
+			operation: "create",
+			path: at,
+			data
+		} : {
+			kind,
+			operation: "replace",
+			path: at,
+			data
+		});
+	}
+	for (const { kind, theirs, at } of taking) respell(`${kind}:${theirs}@${slug}`, `${kind}:${at}`);
+	for (const { kind, path } of folders) respell(`${kind}:${path}@${slug}`, `${kind}:${path}`);
+	const declared = declarationOf(config, slug);
+	if (declared !== void 0) {
+		const removal = /* @__PURE__ */ new Map();
+		for (const { kind, at, named } of taking) {
+			if (!named) continue;
+			const stored = config.storedBody(kind, at);
+			if (!stored || !isMintedRow(stored)) continue;
+			if (config.resolve(kind, at)?.borrowedFrom !== slug) continue;
+			const accessor = config.accessorOf(kind) ?? kind;
+			if (!covers({
+				declared,
+				accessor,
+				path: at
+			})) continue;
+			removal.set(accessor, [...removal.get(accessor) ?? [], at]);
+		}
+		if (removal.size > 0) {
+			const next = narrowDeclaration({
+				config,
+				slug,
+				current: declared,
+				removal,
+				verb: "copy"
+			});
+			patches.push({
+				kind: PIN_KIND,
+				operation: "update",
+				path: slug,
+				data: { link: next ?? null }
+			});
+		}
+	}
+	return {
+		rows: taking.map(({ kind, at, named, extend, overwrite }) => {
+			let status;
+			if (overwrite) status = "overwrite";
+			else if (extend === void 0) status = "create";
+			else status = "replace";
+			return {
+				kind,
+				path: at,
+				status,
+				named
+			};
+		}),
+		folders,
+		reused,
+		rebound,
+		patches
+	};
+}
+/** The rows to copy with each one's dependencies ahead of it, in a stable order otherwise. */
+function dependenciesFirst({ taking, source }) {
+	const byKey = new Map(taking.map((row) => [`${row.kind}:${row.theirs}`, row]));
+	const placed = /* @__PURE__ */ new Set();
+	const ordered = [];
+	const place = (row) => {
+		const key = `${row.kind}:${row.theirs}`;
+		if (placed.has(key)) return;
+		placed.add(key);
+		const body = source.resolve(row.kind, row.theirs)?.toJSON();
+		for (const target of collectRefs(body)) {
+			if (sourceOf(target) !== void 0) continue;
+			const depKind = kindOf(target);
+			const depPath = pathOf(target);
+			const item = byKey.get(`${depKind}:${depPath}`);
+			if (item) place(item);
+			for (const member of source.members(depKind, depPath)) {
+				const memberRow = byKey.get(`${depKind}:${member.path}`);
+				if (memberRow) place(memberRow);
+			}
+		}
+		ordered.push(row);
+	};
+	for (const row of taking) place(row);
+	return ordered;
+}
+//#endregion
+export { planCopy, sourceEntries };