@happyvertical/smrt-core 0.40.70 → 0.42.0

package/dist/collection.js

@@ -1,19 +1,28 @@
+import { chunkArray } from "./utils/chunk.js";
+import { classnameToTablename, toSnakeCase } from "./utils/naming.js";
 import { buildQueryCacheKey, ensureCacheInvalidationListener, getCacheGeneration, getCachedRows, invalidateCollectionCache, registerCrossProcessCacheInterest, resolveDbCacheKey, setCachedRows } from "./collection-cache.js";
-import { GlobalInterceptors, createInterceptorContext } from "./interceptors.js";
+import { toSafeInteger } from "./utils/safe-integer.js";
+import { isTenantScopedClassResolved, resolveDispatchTenantScope } from "./dispatch/tenant-resolver.js";
+import { GlobalInterceptors, createInterceptorContext, resolveGetStringFilter } from "./interceptors.js";
 import { SmrtClass } from "./class.js";
 import { EmbeddingProvider } from "./embeddings/provider.js";
 import { EmbeddingStorage } from "./embeddings/storage.js";
 import { QueryBoundsError, QueryOrderByError } from "./query-bounds.js";
-import { classnameToTablename, toSnakeCase } from "./utils/naming.js";
 import { verifyPersistenceTable } from "./schema/table-verifier.js";
 import { fieldsFromClass, formatDataJs, toCamelCase } from "./utils.js";
 import { ObjectRegistry } from "./registry.js";
