@happyvertical/smrt-core 0.40.70 → 0.41.0

package/dist/cascade.d.ts

@@ -0,0 +1,120 @@
+import { DatabaseInterface } from '@happyvertical/sql';
+import { ObjectRegistry } from './registry.js';
+/**
+ * Referential action applied to rows pointing at a deleted object.
+ *
+ * Same vocabulary as SQL's `ON DELETE`, enforced by the framework instead of
+ * the engine. `NO ACTION` means "leave the rows alone" — SMRT emits no
+ * constraint, so nothing raises.
+ */
+export type OnDeleteAction = 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+/** One reference that must be resolved before the target row can be removed. */
+export interface CascadeReference {
+    /** Registered name of the class holding the referencing column. */
+    className: string;
+    /** Table holding the referencing rows. */
+    tableName: string;
+    /** Field name (camelCase) on the referencing class. */
+    fieldName: string;
+    /** Column (snake_case) holding the reference. */
+    column: string;
+    /** Resolved action, never `NO ACTION` (those are dropped from the plan). */
+    action: Exclude<OnDeleteAction, 'NO ACTION'>;
+    /** `true` when the action was declared rather than derived from the key. */
+    declared: boolean;
+}
+/** A polymorphic association table that can point at any class. */
+export interface CascadePolymorphicReference {
+    /** Registered name of the association class. */
+    className: string;
+    /** Table holding the association rows. */
+    tableName: string;
+}
+/** Everything that must happen before rows of one class can be deleted. */
+export interface CascadePlan {
+    /** Typed `@foreignKey` / `@crossPackageRef` references, action-resolved. */
+    references: CascadeReference[];
+    /** Polymorphic association tables that may point at this class. */
+    polymorphic: CascadePolymorphicReference[];
+    /** `meta_type` values that identify this class in an association row. */
+    metaTypes: string[];
+    /** `true` when nothing references this class and nothing has to be visited. */
+    isEmpty: boolean;
+}
+/**
+ * Read-only slice of `ObjectRegistry` this module needs.
+ *
+ * Taking it as a parameter — rather than importing the registry as a value —
+ * keeps `cascade.ts` out of the `registry → object → cascade` import cycle,
+ * and lets tests drive the planner from a hand-built registry.
+ */
+export type CascadeRegistryView = Pick<typeof ObjectRegistry, 'getRelationshipMap' | 'getFields' | 'getConflictColumns' | 'getTableName' | 'getSelfReferableNames' | 'getClass' | 'getSTIBase' | 'getDescendants'>;
+/**
+ * Normalize a declared `onDelete` value.
+ *
+ * Accepts any casing and both `SET NULL` and `SET_NULL`, matching what the
+ * schema generator has always carried in the manifest. Returns `undefined` for
+ * an unset or unrecognized value so the caller can fall back to the default.
+ */
+export declare function normalizeOnDelete(value: unknown): OnDeleteAction | undefined;
+/**
+ * Build the cascade plan for one class.
+ *
+ * The plan is derived entirely from registry metadata, so it is valid for any
+ * database the class is used against. It is rebuilt per delete rather than
+ * cached: registration is incremental (manifests load lazily, tests register
+ * classes between cases) and a stale plan would silently skip a table.
+ *
+ * @param registry - Registry view (`ObjectRegistry` satisfies it)
+ * @param className - Class whose incoming references should be resolved
+ */
+export declare function buildCascadePlan(registry: CascadeRegistryView, className: string): CascadePlan;
+/** Outcome of a cascade run, returned so the caller can invalidate caches. */
+export interface CascadeResult {
+    /** Tables whose rows were removed or nulled, excluding the target's own. */
+    affectedTables: Set<string>;
+    /**
+     * Qualified class name that owns each entry in {@link affectedTables},
+     * where resolvable — lets the caller check *that* class's own
+     * cross-process cache config rather than only its own.
+     */
+    affectedTableClasses: Map<string, string>;
+}
+/**
+ * Resolve every reference to `ids` of `className` and clean their framework
+ * side rows, then hand control back so the caller can delete the rows.
+ *
+ * Callers are expected to run this on a transaction-bound `db` — see
+ * {@link runCascadeDelete}, which owns that decision.
+ */
+export declare function cascadeReferencesTo(db: DatabaseInterface, registry: CascadeRegistryView, target: {
+    className: string;
+    tableName: string;
+    ids: string[];
+}): Promise<CascadeResult>;
+/**
+ * Run the cascade and the target row's own deletion atomically.
+ *
+ * When anything references the class and the adapter exposes `transaction()`,
+ * the whole sequence runs inside one — including the caller's `deleteSelf`
+ * statement, so a failure part-way through cannot leave the object deleted with
+ * its junction rows intact (or vice versa). Adapters without transaction
+ * support run the same statements sequentially; this is the documented
+ * degradation, not a silent one.
+ *
+ * When nothing references the class there is nothing to keep consistent, and
+ * the transaction is skipped — see the comment on that branch.
+ *
+ * @param db - Database the object is bound to
+ * @param registry - Registry view used to build cascade plans
+ * @param target - Class, table and id of the object being deleted
+ * @param deleteSelf - Issues the target row's own `DELETE`, on the tx-bound db
+ * @returns Tables affected by the cascade, for read-cache invalidation
+ */
+export declare function runCascadeDelete(db: DatabaseInterface, registry: CascadeRegistryView, target: {
+    className: string;
+    tableName: string;
+    /** An unsaved object has none; the cascade is then a no-op. */
+    id: string | null | undefined;
+}, deleteSelf: (db: DatabaseInterface) => Promise<void>): Promise<CascadeResult>;
+//# sourceMappingURL=cascade.d.ts.map

package/dist/cascade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cascade.d.ts","sourceRoot":"","sources":["../src/cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAK5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAMpD;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;AAsB/E,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,MAAM,EAAE,OAAO,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;IAC7C,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,mEAAmE;AACnE,MAAM,WAAW,2BAA2B;IAC1C,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,2EAA2E;AAC3E,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,mEAAmE;IACnE,WAAW,EAAE,2BAA2B,EAAE,CAAC;IAC3C,yEAAyE;IACzE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,IAAI,CACpC,OAAO,cAAc,EACnB,oBAAoB,GACpB,WAAW,GACX,oBAAoB,GACpB,cAAc,GACd,uBAAuB,GACvB,UAAU,GACV,YAAY,GACZ,gBAAgB,CACnB,CAAC;AASF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAM5E;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,mBAAmB,EAC7B,SAAS,EAAE,MAAM,GAChB,WAAW,CAwHb;AA8UD,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;OAIG;IACH,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,iBAAiB,EACrB,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,GAC9D,OAAO,CAAC,aAAa,CAAC,CAwBxB;AASD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,iBAAiB,EACrB,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE;IACN,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC/B,EACD,UAAU,EAAE,CAAC,EAAE,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,GACnD,OAAO,CAAC,aAAa,CAAC,CAgDxB"}

package/dist/cascade.js

