@happyvertical/smrt-core 0.52.0 → 0.53.1

package/dist/migrations/index.d.ts

@@ -19,6 +19,7 @@ export { buildIntegerWidthStatements, buildIntegerWidthTableStatements, collectI
 export { buildMinorUnitsStatements, type MinorUnitsColumnReport, type MinorUnitsColumnState, type MinorUnitsOptions, MinorUnitsPreflightError, type MinorUnitsPreflightResult, type MinorUnitsProblemRow, type MinorUnitsRescaleOptions, type MinorUnitsRescaleResult, type MoneyColumnTarget, preflightMinorUnitsRescale, rescaleMoneyColumnsToMinorUnits, } from './minor-units.js';
 export { collectNullEqualIndexTargets, migrateNullEqualIndexes, type NullEqualIndexOptions, type NullEqualIndexPreflight, type NullEqualIndexReport, type NullEqualIndexTarget, nullEqualDuplicateDetector, nullEqualIndexStatements, preflightNullEqualIndexes, } from './null-equal-indexes.js';
 export { getPendingSchemaStatements, type MigrateSmrtSchemasOptions, type MigrateSmrtSchemasResult, migrateSmrtSchemas, type PendingSchemaStatementsResult, } from './orchestrate.js';
+export { backfillLegacyQualifiedNames, collectLegacyQualifiedNameTargets, countLegacyQualifiedNameReferences, LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX, type LegacyQualifiedNameBackfillOptions, type LegacyQualifiedNameBackfillResult, type LegacyQualifiedNameOptions, type LegacyQualifiedNameReference, type LegacyQualifiedNameReport, type LegacyQualifiedNameTarget, legacyQualifiedNamesBackfillName, } from './qualified-name-aliases.js';
 export { type BuildSqliteRebuildStatementsInput, buildSqliteRebuildStatements, isSqliteRebuildPlaceholder, type PlanSqliteTableRebuildsOptions, planSqliteTableRebuilds, rewriteSqliteCreateTable, SQLITE_REBUILD_TABLE_PREFIX, type SqliteTableRebuildPlan, sqliteRebuildPlaceholderSql, } from './sqlite-rebuild.js';
 export { buildConcurrentIndexPlan, extractCreatedIndexName, MigrationTracker, parsePostgresTimeoutMs, planPostgresStatements, } from './tracker.js';
 export type { ApplyMigrationsOptions, ColumnDefinitionWithName, ColumnInfo, DatabaseEngine, DatabaseInterface, DataMigration, DataMigrationResult, DataMigrationStatement, DriftReport, ForeignKeyInfo, IndexDefinition, IndexInfo, MigrationDefinition, MigrationMode, MigrationResult, MigrationStatus, MigrationsConfig, MigrationTrackerOptions, ParsedMigrationFile, ParseMigrationOptions, RollbackOptions, SchemaChange, SchemaDiff, SchemaMigrationRecord, StiDiscriminatorMigration, TableSchemaInfo, } from './types.js';

package/dist/migrations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migrations/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migrations/index.ts"],"names":[],"mappings":"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"}

package/dist/migrations/index.js

@@ -10,4 +10,5 @@ import { MinorUnitsPreflightError, buildMinorUnitsStatements, preflightMinorUnit
 import { collectNullEqualIndexTargets, migrateNullEqualIndexes, nullEqualDuplicateDetector, nullEqualIndexStatements, preflightNullEqualIndexes } from "./null-equal-indexes.js";
 import { MigrationTracker, buildConcurrentIndexPlan, extractCreatedIndexName, planPostgresStatements } from "./tracker.js";
 import { getPendingSchemaStatements, migrateSmrtSchemas } from "./orchestrate.js";
-export { BackfillTableUnavailableError, BackfillTracker, FRAMEWORK_BASE_TABLE_NAMES, MigrationGenerator, MigrationTracker, MinorUnitsPreflightError, REQUIRED_COLUMN_NOT_ADDED, SQLITE_REBUILD_TABLE_PREFIX, SchemaComparer, buildConcurrentIndexPlan, buildIntegerWidthStatements, buildIntegerWidthTableStatements, buildMinorUnitsStatements, buildSqliteRebuildStatements, canonicalizeDefault, collectIntegerWidthTargets, collectNullEqualIndexTargets, computeChecksum, createMigrationDefinition, dropFrameworkBaseTables, extractCreatedIndexName, generateMigrationSequence, generateMigrationTimestamp, generateSchemaDiff, getPendingSchemaStatements, getSQLFromDiff, hasActionableChanges, isAdvisoryOnlyChange, isInfoOnlyChange, isManualOrAdvisoryChange, isSqliteRebuildPlaceholder, migrateNullEqualIndexes, migrateSmrtSchemas, normalizeSQL, nullEqualDuplicateDetector, nullEqualIndexStatements, parsePostgresTimeoutMs, planFrameworkBaseTableDrop, planPostgresStatements, planSqliteTableRebuilds, preflightIntegerWidthWidening, preflightMinorUnitsRescale, preflightNullEqualIndexes, rescaleMoneyColumnsToMinorUnits, rewriteSqliteCreateTable, shortChecksum, sqliteRebuildPlaceholderSql, uniqueColumnIndexName, verifyChecksum, widenIntegerColumnsToBigInt };
+import { LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX, backfillLegacyQualifiedNames, collectLegacyQualifiedNameTargets, countLegacyQualifiedNameReferences, legacyQualifiedNamesBackfillName } from "./qualified-name-aliases.js";
+export { BackfillTableUnavailableError, BackfillTracker, FRAMEWORK_BASE_TABLE_NAMES, LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX, MigrationGenerator, MigrationTracker, MinorUnitsPreflightError, REQUIRED_COLUMN_NOT_ADDED, SQLITE_REBUILD_TABLE_PREFIX, SchemaComparer, backfillLegacyQualifiedNames, buildConcurrentIndexPlan, buildIntegerWidthStatements, buildIntegerWidthTableStatements, buildMinorUnitsStatements, buildSqliteRebuildStatements, canonicalizeDefault, collectIntegerWidthTargets, collectLegacyQualifiedNameTargets, collectNullEqualIndexTargets, computeChecksum, countLegacyQualifiedNameReferences, createMigrationDefinition, dropFrameworkBaseTables, extractCreatedIndexName, generateMigrationSequence, generateMigrationTimestamp, generateSchemaDiff, getPendingSchemaStatements, getSQLFromDiff, hasActionableChanges, isAdvisoryOnlyChange, isInfoOnlyChange, isManualOrAdvisoryChange, isSqliteRebuildPlaceholder, legacyQualifiedNamesBackfillName, migrateNullEqualIndexes, migrateSmrtSchemas, normalizeSQL, nullEqualDuplicateDetector, nullEqualIndexStatements, parsePostgresTimeoutMs, planFrameworkBaseTableDrop, planPostgresStatements, planSqliteTableRebuilds, preflightIntegerWidthWidening, preflightMinorUnitsRescale, preflightNullEqualIndexes, rescaleMoneyColumnsToMinorUnits, rewriteSqliteCreateTable, shortChecksum, sqliteRebuildPlaceholderSql, uniqueColumnIndexName, verifyChecksum, widenIntegerColumnsToBigInt };

package/dist/migrations/qualified-name-aliases.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Stored references to deprecated qualified names (#3338).
+ *
+ * `@smrt({ previousQualifiedNames })` keeps an old qualified name resolving
+ * after a class moves package; it never rewrites stored data. This module is
+ * the operator side of that bridge:
+ *
+ * - {@link countLegacyQualifiedNameReferences} — read-only counts of rows that
+ *   still store an old name, which `smrt doctor --db` reports so a consumer
+ *   can see when an alias is safe to remove;
+ * - {@link backfillLegacyQualifiedNames} — an opt-in, idempotent rewrite of
+ *   those rows to the current name. It never runs automatically.
+ *
+ * Stored references covered:
+ *
+ * - `meta_type` of every registered `SmrtPolymorphicAssociation` subclass
+ *   table (any class can be a polymorphic target, so every alias is counted);
+ * - `_meta_type` of an STI table whose family includes an aliased class.
+ *
+ * Removing an alias is a breaking change for any row this still counts.
+ */
+import type { DatabaseInterface } from '@happyvertical/sql';
+/** Prefix of the `_smrt_backfills` marker {@link backfillLegacyQualifiedNames} records. */
+export declare const LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX = "@happyvertical/smrt-core:qualified-name-aliases:v1";
+/** One table column that can store a class's qualified name. */
+export interface LegacyQualifiedNameTarget {
+    /** Registered class that owns the table (qualified when available). */
+    className: string;
+    table: string;
+    /** `meta_type` (polymorphic association) or `_meta_type` (STI discriminator). */
+    column: string;
+    kind: 'polymorphic' | 'sti';
+    /** Deprecated names this column may still hold. */
+    aliases: string[];
+    /** Tenant column of the table, when tenant-owned. */
+    tenantColumn?: string;
+    /**
+     * Upsert identity columns that include `column`. A rewrite that would
+     * duplicate a current-name row on these columns is skipped, never forced.
+     */
+    conflictColumns?: string[];
+}
+/** Rows of one target that still store one deprecated name. */
+export interface LegacyQualifiedNameReference {
+    table: string;
+    column: string;
+    kind: 'polymorphic' | 'sti';
+    alias: string;
+    current: string;
+    count: number;
+}
+export interface LegacyQualifiedNameReport {
+    /** Declared alias → current qualified name, sorted by alias. */
+    aliases: Array<{
+        alias: string;
+        current: string;
+    }>;
+    /** Non-zero counts only, sorted by table, column, alias. */
+    references: LegacyQualifiedNameReference[];
+    /** Sum of `references[].count`. */
+    total: number;
+    /** Target tables absent from this database (nothing to count). */
+    missingTables: string[];
+    /** Target tables excluded from a tenant-scoped run (no tenant column). */
+    untenantedTables: string[];
+}
+export interface LegacyQualifiedNameOptions {
+    /**
+     * Restrict counting/rewriting to one tenant's rows. Tables without a tenant
+     * column are then skipped (reported in `untenantedTables`), never touched.
+     */
+    tenantId?: string;
+    /** Engine hint when the adapter URL does not identify it. */
+    engineHint?: string;
+}
+export interface LegacyQualifiedNameBackfillOptions extends LegacyQualifiedNameOptions {
+    /** Report what would change without writing (no marker is recorded). */
+    dryRun?: boolean;
+    /** Re-run even when this alias set's marker is already recorded. */
+    force?: boolean;
+}
+export interface LegacyQualifiedNameBackfillResult {
+    /** `false` when the marker was already recorded (and `force` was unset) or on a dry run. */
+    ran: boolean;
+    dryRun: boolean;
+    /** The `_smrt_backfills` marker for this alias set and scope. */
+    backfillName: string;
+    /** Counts before the rewrite. */
+    before: LegacyQualifiedNameReport;
+    /** Rows rewritten per table/column/alias. */
+    rewritten: LegacyQualifiedNameReference[];
+    /**
+     * Rows left under their old name because the rewrite would duplicate a row
+     * already stored under the current name (resolve those by hand, then re-run).
+     */
+    skippedDuplicates: LegacyQualifiedNameReference[];
+    /** Whether the marker was recorded (only when nothing remains in scope). */
+    recorded: boolean;
+}
+/**
+ * Every table column that can store a deprecated qualified name, derived from
+ * the booted registry. Empty when no class declares `previousQualifiedNames`.
+ */
+export declare function collectLegacyQualifiedNameTargets(): LegacyQualifiedNameTarget[];
+/**
+ * Count rows that still store a deprecated qualified name. Read-only.
+ *
+ * Absent tables are reported in `missingTables`, not as errors: the registry
+ * can carry classes this database never migrated.
+ */
+export declare function countLegacyQualifiedNameReferences(db: DatabaseInterface, options?: LegacyQualifiedNameOptions): Promise<LegacyQualifiedNameReport>;
+/**
+ * Stable `_smrt_backfills` marker for the declared alias set and scope. A new
+ * alias (another model move) produces a new marker, so the backfill runs
+ * again for it.
+ */
+export declare function legacyQualifiedNamesBackfillName(pairs?: Array<{
+    alias: string;
+    current: string;
+}>, tenantId?: string): string;
+/**
+ * Rewrite stored deprecated qualified names to their current names.
+ *
+ * Opt-in and idempotent: it never runs on its own, rewrites only rows whose
+ * value is exactly a declared old name, and records a `_smrt_backfills`
+ * marker (per alias set and tenant scope) once nothing in scope remains, so a
+ * second call is a no-op unless `force` is set. Rows are rewritten inside one
+ * transaction where the adapter provides one; the tenant column, ids and all
+ * other values are never touched, and a tenant-scoped run only touches that
+ * tenant's rows in tenant-owned tables. A row whose rewrite would duplicate a
+ * row already stored under the current name is skipped and reported.
+ */
+export declare function backfillLegacyQualifiedNames(db: DatabaseInterface, options?: LegacyQualifiedNameBackfillOptions): Promise<LegacyQualifiedNameBackfillResult>;
+//# sourceMappingURL=qualified-name-aliases.d.ts.map

package/dist/migrations/qualified-name-aliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualified-name-aliases.d.ts","sourceRoot":"","sources":["../../src/migrations/qualified-name-aliases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAa5D,2FAA2F;AAC3F,eAAO,MAAM,sCAAsC,uDACG,CAAC;AAEvD,gEAAgE;AAChE,MAAM,WAAW,yBAAyB;IACxC,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,aAAa,GAAG,KAAK,CAAC;IAC5B,mDAAmD;IACnD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,+DAA+D;AAC/D,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,aAAa,GAAG,KAAK,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,yBAAyB;IACxC,gEAAgE;IAChE,OAAO,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnD,4DAA4D;IAC5D,UAAU,EAAE,4BAA4B,EAAE,CAAC;IAC3C,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,0EAA0E;IAC1E,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kCACf,SAAQ,0BAA0B;IAClC,wEAAwE;IACxE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,oEAAoE;IACpE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,iCAAiC;IAChD,4FAA4F;IAC5F,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,MAAM,EAAE,yBAAyB,CAAC;IAClC,6CAA6C;IAC7C,SAAS,EAAE,4BAA4B,EAAE,CAAC;IAC1C;;;OAGG;IACH,iBAAiB,EAAE,4BAA4B,EAAE,CAAC;IAClD,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;CACnB;AAmDD;;;GAGG;AACH,wBAAgB,iCAAiC,IAAI,yBAAyB,EAAE,CA6D/E;AA8CD;;;;;GAKG;AACH,wBAAsB,kCAAkC,CACtD,EAAE,EAAE,iBAAiB,EACrB,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,yBAAyB,CAAC,CA4CpC;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,GAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAgB,EAC/D,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAaR;AA+CD;;;;;;;;;;;GAWG;AACH,wBAAsB,4BAA4B,CAChD,EAAE,EAAE,iBAAiB,EACrB,OAAO,GAAE,kCAAuC,GAC/C,OAAO,CAAC,iCAAiC,CAAC,CAiF5C"}

package/dist/migrations/qualified-name-aliases.js

@@ -0,0 +1,294 @@
+import { IMPLICIT_TENANT_COLUMN } from "../schema/conflict-target.js";
+import { toSnakeCase } from "../utils/naming.js";
+import { detectEngine } from "../schema/ddl/index.js";
+import { tableExists } from "../system/compatibility.js";
+import { isFrameworkBaseClass } from "../registry/framework-base-classes.js";
+import { isSmrtCollectionExtendsName } from "../registry/collection-resolution.js";
+import { ObjectRegistry } from "../registry.js";
+import { BackfillTracker } from "./backfill-tracker.js";
+import { createHash } from "node:crypto";
+//#region src/migrations/qualified-name-aliases.ts
+/**
+* Stored references to deprecated qualified names (#3338).
+*
+* `@smrt({ previousQualifiedNames })` keeps an old qualified name resolving
+* after a class moves package; it never rewrites stored data. This module is
+* the operator side of that bridge:
+*
+* - {@link countLegacyQualifiedNameReferences} — read-only counts of rows that
+*   still store an old name, which `smrt doctor --db` reports so a consumer
+*   can see when an alias is safe to remove;
+* - {@link backfillLegacyQualifiedNames} — an opt-in, idempotent rewrite of
+*   those rows to the current name. It never runs automatically.
+*
+* Stored references covered:
+*
+* - `meta_type` of every registered `SmrtPolymorphicAssociation` subclass
+*   table (any class can be a polymorphic target, so every alias is counted);
+* - `_meta_type` of an STI table whose family includes an aliased class.
+*
+* Removing an alias is a breaking change for any row this still counts.
+*/
+/** Prefix of the `_smrt_backfills` marker {@link backfillLegacyQualifiedNames} records. */
+var LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX = "@happyvertical/smrt-core:qualified-name-aliases:v1";
+function compareText(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function aliasPairs() {
+	return [...ObjectRegistry.getQualifiedNameAliases()].map(([alias, current]) => ({
+		alias,
+		current
+	}));
+}
+function quoteIdentifier(name) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name)) throw new Error(`Refusing to quote unexpected identifier "${name}"`);
+	return `"${name}"`;
+}
+function isPolymorphicAssociationFields(fields) {
+	return fields.has("metaType") && fields.has("metaId") && fields.has("role");
+}
+function safeConflictColumns(className) {
+	try {
+		return ObjectRegistry.getConflictColumns(className).map((column) => toSnakeCase(column));
+	} catch {
+		return [];
+	}
+}
+function safeTenantColumn(className) {
+	let declared;
+	try {
+		declared = ObjectRegistry.getTenantColumn(className);
+	} catch {
+		declared = void 0;
+	}
+	if (declared) return declared;
+	return ObjectRegistry.getFields(className).has("tenantId") ? IMPLICIT_TENANT_COLUMN : void 0;
+}
+/**
+* Every table column that can store a deprecated qualified name, derived from
+* the booted registry. Empty when no class declares `previousQualifiedNames`.
+*/
+function collectLegacyQualifiedNameTargets() {
+	const pairs = aliasPairs();
+	if (pairs.length === 0) return [];
+	const allAliases = pairs.map((pair) => pair.alias);
+	const byKey = /* @__PURE__ */ new Map();
+	const add = (target) => {
+		const key = `${target.table}\u0000${target.column}`;
+		const existing = byKey.get(key);
+		if (!existing) {
+			byKey.set(key, target);
+			return;
+		}
+		existing.aliases = [.../* @__PURE__ */ new Set([...existing.aliases, ...target.aliases])].sort(compareText);
+	};
+	for (const className of ObjectRegistry.getQualifiedClassNames()) {
+		const registered = ObjectRegistry.getClass(className);
+		if (!registered) continue;
+		if (isSmrtCollectionExtendsName(registered.extends)) continue;
+		if (isFrameworkBaseClass(registered.name, registered.packageName)) continue;
+		if (!isPolymorphicAssociationFields(registered.fields)) continue;
+		const table = ObjectRegistry.getTableName(className);
+		if (!table) continue;
+		const conflictColumns = safeConflictColumns(className);
+		const tenantColumn = safeTenantColumn(className);
+		add({
+			className,
+			table,
+			column: "meta_type",
+			kind: "polymorphic",
+			aliases: [...allAliases].sort(compareText),
+			...tenantColumn ? { tenantColumn } : {},
+			...conflictColumns.includes("meta_type") ? { conflictColumns } : {}
+		});
+	}
+	for (const { alias, current } of pairs) {
+		if (ObjectRegistry.getTableStrategy(current) !== "sti") continue;
+		const table = ObjectRegistry.getTableName(current);
+		if (!table) continue;
+		const conflictColumns = safeConflictColumns(current);
+		const tenantColumn = safeTenantColumn(current);
+		add({
+			className: current,
+			table,
+			column: "_meta_type",
+			kind: "sti",
+			aliases: [alias],
+			...tenantColumn ? { tenantColumn } : {},
+			...conflictColumns.includes("_meta_type") ? { conflictColumns } : {}
+		});
+	}
+	return [...byKey.values()].sort((left, right) => compareText(left.table, right.table) || compareText(left.column, right.column));
+}
+function rowsOf(result) {
+	if (Array.isArray(result)) return result;
+	if (result && typeof result === "object" && "rows" in result) {
+		const rows = result.rows;
+		if (Array.isArray(rows)) return rows;
+	}
+	return [];
+}
+function resolveEngine(db, engineHint) {
+	const withConfig = db;
+	return detectEngine(db.url || withConfig.config?.url || "", engineHint || withConfig.type || withConfig.config?.type);
+}
+async function countTarget(db, target, tenantId) {
+	const counts = /* @__PURE__ */ new Map();
+	if (target.aliases.length === 0) return counts;
+	const column = quoteIdentifier(target.column);
+	const params = [...target.aliases];
+	let sql = `SELECT ${column} AS name, COUNT(*) AS n FROM ${quoteIdentifier(target.table)} WHERE ${column} IN (${target.aliases.map(() => "?").join(", ")})`;
+	if (tenantId !== void 0 && target.tenantColumn) {
+		sql += ` AND ${quoteIdentifier(target.tenantColumn)} = ?`;
+		params.push(tenantId);
+	}
+	sql += ` GROUP BY ${column}`;
+	for (const row of rowsOf(await db.query(sql, ...params))) {
+		const count = Number(row.n ?? 0);
+		if (count > 0) counts.set(String(row.name), count);
+	}
+	return counts;
+}
+/**
+* Count rows that still store a deprecated qualified name. Read-only.
+*
+* Absent tables are reported in `missingTables`, not as errors: the registry
+* can carry classes this database never migrated.
+*/
+async function countLegacyQualifiedNameReferences(db, options = {}) {
+	const pairs = aliasPairs();
+	const currentByAlias = new Map(pairs.map((pair) => [pair.alias, pair]));
+	const report = {
+		aliases: pairs,
+		references: [],
+		total: 0,
+		missingTables: [],
+		untenantedTables: []
+	};
+	const engine = resolveEngine(db, options.engineHint);
+	for (const target of collectLegacyQualifiedNameTargets()) {
+		if (options.tenantId !== void 0 && !target.tenantColumn) {
+			if (!report.untenantedTables.includes(target.table)) report.untenantedTables.push(target.table);
+			continue;
+		}
+		if (!await tableExists(db, target.table, engine)) {
+			if (!report.missingTables.includes(target.table)) report.missingTables.push(target.table);
+			continue;
+		}
+		const counts = await countTarget(db, target, options.tenantId);
+		for (const alias of target.aliases) {
+			const count = counts.get(alias) ?? 0;
+			if (count === 0) continue;
+			report.references.push({
+				table: target.table,
+				column: target.column,
+				kind: target.kind,
+				alias,
+				current: currentByAlias.get(alias)?.current ?? alias,
+				count
+			});
+			report.total += count;
+		}
+	}
+	report.missingTables.sort(compareText);
+	report.untenantedTables.sort(compareText);
+	return report;
+}
+/**
+* Stable `_smrt_backfills` marker for the declared alias set and scope. A new
+* alias (another model move) produces a new marker, so the backfill runs
+* again for it.
+*/
+function legacyQualifiedNamesBackfillName(pairs = aliasPairs(), tenantId) {
+	const digest = createHash("sha256").update([...pairs].sort((left, right) => compareText(left.alias, right.alias)).map(({ alias, current }) => `${alias}=>${current}`).join("\n")).digest("hex").slice(0, 16);
+	return tenantId === void 0 ? `${LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX}:${digest}` : `${LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX}:${digest}:tenant:${tenantId}`;
+}
+function nullSafeEquals(engine, left, right) {
+	return engine === "sqlite" ? `${left} IS ${right}` : `${left} IS NOT DISTINCT FROM ${right}`;
+}
+function buildRewriteStatement(engine, target, tenantId, alias, current) {
+	const table = quoteIdentifier(target.table);
+	const column = quoteIdentifier(target.column);
+	const params = [current, alias];
+	let sql = `UPDATE ${table} SET ${column} = ? WHERE ${column} = ?`;
+	if (tenantId !== void 0 && target.tenantColumn) {
+		sql += ` AND ${quoteIdentifier(target.tenantColumn)} = ?`;
+		params.push(tenantId);
+	}
+	const identity = (target.conflictColumns ?? []).filter((name) => name !== target.column);
+	if (target.conflictColumns) {
+		const correlated = identity.map((name) => nullSafeEquals(engine, `__smrt_current.${quoteIdentifier(name)}`, `${table}.${quoteIdentifier(name)}`)).join(" AND ");
+		sql += ` AND NOT EXISTS (SELECT 1 FROM ${table} AS __smrt_current WHERE __smrt_current.${column} = ?${correlated ? ` AND ${correlated}` : ""})`;
+		params.push(current);
+	}
+	return {
+		sql,
+		params
+	};
+}
+/**
+* Rewrite stored deprecated qualified names to their current names.
+*
+* Opt-in and idempotent: it never runs on its own, rewrites only rows whose
+* value is exactly a declared old name, and records a `_smrt_backfills`
+* marker (per alias set and tenant scope) once nothing in scope remains, so a
+* second call is a no-op unless `force` is set. Rows are rewritten inside one
+* transaction where the adapter provides one; the tenant column, ids and all
+* other values are never touched, and a tenant-scoped run only touches that
+* tenant's rows in tenant-owned tables. A row whose rewrite would duplicate a
+* row already stored under the current name is skipped and reported.
+*/
+async function backfillLegacyQualifiedNames(db, options = {}) {
+	const pairs = aliasPairs();
+	const backfillName = legacyQualifiedNamesBackfillName(pairs, options.tenantId);
+	const dryRun = options.dryRun === true;
+	const before = await countLegacyQualifiedNameReferences(db, options);
+	const result = {
+		ran: false,
+		dryRun,
+		backfillName,
+		before,
+		rewritten: [],
+		skippedDuplicates: [],
+		recorded: false
+	};
+	if (pairs.length === 0 || dryRun) return result;
+	const tracker = new BackfillTracker({ db });
+	if (!options.force && await tracker.isApplied(backfillName)) return result;
+	const engine = resolveEngine(db, options.engineHint);
+	const targets = new Map(collectLegacyQualifiedNameTargets().map((target) => [`${target.table}\u0000${target.column}`, target]));
+	const rewrite = async (handle) => {
+		for (const reference of before.references) {
+			const target = targets.get(`${reference.table}\u0000${reference.column}`);
+			if (!target) continue;
+			const { sql, params } = buildRewriteStatement(engine, target, options.tenantId, reference.alias, reference.current);
+			await handle.query(sql, ...params);
+		}
+	};
+	if (typeof db.transaction === "function") await db.transaction(async (tx) => rewrite(tx));
+	else await rewrite(db);
+	const after = await countLegacyQualifiedNameReferences(db, options);
+	const remaining = new Map(after.references.map((reference) => [`${reference.table}\u0000${reference.column}\u0000${reference.alias}`, reference]));
+	for (const reference of before.references) {
+		const left = remaining.get(`${reference.table}\u0000${reference.column}\u0000${reference.alias}`);
+		const rewrittenCount = reference.count - (left?.count ?? 0);
+		if (rewrittenCount > 0) result.rewritten.push({
+			...reference,
+			count: rewrittenCount
+		});
+	}
+	result.skippedDuplicates = after.references;
+	result.ran = true;
+	if (after.total === 0) {
+		await tracker.recordApplied(backfillName, {
+			description: "Stored deprecated qualified names rewritten to current names: " + pairs.map(({ alias, current }) => `${alias} -> ${current}`).join(", "),
+			packageName: "@happyvertical/smrt-core"
+		});
+		result.recorded = true;
+	}
+	return result;
+}
+//#endregion
+export { LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX, backfillLegacyQualifiedNames, collectLegacyQualifiedNameTargets, countLegacyQualifiedNameReferences, legacyQualifiedNamesBackfillName };
+
+//# sourceMappingURL=qualified-name-aliases.js.map

package/dist/migrations/qualified-name-aliases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualified-name-aliases.js","names":[],"sources":["../../src/migrations/qualified-name-aliases.ts"],"sourcesContent":["/**\n * Stored references to deprecated qualified names (#3338).\n *\n * `@smrt({ previousQualifiedNames })` keeps an old qualified name resolving\n * after a class moves package; it never rewrites stored data. This module is\n * the operator side of that bridge:\n *\n * - {@link countLegacyQualifiedNameReferences} — read-only counts of rows that\n *   still store an old name, which `smrt doctor --db` reports so a consumer\n *   can see when an alias is safe to remove;\n * - {@link backfillLegacyQualifiedNames} — an opt-in, idempotent rewrite of\n *   those rows to the current name. It never runs automatically.\n *\n * Stored references covered:\n *\n * - `meta_type` of every registered `SmrtPolymorphicAssociation` subclass\n *   table (any class can be a polymorphic target, so every alias is counted);\n * - `_meta_type` of an STI table whose family includes an aliased class.\n *\n * Removing an alias is a breaking change for any row this still counts.\n */\n\nimport { createHash } from 'node:crypto';\nimport type { DatabaseInterface } from '@happyvertical/sql';\nimport { ObjectRegistry } from '../registry';\nimport { isSmrtCollectionExtendsName } from '../registry/collection-resolution.js';\nimport { isFrameworkBaseClass } from '../registry/framework-base-classes.js';\nimport {\n  IMPLICIT_TENANT_COLUMN,\n  IMPLICIT_TENANT_FIELD,\n} from '../schema/conflict-target.js';\nimport { detectEngine } from '../schema/ddl/index.js';\nimport { tableExists } from '../system/compatibility.js';\nimport { toSnakeCase } from '../utils/naming.js';\nimport { BackfillTracker } from './backfill-tracker.js';\n\n/** Prefix of the `_smrt_backfills` marker {@link backfillLegacyQualifiedNames} records. */\nexport const LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX =\n  '@happyvertical/smrt-core:qualified-name-aliases:v1';\n\n/** One table column that can store a class's qualified name. */\nexport interface LegacyQualifiedNameTarget {\n  /** Registered class that owns the table (qualified when available). */\n  className: string;\n  table: string;\n  /** `meta_type` (polymorphic association) or `_meta_type` (STI discriminator). */\n  column: string;\n  kind: 'polymorphic' | 'sti';\n  /** Deprecated names this column may still hold. */\n  aliases: string[];\n  /** Tenant column of the table, when tenant-owned. */\n  tenantColumn?: string;\n  /**\n   * Upsert identity columns that include `column`. A rewrite that would\n   * duplicate a current-name row on these columns is skipped, never forced.\n   */\n  conflictColumns?: string[];\n}\n\n/** Rows of one target that still store one deprecated name. */\nexport interface LegacyQualifiedNameReference {\n  table: string;\n  column: string;\n  kind: 'polymorphic' | 'sti';\n  alias: string;\n  current: string;\n  count: number;\n}\n\nexport interface LegacyQualifiedNameReport {\n  /** Declared alias → current qualified name, sorted by alias. */\n  aliases: Array<{ alias: string; current: string }>;\n  /** Non-zero counts only, sorted by table, column, alias. */\n  references: LegacyQualifiedNameReference[];\n  /** Sum of `references[].count`. */\n  total: number;\n  /** Target tables absent from this database (nothing to count). */\n  missingTables: string[];\n  /** Target tables excluded from a tenant-scoped run (no tenant column). */\n  untenantedTables: string[];\n}\n\nexport interface LegacyQualifiedNameOptions {\n  /**\n   * Restrict counting/rewriting to one tenant's rows. Tables without a tenant\n   * column are then skipped (reported in `untenantedTables`), never touched.\n   */\n  tenantId?: string;\n  /** Engine hint when the adapter URL does not identify it. */\n  engineHint?: string;\n}\n\nexport interface LegacyQualifiedNameBackfillOptions\n  extends LegacyQualifiedNameOptions {\n  /** Report what would change without writing (no marker is recorded). */\n  dryRun?: boolean;\n  /** Re-run even when this alias set's marker is already recorded. */\n  force?: boolean;\n}\n\nexport interface LegacyQualifiedNameBackfillResult {\n  /** `false` when the marker was already recorded (and `force` was unset) or on a dry run. */\n  ran: boolean;\n  dryRun: boolean;\n  /** The `_smrt_backfills` marker for this alias set and scope. */\n  backfillName: string;\n  /** Counts before the rewrite. */\n  before: LegacyQualifiedNameReport;\n  /** Rows rewritten per table/column/alias. */\n  rewritten: LegacyQualifiedNameReference[];\n  /**\n   * Rows left under their old name because the rewrite would duplicate a row\n   * already stored under the current name (resolve those by hand, then re-run).\n   */\n  skippedDuplicates: LegacyQualifiedNameReference[];\n  /** Whether the marker was recorded (only when nothing remains in scope). */\n  recorded: boolean;\n}\n\ntype AliasPair = { alias: string; current: string };\n\nfunction compareText(left: string, right: string): number {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n\nfunction aliasPairs(): AliasPair[] {\n  return [...ObjectRegistry.getQualifiedNameAliases()].map(\n    ([alias, current]) => ({ alias, current }),\n  );\n}\n\nfunction quoteIdentifier(name: string): string {\n  if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name)) {\n    throw new Error(`Refusing to quote unexpected identifier \"${name}\"`);\n  }\n  return `\"${name}\"`;\n}\n\nfunction isPolymorphicAssociationFields(fields: Map<string, unknown>): boolean {\n  // Same rule as delete planning (cascade.ts): all three columns\n  // `SmrtPolymorphicAssociation` contributes.\n  return fields.has('metaType') && fields.has('metaId') && fields.has('role');\n}\n\nfunction safeConflictColumns(className: string): string[] {\n  try {\n    return ObjectRegistry.getConflictColumns(className).map((column) =>\n      toSnakeCase(column),\n    );\n  } catch {\n    return [];\n  }\n}\n\nfunction safeTenantColumn(className: string): string | undefined {\n  let declared: string | undefined;\n  try {\n    declared = ObjectRegistry.getTenantColumn(className);\n  } catch {\n    declared = undefined;\n  }\n  if (declared) return declared;\n  // A `tenantId` field makes rows tenant-owned without any declaration.\n  return ObjectRegistry.getFields(className).has(IMPLICIT_TENANT_FIELD)\n    ? IMPLICIT_TENANT_COLUMN\n    : undefined;\n}\n\n/**\n * Every table column that can store a deprecated qualified name, derived from\n * the booted registry. Empty when no class declares `previousQualifiedNames`.\n */\nexport function collectLegacyQualifiedNameTargets(): LegacyQualifiedNameTarget[] {\n  const pairs = aliasPairs();\n  if (pairs.length === 0) return [];\n  const allAliases = pairs.map((pair) => pair.alias);\n  const byKey = new Map<string, LegacyQualifiedNameTarget>();\n\n  const add = (target: LegacyQualifiedNameTarget) => {\n    const key = `${target.table}\\u0000${target.column}`;\n    const existing = byKey.get(key);\n    if (!existing) {\n      byKey.set(key, target);\n      return;\n    }\n    existing.aliases = [\n      ...new Set([...existing.aliases, ...target.aliases]),\n    ].sort(compareText);\n  };\n\n  for (const className of ObjectRegistry.getQualifiedClassNames()) {\n    const registered = ObjectRegistry.getClass(className);\n    if (!registered) continue;\n    if (isSmrtCollectionExtendsName(registered.extends)) continue;\n    if (isFrameworkBaseClass(registered.name, registered.packageName)) continue;\n    if (!isPolymorphicAssociationFields(registered.fields)) continue;\n    const table = ObjectRegistry.getTableName(className);\n    if (!table) continue;\n    const conflictColumns = safeConflictColumns(className);\n    const tenantColumn = safeTenantColumn(className);\n    add({\n      className,\n      table,\n      column: 'meta_type',\n      kind: 'polymorphic',\n      aliases: [...allAliases].sort(compareText),\n      ...(tenantColumn ? { tenantColumn } : {}),\n      ...(conflictColumns.includes('meta_type') ? { conflictColumns } : {}),\n    });\n  }\n\n  for (const { alias, current } of pairs) {\n    if (ObjectRegistry.getTableStrategy(current) !== 'sti') continue;\n    const table = ObjectRegistry.getTableName(current);\n    if (!table) continue;\n    const conflictColumns = safeConflictColumns(current);\n    const tenantColumn = safeTenantColumn(current);\n    add({\n      className: current,\n      table,\n      column: '_meta_type',\n      kind: 'sti',\n      aliases: [alias],\n      ...(tenantColumn ? { tenantColumn } : {}),\n      ...(conflictColumns.includes('_meta_type') ? { conflictColumns } : {}),\n    });\n  }\n\n  return [...byKey.values()].sort(\n    (left, right) =>\n      compareText(left.table, right.table) ||\n      compareText(left.column, right.column),\n  );\n}\n\nfunction rowsOf(result: unknown): Record<string, unknown>[] {\n  if (Array.isArray(result)) return result as Record<string, unknown>[];\n  if (result && typeof result === 'object' && 'rows' in result) {\n    const rows = (result as { rows?: unknown }).rows;\n    if (Array.isArray(rows)) return rows as Record<string, unknown>[];\n  }\n  return [];\n}\n\nfunction resolveEngine(db: DatabaseInterface, engineHint?: string): string {\n  const withConfig = db as DatabaseInterface & {\n    config?: { url?: string; type?: string };\n    type?: string;\n  };\n  return detectEngine(\n    db.url || withConfig.config?.url || '',\n    engineHint || withConfig.type || withConfig.config?.type,\n  );\n}\n\nasync function countTarget(\n  db: DatabaseInterface,\n  target: LegacyQualifiedNameTarget,\n  tenantId: string | undefined,\n): Promise<Map<string, number>> {\n  const counts = new Map<string, number>();\n  if (target.aliases.length === 0) return counts;\n  const column = quoteIdentifier(target.column);\n  const params: unknown[] = [...target.aliases];\n  let sql =\n    `SELECT ${column} AS name, COUNT(*) AS n FROM ${quoteIdentifier(target.table)} ` +\n    `WHERE ${column} IN (${target.aliases.map(() => '?').join(', ')})`;\n  if (tenantId !== undefined && target.tenantColumn) {\n    sql += ` AND ${quoteIdentifier(target.tenantColumn)} = ?`;\n    params.push(tenantId);\n  }\n  sql += ` GROUP BY ${column}`;\n  for (const row of rowsOf(await db.query(sql, ...params))) {\n    const count = Number(row.n ?? 0);\n    if (count > 0) counts.set(String(row.name), count);\n  }\n  return counts;\n}\n\n/**\n * Count rows that still store a deprecated qualified name. Read-only.\n *\n * Absent tables are reported in `missingTables`, not as errors: the registry\n * can carry classes this database never migrated.\n */\nexport async function countLegacyQualifiedNameReferences(\n  db: DatabaseInterface,\n  options: LegacyQualifiedNameOptions = {},\n): Promise<LegacyQualifiedNameReport> {\n  const pairs = aliasPairs();\n  const currentByAlias = new Map(pairs.map((pair) => [pair.alias, pair]));\n  const report: LegacyQualifiedNameReport = {\n    aliases: pairs,\n    references: [],\n    total: 0,\n    missingTables: [],\n    untenantedTables: [],\n  };\n  const engine = resolveEngine(db, options.engineHint);\n\n  for (const target of collectLegacyQualifiedNameTargets()) {\n    if (options.tenantId !== undefined && !target.tenantColumn) {\n      if (!report.untenantedTables.includes(target.table)) {\n        report.untenantedTables.push(target.table);\n      }\n      continue;\n    }\n    if (!(await tableExists(db, target.table, engine))) {\n      if (!report.missingTables.includes(target.table)) {\n        report.missingTables.push(target.table);\n      }\n      continue;\n    }\n    const counts = await countTarget(db, target, options.tenantId);\n    for (const alias of target.aliases) {\n      const count = counts.get(alias) ?? 0;\n      if (count === 0) continue;\n      report.references.push({\n        table: target.table,\n        column: target.column,\n        kind: target.kind,\n        alias,\n        current: currentByAlias.get(alias)?.current ?? alias,\n        count,\n      });\n      report.total += count;\n    }\n  }\n\n  report.missingTables.sort(compareText);\n  report.untenantedTables.sort(compareText);\n  return report;\n}\n\n/**\n * Stable `_smrt_backfills` marker for the declared alias set and scope. A new\n * alias (another model move) produces a new marker, so the backfill runs\n * again for it.\n */\nexport function legacyQualifiedNamesBackfillName(\n  pairs: Array<{ alias: string; current: string }> = aliasPairs(),\n  tenantId?: string,\n): string {\n  const digest = createHash('sha256')\n    .update(\n      [...pairs]\n        .sort((left, right) => compareText(left.alias, right.alias))\n        .map(({ alias, current }) => `${alias}=>${current}`)\n        .join('\\n'),\n    )\n    .digest('hex')\n    .slice(0, 16);\n  return tenantId === undefined\n    ? `${LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX}:${digest}`\n    : `${LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX}:${digest}:tenant:${tenantId}`;\n}\n\nfunction nullSafeEquals(engine: string, left: string, right: string): string {\n  return engine === 'sqlite'\n    ? `${left} IS ${right}`\n    : `${left} IS NOT DISTINCT FROM ${right}`;\n}\n\nfunction buildRewriteStatement(\n  engine: string,\n  target: LegacyQualifiedNameTarget,\n  tenantId: string | undefined,\n  alias: string,\n  current: string,\n): { sql: string; params: unknown[] } {\n  const table = quoteIdentifier(target.table);\n  const column = quoteIdentifier(target.column);\n  const params: unknown[] = [current, alias];\n  let sql = `UPDATE ${table} SET ${column} = ? WHERE ${column} = ?`;\n  if (tenantId !== undefined && target.tenantColumn) {\n    sql += ` AND ${quoteIdentifier(target.tenantColumn)} = ?`;\n    params.push(tenantId);\n  }\n  const identity = (target.conflictColumns ?? []).filter(\n    (name) => name !== target.column,\n  );\n  if (target.conflictColumns) {\n    // Never rewrite a row onto the identity of one already stored under the\n    // current name: that is a duplicate association, which an operator must\n    // resolve, not a unique-violation the rewrite should provoke.\n    const correlated = identity\n      .map((name) =>\n        nullSafeEquals(\n          engine,\n          `__smrt_current.${quoteIdentifier(name)}`,\n          `${table}.${quoteIdentifier(name)}`,\n        ),\n      )\n      .join(' AND ');\n    sql +=\n      ` AND NOT EXISTS (SELECT 1 FROM ${table} AS __smrt_current ` +\n      `WHERE __smrt_current.${column} = ?${correlated ? ` AND ${correlated}` : ''})`;\n    params.push(current);\n  }\n  return { sql, params };\n}\n\n/**\n * Rewrite stored deprecated qualified names to their current names.\n *\n * Opt-in and idempotent: it never runs on its own, rewrites only rows whose\n * value is exactly a declared old name, and records a `_smrt_backfills`\n * marker (per alias set and tenant scope) once nothing in scope remains, so a\n * second call is a no-op unless `force` is set. Rows are rewritten inside one\n * transaction where the adapter provides one; the tenant column, ids and all\n * other values are never touched, and a tenant-scoped run only touches that\n * tenant's rows in tenant-owned tables. A row whose rewrite would duplicate a\n * row already stored under the current name is skipped and reported.\n */\nexport async function backfillLegacyQualifiedNames(\n  db: DatabaseInterface,\n  options: LegacyQualifiedNameBackfillOptions = {},\n): Promise<LegacyQualifiedNameBackfillResult> {\n  const pairs = aliasPairs();\n  const backfillName = legacyQualifiedNamesBackfillName(\n    pairs,\n    options.tenantId,\n  );\n  const dryRun = options.dryRun === true;\n  const before = await countLegacyQualifiedNameReferences(db, options);\n  const result: LegacyQualifiedNameBackfillResult = {\n    ran: false,\n    dryRun,\n    backfillName,\n    before,\n    rewritten: [],\n    skippedDuplicates: [],\n    recorded: false,\n  };\n  if (pairs.length === 0 || dryRun) return result;\n\n  const tracker = new BackfillTracker({ db });\n  if (!options.force && (await tracker.isApplied(backfillName))) {\n    return result;\n  }\n\n  const engine = resolveEngine(db, options.engineHint);\n  const targets = new Map(\n    collectLegacyQualifiedNameTargets().map((target) => [\n      `${target.table}\\u0000${target.column}`,\n      target,\n    ]),\n  );\n\n  const rewrite = async (handle: DatabaseInterface) => {\n    for (const reference of before.references) {\n      const target = targets.get(`${reference.table}\\u0000${reference.column}`);\n      if (!target) continue;\n      const { sql, params } = buildRewriteStatement(\n        engine,\n        target,\n        options.tenantId,\n        reference.alias,\n        reference.current,\n      );\n      await handle.query(sql, ...params);\n    }\n  };\n  if (typeof db.transaction === 'function') {\n    await db.transaction(async (tx) => rewrite(tx as DatabaseInterface));\n  } else {\n    await rewrite(db);\n  }\n\n  const after = await countLegacyQualifiedNameReferences(db, options);\n  const remaining = new Map(\n    after.references.map((reference) => [\n      `${reference.table}\\u0000${reference.column}\\u0000${reference.alias}`,\n      reference,\n    ]),\n  );\n  for (const reference of before.references) {\n    const left = remaining.get(\n      `${reference.table}\\u0000${reference.column}\\u0000${reference.alias}`,\n    );\n    const rewrittenCount = reference.count - (left?.count ?? 0);\n    if (rewrittenCount > 0) {\n      result.rewritten.push({ ...reference, count: rewrittenCount });\n    }\n  }\n  result.skippedDuplicates = after.references;\n  result.ran = true;\n\n  if (after.total === 0) {\n    await tracker.recordApplied(backfillName, {\n      description:\n        'Stored deprecated qualified names rewritten to current names: ' +\n        pairs.map(({ alias, current }) => `${alias} -> ${current}`).join(', '),\n      packageName: '@happyvertical/smrt-core',\n    });\n    result.recorded = true;\n  }\n  return result;\n}\n"],"mappings":"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"}

package/dist/migrations.js

@@ -10,5 +10,6 @@ import { MinorUnitsPreflightError, buildMinorUnitsStatements, preflightMinorUnit
 import { collectNullEqualIndexTargets, migrateNullEqualIndexes, nullEqualDuplicateDetector, nullEqualIndexStatements, preflightNullEqualIndexes } from "./migrations/null-equal-indexes.js";
 import { MigrationTracker, buildConcurrentIndexPlan, extractCreatedIndexName, planPostgresStatements } from "./migrations/tracker.js";
 import { getPendingSchemaStatements, migrateSmrtSchemas } from "./migrations/orchestrate.js";
+import { LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX, backfillLegacyQualifiedNames, collectLegacyQualifiedNameTargets, countLegacyQualifiedNameReferences, legacyQualifiedNamesBackfillName } from "./migrations/qualified-name-aliases.js";
 import "./migrations/index.js";
-export { BackfillTableUnavailableError, BackfillTracker, FRAMEWORK_BASE_TABLE_NAMES, MigrationGenerator, MigrationTracker, MinorUnitsPreflightError, REQUIRED_COLUMN_NOT_ADDED, SQLITE_REBUILD_TABLE_PREFIX, SchemaComparer, buildConcurrentIndexPlan, buildIntegerWidthStatements, buildIntegerWidthTableStatements, buildMinorUnitsStatements, buildSqliteRebuildStatements, canonicalizeDefault, collectIntegerWidthTargets, collectNullEqualIndexTargets, computeChecksum, createMigrationDefinition, dropFrameworkBaseTables, extractCreatedIndexName, generateMigrationSequence, generateMigrationTimestamp, generateSchemaDiff, getPendingSchemaStatements, getSQLFromDiff, hasActionableChanges, isAdvisoryOnlyChange, isInfoOnlyChange, isManualOrAdvisoryChange, isSqliteRebuildPlaceholder, migrateNullEqualIndexes, migrateSmrtSchemas, normalizeSQL, nullEqualDuplicateDetector, nullEqualIndexStatements, parsePostgresTimeoutMs, planFrameworkBaseTableDrop, planPostgresStatements, planSqliteTableRebuilds, preflightIntegerWidthWidening, preflightMinorUnitsRescale, preflightNullEqualIndexes, rescaleMoneyColumnsToMinorUnits, rewriteSqliteCreateTable, shortChecksum, sqliteRebuildPlaceholderSql, uniqueColumnIndexName, verifyChecksum, widenIntegerColumnsToBigInt };
+export { BackfillTableUnavailableError, BackfillTracker, FRAMEWORK_BASE_TABLE_NAMES, LEGACY_QUALIFIED_NAMES_BACKFILL_PREFIX, MigrationGenerator, MigrationTracker, MinorUnitsPreflightError, REQUIRED_COLUMN_NOT_ADDED, SQLITE_REBUILD_TABLE_PREFIX, SchemaComparer, backfillLegacyQualifiedNames, buildConcurrentIndexPlan, buildIntegerWidthStatements, buildIntegerWidthTableStatements, buildMinorUnitsStatements, buildSqliteRebuildStatements, canonicalizeDefault, collectIntegerWidthTargets, collectLegacyQualifiedNameTargets, collectNullEqualIndexTargets, computeChecksum, countLegacyQualifiedNameReferences, createMigrationDefinition, dropFrameworkBaseTables, extractCreatedIndexName, generateMigrationSequence, generateMigrationTimestamp, generateSchemaDiff, getPendingSchemaStatements, getSQLFromDiff, hasActionableChanges, isAdvisoryOnlyChange, isInfoOnlyChange, isManualOrAdvisoryChange, isSqliteRebuildPlaceholder, legacyQualifiedNamesBackfillName, migrateNullEqualIndexes, migrateSmrtSchemas, normalizeSQL, nullEqualDuplicateDetector, nullEqualIndexStatements, parsePostgresTimeoutMs, planFrameworkBaseTableDrop, planPostgresStatements, planSqliteTableRebuilds, preflightIntegerWidthWidening, preflightMinorUnitsRescale, preflightNullEqualIndexes, rescaleMoneyColumnsToMinorUnits, rewriteSqliteCreateTable, shortChecksum, sqliteRebuildPlaceholderSql, uniqueColumnIndexName, verifyChecksum, widenIntegerColumnsToBigInt };

package/dist/polymorphic-association.d.ts

@@ -80,6 +80,19 @@ export declare class SmrtPolymorphicAssociation extends SmrtObject {
     /** Sort order for ordering targets within a role. */
     sortOrder: number;
     constructor(options?: SmrtPolymorphicAssociationOptions);
+    /**
+     * Store `metaType` under its target's CURRENT qualified name before every
+     * save (#3338). A deprecated name declared in the target's
+     * `previousQualifiedNames` is rewritten first, so new rows — and any legacy
+     * row that is loaded and saved again — never perpetuate it. A target known
+     * only from an installed manifest is lazily loaded first; names that
+     * resolve to no class at all are stored as given.
+     *
+     * This runs in the first save-preparation hook rather than a `save()`
+     * override: a public override would be scanned into every subclass's
+     * manifest as a `save` method.
+     */
+    protected validateBeforeSave(): Promise<void>;
     /**
      * Resolve and load the target object this association points at.
      *
@@ -100,6 +113,11 @@ export declare class SmrtPolymorphicAssociation extends SmrtObject {
      * exists. The target shares this association's database connection via
      * `this.options`.
      *
+     * A `metaType` written under a class's former qualified name (declared in
+     * its `previousQualifiedNames`, e.g. after the class moved package)
+     * resolves to the class, eagerly or through the lazy manifest alias index,
+     * with a one-time deprecation warning (#3338).
+     *
      * Prefer qualified `metaType` values (`@pkg:Class`): a bare simple name
      * resolves to the first registered match, and an ambiguous unqualified name
      * that has to be lazily loaded surfaces a `ConfigurationError` rather than

package/dist/polymorphic-association.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polymorphic-association.d.ts","sourceRoot":"","sources":["../src/polymorphic-association.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAGH,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG9D;;;GAGG;AACH,MAAM,WAAW,iCAAkC,SAAQ,iBAAiB;IAC1E,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,0BAA2B,SAAQ,UAAU;IACxD;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,6BAA6B,EAAG,IAAI,CAAU;IAE9D,kFAAkF;IAElF,QAAQ,SAAM;IAEd;;;;OAIG;IAEH,MAAM,SAAM;IAEZ,+EAA+E;IAE/E,IAAI,SAAa;IAEjB,qDAAqD;IAErD,SAAS,EAAE,MAAM,CAAK;gBAEV,OAAO,GAAE,iCAAsC;IAQ3D;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,OAAO,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,KAAK,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;CAqCtE"}
+{"version":3,"file":"polymorphic-association.d.ts","sourceRoot":"","sources":["../src/polymorphic-association.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAGH,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG9D;;;GAGG;AACH,MAAM,WAAW,iCAAkC,SAAQ,iBAAiB;IAC1E,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,0BAA2B,SAAQ,UAAU;IACxD;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,6BAA6B,EAAG,IAAI,CAAU;IAE9D,kFAAkF;IAElF,QAAQ,SAAM;IAEd;;;;OAIG;IAEH,MAAM,SAAM;IAEZ,+EAA+E;IAE/E,IAAI,SAAa;IAEjB,qDAAqD;IAErD,SAAS,EAAE,MAAM,CAAK;gBAEV,OAAO,GAAE,iCAAsC;IAQ3D;;;;;;;;;;;OAWG;cACsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,OAAO,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,KAAK,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;CAsCtE"}

package/dist/polymorphic-association.js

@@ -78,6 +78,25 @@ var SmrtPolymorphicAssociation = class extends SmrtObject {
 		if (options.sortOrder !== void 0) this.sortOrder = options.sortOrder;
 	}
 	/**
+	* Store `metaType` under its target's CURRENT qualified name before every
+	* save (#3338). A deprecated name declared in the target's
+	* `previousQualifiedNames` is rewritten first, so new rows — and any legacy
+	* row that is loaded and saved again — never perpetuate it. A target known
+	* only from an installed manifest is lazily loaded first; names that
+	* resolve to no class at all are stored as given.
+	*
+	* This runs in the first save-preparation hook rather than a `save()`
+	* override: a public override would be scanned into every subclass's
+	* manifest as a `save` method.
+	*/
+	async validateBeforeSave() {
+		if (this.metaType) {
+			const current = await ObjectRegistry.resolveQualifiedNameAsync(this.metaType, { source: "SmrtPolymorphicAssociation.save" });
+			if (current && current !== this.metaType) this.metaType = current;
+		}
+		await super.validateBeforeSave();
+	}
+	/**
 	* Resolve and load the target object this association points at.
 	*
 	* Resolves `metaType` to its registered class via
@@ -97,6 +116,11 @@ var SmrtPolymorphicAssociation = class extends SmrtObject {
 	* exists. The target shares this association's database connection via
 	* `this.options`.
 	*
+	* A `metaType` written under a class's former qualified name (declared in
+	* its `previousQualifiedNames`, e.g. after the class moved package)
+	* resolves to the class, eagerly or through the lazy manifest alias index,
+	* with a one-time deprecation warning (#3338).
+	*
 	* Prefer qualified `metaType` values (`@pkg:Class`): a bare simple name
 	* resolves to the first registered match, and an ambiguous unqualified name
 	* that has to be lazily loaded surfaces a `ConfigurationError` rather than
@@ -106,10 +130,11 @@ var SmrtPolymorphicAssociation = class extends SmrtObject {
 	*/
 	async hydrate() {
 		if (!this.metaType || !this.metaId) return null;
-		let registered = ObjectRegistry.getClassByQualifiedName(this.metaType) ?? ObjectRegistry.getClass(this.metaType);
+		const lookup = { source: "SmrtPolymorphicAssociation.hydrate" };
+		let registered = ObjectRegistry.getClassByQualifiedName(this.metaType, lookup) ?? ObjectRegistry.getClass(this.metaType);
 		if (!registered) {
 			if (!await ObjectRegistry.tryLoadFromExternalPackage(this.metaType)) return null;
-			registered = ObjectRegistry.getClassByQualifiedName(this.metaType) ?? ObjectRegistry.getClass(this.metaType);
+			registered = ObjectRegistry.getClassByQualifiedName(this.metaType, lookup) ?? ObjectRegistry.getClass(this.metaType);
 		}
 		if (!registered) return null;
 		return await (await ObjectRegistry.getCollection(registered.qualifiedName ?? registered.name, this.options)).get({ id: this.metaId });