@rebasepro/server 0.23.0 → 0.24.0

package/dist/api/rest/api-generator.d.ts

@@ -1,7 +1,32 @@
 import { Hono } from "hono";
 import { AuthAdapter, DataDriver, CollectionConfig } from "@rebasepro/types";
-import { HonoEnv } from "../types.js";
+import { QueryOptions, HonoEnv } from "../types.js";
 import { type ListLimitOptions } from "./query-parser.js";
+/**
+ * The row a single-row write addresses, as its route found it.
+ *
+ * `/comments/7` and `/posts/1/comments/7` address the same kind of row — a row
+ * of `comments` — two ways, and a write to it is one operation whichever way
+ * it arrived: the same body checks, the same `If-Match`, the same
+ * `Idempotency-Key`, the same answer. It was two pipelines, and the nested one
+ * re-listed two of the root's checks by hand and skipped the rest.
+ */
+export interface RowAddress {
+    /** The collection the row belongs to: what a body is checked against and an `ETag` computed for. */
+    collection: CollectionConfig;
+    /**
+     * The path the driver reads and writes at: the collection's own, or a
+     * nested one, which the driver resolves and scopes to its parent row.
+     */
+    path: string;
+    /**
+     * Handed to the driver beside `path`. Unset for a nested path, whose
+     * collection the driver resolves from the path itself.
+     */
+    driverCollection?: CollectionConfig;
+    /** What a 404 calls the address. */
+    name: string;
+}
 /**
  * Lightweight REST API generator that leverages existing Rebase DataDriver.
  * Supports `include` query parameter for eager-loading relations via Drizzle.
@@ -113,13 +138,16 @@ export declare class RestApiGenerator {
      */
     private createUnmatchedRoute;
     /**
-     * Check API key permissions for a collection operation.
-     * Throws 403 if the key doesn't have the required permission.
-     * No-ops if the request is not authenticated via an API key.
+     * Check a narrowed credential's data scope for a collection operation:
+     * `data:<operation>` on the collection, or unqualified.
+     *
+     * Throws 403 when it is missing. A person's own session holds the whole
+     * data plane — their rows are RLS's to decide — so this only ever refuses
+     * an API key or a token.
      */
     private enforceApiKeyPermission;
     /**
-     * API key permission check for nested paths.
+     * Data-scope check for nested paths.
      *
      * The operation lands on the collection the path addresses — the target
      * of its last relation — so that is the collection the key must hold the
@@ -260,7 +288,7 @@ export declare class RestApiGenerator {
      *   and a tag compared against a read that hides it compares against
      *   nothing.
      */
-    private rowForETag;
+    static rowForETag(driver: DataDriver, address: RowAddress, id: string, alreadyRead: Record<string, unknown> | undefined, withDeleted?: QueryOptions["withDeleted"]): Promise<Record<string, unknown> | undefined>;
     /**
      * `GET /:id`, at a row's own address or through a parent: the row as the
      * query asked for it, and the `ETag` naming its version.
@@ -272,7 +300,10 @@ export declare class RestApiGenerator {
      * relation was a 412. A narrowed read therefore takes its tag from
      * {@link rowForETag}, the read the write routes make.
      */
-    private readRow;
+    static readRow(driver: DataDriver, address: RowAddress, id: string, queryOptions: QueryOptions): Promise<{
+        row: Record<string, unknown>;
+        etag: string | undefined;
+    } | undefined>;
     /**
      * Answer a bulk write, honouring `Prefer: return=minimal`.
      *
@@ -344,13 +375,16 @@ export declare class RestApiGenerator {
      * @param collectionPath the path to read — a nested listing passes its own
      *   `parent/:id/child` path, which the driver resolves.
      */
-    private readPage;
+    static readPage(driver: DataDriver, collection: CollectionConfig, queryOptions: QueryOptions, searchString?: string, searchExplain?: boolean, collectionPath?: string): Promise<{
+        rows: Record<string, unknown>[];
+        meta: Record<string, unknown>;
+    }>;
     /**
      * Fetch raw collection data without Entity wrapper (fallback for non-Postgres)
      */
-    private fetchRawCollection;
+    static fetchRawCollection(driver: DataDriver, collection: CollectionConfig, queryOptions: QueryOptions, searchString?: string, searchExplain?: boolean, collectionPath?: string, startAfter?: Record<string, unknown>): Promise<Record<string, unknown>[]>;
     /**
      * Count raw entities for a collection
      */
-    private countRawEntities;
+    static countRawEntities(driver: DataDriver, collection: CollectionConfig, queryOptions: QueryOptions, searchString?: string, collectionPath?: string): Promise<number>;
 }

package/dist/api/rest/write-validation.d.ts

@@ -1,4 +1,4 @@
-import { CollectionConfig } from "@rebasepro/types";
+import { CollectionConfig, type IncludeSpec } from "@rebasepro/types";
 import { type FieldViewer } from "@rebasepro/common";
 /**
  * Refuse a write naming a field this caller may not set.
@@ -151,7 +151,7 @@ export declare function assertWriteValuesValid(values: Record<string, unknown>,
  * assuming one.
  */
 export declare function projectResponseFields<T extends Record<string, unknown>>(rows: T[], fields: readonly string[] | undefined, collection: CollectionConfig, options?: {
-    include?: readonly string[];
+    include?: IncludeSpec;
 }): T[];
 /**
  * Both write checks, as one call, for a transport that is not the REST router.

package/dist/api/types.d.ts

@@ -31,8 +31,24 @@ export type HonoEnv = {
          */
         recipientEmail?: string;
         driver?: DataDriver;
-        /** Set when the request is authenticated via a Service API Key. */
+        /** Set when the request is authenticated with an API key (`rk_`). */
         apiKey?: ApiKeyMasked;
+        /**
+         * What the caller may do, when its credential is narrower than its
+         * person — an API key or an MCP token. Absent for a person's own
+         * session, who holds what their roles hold. Read it through
+         * `callerScopes` / `hasScope`, which fill in that second case.
+         */
+        scopes?: string[];
+        /**
+         * Who asked, when an administrator's request runs as another user
+         * (`x-rebase-impersonate`). `user` and `driver` are then the
+         * impersonated user's; this is the only place the administrator
+         * remains. See `auth/impersonation.ts`.
+         */
+        impersonator?: {
+            uid: string;
+        };
         /** Unique request correlation ID (generated or propagated from X-Request-ID header). */
         requestId?: string;
         /**

package/dist/{ast-schema-editor-Mvr50v_S.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-vkcwKXbT.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}}`;
@@ -296,6 +352,7 @@ var AstSchemaEditor = class AstSchemaEditor {
 		else this.project.removeSourceFile(file);
 	}
 	async saveProperty(collectionId, propertyKey, propertyConfig) {
+		this.syncWithDisk();
 		try {
 			await this.writeProperty(collectionId, propertyKey, propertyConfig);
 		} catch (err) {
@@ -330,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);
@@ -356,6 +414,9 @@ 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) {
@@ -363,6 +424,180 @@ var AstSchemaEditor = class AstSchemaEditor {
 			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);
@@ -554,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-Mvr50v_S.js.map
+//# sourceMappingURL=ast-schema-editor-CWqS_sLJ.js.map