@happyvertical/smrt-core 0.40.69 → 0.41.0

package/dist/registry.js

@@ -1,6 +1,7 @@
+import { ConfigurationError } from "./errors.js";
+import { classnameToTablename, toSnakeCase } from "./utils/naming.js";
 import { applyOneToManyChildAccessors } from "./child-accessors.js";
 import { applyPendingDecoratorRegistrations } from "./decorators/compatibility.js";
-import { ConfigurationError } from "./errors.js";
 import { clearRegistryDiagnostics, flushRegistryDiagnostics, getRegistryDiagnostics, recordRegistryDiagnostic } from "./registry/diagnostics.js";
 import { createQualifiedName, isQualifiedName, parseQualifiedName } from "./utils/qualified-names.js";
 import { cloneManifestSchemaColumns, discoverCachedManifestSync, getNodeBuiltins, loadExternalManifestSyncWithNode } from "./manifest/store.js";
@@ -11,7 +12,7 @@ import { getClasses, getCollectionCache, getCollectionTableNames, getCollections
 import { findClass, findClassesByName, getAllClasses, getCanonicalClassName, getClass, getClassByConstructor, getClassByQualifiedName, getClassInPackage, getClassNames, getClassesByPackage, getClassesByVisibility, getPublicClasses, getQualifiedClassNames, hasClass, hasClassCaseInsensitive, resolveType } from "./registry/name-resolver.js";
 import { getAllFields, getAllMethods, getInheritanceChain, mergeFieldConfigs } from "./registry/inheritance-resolver.js";
 import { resolveCollectionCacheConfig } from "./registry/cache-config.js";
-import { classnameToTablename, toSnakeCase } from "./utils/naming.js";
+import { defaultConflictColumns, resolveTenantColumn } from "./schema/conflict-target.js";
 import "./utils.js";
 import { createFieldFromManifest, manifestFieldDiffers, mergeManifestField } from "./registry/manifest-field-merge.js";
 import { compileValidators } from "./registry/validator.js";
@@ -1664,16 +1665,29 @@ var ObjectRegistry = class ObjectRegistry {
 	/**
 	* Get the conflict columns for UPSERT operations on a class
 	*
-	* Returns custom conflict columns if specified, otherwise defaults based on
-	* table strategy:
-	* - CTI: ['slug', 'context']
-	* - STI: ['slug', 'context', '_meta_type']
+	* The conflict target is a property of the TABLE, resolved from its
+	* schema-owning class — the STI root for a single-table hierarchy, the
+	* class itself otherwise — so every class sharing a table upserts on the
+	* same key the schema indexes. In order:
+	*
+	* 1. explicit `@smrt({ conflictColumns })` on the schema owner;
+	* 2. `@report` classes: `[tenant column, ...group/bucket columns]`, or
+	*    `['id']` when the report declares no grouping;
+	* 3. a custom primary key (`@field({ primaryKey: true })`): the declared
+	*    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`.
 	*
 	* STI subclasses share a table, so the discriminator participates in
 	* identity — two subtypes can coexist with the same (slug, context). The
-	* matching unique constraint on `(slug, context, _meta_type)` must exist
-	* in the live schema; if a deployment carries a stale 2-column unique
-	* instead, run `smrt db:migrate` to repair it (see issue #1165).
+	* matching unique index must exist in the live schema; if a deployment
+	* carries a stale shape, `smrt db:migrate` swaps it in place (issue #1165,
+	* #2360). NULL-tenant rows dedup through the SDK's null-aware upsert
+	* (`IS NOT DISTINCT FROM`), see `schema/conflict-target.ts`.
 	*
 	* @param className - Name of the class to get conflict columns for
 	* @returns Array of column names to use for conflict detection
@@ -1686,26 +1700,53 @@ var ObjectRegistry = class ObjectRegistry {
 	*
 	* ObjectRegistry.getConflictColumns('EventParticipant');
 	* // Returns: ['event_id', 'profile_id']
+	*
+	* @smrt({ tenantScoped: true })
+	* class Document extends SmrtObject {}
+	*
+	* ObjectRegistry.getConflictColumns('Document');
+	* // Returns: ['tenant_id', 'slug', 'context']
 	* ```
 	*/
 	static getConflictColumns(className) {
 		const registered = ObjectRegistry.findClass(className);
-		if (!registered) return ["slug", "context"];
-		if (registered.config?.conflictColumns) return registered.config.conflictColumns;
-		if (registered.config?.report) {
-			const tenantField = registered.tenantScopedConfig?.field;
-			const tenantColumn = tenantField && registered.fields.has(tenantField) ? toSnakeCase(tenantField) : "";
-			const reportConflictColumns = Array.from(registered.fields.entries()).filter(([, field]) => {
+		if (!registered) return defaultConflictColumns("cti");
+		const tableStrategy = ObjectRegistry.getTableStrategy(className);
+		const ownerName = tableStrategy === "sti" ? ObjectRegistry.getSTIBase(className) : null;
+		const owner = ownerName && ownerName !== className ? ObjectRegistry.findClass(ownerName) ?? registered : registered;
+		if (owner.config?.conflictColumns) return owner.config.conflictColumns;
+		if (owner.config?.report) {
+			const reportConflictColumns = Array.from(owner.fields.entries()).filter(([, field]) => {
 				const kind = field?._meta?.__report?.kind ?? field?.__report?.kind;
 				return kind === "group" || kind === "bucket";
 			}).map(([fieldName]) => toSnakeCase(fieldName));
+			const tenantColumn = ObjectRegistry.getTenantColumn(className);
 			return reportConflictColumns.length > 0 ? [...tenantColumn ? [tenantColumn] : [], ...reportConflictColumns] : ["id"];
 		}
-		return ObjectRegistry.getTableStrategy(className) === "sti" ? [
-			"slug",
-			"context",
-			"_meta_type"
-		] : ["slug", "context"];
+		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));
+	}
+	/**
+	* The tenant column of the table a class writes to, or `undefined` when its
+	* schema owner (the STI root for a single-table hierarchy, the class itself
+	* otherwise) is not tenant-scoped (#2360).
+	*
+	* Resolved from the owner's normalized `tenantScoped` configuration
+	* (`@smrt({ tenantScoped })`, or `@TenantScoped()` carried by the
+	* manifest), never from the standalone tenancy registry: the schema
+	* generator and `getConflictColumns()` must agree before any interceptor
+	* is enabled.
+	*
+	* @param className - Name of the class (simple or qualified)
+	* @returns The snake_case tenant column name, e.g. `tenant_id`
+	*/
+	static getTenantColumn(className) {
+		const registered = ObjectRegistry.findClass(className);
+		if (!registered) return void 0;
+		const ownerName = ObjectRegistry.getTableStrategy(className) === "sti" ? ObjectRegistry.getSTIBase(className) : null;
+		const owner = ownerName && ownerName !== className ? ObjectRegistry.findClass(ownerName) ?? registered : registered;
+		return resolveTenantColumn(owner.tenantScopedConfig?.field, (fieldName) => owner.fields.has(fieldName), toSnakeCase);
 	}
 	/**
 	* Get the tenant scoping configuration for a class (Issue #688)
@@ -1830,69 +1871,6 @@ var ObjectRegistry = class ObjectRegistry {
 		return descendants;
 	}
 	/**
-	* Persist registry state to system tables
-	*
-	* Saves all registered class metadata to the _smrt_registry system table
-	* for runtime introspection and debugging. This enables applications to
-	* query what SMRT objects exist and their configurations.
-	*
-	* @param db - Database interface to persist to
-	* @returns Promise that resolves when persistence is complete
-	* @example
-	* ```typescript
-	* // After registering all classes
-	* await ObjectRegistry.persistToDatabase(db);
-	*
-	* // Later, query the system table
-	* const rows = await db.all('SELECT * FROM _smrt_registry');
-	* console.log('Registered classes:', rows.map(r => r.class_name));
-	* ```
-	*/
-	static async persistToDatabase(db) {
-		for (const [className, registered] of ObjectRegistry.classes.entries()) {
-			const fieldsData = {};
-			for (const [key, value] of registered.fields) fieldsData[key] = {
-				type: value.type,
-				options: value.options
-			};
-			await db.upsert("_smrt_registry", ["class_name"], {
-				class_name: className,
-				schema_version: "1.0.0",
-				fields: JSON.stringify(fieldsData),
-				relationships: JSON.stringify(ObjectRegistry.getRelationships(className)),
-				config: JSON.stringify(registered.config),
-				manifest: JSON.stringify({
-					name: registered.name,
-					tableName: registered.schema?.tableName,
-					tools: registered.tools
-				}),
-				last_updated: /* @__PURE__ */ new Date()
-			});
-		}
-	}
-	/**
-	* Load registry metadata from system tables
-	*
-	* Reads the _smrt_registry system table to inspect what classes
-	* have been registered. This is primarily for introspection and
-	* debugging - actual class registration happens via @smrt() decorator.
-	*
-	* @param db - Database interface to load from
-	* @returns Promise resolving to array of class metadata
-	* @example
-	* ```typescript
-	* const metadata = await ObjectRegistry.loadFromDatabase(db);
-	* for (const meta of metadata) {
-	*   console.log(`Class: ${meta.class_name}`);
-	*   console.log(`Table: ${JSON.parse(meta.manifest).tableName}`);
-	* }
-	* ```
-	*/
-	static async loadFromDatabase(db) {
-		const { rows } = await db.query("SELECT * FROM _smrt_registry ORDER BY class_name");
-		return rows;
-	}
-	/**
 	* Get embedding configuration for a class
 	*
 	* Returns the class-specific embedding config if embeddings are enabled.