@happyvertical/smrt-core 0.51.39 → 0.52.0

package/dist/registry.js

@@ -1,12 +1,13 @@
 import { ConfigurationError } from "./errors.js";
+import { defaultConflictColumns, resolveOwnershipTenantColumn, resolveTenantColumn } from "./schema/conflict-target.js";
 import { classnameToTablename, toSnakeCase } from "./utils/naming.js";
+import { buildCascadePlan } from "./cascade.js";
 import { applyOneToManyChildAccessors } from "./child-accessors.js";
 import { applyPendingDecoratorRegistrations } from "./decorators/compatibility.js";
 import { bumpRegistryGeneration, getRegistryGeneration } from "./registry/generation.js";
 import { createQualifiedName, isQualifiedName, parseQualifiedName } from "./utils/qualified-names.js";
 import { LRUCache } from "./utils/lru-cache.js";
 import { getClasses, getCollectionCache, getCollectionTableNames, getCollections, getConstructorFieldDecorators, getConstructorTenantScopedDeclarations, getDbInstanceIds, getDiscoveryAttemptCache, getFieldDecorators, getInheritanceCache, getLegacyFieldDecorators, getMethodDecorators, getNextDbId, getSourceFileFromStack, getStiSiblingsLoaded, setNextDbId, verboseLog } from "./registry/shared-state.js";
-import { defaultConflictColumns, resolveTenantColumn } from "./schema/conflict-target.js";
 import { clearRegistryDiagnostics, flushRegistryDiagnostics, getRegistryDiagnostics, recordRegistryDiagnostic } from "./registry/diagnostics.js";
 import { cloneManifestSchemaColumns, discoverCachedManifestSync, getManifestCache, getNodeBuiltins, loadExternalManifestSyncWithNode } from "./manifest/store.js";
 import { getDefaultCompositeSource } from "./manifest/sources/composite.js";
