@rebasepro/server 0.22.0 → 0.24.0

package/dist/{ast-schema-editor-CslO8Oje.js → ast-schema-editor-CWqS_sLJ.js}

@@ -2,8 +2,8 @@ import { createRequire as __rebaseCreateRequire } from "module";
 import __rebaseProcess from "process";
 globalThis.process ??= __rebaseProcess;
 __rebaseCreateRequire(import.meta.url);
-import "./src-Br6ARbs6.js";
-import { i as nestAdminPropertyKeys, r as nestAdminCollectionKeys } from "./admin_block-DxKLmdiv.js";
+import "./src-CatHFUym.js";
+import { a as nestCollectionPatchPaths, l as nestAdminCollectionKeys, n as collectionPatchProblems, o as runtimeOnlyKeyIn, u as nestAdminPropertyKeys } from "./collection_patch-BRu-BvDv.js";
 import * as fs$1 from "fs";
 import * as path$1 from "path";
 import { IndentationText, Node, Project, SyntaxKind } from "ts-morph";
@@ -130,6 +130,26 @@ var AstSchemaEditor = class AstSchemaEditor {
 		if (!resolved.startsWith(this.collectionsDir + path$1.sep) && resolved !== this.collectionsDir) throw new Error("Path traversal detected: resolved path is outside the collections directory.");
 		return resolved;
 	}