-import { chunkArray } from "./utils/chunk.js";
 import { createLogger } from "@happyvertical/logger";
 import { buildWhere } from "@happyvertical/sql";
 //#region src/collection.ts
 var logger = createLogger({ level: "info" });
 /**
+* `_smrt_contexts.owner_id` value for collection-level (as opposed to
+* per-object) memory. Tenant-scoped collections suffix the active tenant id
+* (`__collection__:<tenantId>`) so learned memory never crosses tenants —
+* see {@link SmrtCollection.resolveCollectionMemoryOwnerId} (#2365).
+*/
+var COLLECTION_MEMORY_OWNER_ID = "__collection__";
+/**
 * Validate an optional collection-level list bound (#2367).
 *
 * @returns the bound, or `undefined` when the option was not supplied
@@ -752,10 +761,7 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 		const itemQualifiedName = this.getResolvedItemQualifiedName();
 		const interceptorContext = createInterceptorContext(itemClassName, "get", this.constructor.name);
 		const interceptedFilter = await GlobalInterceptors.executeBeforeGet(itemClassName, filter, interceptorContext);
-		let where = typeof interceptedFilter === "string" ? /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(interceptedFilter) ? { id: interceptedFilter } : {
-			slug: interceptedFilter,
-			context: ""
-		} : interceptedFilter;
+		let where = typeof interceptedFilter === "string" ? resolveGetStringFilter(interceptedFilter) : interceptedFilter;
 		const isSTI = ObjectRegistry.getTableStrategy(itemQualifiedName) === "sti";
 		if (isSTI) {
 			const stiBase = ObjectRegistry.getSTIBase(itemQualifiedName);
@@ -1361,8 +1367,7 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 		}
 		where = resolveMetaTypeInWhere(where);
 		const { sql: whereSql, values: whereValues } = buildWhere(this.convertWhereKeys(where || {}));
-		const result = await this.db.query(`SELECT COUNT(*) as count FROM ${this.tableName} ${whereSql}`, ...whereValues);
-		return Number.parseInt(result.rows[0].count, 10);
+		return toSafeInteger((await this.db.query(`SELECT COUNT(*) as count FROM ${this.tableName} ${whereSql}`, ...whereValues)).rows[0].count, "Collection count");
 	}
 	/**
 	* Resolve this collection's STI child discriminator — the qualified item
@@ -1470,11 +1475,41 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 		return instances;
 	}
 	/**
+	* Resolve the `_smrt_contexts.owner_id` key for collection-level memory
+	* (#2365).
+	*
+	* `_smrt_contexts` has no tenant column, so before this hook a tenant-scoped
+	* collection's learned memory (`remember()`/`recall()`) was filed under one
+	* shared `__collection__` key and leaked across tenants. For a tenant-scoped
+	* item class under an active tenant context the key becomes
+	* `__collection__:<tenantId>`; everything else (tenancy disabled, no active
+	* tenant, system context, non-tenant-scoped class) keeps the shared
+	* `__collection__` key. Tenant-keyed memory is strictly isolated — a tenant
+	* recall does NOT fall back to the shared key, so memory learned outside a
+	* tenant context is invisible inside one (and vice versa).
+	*
+	* Tenant resolution uses the same core-side trust anchors as the generated
+	* REST read scope (#1782): `resolveDispatchTenantScope()` for the active
+	* tenant and the triple tenant-scoped-class check covering `@smrt()` config,
+	* manifest config, and the tenancy-filled `@TenantScoped()` resolver.
+	*/
+	resolveCollectionMemoryOwnerId() {
+		const itemClassName = this.getResolvedItemClassName();
+		if (!(ObjectRegistry.isTenantScoped(itemClassName) || !!ObjectRegistry.getConfig(itemClassName)?.tenantScoped || isTenantScopedClassResolved(itemClassName))) return COLLECTION_MEMORY_OWNER_ID;
+		const scope = resolveDispatchTenantScope();
+		if (!scope.enforced || !scope.tenantId) return COLLECTION_MEMORY_OWNER_ID;
+		return `${COLLECTION_MEMORY_OWNER_ID}:${scope.tenantId}`;
+	}
+	/**
 	* Remember collection-level context
 	*
 	* Stores context applicable to all instances of this collection type.
 	* Use for patterns that apply to the entire collection (e.g., default parsing strategies).
 	*
+	* Under an active tenant context on a tenant-scoped class, memory is keyed
+	* per tenant and never shared across tenants (#2365) — see
+	* {@link resolveCollectionMemoryOwnerId}.
+	*
 	* `expiresAt` is stored on the `_smrt_contexts` row as caller-managed metadata.
 	* {@link recall} and {@link recallAll} do **not** filter on it, so an expired
 	* entry is still returned; filter or delete expired entries yourself.
@@ -1514,7 +1549,7 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 		], {
 			id,
 			owner_class: this._itemClass.name,
-			owner_id: "__collection__",
+			owner_id: this.resolveCollectionMemoryOwnerId(),
 			scope: options.scope,
 			key: options.key,
 			value: JSON.stringify(options.value),
@@ -1548,12 +1583,13 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 	*/
 	async recall(options) {
 		if (!this.systemDb) throw new Error("Database not initialized. Call initialize() first.");
+		const ownerId = this.resolveCollectionMemoryOwnerId();
 		let result;
 		if (options.minConfidence !== void 0) result = await this.systemDb.single`
         SELECT value, confidence
         FROM _smrt_contexts
         WHERE owner_class = ${this._itemClass.name}
-          AND owner_id = ${"__collection__"}
+          AND owner_id = ${ownerId}
           AND scope = ${options.scope}
           AND key = ${options.key}
           AND confidence >= ${options.minConfidence}
@@ -1564,7 +1600,7 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
         SELECT value, confidence
         FROM _smrt_contexts
         WHERE owner_class = ${this._itemClass.name}
-          AND owner_id = ${"__collection__"}
+          AND owner_id = ${ownerId}
           AND scope = ${options.scope}
           AND key = ${options.key}
         ORDER BY confidence DESC, version DESC
@@ -1619,7 +1655,7 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
       FROM _smrt_contexts
       WHERE owner_class = ? AND owner_id = ?
     `;
-		const params = [this._itemClass.name, "__collection__"];
+		const params = [this._itemClass.name, this.resolveCollectionMemoryOwnerId()];
 		if (options.scope) if (options.includeDescendants) {
 			query += ` AND (scope = ? OR scope LIKE ?)`;
 			params.push(options.scope, `${options.scope}/%`);
@@ -1664,7 +1700,7 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 	async forget(options) {
 		if (!this.systemDb) throw new Error("Database not initialized. Call initialize() first.");
 		await this.systemDb.query(`DELETE FROM _smrt_contexts
-       WHERE owner_class = ? AND owner_id = ? AND scope = ? AND key = ?`, this._itemClass.name, "__collection__", options.scope, options.key);
+       WHERE owner_class = ? AND owner_id = ? AND scope = ? AND key = ?`, this._itemClass.name, this.resolveCollectionMemoryOwnerId(), options.scope, options.key);
 	}
 	/**
 	* Forget all collection-level context in a scope
@@ -1688,7 +1724,7 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
       DELETE FROM _smrt_contexts
       WHERE owner_class = ? AND owner_id = ?
     `;
-		const params = [this._itemClass.name, "__collection__"];
+		const params = [this._itemClass.name, this.resolveCollectionMemoryOwnerId()];
 		if (options.includeDescendants) {
 			query += ` AND (scope = ? OR scope LIKE ?)`;
 			params.push(options.scope, `${options.scope}/%`);
@@ -1705,6 +1741,11 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 	* Generates an embedding for the query text and finds similar objects
 	* based on cosine similarity of stored embeddings.
 	*
+	* Under an active tenant context on a tenant-scoped class, candidates are
+	* restricted to the tenant's rows BEFORE top-K ranking (#2365), so results
+	* are never starved by — and similarity ranks never leak — other tenants'
+	* content.
+	*
 	* @param query - Text to search for
 	* @param options - Search options
 	* @param options.field - Specific field to search (defaults to first embedding
@@ -1837,11 +1878,22 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 			fallbackToAI: embeddingConfig.fallbackToAI
 		}, this.ai).getModelName();
 		const vector = (ObjectRegistry.getProjectEmbeddingConfig()?.storage || "json") === "native" ? this.systemDb.vector : void 0;
+		const itemClassName = this.getResolvedItemClassName();
+		const tenantPrefilterContext = createInterceptorContext(itemClassName, "list", this.constructor.name);
+		const tenantPrefilter = await GlobalInterceptors.executeBeforeList(itemClassName, { where: {} }, tenantPrefilterContext);
+		let candidateObjectIds;
+		if (tenantPrefilter.where && Object.keys(tenantPrefilter.where).length > 0) {
+			const { sql: candidateWhereSql, values: candidateValues } = buildWhere(this.convertWhereKeys(tenantPrefilter.where));
+			const { rows: candidateRows } = await this.db.query(`SELECT id FROM ${this.tableName} ${candidateWhereSql}`, ...candidateValues);
+			candidateObjectIds = candidateRows.map((row) => String(row.id));
+			if (candidateObjectIds.length === 0) return [];
+		}
 		const scored = await EmbeddingStorage.searchSimilar(this.systemDb, this._itemClass.name, embedding, {
 			field: searchField,
 			model,
 			limit,
-			minSimilarity
+			minSimilarity,
+			objectIds: candidateObjectIds
 		}, vector);
 		if (scored.length === 0) return [];
 		const objectIds = scored.map((s) => s.objectId);