@@ -99,11 +100,17 @@ function applyManifestFieldColumnMetadata(columns, fieldEntries) {
 		const columnName = toSnakeCase(fieldName);
 		const existingColumn = columns[columnName];
 		if (!existingColumn) continue;
-		columns[columnName] = {
+		const column = {
 			...existingColumn,
 			...sqlType ? { type: String(sqlType).toUpperCase() } : {},
 			...referenceKind ? { referenceKind } : {}
 		};
+		if (String(column.type).toUpperCase() === "UUID") {
+			const loose = column;
+			if (loose.default === "") delete loose.default;
+			if (loose.defaultValue === "") delete loose.defaultValue;
+		}
+		columns[columnName] = column;
 	}
 }
 async function discoverInstalledSmrtPackages() {
@@ -143,6 +150,22 @@ function resolveManifestByUpwardSearch(builtins, missingPath) {
 	return null;
 }
 /**
+* The absolute filesystem path behind a Vite dev-server URL
+* (`http(s)://host/@fs/<absolute path>`), or `null` for any other string.
+*/
+function viteFsUrlToPath(urlString) {
+	if (!/^https?:\/\//i.test(urlString)) return null;
+	let pathname;
+	try {
+		pathname = new URL(urlString).pathname;
+	} catch {
+		return null;
+	}
+	if (!pathname.startsWith("/@fs/")) return null;
+	const decoded = decodeURIComponent(pathname.slice(4));
+	return /^\/[A-Za-z]:\//.test(decoded) ? decoded.slice(1) : decoded;
+}
+/**
 * Central registry for all SMRT objects
 *
 * Uses globalThis for cross-module state sharing, ensuring all module instances
@@ -1069,8 +1092,10 @@ var ObjectRegistry = class ObjectRegistry {
 		let manifest = null;
 		try {
 			const urlString = manifestUrl instanceof URL ? manifestUrl.href : manifestUrl;
+			const devServerPath = viteFsUrlToPath(urlString);
 			let filePath;
-			if (manifestUrl instanceof URL) filePath = builtins.url.fileURLToPath(manifestUrl);
+			if (devServerPath) filePath = devServerPath;
+			else if (manifestUrl instanceof URL) filePath = builtins.url.fileURLToPath(manifestUrl);
 			else if (urlString.startsWith("file:")) filePath = builtins.url.fileURLToPath(urlString);
 			else filePath = urlString;
 			if (!builtins.fs.existsSync(filePath)) {
@@ -2004,10 +2029,11 @@ var ObjectRegistry = class ObjectRegistry {
 	*    primary-key column(s) — the only unique key such a table has;
 	* 4. the strategy default — CTI `['slug', 'context']`, STI
 	*    `['slug', 'context', '_meta_type']` — led by the tenant column when
-	*    the schema owner is tenant-scoped (#2360): tenant-scoped rows are
-	*    unique per tenant, and without the tenant column a second tenant's
-	*    `save()` of the same natural key updated the first tenant's row
-	*    through `DO UPDATE SET`.
+	*    the schema owner is tenant-scoped (#2360) or carries an undeclared
+	*    `tenantId` field ({@link ObjectRegistry.getOwnershipTenantColumn}):
+	*    tenant-owned rows are unique per tenant, and without the tenant column
+	*    a second tenant's `save()` of the same natural key updated the first
+	*    tenant's row through `DO UPDATE SET`.
 	*
 	* STI subclasses share a table, so the discriminator participates in
 	* identity — two subtypes can coexist with the same (slug, context). The
@@ -2053,7 +2079,92 @@ var ObjectRegistry = class ObjectRegistry {
 		}
 		const primaryKeyColumns = Array.from(owner.fields.entries()).filter(([, field]) => field?._meta?.primaryKey === true).map(([fieldName]) => toSnakeCase(fieldName));
 		if (primaryKeyColumns.length > 0) return primaryKeyColumns;
-		return defaultConflictColumns(tableStrategy, ObjectRegistry.getTenantColumn(className));
+		return defaultConflictColumns(tableStrategy, ObjectRegistry.getOwnershipTenantColumn(className));
+	}
+	/**
+	* The column that owns a table's rows for natural-key identity: the
+	* declared tenant column ({@link ObjectRegistry.getTenantColumn}), else
+	* `tenant_id` when the schema owner has a `tenantId` field but declares no
+	* tenancy — the shape a consumer registers with the tenancy interceptor at
+	* runtime. The default conflict target and unique index lead with it, so a
+	* second tenant's same-slug row is a second row rather than an upsert onto
+	* the first tenant's. See `resolveOwnershipTenantColumn()`.
+	*
+	* @param className - Name of the class (simple or qualified)
+	* @returns The snake_case ownership column, or `undefined`
+	*/
+	static getOwnershipTenantColumn(className) {
+		const declared = ObjectRegistry.getTenantColumn(className);
+		const registered = ObjectRegistry.findClass(className);
+		if (!registered) return declared;
+		const ownerName = ObjectRegistry.getTableStrategy(className) === "sti" ? ObjectRegistry.getSTIBase(className) : null;
+		const owner = ownerName && ownerName !== className ? ObjectRegistry.findClass(ownerName) ?? registered : registered;
+		return resolveOwnershipTenantColumn(declared, (columnName) => [...owner.fields.entries()].some(([fieldName, field]) => field?.type !== "oneToMany" && field?.type !== "manyToMany" && toSnakeCase(fieldName) === columnName));
+	}
+	/**
+	* Every typed reference (`@foreignKey` / `@crossPackageRef`) that points at
+	* `className`, resolved the same way `SmrtObject.delete()` resolves them for
+	* cascades: the referencing class, its table and column, and the resolved
+	* `onDelete` action. Use it to re-point references before replacing one row
+	* with another (a tag merge) instead of letting a delete cascade them away.
+	*
+	* @param className - Name of the referenced class (simple or qualified)
+	*/
+	static getIncomingReferences(className) {
+		return buildCascadePlan(ObjectRegistry, className).references.map((reference) => ({
+			className: reference.className,
+			tableName: reference.tableName,
+			column: reference.column,
+			onDelete: reference.action
+		}));
+	}
+	/**
+	* Runtime ownership-column sources (see
+	* {@link ObjectRegistry.registerOwnershipColumnSource}).
+	*/
+	static ownershipColumnSources = /* @__PURE__ */ new Set();
+	/**
+	* Register a source of RUNTIME ownership columns: columns that record a
+	* row's owner for a class whose manifest does not say so — the tenancy
+	* package's `registerTenantScopedClass('Team', { field: 'organizationId' })`
+	* is the canonical producer.
+	*
+	* Core reads these only to protect ownership on save
+	* ({@link ObjectRegistry.getOwnershipColumns}); they never change the
+	* conflict target or the schema, which are build-time contracts a runtime
+	* registration cannot alter without breaking `ON CONFLICT` binding. The
+	* source is consulted on every lookup, so registrations that bind later (a
+	* selector registered before its class) or are removed take effect
+	* immediately.
+	*
+	* @param source - maps a qualified class name to its runtime ownership
+	*   columns (snake_case), or `undefined` when it has none
+	* @returns a disposer that removes the source
+	*/
+	static registerOwnershipColumnSource(source) {
+		ObjectRegistry.ownershipColumnSources.add(source);
+		return () => {
+			ObjectRegistry.ownershipColumnSources.delete(source);
+		};
+	}
+	/**
+	* Every column that records a row's owner for natural-key save protection:
+	* `tenant_id`, the declared tenant column, each `@tenantId`-marked field's
+	* column, and every runtime ownership column a registered source reports
+	* ({@link ObjectRegistry.registerOwnershipColumnSource}) — so a runtime
+	* tenancy registration on a custom field (`organizationId`) is compared like
+	* `tenant_id`.
+	*
+	* @param className - Name of the class (simple or qualified)
+	*/
+	static getOwnershipColumns(className) {
+		const columns = /* @__PURE__ */ new Set(["tenant_id"]);
+		const declared = ObjectRegistry.getTenantColumn(className);
+		if (declared) columns.add(declared);
+		for (const [name, field] of ObjectRegistry.getFields(className)) if (field.__tenancy?.isTenantIdField || field._meta?.__tenancy?.isTenantIdField) columns.add(toSnakeCase(name));
+		const qualifiedName = ObjectRegistry.findClass(className)?.qualifiedName ?? className;
+		for (const source of ObjectRegistry.ownershipColumnSources) for (const column of source(qualifiedName) ?? []) if (column) columns.add(column);
+		return columns;
 	}
 	/**
 	* The tenant column of the table a class writes to, or `undefined` when its