@happyvertical/smrt-core 0.43.9 → 0.43.10

package/dist/collection.js

@@ -16,6 +16,78 @@ import { createLogger } from "@happyvertical/logger";
 import { buildWhere } from "@happyvertical/sql";
 //#region src/collection.ts
 var logger = createLogger({ level: "info" });
+/** SQL words outside comments and quoted literals/identifiers. */
+function executableSqlWords(sql) {
+	const words = [];
+	let index = 0;
+	while (index < sql.length) {
+		const character = sql[index];
+		const next = sql[index + 1];
+		if (character === "-" && next === "-") {
+			index = sql.indexOf("\n", index + 2);
+			if (index === -1) break;
+			continue;
+		}
+		if (character === "/" && next === "*") {
+			let depth = 1;
+			index += 2;
+			while (index < sql.length && depth > 0) if (sql[index] === "/" && sql[index + 1] === "*") {
+				depth += 1;
+				index += 2;
+			} else if (sql[index] === "*" && sql[index + 1] === "/") {
+				depth -= 1;
+				index += 2;
+			} else index += 1;
+			if (depth > 0) break;
+			continue;
+		}
+		if (character === "'" || character === "\"" || character === "`") {
+			const quote = character;
+			const backslashEscapes = quote === "'" && index > 0 && /[eE]/.test(sql[index - 1]) && (index === 1 || !/[A-Za-z0-9_$]/.test(sql[index - 2]));
+			index += 1;
+			while (index < sql.length) {
+				if (backslashEscapes && sql[index] === "\\") {
+					index += 2;
+					continue;
+				}
+				if (sql[index] === quote) {
+					if (sql[index + 1] === quote) {
+						index += 2;
+						continue;
+					}
+					index += 1;
+					break;
+				}
+				index += 1;
+			}
+			continue;
+		}
+		if (character === "$") {
+			const tag = sql.slice(index).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/)?.[0];
+			if (tag) {
+				const end = sql.indexOf(tag, index + tag.length);
+				if (end === -1) break;
+				index = end + tag.length;
+				continue;
+			}
+		}
+		if (/[A-Za-z_]/.test(character)) {
+			const start = index;
+			index += 1;
+			while (index < sql.length && /[A-Za-z0-9_$]/.test(sql[index])) index += 1;
+			words.push(sql.slice(start, index).toLowerCase());
+			continue;
+		}
+		index += 1;
+	}
+	return words;
+}
+function isMutatingSql(words) {
+	return words.some((word, index) => {
+		const next = words[index + 1];
+		return word === "update" || word === "insert" && next === "into" || word === "delete" && next === "from" || word === "merge" && next === "into" || word === "truncate" && next === "table" || word === "replace" && next === "into";
+	});
+}
 /**
 * `_smrt_contexts.owner_id` value for collection-level (as opposed to
 * per-object) memory. Tenant-scoped collections suffix the active tenant id
@@ -450,6 +522,26 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 		const isDuckDbConnection = (db.client?.constructor?.name?.toLowerCase() ?? "").includes("duckdb") || typeof db.exportTable === "function" && db.client !== void 0 && "connection" in db.client;
 		return detectEngine(db.url || db.config?.url || "", this.getDatabaseEngineHint() || db.type || db.config?.type || (isDuckDbConnection ? "duckdb" : void 0));
 	}
+	getHydrationSelectSql(schema = ObjectRegistry.getSchema(this.getResolvedItemQualifiedName()) ?? ObjectRegistry.getSchema(this.getResolvedItemClassName())) {
+		if (this.getDatabaseEngine() !== "duckdb") return "*";
+		const registeredFields = ObjectRegistry.getFields(this.getResolvedItemQualifiedName()).size > 0 ? ObjectRegistry.getFields(this.getResolvedItemQualifiedName()) : ObjectRegistry.getFields(this.getResolvedItemClassName());
+		const itemColumns = /* @__PURE__ */ new Set(["id", ...Array.from(registeredFields.keys(), (fieldName) => this.toDbColumnName(fieldName))]);
+		const uuidColumns = Object.entries(schema?.columns ?? {}).filter(([columnName, column]) => itemColumns.has(columnName) && String(column.type).toUpperCase() === "UUID").map(([columnName]) => columnName);
+		if (uuidColumns.length === 0) return "*";
+		return `* REPLACE (${uuidColumns.map((columnName) => {
+			const quoted = this.quoteProjectionIdentifier(columnName);
+			return `CAST(${quoted} AS VARCHAR) AS ${quoted}`;
+		}).join(", ")})`;
+	}
+	hasDuckDbUuidColumnsOutsideHydrationSelect() {
+		if (this.getDatabaseEngine() !== "duckdb") return false;
+		const qualifiedName = this.getResolvedItemQualifiedName();
+		const className = this.getResolvedItemClassName();
+		const schema = ObjectRegistry.getSchema(qualifiedName) ?? ObjectRegistry.getSchema(className);
+		const registeredFields = ObjectRegistry.getFields(qualifiedName).size > 0 ? ObjectRegistry.getFields(qualifiedName) : ObjectRegistry.getFields(className);
+		const selectedColumns = /* @__PURE__ */ new Set(["id", ...Array.from(registeredFields.keys(), (fieldName) => this.toDbColumnName(fieldName))]);
+		return Object.entries(schema?.columns ?? {}).some(([columnName, column]) => !selectedColumns.has(columnName) && String(column.type).toUpperCase() === "UUID");
+	}
 	isOmittedCustomPrimaryKeySystemField(fieldName, hasCustomPrimaryKey, explicitFieldNames) {
 		return hasCustomPrimaryKey && !explicitFieldNames.has(fieldName) && (fieldName === "id" || fieldName === "slug" || fieldName === "context");
 	}