+	/**
+	* Bring the in-memory project back in line with the disk.
+	*
+	* The source-only editor builds ONE of these at boot and serves every
+	* request with it, and ts-morph reads a file once and then trusts its
+	* copy. `project.save()` writes that copy back whole, so anything that
+	* reached the disk in between — the live editor's committed change (it
+	* builds a fresh editor per request), or the developer's own edit in the
+	* IDE — was overwritten by the boot-time copy plus this edit. In `rebase
+	* dev` the tsx-watch restart usually closed the window; outside watch mode
+	* the loss was permanent.
+	*
+	* Called at the top of every public method, so each edit applies to what
+	* is on disk now.
+	*/
+	syncWithDisk() {
+		for (const file of this.project.getSourceFiles()) if (!fs$1.existsSync(file.getFilePath())) this.project.removeSourceFile(file);
+		else file.refreshFromFileSystemSync();
+		if (fs$1.existsSync(this.collectionsDir)) this.project.addSourceFilesAtPaths(`${this.collectionsDir}/**/*.ts`);
+	}
 	getCollectionFile(collectionId) {
 		const safeId = this.sanitizeCollectionId(collectionId);
 		const filePath = this.safePath(`${safeId}.ts`);
@@ -212,6 +232,39 @@ var AstSchemaEditor = class AstSchemaEditor {
 	static isPlainObject(value) {
 		return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof RawExpression);
 	}
+	/**
+	* The field that identifies each element of an array of objects, so an
+	* old element can be found again in the new array.
+	*
+	* Arrays travel whole (see `collection_patch.ts`), and an element's
+	* position is not its identity — adding an entity action at the front
+	* shifts every other one. `key`, `id`, `relationName`, `name`: the first
+	* one every new element carries, distinct, wins.
+	*/
+	static identityField(items) {
+		for (const field of [
+			"key",
+			"id",
+			"relationName",
+			"name",
+			"slug"
+		]) {
+			const values = items.map((item) => AstSchemaEditor.isPlainObject(item) ? item[field] : void 0);
+			if (values.every((value) => typeof value === "string" || typeof value === "number") && new Set(values).size === values.length) return field;
+		}
+	}
+	/** The old array's object elements, keyed by `field`'s literal value. */
+	oldElementsBy(oldArray, field) {
+		const byKey = /* @__PURE__ */ new Map();
+		const array = oldArray.asKind(SyntaxKind.ArrayLiteralExpression);
+		for (const element of array?.getElements() ?? []) {
+			const object = element.asKind(SyntaxKind.ObjectLiteralExpression);
+			const value = object ? this.initializerOf(object, field) : void 0;
+			const literal = value?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue() ?? value?.asKind(SyntaxKind.NoSubstitutionTemplateLiteral)?.getLiteralValue() ?? value?.asKind(SyntaxKind.NumericLiteral)?.getText();
+			if (object && literal !== void 0) byKey.set(String(literal), object);
+		}
+		return byKey;
+	}
 	convertJsonToAstString(obj, indentLevel = 0, oldAstNode) {
 		const indentStr = "    ";
 		const indent = indentStr.repeat(indentLevel);
@@ -222,14 +275,17 @@ var AstSchemaEditor = class AstSchemaEditor {
 		if (typeof obj === "number" || typeof obj === "boolean") return String(obj);
 		if (Array.isArray(obj)) {
 			if (obj.length === 0) return "[]";
-			return `[\n${innerIndent}${obj.map((item) => this.convertJsonToAstString(item, indentLevel + 1)).join(`,\n${innerIndent}`)}\n${indent}]`;
+			const field = oldAstNode ? AstSchemaEditor.identityField(obj) : void 0;
+			const old = oldAstNode && field ? this.oldElementsBy(oldAstNode, field) : void 0;
+			return `[\n${innerIndent}${obj.map((item) => this.convertJsonToAstString(item, indentLevel + 1, old && field && AstSchemaEditor.isPlainObject(item) ? old.get(String(item[field])) : void 0)).join(`,\n${innerIndent}`)}\n${indent}]`;
 		}
 		if (typeof obj === "object") {
 			const record = obj;
 			const keys = Object.keys(record);
+			const oldObject = oldAstNode?.asKind(SyntaxKind.ObjectLiteralExpression);
 			const preservedProps = [];
-			if (oldAstNode) {
-				const oldProps = oldAstNode.getProperties();
+			if (oldObject) {
+				const oldProps = oldObject.getProperties();
 				for (const oldProp of oldProps) if (oldProp.isKind(SyntaxKind.PropertyAssignment)) {
 					let name = oldProp.getNameNode().getText();
 					if (name.startsWith("\"") && name.endsWith("\"")) name = name.slice(1, -1);
@@ -247,9 +303,9 @@ var AstSchemaEditor = class AstSchemaEditor {
 			return `{\n${innerIndent}${[...keys.map((key) => {
 				const keyStr = AstSchemaEditor.quoteKey(key);
 				let childAstNode;
-				if (oldAstNode && AstSchemaEditor.isPlainObject(record[key])) {
-					const oldProp = this.findProperty(oldAstNode, key);
-					if (oldProp && oldProp.isKind(SyntaxKind.PropertyAssignment)) childAstNode = oldProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+				if (oldObject && (AstSchemaEditor.isPlainObject(record[key]) || Array.isArray(record[key]))) {
+					const oldProp = this.findProperty(oldObject, key);
+					if (oldProp && oldProp.isKind(SyntaxKind.PropertyAssignment)) childAstNode = oldProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression) ?? oldProp.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression);
 				}
 				return `${keyStr}: ${this.convertJsonToAstString(record[key], indentLevel + 1, childAstNode)}`;
 			}), ...preservedProps].join(`,\n${innerIndent}`)}\n${indent}}`;
@@ -280,7 +336,31 @@ var AstSchemaEditor = class AstSchemaEditor {
 			});
 		}
 	}
+	/**
+	* Drop whatever a refused edit left in memory.
+	*
+	* One editor serves every request, and `project.save()` writes every file
+	* with unsaved changes. So an edit refused halfway through — a relation with
+	* no target, found after the name was already rewritten and an import
+	* added — reached the disk with the next save of some other collection, and
+	* a file refused as it was being created appeared anyway.
+	*/
+	forgetUnsaved(collectionId) {
+		const file = this.project.getSourceFile(path$1.resolve(this.collectionsDir, `${collectionId}.ts`));
+		if (!file || file.isSaved()) return;
+		if (fs$1.existsSync(file.getFilePath())) file.refreshFromFileSystemSync();
+		else this.project.removeSourceFile(file);
+	}
 	async saveProperty(collectionId, propertyKey, propertyConfig) {
+		this.syncWithDisk();
+		try {
+			await this.writeProperty(collectionId, propertyKey, propertyConfig);
+		} catch (err) {
+			this.forgetUnsaved(collectionId);
+			throw err;
+		}
+	}
+	async writeProperty(collectionId, propertyKey, propertyConfig) {
 		const collectionObj = this.requireCollectionObject(collectionId);
 		const nestedConfig = nestAdminPropertyKeys(propertyConfig);
 		let propertiesProp = collectionObj.getProperty("properties");
@@ -293,7 +373,8 @@ var AstSchemaEditor = class AstSchemaEditor {
 			const existingProp = this.findProperty(propsObj, propertyKey);
 			let oldPropAstNode;
 			if (existingProp && existingProp.isKind(SyntaxKind.PropertyAssignment)) oldPropAstNode = existingProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
-			const newInitializer = this.convertJsonToAstString(nestedConfig, 2, oldPropAstNode);
+			const withTargets = this.relationTargetsAsSource(collectionId, this.getCollectionFile(collectionId), { [propertyKey]: nestedConfig }, propsObj)[propertyKey];
+			const newInitializer = this.convertJsonToAstString(withTargets, 2, oldPropAstNode);
 			if (existingProp) {
 				if (existingProp.isKind(SyntaxKind.PropertyAssignment)) existingProp.setInitializer(newInitializer);
 			} else propsObj.addPropertyAssignment({
@@ -306,6 +387,7 @@ var AstSchemaEditor = class AstSchemaEditor {
 		}
 	}
 	async deleteProperty(collectionId, propertyKey) {
+		this.syncWithDisk();
 		const propertiesProp = this.requireCollectionObject(collectionId).getProperty("properties");
 		if (propertiesProp) {
 			const propsObj = propertiesProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
@@ -332,6 +414,191 @@ var AstSchemaEditor = class AstSchemaEditor {
 	* default, which in the scaffold is `access: "public"`.
 	*/
 	async saveCollection(collectionId, collectionData, options = {}) {
+		this.syncWithDisk();
+		const runtimeOnly = runtimeOnlyKeyIn(collectionData);
+		if (runtimeOnly) throw new Error(`Refusing to write "${collectionId}": it holds "${runtimeOnly}", which the runtime adds to a collection it has loaded and a collection file must not hold. Save what changed instead.`);
+		try {
+			await this.writeCollection(collectionId, collectionData, options);
+		} catch (err) {
+			this.forgetUnsaved(collectionId);
+			throw err;
+		}
+	}
+	/**
+	* Write what changed about a collection, and nothing else.
+	*
+	* The patch is the difference between the collection the panel loaded and
+	* the one it is saving (`diffCollections` in `@rebasepro/types`), so it
+	* names only keys the person changed. Each is written where it is; every
+	* other byte of the file — imports, comments, formatting, handlers,
+	* properties shared from another module — is left as it was.
+	*
+	* A key whose value in the file is code — `status: statusProperty`,
+	* `enum: LOCALE_ENUM`, a spread — is not overwritten with the JSON the
+	* panel saw of it, which is what the whole-collection save did. The edit
+	* is refused, naming the code, so it can be made where that code lives.
+	*
+	* All or nothing: a refused operation leaves the file as it was, including
+	* the operations before it.
+	*/
+	async applyPatch(collectionId, patch) {
+		this.syncWithDisk();
+		const problems = collectionPatchProblems(patch);
+		if (problems.length > 0) throw new Error(`Refusing to edit "${collectionId}": ${problems.join(" ")}`);
+		try {
+			await this.writePatch(collectionId, nestCollectionPatchPaths(patch));
+		} catch (err) {
+			this.forgetUnsaved(collectionId);
+			throw err;
+		}
+	}
+	async writePatch(collectionId, patch) {
+		this.requireCollectionObject(collectionId);
+		const file = this.getCollectionFile(collectionId);
+		for (const op of patch) this.applyPatchOp(collectionId, file, this.requireCollectionObject(collectionId), op);
+		await this.project.save();
+	}
+	applyPatchOp(collectionId, file, collectionObj, op) {
+		const { path: keys } = op;
+		const dotted = (end) => keys.slice(0, end).join(".");
+		let target = collectionObj;
+		for (let depth = 0; depth < keys.length - 1; depth++) {
+			const key = keys[depth];
+			const member = this.findMember(target, key);
+			if (!member) {
+				const spread = this.spreadIn(target);
+				if (spread) throw this.codeRefusal(collectionId, file, dotted(depth + 1), spread, "comes from");
+				if (op.op === "remove") return;
+				target = target.addPropertyAssignment({
+					name: AstSchemaEditor.quoteKey(key),
+					initializer: "{}"
+				}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+				continue;
+			}
+			const value = member.isKind(SyntaxKind.PropertyAssignment) ? AstSchemaEditor.unwrapExpression(member.getInitializer()) : void 0;
+			const next = value?.asKind(SyntaxKind.ObjectLiteralExpression);
+			if (!next) throw this.codeRefusal(collectionId, file, dotted(depth + 1), value ?? member, "is");
+			target = next;
+		}
+		const key = keys[keys.length - 1];
+		const member = this.findMember(target, key);
+		if (op.op === "remove") {
+			if (member) {
+				member.remove();
+				return;
+			}
+			const spread = this.spreadIn(target);
+			if (spread) throw this.codeRefusal(collectionId, file, dotted(keys.length), spread, "comes from");
+			return;
+		}
+		if (keys.length === 1 && key === "relations") {
+			this.writeRelations(collectionId, file, collectionObj, op.value);
+			this.findMember(collectionObj, "relations")?.formatText();
+			return;
+		}
+		const old = member?.isKind(SyntaxKind.PropertyAssignment) ? member.getInitializer() : void 0;
+		if (member && (!old || !AstSchemaEditor.isLiteralValue(old))) throw this.codeRefusal(collectionId, file, dotted(keys.length), old ?? member, "is");
+		if (old?.isKind(SyntaxKind.ArrayLiteralExpression)) {
+			const code = old.getElements().find((element) => !AstSchemaEditor.isLiteralValue(element));
+			if (code) throw this.codeRefusal(collectionId, file, dotted(keys.length), code, "holds");
+		}
+		const value = this.patchValueAsSource(collectionId, file, keys, op.value, old);
+		const text = this.convertJsonToAstString(value, 0, old);
+		(member?.isKind(SyntaxKind.PropertyAssignment) ? member.setInitializer(text) : target.addPropertyAssignment({
+			name: AstSchemaEditor.quoteKey(key),
+			initializer: text
+		})).formatText();
+	}
+	/**
+	* A patched value with every relation target it carries turned back into
+	* source — `() => xCollection` plus its import — according to where the
+	* path lands: a relation's `target`, a relation, a property, or a map of
+	* properties.
+	*/
+	patchValueAsSource(collectionId, file, keys, value, old) {
+		let position = "collection";
+		for (const key of keys) switch (position) {
+			case "collection":
+				position = key === "properties" ? "properties" : "other";
+				break;
+			case "properties":
+				position = "property";
+				break;
+			case "property":
+				position = key === "properties" ? "properties" : key === "of" ? "property" : key === "oneOf" ? "oneOf" : key === "relation" ? "relation" : "other";
+				break;
+			case "oneOf":
+				position = key === "properties" ? "properties" : "other";
+				break;
+			case "relation":
+				if (key === "target" && typeof value === "string" && value.trim().length > 0) {
+					const trimmed = value.trim();
+					return new RawExpression(ARROW_TO_IDENTIFIER.test(trimmed) ? trimmed : this.targetThunk(file, trimmed));
+				}
+				position = "other";
+				break;
+			default: position = "other";
+		}
+		const oldObject = old?.asKind(SyntaxKind.ObjectLiteralExpression);
+		const where = keys.join(".");
+		if (position === "property") return this.propertyRelationTargetsAsSource(collectionId, file, value, oldObject, where);
+		if (position === "properties") return this.relationTargetsAsSource(collectionId, file, value, oldObject, where);
+		if (position === "relation" && AstSchemaEditor.isPlainObject(value)) {
+			const wrapped = this.propertyRelationTargetsAsSource(collectionId, file, {
+				type: "relation",
+				relation: value
+			}, oldObject ? void 0 : void 0, where);
+			const relation = AstSchemaEditor.isPlainObject(wrapped) ? wrapped.relation : value;
+			if (AstSchemaEditor.isPlainObject(relation) && !("target" in relation) && !(oldObject && this.findProperty(oldObject, "target"))) throw new Error(`Relation "${where}" on collection "${collectionId}" has no target collection. Pick one before saving.`);
+			return relation;
+		}
+		return value;
+	}
+	/** A member of an object literal by name: an assignment, a shorthand, a method. */
+	findMember(obj, name) {
+		return obj.getProperties().find((member) => {
+			if (member.isKind(SyntaxKind.SpreadAssignment)) return false;
+			const memberName = member.getName();
+			return memberName === name || memberName === JSON.stringify(name) || memberName === `'${name}'`;
+		});
+	}
+	spreadIn(obj) {
+		return obj.getProperties().find((member) => member.isKind(SyntaxKind.SpreadAssignment));
+	}
+	/** `x as const`, `x satisfies T`, `(x)` — the value inside. */
+	static unwrapExpression(node) {
+		if (!node) return void 0;
+		if (Node.isAsExpression(node) || Node.isSatisfiesExpression(node) || Node.isParenthesizedExpression(node)) return AstSchemaEditor.unwrapExpression(node.getExpression());
+		return node;
+	}
+	/**
+	* Whether a value in the file is data the panel's JSON fully describes —
+	* a literal — rather than code it saw only the result of.
+	*/
+	static isLiteralValue(node) {
+		const value = AstSchemaEditor.unwrapExpression(node);
+		if (!value) return false;
+		switch (value.getKind()) {
+			case SyntaxKind.ObjectLiteralExpression:
+			case SyntaxKind.ArrayLiteralExpression:
+			case SyntaxKind.StringLiteral:
+			case SyntaxKind.NoSubstitutionTemplateLiteral:
+			case SyntaxKind.NumericLiteral:
+			case SyntaxKind.TrueKeyword:
+			case SyntaxKind.FalseKeyword:
+			case SyntaxKind.NullKeyword: return true;
+			case SyntaxKind.PrefixUnaryExpression: return value.asKindOrThrow(SyntaxKind.PrefixUnaryExpression).getOperand().isKind(SyntaxKind.NumericLiteral);
+			case SyntaxKind.Identifier: return value.getText() === "undefined";
+			default: return false;
+		}
+	}
+	/** "`properties.status` is `statusProperty` in posts.ts…" */
+	codeRefusal(collectionId, file, where, code, verb) {
+		const text = code.getText();
+		const shown = text.length > 60 ? `${text.slice(0, 57)}…` : text;
+		return /* @__PURE__ */ new Error(`\`${where}\` ${verb} \`${shown}\` in ${path$1.basename(file.getFilePath())}, which is code the editor cannot change without losing what it does. Change "${collectionId}" there instead.`);
+	}
+	async writeCollection(collectionId, collectionData, options) {
 		const partial = options.partial === true;
 		let file = this.getCollectionFile(collectionId);
 		const collectionObj = file ? this.getCollectionObject(collectionId) : null;
@@ -342,7 +609,14 @@ var AstSchemaEditor = class AstSchemaEditor {
 			const newFilePath = this.safePath(`${safeId}.ts`);
 			if (fs$1.existsSync(newFilePath)) throw new Error(`Refusing to overwrite ${newFilePath}: a file for "${collectionId}" already exists but could not be parsed.`);
 			const varName = `${AstSchemaEditor.collectionVarName(safeId)}Collection`;
-			file = this.project.createSourceFile(newFilePath, `import { CollectionConfig } from "@rebasepro/types";\n\nconst ${varName}: CollectionConfig = ${this.convertJsonToAstString(nestAdminKeysDeep(collectionData))};\n\nexport default ${varName};\n`);
+			file = this.project.createSourceFile(newFilePath, `import { CollectionConfig } from "@rebasepro/types";\n\nconst ${varName}: CollectionConfig = {};\n\nexport default ${varName};\n`);
+			const { relations, ...rest } = nestAdminKeysDeep(collectionData);
+			const data = "properties" in rest ? {
+				...rest,
+				properties: this.relationTargetsAsSource(collectionId, file, rest.properties, void 0)
+			} : rest;
+			file.getVariableDeclarationOrThrow(varName).setInitializer(this.convertJsonToAstString(data));
+			if (relations !== void 0) this.writeRelations(collectionId, file, this.requireCollectionObject(collectionId), relations);
 		} else {
 			if (!partial) {
 				if (!("securityRules" in collectionData) || collectionData.securityRules === void 0 || Array.isArray(collectionData.securityRules) && collectionData.securityRules.length === 0) {
@@ -360,6 +634,7 @@ var AstSchemaEditor = class AstSchemaEditor {
 				const prop = collectionObj.getProperty(key);
 				let oldAstNode;
 				if (prop && prop.isKind(SyntaxKind.PropertyAssignment)) oldAstNode = prop.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+				if (key === "properties") collectionData[key] = this.relationTargetsAsSource(collectionId, file, collectionData[key], oldAstNode);
 				if (partial && oldAstNode && AstSchemaEditor.isPlainObject(collectionData[key])) {
 					this.mergeIntoObjectLiteral(oldAstNode, collectionData[key], 2);
 					continue;
@@ -376,6 +651,66 @@ var AstSchemaEditor = class AstSchemaEditor {
 		await this.project.save();
 	}
 	/**
+	* Every property relation's `target`, as source.
+	*
+	* The collection-level `relations` array has {@link writeRelations}. A
+	* relation declared on a property went through `convertJsonToAstString`
+	* like any other value, so a target the property form had picked — a slug,
+	* which is all JSON can carry — was written as the string literal
+	* `target: "authors"`, and the next boot threw in `resolveRelation` for every
+	* collection in the directory. The same rule applies here as there: a slug
+	* becomes `() => xCollection` plus its import, an arrow returning one
+	* identifier is written through, and a relation sent without a target keeps
+	* the one already in the file — or is refused, when there is none.
+	*
+	* Walks into `map` properties, an array's `of` and a block's `oneOf`, which
+	* the registry resolves relations in too. `oldProperties` is the same
+	* properties object in the file, when there is one.
+	*/
+	relationTargetsAsSource(collectionId, file, properties, oldProperties, path = "properties") {
+		if (!AstSchemaEditor.isPlainObject(properties)) return {};
+		return Object.fromEntries(Object.entries(properties).map(([key, property]) => [key, this.propertyRelationTargetsAsSource(collectionId, file, property, oldProperties ? this.objectAt(oldProperties, key) : void 0, `${path}.${key}`)]));
+	}
+	propertyRelationTargetsAsSource(collectionId, file, property, oldProperty, path) {
+		if (!AstSchemaEditor.isPlainObject(property)) return property;
+		const next = { ...property };
+		if (property.type === "relation" && AstSchemaEditor.isPlainObject(property.relation)) {
+			const relation = { ...property.relation };
+			const rawTarget = relation.target;
+			if (typeof rawTarget === "string" && rawTarget.trim().length > 0) {
+				const trimmed = rawTarget.trim();
+				relation.target = new RawExpression(ARROW_TO_IDENTIFIER.test(trimmed) ? trimmed : this.targetThunk(file, trimmed));
+			} else {
+				const oldRelation = oldProperty ? this.objectAt(oldProperty, "relation") : void 0;
+				if (!oldRelation || !this.findProperty(oldRelation, "target")) throw new Error(`Relation property "${path}" on collection "${collectionId}" has no target collection. Pick one before saving.`);
+				delete relation.target;
+			}
+			next.relation = relation;
+		}
+		if (AstSchemaEditor.isPlainObject(property.properties)) next.properties = this.relationTargetsAsSource(collectionId, file, property.properties, oldProperty ? this.objectAt(oldProperty, "properties") : void 0, path);
+		if (Array.isArray(property.of)) {
+			const oldOf = oldProperty ? this.initializerOf(oldProperty, "of")?.asKind(SyntaxKind.ArrayLiteralExpression) : void 0;
+			next.of = property.of.map((item, index) => this.propertyRelationTargetsAsSource(collectionId, file, item, oldOf?.getElements()[index]?.asKind(SyntaxKind.ObjectLiteralExpression), `${path}.of[${index}]`));
+		} else if (AstSchemaEditor.isPlainObject(property.of)) next.of = this.propertyRelationTargetsAsSource(collectionId, file, property.of, oldProperty ? this.objectAt(oldProperty, "of") : void 0, `${path}.of`);
+		if (AstSchemaEditor.isPlainObject(property.oneOf) && AstSchemaEditor.isPlainObject(property.oneOf.properties)) {
+			const oldOneOf = oldProperty ? this.objectAt(oldProperty, "oneOf") : void 0;
+			next.oneOf = {
+				...property.oneOf,
+				properties: this.relationTargetsAsSource(collectionId, file, property.oneOf.properties, oldOneOf ? this.objectAt(oldOneOf, "properties") : void 0, `${path}.oneOf`)
+			};
+		}
+		return next;
+	}
+	/** The initializer of `obj[key]` in the file, when it is written as a property assignment. */
+	initializerOf(obj, key) {
+		const prop = this.findProperty(obj, key);
+		return prop && prop.isKind(SyntaxKind.PropertyAssignment) ? prop.getInitializer() : void 0;
+	}
+	/** `obj[key]` in the file, when it is an object literal. */
+	objectAt(obj, key) {
+		return this.initializerOf(obj, key)?.asKind(SyntaxKind.ObjectLiteralExpression);
+	}
+	/**
 	* Write the collection-level `relations` array.
 	*
 	* Relations are the one key whose values are not all data: `target` is a
@@ -454,12 +789,75 @@ var AstSchemaEditor = class AstSchemaEditor {
 		if (expr && expr.getKind() === SyntaxKind.Identifier) return expr.getText();
 		for (const varDecl of file.getVariableDeclarations()) if (this.unwrapCollectionObject(varDecl.getInitializer())) return varDecl.getName();
 	}
+	/**
+	* Delete a collection's file, and take it out of `index.ts`.
+	*
+	* This used to unlink `<slug>.ts` and stop. Every scaffold's `index.ts`
+	* imports every collection, so the next boot failed for the whole project
+	* ("Cannot find module …/tags"), and a collection another one linked to
+	* took that one down with it. Now:
+	*
+	* - a file any other module imports is refused, naming the importers — a
+	*   relation to it has to go first, and that is a change the person makes;
+	* - `index.ts`'s import of it is removed, and so is each place it is listed
+	*   in an array; any other use there is refused, naming the line;
+	* - the file is deleted.
+	*
+	* Only the source. The table and its rows are not touched.
+	*
+	* Returns what changed, as absolute paths, so the caller can commit it.
+	*/
 	async deleteCollection(collectionId) {
-		const file = this.getCollectionFile(collectionId);
-		if (file) file.deleteImmediatelySync();
+		this.syncWithDisk();
+		const target = this.getCollectionFile(collectionId);
+		if (!target) throw new Error(`Collection "${collectionId}" has no file at ${path$1.join(this.collectionsDir, `${collectionId}.ts`)}.`);
+		const targetPath = target.getFilePath();
+		const indexPath = path$1.join(this.collectionsDir, "index.ts");
+		const importers = this.project.getSourceFiles().filter((file) => file !== target && this.declarationsOf(file, targetPath).length > 0);
+		const others = importers.filter((file) => file.getFilePath() !== indexPath);
+		if (others.length > 0) throw new Error(`Cannot delete "${collectionId}": ${others.map((file) => path$1.basename(file.getFilePath())).join(", ")} ${others.length === 1 ? "imports" : "import"} it — a relation to it, most likely. Remove that first; deleting the file would stop every collection from loading.`);
+		const changed = [];
+		const index = importers.find((file) => file.getFilePath() === indexPath);
+		try {
+			if (index) {
+				for (const declaration of this.declarationsOf(index, targetPath)) {
+					const names = declaration.isKind(SyntaxKind.ImportDeclaration) ? [declaration.getDefaultImport()?.getText(), ...declaration.getNamedImports().map((named) => (named.getAliasNode() ?? named.getNameNode()).getText())].filter((name) => Boolean(name)) : [];
+					for (const name of names) {
+						const uses = index.getDescendantsOfKind(SyntaxKind.Identifier).filter((identifier) => identifier.getText() === name && !identifier.getFirstAncestorByKind(SyntaxKind.ImportDeclaration));
+						for (const use of uses) {
+							const array = use.getParentIfKind(SyntaxKind.ArrayLiteralExpression);
+							if (!array) throw new Error(`Cannot delete "${collectionId}": index.ts uses \`${name}\` at line ${use.getStartLineNumber()} in a way the editor cannot remove. Remove it there first.`);
+							array.removeElement(use);
+						}
+					}
+					declaration.remove();
+				}
+				changed.push(index.getFilePath());
+			}
+			target.delete();
+			await this.project.save();
+		} catch (err) {
+			if (index && !index.isSaved()) index.refreshFromFileSystemSync();
+			this.syncWithDisk();
+			throw err;
+		}
+		return {
+			deleted: targetPath,
+			changed
+		};
+	}
+	/** The import and export declarations in `file` whose relative specifier resolves to `targetPath`. */
+	declarationsOf(file, targetPath) {
+		const stem = (absolute) => absolute.replace(/\.(ts|tsx|js|mjs|cjs)$/, "");
+		const target = stem(targetPath);
+		return [...file.getImportDeclarations(), ...file.getExportDeclarations()].filter((declaration) => {
+			const specifier = declaration.getModuleSpecifierValue();
+			if (!specifier || !specifier.startsWith(".")) return false;
+			return stem(path$1.resolve(path$1.dirname(file.getFilePath()), specifier)) === target;
+		});
 	}
 };
 //#endregion
 export { AstSchemaEditor };
 
-//# sourceMappingURL=ast-schema-editor-CslO8Oje.js.map
+//# sourceMappingURL=ast-schema-editor-CWqS_sLJ.js.map