@@ -0,0 +1,430 @@
+import { classifyDatabaseError } from "./db-errors.js";
+import { ConfigurationError, DatabaseError } from "./errors.js";
+import { chunkArray } from "./utils/chunk.js";
+import { toSnakeCase } from "./utils/naming.js";
+import { createLogger } from "@happyvertical/logger";
+//#region src/cascade.ts
+/**
+* App-side referential integrity for `SmrtObject.delete()` (#2371).
+*
+* SMRT emits **no** DB-level `FOREIGN KEY` constraints on any engine, so the
+* database will never clean up after a deleted row. Before this module,
+* `delete()` removed the object's own row and nothing else: junction rows,
+* polymorphic association rows, `_smrt_embeddings` and `_smrt_contexts` entries
+* were all left pointing at an id that no longer resolved, and
+* `@foreignKey(..., { onDelete })` was metadata nobody read.
+*
+* This module implements those semantics in the application layer. It mirrors
+* what a DB-level constraint would do, deliberately including the parts that
+* make it *unlike* a model-layer delete:
+*
+* - Cascaded rows are removed with set-based statements. Their `beforeDelete` /
+*   `afterDelete` hooks and interceptors do **not** run, and no change-feed
+*   tombstone is written for them — exactly as `ON DELETE CASCADE` behaves.
+*   Only the object `delete()` was called on runs the full lifecycle.
+* - When anything needs cascading, everything runs inside a single
+*   transaction when the adapter exposes one, so a partial cascade cannot
+*   survive a failure. A class with no typed references AND no registered
+*   polymorphic association class anywhere in the process skips the
+*   transaction — see {@link runCascadeDelete}. A `metaType` column can point
+*   at any class at runtime, so a polymorphic association class is always
+*   plausibly relevant; in an app with even one registered, this fast path is
+*   rare, not the common case.
+*
+* ## Which references are followed
+*
+* A reference is any `@foreignKey` / `@crossPackageRef` field on a registered
+* class whose target resolves to the deleted object's class (or one of its
+* registered STI ancestors), plus the polymorphic `(metaType, metaId)` pair on
+* {@link SmrtPolymorphicAssociation} subclasses.
+*
+* The action comes from the field's declared `onDelete`. When it is not
+* declared, the default is derived from the referencing class's natural key:
+*
+* | Reference | Default when `onDelete` is absent |
+* |---|---|
+* | Column is part of the referencing class's `conflictColumns`, and is not a `@tenantId()` field | `CASCADE` |
+* | Polymorphic `(metaType, metaId)` association row | `CASCADE` |
+* | Anything else, including every `@tenantId()` field | `NO ACTION` (legacy behaviour — the row is left alone) |
+*
+* The natural-key rule is what makes junction rows work without any
+* per-package annotation: a junction declares
+* `@smrt({ conflictColumns: ['content_id', 'asset_id', 'relationship'] })`, so
+* `content_id` identifies the row and the row cannot outlive the content it
+* links. An ordinary child (`Order.customerId`) is keyed by `(slug, context)`,
+* so it keeps today's behaviour unless it opts in with
+* `@foreignKey(Customer, { onDelete: 'CASCADE' })`.
+*
+* `@tenantId()` fields are excluded from the natural-key rule even though
+* `@happyvertical/smrt-tenancy` leads a tenant-scoped class's *default*
+* `conflictColumns` with the tenant column (#2360): the tenant column scopes
+* ownership, it does not identify the row the way a junction's foreign key
+* does, and it targets a class (`Tenant`) that is virtually always
+* referenced. Without this exclusion, deleting one `Tenant` row would
+* recursively CASCADE through every tenant-scoped table that has not
+* declared its own `conflictColumns` — the overwhelming majority. The field
+* is detected via the `__tenancy.isTenantIdField` marker `@tenantId()`
+* attaches to its own registration (`FieldMeta.__tenancy`, read structurally
+* so `smrt-core` never depends on `smrt-tenancy`). `@tenantId()` exposes no
+* `onDelete` option today, so this cannot currently be overridden per field.
+*
+* @see https://github.com/happyvertical/smrt/issues/2371
+* @module
+*/
+var logger = createLogger({ level: "info" });
+/** Table holding framework-managed per-object memory entries. */
+var CONTEXTS_TABLE = "_smrt_contexts";
+/** Table holding framework-managed per-object embedding vectors. */
+var EMBEDDINGS_TABLE = "_smrt_embeddings";
+/**
+* Reserved `_smrt_contexts.owner_id` used by `SmrtCollection.remember()` for
+* collection-scoped memory. A real object id is a UUID and can never equal it,
+* but the guard keeps a malformed id from wiping every sibling's defaults.
+*/
+var COLLECTION_OWNER_SENTINEL = "__collection__";
+/**
+* Maximum number of cascade levels followed from the object `delete()` was
+* called on. A cycle between two classes that both declare `onDelete: 'CASCADE'`
+* is broken by the visited set; this bound catches unbounded *chains*.
+*/
+var MAX_CASCADE_DEPTH = 10;
+var CASCADE_ACTIONS = /* @__PURE__ */ new Set([
+	"CASCADE",
+	"SET NULL",
+	"RESTRICT",
+	"NO ACTION"
+]);
+/**
+* Normalize a declared `onDelete` value.
+*
+* Accepts any casing and both `SET NULL` and `SET_NULL`, matching what the
+* schema generator has always carried in the manifest. Returns `undefined` for
+* an unset or unrecognized value so the caller can fall back to the default.
+*/
+function normalizeOnDelete(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim().toUpperCase().replace(/_/g, " ");
+	return CASCADE_ACTIONS.has(normalized) ? normalized : void 0;
+}
+function isPolymorphicAssociationClass(fields) {
+	return fields.has("metaType") && fields.has("metaId") && fields.has("role");
+}
+/**
+* Build the cascade plan for one class.
+*
+* The plan is derived entirely from registry metadata, so it is valid for any
+* database the class is used against. It is rebuilt per delete rather than
+* cached: registration is incremental (manifests load lazily, tests register
+* classes between cases) and a stale plan would silently skip a table.
+*
+* @param registry - Registry view (`ObjectRegistry` satisfies it)
+* @param className - Class whose incoming references should be resolved
+*/
+function buildCascadePlan(registry, className) {
+	const targetNames = new Set(registry.getSelfReferableNames(className));
+	for (const name of [...targetNames]) {
+		const qualified = registry.getClass(name)?.qualifiedName;
+		if (qualified) targetNames.add(qualified);
+	}
+	const references = [];
+	const polymorphic = [];
+	for (const [sourceClass, relationships] of registry.getRelationshipMap()) {
+		const fields = registry.getFields(sourceClass);
+		if (isPolymorphicAssociationClass(fields)) {
+			const tableName = registry.getTableName(sourceClass);
+			if (tableName) polymorphic.push({
+				className: sourceClass,
+				tableName
+			});
+		}
+		if (relationships.length === 0) continue;
+		let conflictColumns;
+		for (const relationship of relationships) {
+			if (relationship.type !== "foreignKey" && relationship.type !== "crossPackageRef") continue;
+			if (!targetNames.has(relationship.targetClass)) continue;
+			const tableName = registry.getTableName(sourceClass);
+			if (!tableName) continue;
+			const column = toSnakeCase(relationship.fieldName);
+			const declaredAction = normalizeOnDelete(relationship.options?.onDelete);
+			if (!conflictColumns) conflictColumns = new Set(registry.getConflictColumns(sourceClass));
+			const isTenantIdField = relationship.options?.__tenancy?.isTenantIdField === true;
+			const action = declaredAction ?? (!isTenantIdField && conflictColumns.has(column) ? "CASCADE" : "NO ACTION");
+			if (action === "NO ACTION") continue;
+			if (action === "SET NULL" && fields.get(relationship.fieldName)?.required) throw ConfigurationError.invalidConfiguration(`${sourceClass}.${relationship.fieldName} onDelete: 'SET NULL'`, relationship.fieldName, "a nullable field (mark it `nullable: true`, or use 'CASCADE' / 'RESTRICT')");
+			references.push({
+				className: sourceClass,
+				tableName,
+				fieldName: relationship.fieldName,
+				column,
+				action,
+				declared: declaredAction !== void 0
+			});
+		}
+	}
+	const metaTypes = [];
+	const qualified = registry.getClass(className)?.qualifiedName;
+	if (qualified) metaTypes.push(qualified);
+	const simple = registry.getClass(className)?.name ?? className;
+	if (!metaTypes.includes(simple)) metaTypes.push(simple);
+	return {
+		references,
+		polymorphic,
+		metaTypes,
+		isEmpty: references.length === 0 && polymorphic.length === 0
+	};
+}
+/** Resolve a registry-recorded class name to its qualified form, when known. */
+function toQualifiedClassName(registry, className) {
+	return registry.getClass(className)?.qualifiedName ?? className;
+}
+/**
+* Every value `_smrt_contexts.owner_class` / `_smrt_embeddings.object_class`
+* could plausibly hold for a row belonging to an id of `className` (review
+* fix): both name forms (qualified + simple — older rows predate package
+* qualification) of `className` itself, plus every other member of its STI
+* hierarchy sharing its table. A CASCADE-collected id can belong to any
+* concrete STI subclass of the declaring reference, which stamps its own
+* (more specific) runtime class name at write time, not the reference's.
+*
+* Narrowing by this set — instead of matching by id alone — closes a
+* cross-class collision: two unrelated classes using `idType: 'text'`
+* (non-UUID, not guaranteed globally unique) could otherwise share an id
+* value and have one's `remember()`/embeddings rows deleted by the other's
+* cascade.
+*/
+function ownerClassCandidates(registry, className) {
+	const stiBase = registry.getSTIBase(className) ?? className;
+	const members = /* @__PURE__ */ new Set([
+		className,
+		stiBase,
+		...registry.getDescendants(stiBase)
+	]);
+	const names = /* @__PURE__ */ new Set();
+	for (const member of members) {
+		names.add(member);
+		const registered = registry.getClass(member);
+		if (registered?.qualifiedName) names.add(registered.qualifiedName);
+		if (registered?.name) names.add(registered.name);
+	}
+	return [...names];
+}
+/**
+* Build the `where` clause matching `column` against one or more ids.
+*
+* A single id uses equality so the planner can use a plain index; multiple ids
+* use the adapter's `in` operator.
+*/
+function idPredicate(column, ids) {
+	return ids.length === 1 ? { [column]: ids[0] } : { [`${column} in`]: ids };
+}
+/**
+* Run a cascade statement against a *referencing* table, tolerating the
+* table (or an expected column) not existing in this database.
+*
+* The cascade plan is built from the in-process registry, which can carry a
+* class from any imported package — including one whose table this specific
+* database was never migrated to include (a partially adopted feature, a
+* package pulled in for its types, or, in a test process, a fixture some
+* other test file registered). A missing referencing table trivially has no
+* rows to act on, so the correct behaviour is identical to the table
+* existing and being empty — this must never abort an otherwise valid
+* delete. Any other failure (a real constraint violation, a lock timeout, a
+* genuine SQL error unrelated to the table's existence) still propagates.
+*/
+async function tolerateMissingTable(operation, fallback, context) {
+	try {
+		return await operation();
+	} catch (error) {
+		if (classifyDatabaseError(error).kind === "undefined_object") {
+			logger.warn(`Cascade delete skipped ${context.action} on '${context.table}': table or column not found in this database.`, { error: error instanceof Error ? error.message : String(error) });
+			return fallback;
+		}
+		throw error;
+	}
+}
+async function selectIds(db, tableName, column, ids) {
+	const found = [];
+	for (const batch of chunkArray(ids, 900)) {
+		const rows = await tolerateMissingTable(() => db.list(tableName, idPredicate(column, batch)), [], {
+			table: tableName,
+			action: "CASCADE select"
+		});
+		for (const row of rows) {
+			const id = row?.id;
+			if (typeof id === "string" && id.length > 0) found.push(id);
+		}
+	}
+	return found;
+}
+async function deleteByIds(db, tableName, ids) {
+	for (const batch of chunkArray(ids, 900)) await tolerateMissingTable(() => db.delete(tableName, idPredicate("id", batch)), void 0, {
+		table: tableName,
+		action: "CASCADE delete"
+	});
+}
+/**
+* Remove the framework-managed side rows owned by the given object ids.
+*
+* `_smrt_contexts` and `_smrt_embeddings` are keyed by `(owner_class, owner_id)`
+* and `(object_class, object_id)` respectively. Matched by id *and* class
+* (review fix): id alone would let two unrelated classes using
+* `idType: 'text'` (non-UUID, not guaranteed globally unique) collide on a
+* shared id value and delete each other's memory/embeddings rows. `classNames`
+* is the STI-hierarchy-expanded candidate set from
+* {@link ownerClassCandidates} — the class column stores the *runtime*
+* constructor name, which for an STI hierarchy is a concrete subclass rather
+* than the class the cascade was planned from, so a single exact name is not
+* enough.
+*
+* A missing system table is not an error — an application database may predate
+* the table, and losing derived rows must never fail an otherwise valid delete.
+*/
+async function deleteSystemRows(db, ids, classNames) {
+	const ownerIds = ids.filter((id) => typeof id === "string" && id.length > 0 && id !== COLLECTION_OWNER_SENTINEL);
+	if (ownerIds.length === 0 || classNames.length === 0) return;
+	for (const [table, idColumn, classColumn] of [[
+		CONTEXTS_TABLE,
+		"owner_id",
+		"owner_class"
+	], [
+		EMBEDDINGS_TABLE,
+		"object_id",
+		"object_class"
+	]]) for (const batch of chunkArray(ownerIds, 900)) try {
+		await db.delete(table, {
+			...idPredicate(idColumn, batch),
+			...idPredicate(classColumn, classNames)
+		});
+	} catch (error) {
+		logger.warn(`Failed to clean ${table} rows during cascade delete: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* Resolve every reference pointing at `ids` of `className`, recursively.
+*
+* Does **not** delete the rows identified by `ids` — the caller owns that, so
+* `SmrtObject.delete()` keeps issuing its own final statement and its own
+* lifecycle hooks.
+*/
+async function resolveReferences(ctx, className, tableName, ids, depth) {
+	const pending = ids.filter((id) => {
+		const key = `${tableName}:${id}`;
+		if (ctx.visited.has(key)) return false;
+		ctx.visited.add(key);
+		return true;
+	});
+	if (pending.length === 0) return;
+	if (depth > MAX_CASCADE_DEPTH) throw DatabaseError.constraintViolation(`cascade delete from ${className} exceeded the maximum depth of ${MAX_CASCADE_DEPTH}; check for a chain of onDelete: 'CASCADE' references that never terminates`, className);
+	const plan = buildCascadePlan(ctx.registry, className);
+	for (const reference of plan.references) {
+		if (reference.action !== "RESTRICT") continue;
+		let remaining = 0;
+		for (const batch of chunkArray(pending, 900)) {
+			remaining += await tolerateMissingTable(() => ctx.db.count(reference.tableName, idPredicate(reference.column, batch)), 0, {
+				table: reference.tableName,
+				action: "RESTRICT check"
+			});
+			if (remaining > 0) break;
+		}
+		if (remaining > 0) throw DatabaseError.constraintViolation(`${reference.className}.${reference.fieldName} declares onDelete: 'RESTRICT' and ${remaining} row(s) still reference this ${className}`, reference.column);
+	}
+	for (const reference of plan.references) {
+		if (reference.action === "SET NULL") {
+			for (const batch of chunkArray(pending, 900)) await tolerateMissingTable(() => ctx.db.update(reference.tableName, idPredicate(reference.column, batch), { [reference.column]: null }), void 0, {
+				table: reference.tableName,
+				action: "SET NULL"
+			});
+			ctx.affectedTables.add(reference.tableName);
+			ctx.affectedTableClasses.set(reference.tableName, toQualifiedClassName(ctx.registry, reference.className));
+			continue;
+		}
+		if (reference.action !== "CASCADE") continue;
+		const childIds = await selectIds(ctx.db, reference.tableName, reference.column, pending);
+		if (childIds.length === 0) continue;
+		await resolveReferences(ctx, reference.className, reference.tableName, childIds, depth + 1);
+		await deleteSystemRows(ctx.db, childIds, ownerClassCandidates(ctx.registry, reference.className));
+		await deleteByIds(ctx.db, reference.tableName, childIds);
+		ctx.affectedTables.add(reference.tableName);
+		ctx.affectedTableClasses.set(reference.tableName, toQualifiedClassName(ctx.registry, reference.className));
+	}
+	for (const association of plan.polymorphic) for (const batch of chunkArray(pending, 900)) {
+		const where = { ...idPredicate("meta_id", batch) };
+		if (plan.metaTypes.length === 1) where.meta_type = plan.metaTypes[0];
+		else where["meta_type in"] = plan.metaTypes;
+		if (((await tolerateMissingTable(() => ctx.db.delete(association.tableName, where), void 0, {
+			table: association.tableName,
+			action: "polymorphic association cleanup"
+		}))?.affected ?? 0) > 0) {
+			ctx.affectedTables.add(association.tableName);
+			ctx.affectedTableClasses.set(association.tableName, toQualifiedClassName(ctx.registry, association.className));
+		}
+	}
+}
+/**
+* Resolve every reference to `ids` of `className` and clean their framework
+* side rows, then hand control back so the caller can delete the rows.
+*
+* Callers are expected to run this on a transaction-bound `db` — see
+* {@link runCascadeDelete}, which owns that decision.
+*/
+async function cascadeReferencesTo(db, registry, target) {
+	const ctx = {
+		db,
+		registry,
+		visited: /* @__PURE__ */ new Set(),
+		affectedTables: /* @__PURE__ */ new Set(),
+		affectedTableClasses: /* @__PURE__ */ new Map()
+	};
+	await resolveReferences(ctx, target.className, target.tableName, target.ids, 0);
+	await deleteSystemRows(db, target.ids, ownerClassCandidates(registry, target.className));
+	return {
+		affectedTables: ctx.affectedTables,
+		affectedTableClasses: ctx.affectedTableClasses
+	};
+}
+/**
+* Run the cascade and the target row's own deletion atomically.
+*
+* When anything references the class and the adapter exposes `transaction()`,
+* the whole sequence runs inside one — including the caller's `deleteSelf`
+* statement, so a failure part-way through cannot leave the object deleted with
+* its junction rows intact (or vice versa). Adapters without transaction
+* support run the same statements sequentially; this is the documented
+* degradation, not a silent one.
+*
+* When nothing references the class there is nothing to keep consistent, and
+* the transaction is skipped — see the comment on that branch.
+*
+* @param db - Database the object is bound to
+* @param registry - Registry view used to build cascade plans
+* @param target - Class, table and id of the object being deleted
+* @param deleteSelf - Issues the target row's own `DELETE`, on the tx-bound db
+* @returns Tables affected by the cascade, for read-cache invalidation
+*/
+async function runCascadeDelete(db, registry, target, deleteSelf) {
+	const ids = target.id ? [target.id] : [];
+	if (buildCascadePlan(registry, target.className).isEmpty) {
+		await deleteSelf(db);
+		await deleteSystemRows(db, ids, ownerClassCandidates(registry, target.className));
+		return {
+			affectedTables: /* @__PURE__ */ new Set(),
+			affectedTableClasses: /* @__PURE__ */ new Map()
+		};
+	}
+	const run = async (bound) => {
+		const result = await cascadeReferencesTo(bound, registry, {
+			className: target.className,
+			tableName: target.tableName,
+			ids
+		});
+		await deleteSelf(bound);
+		return result;
+	};
+	const transaction = db.transaction;
+	if (typeof transaction !== "function") return run(db);
+	return transaction.call(db, run);
+}
+//#endregion
+export { buildCascadePlan, cascadeReferencesTo, normalizeOnDelete, runCascadeDelete };
+
+//# sourceMappingURL=cascade.js.map

package/dist/cascade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cascade.js","names":[],"sources":["../src/cascade.ts"],"sourcesContent":["/**\n * App-side referential integrity for `SmrtObject.delete()` (#2371).\n *\n * SMRT emits **no** DB-level `FOREIGN KEY` constraints on any engine, so the\n * database will never clean up after a deleted row. Before this module,\n * `delete()` removed the object's own row and nothing else: junction rows,\n * polymorphic association rows, `_smrt_embeddings` and `_smrt_contexts` entries\n * were all left pointing at an id that no longer resolved, and\n * `@foreignKey(..., { onDelete })` was metadata nobody read.\n *\n * This module implements those semantics in the application layer. It mirrors\n * what a DB-level constraint would do, deliberately including the parts that\n * make it *unlike* a model-layer delete:\n *\n * - Cascaded rows are removed with set-based statements. Their `beforeDelete` /\n *   `afterDelete` hooks and interceptors do **not** run, and no change-feed\n *   tombstone is written for them — exactly as `ON DELETE CASCADE` behaves.\n *   Only the object `delete()` was called on runs the full lifecycle.\n * - When anything needs cascading, everything runs inside a single\n *   transaction when the adapter exposes one, so a partial cascade cannot\n *   survive a failure. A class with no typed references AND no registered\n *   polymorphic association class anywhere in the process skips the\n *   transaction — see {@link runCascadeDelete}. A `metaType` column can point\n *   at any class at runtime, so a polymorphic association class is always\n *   plausibly relevant; in an app with even one registered, this fast path is\n *   rare, not the common case.\n *\n * ## Which references are followed\n *\n * A reference is any `@foreignKey` / `@crossPackageRef` field on a registered\n * class whose target resolves to the deleted object's class (or one of its\n * registered STI ancestors), plus the polymorphic `(metaType, metaId)` pair on\n * {@link SmrtPolymorphicAssociation} subclasses.\n *\n * The action comes from the field's declared `onDelete`. When it is not\n * declared, the default is derived from the referencing class's natural key:\n *\n * | Reference | Default when `onDelete` is absent |\n * |---|---|\n * | Column is part of the referencing class's `conflictColumns`, and is not a `@tenantId()` field | `CASCADE` |\n * | Polymorphic `(metaType, metaId)` association row | `CASCADE` |\n * | Anything else, including every `@tenantId()` field | `NO ACTION` (legacy behaviour — the row is left alone) |\n *\n * The natural-key rule is what makes junction rows work without any\n * per-package annotation: a junction declares\n * `@smrt({ conflictColumns: ['content_id', 'asset_id', 'relationship'] })`, so\n * `content_id` identifies the row and the row cannot outlive the content it\n * links. An ordinary child (`Order.customerId`) is keyed by `(slug, context)`,\n * so it keeps today's behaviour unless it opts in with\n * `@foreignKey(Customer, { onDelete: 'CASCADE' })`.\n *\n * `@tenantId()` fields are excluded from the natural-key rule even though\n * `@happyvertical/smrt-tenancy` leads a tenant-scoped class's *default*\n * `conflictColumns` with the tenant column (#2360): the tenant column scopes\n * ownership, it does not identify the row the way a junction's foreign key\n * does, and it targets a class (`Tenant`) that is virtually always\n * referenced. Without this exclusion, deleting one `Tenant` row would\n * recursively CASCADE through every tenant-scoped table that has not\n * declared its own `conflictColumns` — the overwhelming majority. The field\n * is detected via the `__tenancy.isTenantIdField` marker `@tenantId()`\n * attaches to its own registration (`FieldMeta.__tenancy`, read structurally\n * so `smrt-core` never depends on `smrt-tenancy`). `@tenantId()` exposes no\n * `onDelete` option today, so this cannot currently be overridden per field.\n *\n * @see https://github.com/happyvertical/smrt/issues/2371\n * @module\n */\n\nimport { createLogger } from '@happyvertical/logger';\nimport type { DatabaseInterface } from '@happyvertical/sql';\nimport { classifyDatabaseError } from './db-errors.js';\nimport { ConfigurationError, DatabaseError } from './errors.js';\n// Type-only: erased at runtime, so it cannot re-enter the\n// `registry → object → cascade` import cycle.\nimport type { ObjectRegistry } from './registry.js';\nimport { chunkArray, IN_LIST_CHUNK_SIZE } from './utils/chunk.js';\nimport { toSnakeCase } from './utils/naming.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/**\n * Referential action applied to rows pointing at a deleted object.\n *\n * Same vocabulary as SQL's `ON DELETE`, enforced by the framework instead of\n * the engine. `NO ACTION` means \"leave the rows alone\" — SMRT emits no\n * constraint, so nothing raises.\n */\nexport type OnDeleteAction = 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';\n\n/** Table holding framework-managed per-object memory entries. */\nconst CONTEXTS_TABLE = '_smrt_contexts';\n\n/** Table holding framework-managed per-object embedding vectors. */\nconst EMBEDDINGS_TABLE = '_smrt_embeddings';\n\n/**\n * Reserved `_smrt_contexts.owner_id` used by `SmrtCollection.remember()` for\n * collection-scoped memory. A real object id is a UUID and can never equal it,\n * but the guard keeps a malformed id from wiping every sibling's defaults.\n */\nconst COLLECTION_OWNER_SENTINEL = '__collection__';\n\n/**\n * Maximum number of cascade levels followed from the object `delete()` was\n * called on. A cycle between two classes that both declare `onDelete: 'CASCADE'`\n * is broken by the visited set; this bound catches unbounded *chains*.\n */\nconst MAX_CASCADE_DEPTH = 10;\n\n/** One reference that must be resolved before the target row can be removed. */\nexport interface CascadeReference {\n  /** Registered name of the class holding the referencing column. */\n  className: string;\n  /** Table holding the referencing rows. */\n  tableName: string;\n  /** Field name (camelCase) on the referencing class. */\n  fieldName: string;\n  /** Column (snake_case) holding the reference. */\n  column: string;\n  /** Resolved action, never `NO ACTION` (those are dropped from the plan). */\n  action: Exclude<OnDeleteAction, 'NO ACTION'>;\n  /** `true` when the action was declared rather than derived from the key. */\n  declared: boolean;\n}\n\n/** A polymorphic association table that can point at any class. */\nexport interface CascadePolymorphicReference {\n  /** Registered name of the association class. */\n  className: string;\n  /** Table holding the association rows. */\n  tableName: string;\n}\n\n/** Everything that must happen before rows of one class can be deleted. */\nexport interface CascadePlan {\n  /** Typed `@foreignKey` / `@crossPackageRef` references, action-resolved. */\n  references: CascadeReference[];\n  /** Polymorphic association tables that may point at this class. */\n  polymorphic: CascadePolymorphicReference[];\n  /** `meta_type` values that identify this class in an association row. */\n  metaTypes: string[];\n  /** `true` when nothing references this class and nothing has to be visited. */\n  isEmpty: boolean;\n}\n\n/**\n * Read-only slice of `ObjectRegistry` this module needs.\n *\n * Taking it as a parameter — rather than importing the registry as a value —\n * keeps `cascade.ts` out of the `registry → object → cascade` import cycle,\n * and lets tests drive the planner from a hand-built registry.\n */\nexport type CascadeRegistryView = Pick<\n  typeof ObjectRegistry,\n  | 'getRelationshipMap'\n  | 'getFields'\n  | 'getConflictColumns'\n  | 'getTableName'\n  | 'getSelfReferableNames'\n  | 'getClass'\n  | 'getSTIBase'\n  | 'getDescendants'\n>;\n\nconst CASCADE_ACTIONS = new Set<OnDeleteAction>([\n  'CASCADE',\n  'SET NULL',\n  'RESTRICT',\n  'NO ACTION',\n]);\n\n/**\n * Normalize a declared `onDelete` value.\n *\n * Accepts any casing and both `SET NULL` and `SET_NULL`, matching what the\n * schema generator has always carried in the manifest. Returns `undefined` for\n * an unset or unrecognized value so the caller can fall back to the default.\n */\nexport function normalizeOnDelete(value: unknown): OnDeleteAction | undefined {\n  if (typeof value !== 'string') return undefined;\n  const normalized = value.trim().toUpperCase().replace(/_/g, ' ');\n  return CASCADE_ACTIONS.has(normalized as OnDeleteAction)\n    ? (normalized as OnDeleteAction)\n    : undefined;\n}\n\nfunction isPolymorphicAssociationClass(fields: Map<string, unknown>): boolean {\n  // The three columns `SmrtPolymorphicAssociation` contributes. Requiring all\n  // of them keeps an unrelated class that happens to carry a `metaType` from\n  // being treated as an association table.\n  return fields.has('metaType') && fields.has('metaId') && fields.has('role');\n}\n\n/**\n * Build the cascade plan for one class.\n *\n * The plan is derived entirely from registry metadata, so it is valid for any\n * database the class is used against. It is rebuilt per delete rather than\n * cached: registration is incremental (manifests load lazily, tests register\n * classes between cases) and a stale plan would silently skip a table.\n *\n * @param registry - Registry view (`ObjectRegistry` satisfies it)\n * @param className - Class whose incoming references should be resolved\n */\nexport function buildCascadePlan(\n  registry: CascadeRegistryView,\n  className: string,\n): CascadePlan {\n  // `className` is normally already qualified (delete() passes\n  // getResolvedQualifiedName()), but a common same-package `@foreignKey('X')`\n  // still stores its target as the bare simple name `X`. That still matches:\n  // getSelfReferableNames() walks the full ancestor chain (self included) and\n  // adds each ancestor's *simple* name via `getClass(ancestor)?.name`, so the\n  // simple form is already in the seed set below, not just the loop's\n  // qualified-variant augmentation.\n  const targetNames = new Set(registry.getSelfReferableNames(className));\n  for (const name of [...targetNames]) {\n    const qualified = registry.getClass(name)?.qualifiedName;\n    if (qualified) targetNames.add(qualified);\n  }\n\n  const references: CascadeReference[] = [];\n  const polymorphic: CascadePolymorphicReference[] = [];\n\n  for (const [sourceClass, relationships] of registry.getRelationshipMap()) {\n    const fields = registry.getFields(sourceClass);\n\n    if (isPolymorphicAssociationClass(fields)) {\n      const tableName = registry.getTableName(sourceClass);\n      if (tableName) {\n        polymorphic.push({ className: sourceClass, tableName });\n      }\n    }\n\n    if (relationships.length === 0) continue;\n\n    let conflictColumns: Set<string> | undefined;\n\n    for (const relationship of relationships) {\n      if (\n        relationship.type !== 'foreignKey' &&\n        relationship.type !== 'crossPackageRef'\n      ) {\n        continue;\n      }\n      if (!targetNames.has(relationship.targetClass)) continue;\n\n      const tableName = registry.getTableName(sourceClass);\n      if (!tableName) continue;\n\n      const column = toSnakeCase(relationship.fieldName);\n      const declaredAction = normalizeOnDelete(relationship.options?.onDelete);\n\n      if (!conflictColumns) {\n        conflictColumns = new Set(registry.getConflictColumns(sourceClass));\n      }\n\n      // A `@tenantId()` field is a structural scoping marker, not a\n      // junction/ownership key — it lands in `conflictColumns` only because\n      // #2360 leads every tenant-scoped class's *default* natural key with\n      // the tenant column, not because the referencing row is *identified*\n      // by its tenant the way a junction row is identified by its parent.\n      // Without this guard, deleting a `Tenant` would silently CASCADE\n      // through the tenant column of every tenant-scoped class in the\n      // schema that has not declared its own `conflictColumns` — the\n      // overwhelming majority. `@tenantId()` exposes no `onDelete` today, so\n      // an explicit declaration can never widen this back to CASCADE; that\n      // is deliberate until tenant-delete cascade is an explicit decision.\n      const isTenantIdField =\n        relationship.options?.__tenancy?.isTenantIdField === true;\n\n      const action =\n        declaredAction ??\n        (!isTenantIdField && conflictColumns.has(column)\n          ? 'CASCADE'\n          : 'NO ACTION');\n\n      if (action === 'NO ACTION') continue;\n\n      if (\n        action === 'SET NULL' &&\n        fields.get(relationship.fieldName)?.required\n      ) {\n        // Fail on the declaration, not later on a NOT NULL violation from the\n        // engine — the message there names a column, not the decorator.\n        throw ConfigurationError.invalidConfiguration(\n          `${sourceClass}.${relationship.fieldName} onDelete: 'SET NULL'`,\n          relationship.fieldName,\n          \"a nullable field (mark it `nullable: true`, or use 'CASCADE' / 'RESTRICT')\",\n        );\n      }\n\n      references.push({\n        className: sourceClass,\n        tableName,\n        fieldName: relationship.fieldName,\n        column,\n        action,\n        declared: declaredAction !== undefined,\n      });\n    }\n  }\n\n  // Both forms are matched deliberately: an association row written before a\n  // class was package-qualified still carries the simple `meta_type`. The\n  // qualified form alone is unambiguous; the simple-name fallback can still\n  // match a same-simple-name sibling class's row if it also shares a\n  // `meta_id` — a real, not just theoretical, risk for a class declaring\n  // `idType: 'text'` (non-UUID, not guaranteed globally unique), the same gap\n  // `deleteSystemRows()` closed for `_smrt_contexts` / `_smrt_embeddings`\n  // (review fix) by adding a class-name filter. Closing it here needs the\n  // same STI-and-legacy-name-aware filter this module already builds for\n  // `deleteSystemRows()` narrowed further to registry-unambiguous simple\n  // names; tracked under #2419 alongside the other same-simple-name\n  // collision gaps rather than reworked here.\n  const metaTypes: string[] = [];\n  const qualified = registry.getClass(className)?.qualifiedName;\n  if (qualified) metaTypes.push(qualified);\n  const simple = registry.getClass(className)?.name ?? className;\n  if (!metaTypes.includes(simple)) metaTypes.push(simple);\n\n  return {\n    references,\n    polymorphic,\n    metaTypes,\n    isEmpty: references.length === 0 && polymorphic.length === 0,\n  };\n}\n\n/** Per-delete state shared by every level of the cascade. */\ninterface CascadeContext {\n  db: DatabaseInterface;\n  registry: CascadeRegistryView;\n  /** `table:id` pairs already expanded, so a reference cycle terminates. */\n  visited: Set<string>;\n  /** Tables touched by the cascade, for read-cache invalidation. */\n  affectedTables: Set<string>;\n  /**\n   * Qualified name of the class that owns each affected table, so the\n   * caller can resolve *that* class's own `@smrt({ cache })` config —\n   * cross-process cache invalidation is a per-class opt-in, and a table\n   * cascaded into belongs to a different class than the one `delete()` was\n   * called on.\n   */\n  affectedTableClasses: Map<string, string>;\n}\n\n/** Resolve a registry-recorded class name to its qualified form, when known. */\nfunction toQualifiedClassName(\n  registry: CascadeRegistryView,\n  className: string,\n): string {\n  return registry.getClass(className)?.qualifiedName ?? className;\n}\n\n/**\n * Every value `_smrt_contexts.owner_class` / `_smrt_embeddings.object_class`\n * could plausibly hold for a row belonging to an id of `className` (review\n * fix): both name forms (qualified + simple — older rows predate package\n * qualification) of `className` itself, plus every other member of its STI\n * hierarchy sharing its table. A CASCADE-collected id can belong to any\n * concrete STI subclass of the declaring reference, which stamps its own\n * (more specific) runtime class name at write time, not the reference's.\n *\n * Narrowing by this set — instead of matching by id alone — closes a\n * cross-class collision: two unrelated classes using `idType: 'text'`\n * (non-UUID, not guaranteed globally unique) could otherwise share an id\n * value and have one's `remember()`/embeddings rows deleted by the other's\n * cascade.\n */\nfunction ownerClassCandidates(\n  registry: CascadeRegistryView,\n  className: string,\n): string[] {\n  const stiBase = registry.getSTIBase(className) ?? className;\n  const members = new Set<string>([\n    className,\n    stiBase,\n    ...registry.getDescendants(stiBase),\n  ]);\n\n  const names = new Set<string>();\n  for (const member of members) {\n    names.add(member);\n    const registered = registry.getClass(member);\n    if (registered?.qualifiedName) names.add(registered.qualifiedName);\n    if (registered?.name) names.add(registered.name);\n  }\n  return [...names];\n}\n\n/**\n * Build the `where` clause matching `column` against one or more ids.\n *\n * A single id uses equality so the planner can use a plain index; multiple ids\n * use the adapter's `in` operator.\n */\nfunction idPredicate(column: string, ids: string[]): Record<string, unknown> {\n  return ids.length === 1 ? { [column]: ids[0] } : { [`${column} in`]: ids };\n}\n\n/**\n * Run a cascade statement against a *referencing* table, tolerating the\n * table (or an expected column) not existing in this database.\n *\n * The cascade plan is built from the in-process registry, which can carry a\n * class from any imported package — including one whose table this specific\n * database was never migrated to include (a partially adopted feature, a\n * package pulled in for its types, or, in a test process, a fixture some\n * other test file registered). A missing referencing table trivially has no\n * rows to act on, so the correct behaviour is identical to the table\n * existing and being empty — this must never abort an otherwise valid\n * delete. Any other failure (a real constraint violation, a lock timeout, a\n * genuine SQL error unrelated to the table's existence) still propagates.\n */\nasync function tolerateMissingTable<T>(\n  operation: () => Promise<T>,\n  fallback: T,\n  context: { table: string; action: string },\n): Promise<T> {\n  try {\n    return await operation();\n  } catch (error) {\n    if (classifyDatabaseError(error).kind === 'undefined_object') {\n      logger.warn(\n        `Cascade delete skipped ${context.action} on '${context.table}': ` +\n          'table or column not found in this database.',\n        { error: error instanceof Error ? error.message : String(error) },\n      );\n      return fallback;\n    }\n    throw error;\n  }\n}\n\nasync function selectIds(\n  db: DatabaseInterface,\n  tableName: string,\n  column: string,\n  ids: string[],\n): Promise<string[]> {\n  const found: string[] = [];\n  for (const batch of chunkArray(ids, IN_LIST_CHUNK_SIZE)) {\n    const rows = await tolerateMissingTable(\n      () => db.list(tableName, idPredicate(column, batch)),\n      [] as Record<string, unknown>[],\n      { table: tableName, action: 'CASCADE select' },\n    );\n    for (const row of rows) {\n      const id = row?.id;\n      if (typeof id === 'string' && id.length > 0) found.push(id);\n    }\n  }\n  return found;\n}\n\nasync function deleteByIds(\n  db: DatabaseInterface,\n  tableName: string,\n  ids: string[],\n): Promise<void> {\n  for (const batch of chunkArray(ids, IN_LIST_CHUNK_SIZE)) {\n    await tolerateMissingTable(\n      () => db.delete(tableName, idPredicate('id', batch)),\n      undefined,\n      { table: tableName, action: 'CASCADE delete' },\n    );\n  }\n}\n\n/**\n * Remove the framework-managed side rows owned by the given object ids.\n *\n * `_smrt_contexts` and `_smrt_embeddings` are keyed by `(owner_class, owner_id)`\n * and `(object_class, object_id)` respectively. Matched by id *and* class\n * (review fix): id alone would let two unrelated classes using\n * `idType: 'text'` (non-UUID, not guaranteed globally unique) collide on a\n * shared id value and delete each other's memory/embeddings rows. `classNames`\n * is the STI-hierarchy-expanded candidate set from\n * {@link ownerClassCandidates} — the class column stores the *runtime*\n * constructor name, which for an STI hierarchy is a concrete subclass rather\n * than the class the cascade was planned from, so a single exact name is not\n * enough.\n *\n * A missing system table is not an error — an application database may predate\n * the table, and losing derived rows must never fail an otherwise valid delete.\n */\nasync function deleteSystemRows(\n  db: DatabaseInterface,\n  ids: string[],\n  classNames: string[],\n): Promise<void> {\n  const ownerIds = ids.filter(\n    (id) =>\n      typeof id === 'string' &&\n      id.length > 0 &&\n      id !== COLLECTION_OWNER_SENTINEL,\n  );\n  if (ownerIds.length === 0 || classNames.length === 0) return;\n\n  for (const [table, idColumn, classColumn] of [\n    [CONTEXTS_TABLE, 'owner_id', 'owner_class'],\n    [EMBEDDINGS_TABLE, 'object_id', 'object_class'],\n  ] as const) {\n    for (const batch of chunkArray(ownerIds, IN_LIST_CHUNK_SIZE)) {\n      try {\n        await db.delete(table, {\n          ...idPredicate(idColumn, batch),\n          ...idPredicate(classColumn, classNames),\n        });\n      } catch (error) {\n        logger.warn(\n          `Failed to clean ${table} rows during cascade delete: ${\n            error instanceof Error ? error.message : String(error)\n          }`,\n        );\n      }\n    }\n  }\n}\n\n/**\n * Resolve every reference pointing at `ids` of `className`, recursively.\n *\n * Does **not** delete the rows identified by `ids` — the caller owns that, so\n * `SmrtObject.delete()` keeps issuing its own final statement and its own\n * lifecycle hooks.\n */\nasync function resolveReferences(\n  ctx: CascadeContext,\n  className: string,\n  tableName: string,\n  ids: string[],\n  depth: number,\n): Promise<void> {\n  const pending = ids.filter((id) => {\n    const key = `${tableName}:${id}`;\n    if (ctx.visited.has(key)) return false;\n    ctx.visited.add(key);\n    return true;\n  });\n  if (pending.length === 0) return;\n\n  if (depth > MAX_CASCADE_DEPTH) {\n    throw DatabaseError.constraintViolation(\n      `cascade delete from ${className} exceeded the maximum depth of ` +\n        `${MAX_CASCADE_DEPTH}; check for a chain of onDelete: 'CASCADE' ` +\n        'references that never terminates',\n      className,\n    );\n  }\n\n  const plan = buildCascadePlan(ctx.registry, className);\n\n  // RESTRICT first: refuse before anything has been mutated.\n  for (const reference of plan.references) {\n    if (reference.action !== 'RESTRICT') continue;\n    let remaining = 0;\n    for (const batch of chunkArray(pending, IN_LIST_CHUNK_SIZE)) {\n      remaining += await tolerateMissingTable(\n        () =>\n          ctx.db.count(\n            reference.tableName,\n            idPredicate(reference.column, batch),\n          ),\n        0,\n        { table: reference.tableName, action: 'RESTRICT check' },\n      );\n      if (remaining > 0) break;\n    }\n    if (remaining > 0) {\n      throw DatabaseError.constraintViolation(\n        `${reference.className}.${reference.fieldName} declares ` +\n          `onDelete: 'RESTRICT' and ${remaining} row(s) still reference this ` +\n          `${className}`,\n        reference.column,\n      );\n    }\n  }\n\n  for (const reference of plan.references) {\n    if (reference.action === 'SET NULL') {\n      for (const batch of chunkArray(pending, IN_LIST_CHUNK_SIZE)) {\n        await tolerateMissingTable(\n          () =>\n            ctx.db.update(\n              reference.tableName,\n              idPredicate(reference.column, batch),\n              { [reference.column]: null },\n            ),\n          undefined,\n          { table: reference.tableName, action: 'SET NULL' },\n        );\n      }\n      ctx.affectedTables.add(reference.tableName);\n      ctx.affectedTableClasses.set(\n        reference.tableName,\n        toQualifiedClassName(ctx.registry, reference.className),\n      );\n      continue;\n    }\n\n    if (reference.action !== 'CASCADE') continue;\n\n    const childIds = await selectIds(\n      ctx.db,\n      reference.tableName,\n      reference.column,\n      pending,\n    );\n    if (childIds.length === 0) continue;\n\n    await resolveReferences(\n      ctx,\n      reference.className,\n      reference.tableName,\n      childIds,\n      depth + 1,\n    );\n    await deleteSystemRows(\n      ctx.db,\n      childIds,\n      ownerClassCandidates(ctx.registry, reference.className),\n    );\n    await deleteByIds(ctx.db, reference.tableName, childIds);\n    ctx.affectedTables.add(reference.tableName);\n    ctx.affectedTableClasses.set(\n      reference.tableName,\n      toQualifiedClassName(ctx.registry, reference.className),\n    );\n  }\n\n  for (const association of plan.polymorphic) {\n    for (const batch of chunkArray(pending, IN_LIST_CHUNK_SIZE)) {\n      const where: Record<string, unknown> = {\n        ...idPredicate('meta_id', batch),\n      };\n      if (plan.metaTypes.length === 1) {\n        where.meta_type = plan.metaTypes[0];\n      } else {\n        where['meta_type in'] = plan.metaTypes;\n      }\n      const result = await tolerateMissingTable(\n        () => ctx.db.delete(association.tableName, where),\n        undefined,\n        {\n          table: association.tableName,\n          action: 'polymorphic association cleanup',\n        },\n      );\n      if ((result?.affected ?? 0) > 0) {\n        ctx.affectedTables.add(association.tableName);\n        ctx.affectedTableClasses.set(\n          association.tableName,\n          toQualifiedClassName(ctx.registry, association.className),\n        );\n      }\n    }\n  }\n}\n\n/** Outcome of a cascade run, returned so the caller can invalidate caches. */\nexport interface CascadeResult {\n  /** Tables whose rows were removed or nulled, excluding the target's own. */\n  affectedTables: Set<string>;\n  /**\n   * Qualified class name that owns each entry in {@link affectedTables},\n   * where resolvable — lets the caller check *that* class's own\n   * cross-process cache config rather than only its own.\n   */\n  affectedTableClasses: Map<string, string>;\n}\n\n/**\n * Resolve every reference to `ids` of `className` and clean their framework\n * side rows, then hand control back so the caller can delete the rows.\n *\n * Callers are expected to run this on a transaction-bound `db` — see\n * {@link runCascadeDelete}, which owns that decision.\n */\nexport async function cascadeReferencesTo(\n  db: DatabaseInterface,\n  registry: CascadeRegistryView,\n  target: { className: string; tableName: string; ids: string[] },\n): Promise<CascadeResult> {\n  const ctx: CascadeContext = {\n    db,\n    registry,\n    visited: new Set(),\n    affectedTables: new Set(),\n    affectedTableClasses: new Map(),\n  };\n  await resolveReferences(\n    ctx,\n    target.className,\n    target.tableName,\n    target.ids,\n    0,\n  );\n  await deleteSystemRows(\n    db,\n    target.ids,\n    ownerClassCandidates(registry, target.className),\n  );\n  return {\n    affectedTables: ctx.affectedTables,\n    affectedTableClasses: ctx.affectedTableClasses,\n  };\n}\n\ntype TransactionCapable = DatabaseInterface & {\n  transaction?: <T>(\n    this: DatabaseInterface,\n    callback: (tx: DatabaseInterface) => Promise<T>,\n  ) => Promise<T>;\n};\n\n/**\n * Run the cascade and the target row's own deletion atomically.\n *\n * When anything references the class and the adapter exposes `transaction()`,\n * the whole sequence runs inside one — including the caller's `deleteSelf`\n * statement, so a failure part-way through cannot leave the object deleted with\n * its junction rows intact (or vice versa). Adapters without transaction\n * support run the same statements sequentially; this is the documented\n * degradation, not a silent one.\n *\n * When nothing references the class there is nothing to keep consistent, and\n * the transaction is skipped — see the comment on that branch.\n *\n * @param db - Database the object is bound to\n * @param registry - Registry view used to build cascade plans\n * @param target - Class, table and id of the object being deleted\n * @param deleteSelf - Issues the target row's own `DELETE`, on the tx-bound db\n * @returns Tables affected by the cascade, for read-cache invalidation\n */\nexport async function runCascadeDelete(\n  db: DatabaseInterface,\n  registry: CascadeRegistryView,\n  target: {\n    className: string;\n    tableName: string;\n    /** An unsaved object has none; the cascade is then a no-op. */\n    id: string | null | undefined;\n  },\n  deleteSelf: (db: DatabaseInterface) => Promise<void>,\n): Promise<CascadeResult> {\n  const ids = target.id ? [target.id] : [];\n\n  // Nothing references this class AND no polymorphic association class is\n  // registered anywhere in the process. `plan.polymorphic` is unconditionally\n  // every registered `SmrtPolymorphicAssociation` subclass — a `metaType`\n  // column can point at any class at runtime, so there is no static metadata\n  // to scope it by, unlike a typed `@foreignKey`/`@crossPackageRef`. This\n  // branch is therefore common for a class with no incoming references in an\n  // app with no polymorphic associations at all, but rare — not \"the\n  // overwhelmingly common case\" — once even one polymorphic class exists\n  // anywhere in the process, since every delete's plan then carries it.\n  // Opening a transaction to wrap statements that cannot disagree with each\n  // other would cost two extra round trips, and on single-connection adapters\n  // it would serialize concurrent deletes behind the transaction queue. Order\n  // the two statements instead: the row goes first, so a failure leaves\n  // everything as it was, and the derived side rows follow under the\n  // best-effort contract they already carry.\n  if (buildCascadePlan(registry, target.className).isEmpty) {\n    await deleteSelf(db);\n    await deleteSystemRows(\n      db,\n      ids,\n      ownerClassCandidates(registry, target.className),\n    );\n    return { affectedTables: new Set(), affectedTableClasses: new Map() };\n  }\n\n  const run = async (bound: DatabaseInterface): Promise<CascadeResult> => {\n    const result = await cascadeReferencesTo(bound, registry, {\n      className: target.className,\n      tableName: target.tableName,\n      ids,\n    });\n    await deleteSelf(bound);\n    return result;\n  };\n\n  const transaction = (db as TransactionCapable).transaction;\n  if (typeof transaction !== 'function') {\n    return run(db);\n  }\n\n  return transaction.call<\n    DatabaseInterface,\n    [(tx: DatabaseInterface) => Promise<CascadeResult>],\n    Promise<CascadeResult>\n  >(db, run);\n}\n"],"mappings":"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"}