@@ -489,7 +581,9 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 			const isTransient = fieldDef?.transient === true || fieldDef?._meta?.transient === true;
 			if (fieldType === "meta" || isTransient || fieldType === "oneToMany" || fieldType === "manyToMany") throw new Error(`Invalid select field: '${fieldName}' is not a column-backed field on ${itemClassName}.`);
 			const columnName = this.toDbColumnName(fieldName);
-			selectExpressions.push(`${this.quoteProjectionIdentifier(columnName)} AS ${this.quoteProjectionIdentifier(fieldName)}`);
+			const quotedColumn = this.quoteProjectionIdentifier(columnName);
+			const selectValue = this.getDatabaseEngine() === "duckdb" && String(schema?.columns[columnName]?.type).toUpperCase() === "UUID" ? `CAST(${quotedColumn} AS VARCHAR)` : quotedColumn;
+			selectExpressions.push(`${selectValue} AS ${this.quoteProjectionIdentifier(fieldName)}`);
 			outputFields.push(fieldName);
 		}
 		return {
@@ -603,7 +697,10 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 			while (occupiedParentIdentifiers.has(alias) || [...relatedFieldAliases.values()].includes(alias));
 			relatedFieldAliases.set(fieldName, alias);
 		}
-		const parentSelectSql = parentColumnNames.length > 0 ? parentColumnNames.map((columnName) => this.quoteProjectionIdentifier(columnName)).join(", ") : "*";
+		const parentSelectSql = parentColumnNames.length > 0 ? parentColumnNames.map((columnName) => {
+			const quoted = this.quoteProjectionIdentifier(columnName);
+			return this.getDatabaseEngine() === "duckdb" && String(parentSchema?.columns[columnName]?.type).toUpperCase() === "UUID" ? `CAST(${quoted} AS VARCHAR) AS ${quoted}` : quoted;
+		}).join(", ") : "*";
 		const relatedAlias = (fieldName) => {
 			const alias = relatedFieldAliases.get(fieldName);
 			if (!alias) throw new Error(`Missing latest-related alias for '${fieldName}'.`);
@@ -612,12 +709,15 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 		const relatedSelectExpressions = Array.from(relatedOutputFields).map((fieldName) => {
 			const column = relatedFieldColumns.get(fieldName) ?? relatedCollection.toDbColumnName(fieldName);
 			const alias = relatedAlias(fieldName);
-			return `${relatedCollection.quoteProjectionIdentifier(column)} AS ${relatedCollection.quoteProjectionIdentifier(alias)}`;
+			const quotedColumn = relatedCollection.quoteProjectionIdentifier(column);
+			const relatedSchema = ObjectRegistry.getSchema(relatedQualifiedName) ?? ObjectRegistry.getSchema(relatedItemClassName);
+			const source = `r.${quotedColumn}`;
+			return `${relatedCollection.getDatabaseEngine() === "duckdb" && String(relatedSchema?.columns[column]?.type).toUpperCase() === "UUID" ? `CAST(${source} AS VARCHAR)` : source} AS ${relatedCollection.quoteProjectionIdentifier(alias)}`;
 		});
 		const relatedRankOrder = [relatedCollection.qualifyLatestOrderTerms("r", relatedOrderTerms), `r.${relatedCollection.quoteProjectionIdentifier(relatedPrimaryKey.column)} DESC`].filter(Boolean).join(", ");
 		const latestRankAlias = relatedCollection.quoteProjectionIdentifier("__smrt_latest_rank");
 		const latestRelatedAlias = (fieldName) => relatedCollection.quoteProjectionIdentifier(relatedAlias(fieldName));
-		const relatedCte = `WITH ranked_latest_related AS (SELECT ${relatedSelectExpressions.map((expression) => `r.${expression}`).join(", ")}, ROW_NUMBER() OVER (PARTITION BY r.${relatedCollection.quoteProjectionIdentifier(relatedCollection.toDbColumnName(inverseForeignKey.fieldName))} ORDER BY ${relatedRankOrder}) AS ${latestRankAlias} FROM ${relatedCollection.tableName} r${relatedWhereSql ? ` ${relatedWhereSql}` : ""}) `;
+		const relatedCte = `WITH ranked_latest_related AS (SELECT ${relatedSelectExpressions.join(", ")}, ROW_NUMBER() OVER (PARTITION BY r.${relatedCollection.quoteProjectionIdentifier(relatedCollection.toDbColumnName(inverseForeignKey.fieldName))} ORDER BY ${relatedRankOrder}) AS ${latestRankAlias} FROM ${relatedCollection.tableName} r${relatedWhereSql ? ` ${relatedWhereSql}` : ""}) `;
 		const { sql: rawWhereSql, values: parentWhereValues } = buildWhere(this.convertWhereKeys(where || {}));
 		const parentWhereSql = rawWhereSql.replace(/\$(\d+)/g, (_match, index) => `$${Number(index) + relatedWhereValues.length}`);
 		const relatedJoinConditions = [`rr.${latestRankAlias} = 1`, `rr.${latestRelatedAlias(inverseForeignKey.fieldName)} = ${this.quoteProjectionIdentifier(parentPrimaryKey.column)}`];
@@ -647,16 +747,21 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 			limitOffsetValues.push(boundedOffset);
 		}
 		const sql = `${relatedCte}SELECT ${parentSelectSql}, ${Array.from(relatedOutputFields).map((fieldName) => `rr.${latestRelatedAlias(fieldName)} AS ${this.quoteProjectionIdentifier(relatedAlias(fieldName))}`).join(", ")} FROM ${this.quoteProjectionIdentifier(this.tableName)} LEFT JOIN ranked_latest_related rr ON ${relatedJoinConditions.join(" AND ")} ${parentWhereSql} ${orderFragments.length > 0 ? `ORDER BY ${orderFragments.join(", ")}` : ""}${limitOffsetSql}`;
-		const rows = await this.db.query(sql, ...relatedWhereValues, ...parentWhereValues, ...limitOffsetValues);
+		const queryValues = [
+			...relatedWhereValues,
+			...parentWhereValues,
+			...limitOffsetValues
+		];
+		const rows = await this.queryDuckDbCanonicalSelectRows(sql, queryValues);
 		const instances = [];
 		const relatedAliasNames = new Set(relatedFieldAliases.values());
 		const polymorphicFields = /* @__PURE__ */ new Map();
-		for (const row of rows.rows) {
+		for (const row of rows) {
 			const parentRow = Object.fromEntries(Object.entries(row).filter(([key]) => !relatedAliasNames.has(key)));
 			instances.push(await this.hydrateResultRow(parentRow, parentFields, isSTI, polymorphicFields));
 		}
 		const relatedByParentId = /* @__PURE__ */ new Map();
-		for (const row of rows.rows) {
+		for (const row of rows) {
 			const parentId = row[parentPrimaryKey.column];
 			if (parentId === null || parentId === void 0) continue;
 			const relatedRow = Object.fromEntries(relatedProjection.outputFields.map((fieldName) => [fieldName, row[relatedAlias(fieldName)]]));
@@ -937,8 +1042,8 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 	* differently-scoped queries can never share an entry. Cached values are
 	* raw rows; callers still run their normal post-query formatting path.
 	*/
-	async queryRowsWithCache(sql, params, cacheConfig) {
-		if (!cacheConfig) return (await this.db.query(sql, ...params)).rows;
+	async queryRowsWithCache(sql, params, cacheConfig, describeUuidOutputs) {
+		if (!cacheConfig) return await this.queryDuckDbCanonicalSelectRows(sql, params, describeUuidOutputs);
 		const dbKey = resolveDbCacheKey(this.db);
 		const queryKey = buildQueryCacheKey(sql, params);
 		if (cacheConfig.crossProcess) {
@@ -948,9 +1053,31 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 		const cached = getCachedRows(dbKey, this.tableName, queryKey);
 		if (cached) return cached;
 		const generation = getCacheGeneration(dbKey, this.tableName);
-		const result = await this.db.query(sql, ...params);
-		setCachedRows(dbKey, this.tableName, queryKey, result.rows, cacheConfig.ttl, generation);
-		return result.rows;
+		const rows = await this.queryDuckDbCanonicalSelectRows(sql, params, describeUuidOutputs);
+		setCachedRows(dbKey, this.tableName, queryKey, rows, cacheConfig.ttl, generation);
+		return rows;
+	}
+	/**
+	* Describe a native DuckDB SELECT before executing it, then cast UUID output
+	* columns in the one data-bearing execution. DuckDB's JavaScript binding
+	* exposes UUID values as lossy HUGEINT wrappers, so they cannot be repaired
+	* from the first result without replaying volatile SELECT expressions or
+	* combining two different database snapshots.
+	*/
+	async queryDuckDbCanonicalSelectRows(sql, params, describeUuidOutputs = true) {
+		if (this.getDatabaseEngine() !== "duckdb" || !describeUuidOutputs) return (await this.db.query(sql, ...params)).rows;
+		const readSql = sql.trim().replace(/;$/, "");
+		const words = executableSqlWords(readSql);
+		if (isMutatingSql(words)) return (await this.db.query(sql, ...params)).rows;
+		if (words[0] !== "select" && words[0] !== "with") return (await this.db.query(sql, ...params)).rows;
+		const uuidColumns = (await this.db.query(`DESCRIBE ${readSql}`, ...params)).rows.filter((row) => String(row.column_type).toUpperCase() === "UUID").map((row) => String(row.column_name));
+		if (uuidColumns.length === 0) return (await this.db.query(sql, ...params)).rows;
+		const alias = this.quoteProjectionIdentifier("__smrt_uuid_rows");
+		const replacements = uuidColumns.map((column) => {
+			const quoted = this.quoteProjectionIdentifier(column);
+			return `CAST(${alias}.${quoted} AS VARCHAR) AS ${quoted}`;
+		}).join(", ");
+		return (await this.db.query(`SELECT ${alias}.* REPLACE (${replacements}) FROM (${readSql}) AS ${alias}`, ...params)).rows;
 	}
 	/**
 	* Retrieves a single object from the collection by ID, slug, or a custom filter.
@@ -1005,8 +1132,8 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 			};
 		}
 		const { sql: whereSql, values: whereValues } = buildWhere(this.convertWhereKeys(where));
-		const fullSQL = `SELECT * FROM ${this.tableName} ${whereSql} LIMIT 1`;
-		const rows = await this.queryRowsWithCache(fullSQL, whereValues, this.resolveReadCacheConfig(options.cache));
+		const fullSQL = `SELECT ${this.getHydrationSelectSql()} FROM ${this.tableName} ${whereSql} LIMIT 1`;
+		const rows = await this.queryRowsWithCache(fullSQL, whereValues, this.resolveReadCacheConfig(options.cache), this.hasDuckDbUuidColumnsOutsideHydrationSelect());
 		if (!rows?.[0]) return await GlobalInterceptors.executeAfterGet(itemClassName, null, interceptorContext);
 		const fields = this.getFieldsSync();
 		const instance = await this.hydrateResultRow(rows[0], fields, isSTI);
@@ -1040,9 +1167,9 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 			limitOffsetSql += ` OFFSET $${paramIndex++}`;
 			limitOffsetValues.push(boundedOffset);
 		}
-		const sql = `SELECT ${projection ? projection.sql : "*"} FROM ${this.tableName} ${whereSql} ${orderBySql} ${limitOffsetSql}`;
+		const sql = `SELECT ${projection ? projection.sql : this.getHydrationSelectSql()} FROM ${this.tableName} ${whereSql} ${orderBySql} ${limitOffsetSql}`;
 		const params = [...whereValues, ...limitOffsetValues];
-		const rows = await this.queryRowsWithCache(sql, params, this.resolveReadCacheConfig(interceptedOptions.cache));
+		const rows = await this.queryRowsWithCache(sql, params, this.resolveReadCacheConfig(interceptedOptions.cache), !projection && this.hasDuckDbUuidColumnsOutsideHydrationSelect());
 		if (projection) return rows.map((item) => this.formatProjectionRow(item, fields, projection.outputFields));
 		const instances = await this.hydrateResultRows(rows, fields, isSTI);
 		if (interceptedOptions.include && interceptedOptions.include.length > 0) await this.eagerLoadRelationships(instances, interceptedOptions.include);
@@ -1753,11 +1880,11 @@ var SmrtCollection = class SmrtCollection extends SmrtClass {
 			params,
 			allowRawOnTenantScoped: options.allowRawOnTenantScoped
 		}, interceptorContext);
-		const result = await this.db.query(interceptedQuery.sql, ...interceptedQuery.params);
+		const rows = await this.queryDuckDbCanonicalSelectRows(interceptedQuery.sql, interceptedQuery.params);
 		if (/\b(?:insert|update|delete|merge|truncate|replace)\b/i.test(interceptedQuery.sql)) invalidateCollectionCache(resolveDbCacheKey(this.db), this.tableName);
 		const fields = this.getFieldsSync();
 		const isSTI = ObjectRegistry.getTableStrategy(this.getResolvedItemQualifiedName()) === "sti";
-		const instances = await this.hydrateResultRows(result.rows, fields, isSTI);
+		const instances = await this.hydrateResultRows(rows, fields, isSTI);
 		return await GlobalInterceptors.executeAfterQuery(this._itemClass.name, instances, interceptorContext);
 	}
 	async hydrateResultRow(row, fields, isSTI, polymorphicFields = /* @__PURE__ */ new Map()) {