@zenstackhq/orm 3.7.0-beta.1 → 3.7.1

package/dist/index.mjs

@@ -189,6 +189,7 @@ var query_utils_exports = /* @__PURE__ */ __exportAll({
 	fieldHasDefaultValue: () => fieldHasDefaultValue,
 	flattenCompoundUniqueFilters: () => flattenCompoundUniqueFilters,
 	getDelegateDescendantModels: () => getDelegateDescendantModels,
+	getDelegateDiscriminatorValue: () => getDelegateDiscriminatorValue,
 	getDiscriminatorField: () => getDiscriminatorField,
 	getEnum: () => getEnum,
 	getField: () => getField,
@@ -422,6 +423,10 @@ function getDiscriminatorField(schema, model) {
 	if (!discriminator || !ExpressionUtils.isField(discriminator.value)) throw createInternalError(`Discriminator field not defined for model "${model}"`, model);
 	return discriminator.value.field;
 }
+function getDelegateDiscriminatorValue(schema, model) {
+	const modelDef = requireModel(schema, model);
+	return modelDef.delegateMap ?? modelDef.name;
+}
 function getDelegateDescendantModels(schema, model, collected = /* @__PURE__ */ new Set()) {
 	Object.values(schema.models).filter((m) => m.baseModel === model).forEach((def) => {
 		if (!collected.has(def)) {
@@ -531,6 +536,8 @@ const FILTER_PROPERTY_TO_KIND = {
 	array_contains: "Json",
 	array_starts_with: "Json",
 	array_ends_with: "Json",
+	fuzzy: "Fuzzy",
+	fts: "FullText",
 	has: "List",
 	hasEvery: "List",
 	hasSome: "List",
@@ -550,6 +557,19 @@ let TransactionIsolationLevel = /* @__PURE__ */ function(TransactionIsolationLev
 	return TransactionIsolationLevel;
 }({});
 /**
+* Symbol used as a type-only key on `ClientContract` to brand the `ExtQueryArgs`
+* generic slot. Hidden from member-access autocomplete since symbol keys are
+* not surfaced. Consumed by `InferExtQueryArgs` to recover the slot.
+* @internal
+*/
+const ExtQueryArgsMarker = Symbol("zenstack.client.extQueryArgs");
+/**
+* Symbol used as a type-only key on `ClientContract` to brand the `ExtResult`
+* generic slot. Consumed by `InferExtResult` to recover the slot.
+* @internal
+*/
+const ExtResultMarker = Symbol("zenstack.client.extResult");
+/**
 * CRUD operations.
 */
 const CRUD = [
@@ -572,8 +592,13 @@ var BaseCrudDialect = class {
 	}
 	/**
 	* Transforms input value before sending to database.
+	*
+	* `fieldDef` is optional so existing callers that don't have it stay
+	* source-compatible. Dialects can use it to inspect `@db.*` native-type
+	* attributes (e.g. to format `@db.Time` values as `HH:MM:SS` rather than
+	* full ISO timestamps).
 	*/
-	transformInput(value, _type, _forArrayField) {
+	transformInput(value, _type, _forArrayField, _fieldDef) {
 		return value;
 	}
 	/**
@@ -616,7 +641,17 @@ var BaseCrudDialect = class {
 			if (existingOrderBy.length > 0 && !alreadySatisfied) effectiveOrderBy = [...distinctFields.map((f) => ({ [f]: "asc" })), ...existingOrderBy];
 		}
 		result = this.buildOrderBy(result, model, modelAlias, effectiveOrderBy, negateOrderBy, take);
-		if (args.cursor) result = this.buildCursorFilter(model, result, args.cursor, effectiveOrderBy, negateOrderBy, modelAlias);
+		if (args.cursor) {
+			if (effectiveOrderBy) {
+				const offendingKey = enumerate(effectiveOrderBy).map((ob) => {
+					if (typeof ob !== "object" || ob === null) return void 0;
+					if ("_fuzzyRelevance" in ob) return "_fuzzyRelevance";
+					if ("_ftsRelevance" in ob) return "_ftsRelevance";
+				}).find((k) => k !== void 0);
+				if (offendingKey) throw createNotSupportedError(`cursor pagination cannot be combined with "${offendingKey}" ordering`);
+			}
+			result = this.buildCursorFilter(model, result, args.cursor, effectiveOrderBy, negateOrderBy, modelAlias);
+		}
 		return result;
 	}
 	buildFilter(model, modelAlias, where) {
@@ -756,7 +791,7 @@ var BaseCrudDialect = class {
 		for (const [key, _value] of Object.entries(payload)) {
 			if (_value === void 0) continue;
 			invariant(fieldDef.array, "Field must be an array type to build array filter");
-			const value = this.transformInput(_value, fieldType, true);
+			const value = this.transformInput(_value, fieldType, true, fieldDef);
 			let receiver = fieldRef;
 			if (isEnum(this.schema, fieldType)) receiver = this.eb.cast(fieldRef, sql.raw("text[]"));
 			const buildArray = (value) => {
@@ -791,7 +826,7 @@ var BaseCrudDialect = class {
 			if (payload instanceof DbNullClass || payload instanceof JsonNullClass || payload instanceof AnyNullClass) return this.buildJsonValueFilterClause(fieldRef, payload);
 			return this.buildJsonFilter(fieldRef, payload, fieldDef);
 		}
-		return match(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(fieldRef, payload)).with("Json", () => this.buildJsonFilter(fieldRef, payload, fieldDef)).with("Unsupported", () => {
+		return match(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload, fieldDef)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(fieldRef, payload)).with("Json", () => this.buildJsonFilter(fieldRef, payload, fieldDef)).with("Unsupported", () => {
 			throw createInvalidInputError(`Unsupported field cannot be used in filters`);
 		}).exhaustive();
 	}
@@ -959,13 +994,23 @@ var BaseCrudDialect = class {
 			consumedKeys
 		};
 	}
-	buildStringFilter(fieldRef, payload) {
+	buildStringFilter(fieldRef, payload, fieldDef) {
 		let mode;
 		if (payload && typeof payload === "object" && "mode" in payload) mode = payload.mode;
-		const { conditions, consumedKeys } = this.buildStandardFilter("String", payload, mode === "insensitive" ? this.eb.fn("lower", [fieldRef]) : fieldRef, (value) => this.prepStringCasing(this.eb, value, mode), (value) => this.buildStringFilter(fieldRef, value));
+		const { conditions, consumedKeys } = this.buildStandardFilter("String", payload, mode === "insensitive" ? this.eb.fn("lower", [fieldRef]) : fieldRef, (value) => this.prepStringCasing(this.eb, value, mode), (value) => this.buildStringFilter(fieldRef, value, fieldDef));
 		if (payload && typeof payload === "object") for (const [key, value] of Object.entries(payload)) {
 			if (key === "mode" || consumedKeys.includes(key)) continue;
 			if (value === void 0) continue;
+			if (key === "fuzzy") {
+				invariant(fieldDef?.fuzzy === true, `field "${fieldDef?.name ?? "<unknown>"}" is not fuzzy-searchable; add the \`@fuzzy\` attribute to use the \`fuzzy\` filter`);
+				conditions.push(this.buildFuzzyFilter(fieldRef, this.normalizeFuzzyOptions(value)));
+				continue;
+			}
+			if (key === "fts") {
+				invariant(fieldDef?.fullText === true, `field "${fieldDef?.name ?? "<unknown>"}" is not full-text-searchable; add the \`@fullText\` attribute to use the \`fts\` filter`);
+				conditions.push(this.buildFullTextFilter(fieldRef, value));
+				continue;
+			}
 			invariant(typeof value === "string", `${key} value must be a string`);
 			const escapedValue = this.escapeLikePattern(value);
 			const condition = match(key).with("contains", () => this.buildStringLike(fieldRef, `%${escapedValue}%`, mode === "insensitive")).with("startsWith", () => this.buildStringLike(fieldRef, `${escapedValue}%`, mode === "insensitive")).with("endsWith", () => this.buildStringLike(fieldRef, `%${escapedValue}`, mode === "insensitive")).otherwise(() => {
@@ -1034,6 +1079,14 @@ var BaseCrudDialect = class {
 		enumerate(orderBy).forEach((orderBy, index) => {
 			for (const [field, value] of Object.entries(orderBy)) {
 				if (!value) continue;
+				if (field === "_fuzzyRelevance") {
+					result = this.applyFuzzyRelevanceOrderBy(result, model, modelAlias, value, negated, buildFieldRef);
+					continue;
+				}
+				if (field === "_ftsRelevance") {
+					result = this.applyFtsRelevanceOrderBy(result, model, modelAlias, value, negated, buildFieldRef);
+					continue;
+				}
 				if ([
 					"_count",
 					"_avg",
@@ -1041,47 +1094,84 @@ var BaseCrudDialect = class {
 					"_min",
 					"_max"
 				].includes(field)) {
-					invariant(typeof value === "object", `invalid orderBy value for field "${field}"`);
-					for (const [k, v] of Object.entries(value)) {
-						invariant(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-						result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), this.negateSort(v, negated));
-					}
+					result = this.applyAggregationOrderBy(result, model, modelAlias, field, value, negated, buildFieldRef);
 					continue;
 				}
 				const fieldDef = requireField(this.schema, model, field);
-				if (!fieldDef.relation) {
-					const fieldRef = buildFieldRef(model, field, modelAlias);
-					if (value === "asc" || value === "desc") result = result.orderBy(fieldRef, this.negateSort(value, negated));
-					else if (typeof value === "object" && "nulls" in value && "sort" in value && (value.sort === "asc" || value.sort === "desc") && (value.nulls === "first" || value.nulls === "last")) result = this.buildOrderByField(result, fieldRef, this.negateSort(value.sort, negated), value.nulls);
-				} else {
-					const relationModel = fieldDef.type;
-					if (fieldDef.array) {
-						if (typeof value !== "object") throw createInvalidInputError(`invalid orderBy value for field "${field}"`);
-						if ("_count" in value) {
-							invariant(value._count === "asc" || value._count === "desc", "invalid orderBy value for field \"_count\"");
-							const sort = this.negateSort(value._count, negated);
-							result = result.orderBy((eb) => {
-								const subQueryAlias = tmpAlias(`${modelAlias}$ob$${field}$ct`);
-								let subQuery = this.buildSelectModel(relationModel, subQueryAlias);
-								const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, subQueryAlias);
-								subQuery = subQuery.where(() => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
-								subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
-								return subQuery;
-							}, sort);
-						}
-					} else {
-						const joinAlias = tmpAlias(`${modelAlias}$ob$${index}`);
-						result = result.leftJoin(`${relationModel} as ${joinAlias}`, (join) => {
-							const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, joinAlias);
-							return join.on((eb) => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
-						});
-						result = this.buildOrderBy(result, relationModel, joinAlias, value, negated, take);
-					}
-				}
+				if (!fieldDef.relation) result = this.applyScalarOrderBy(result, model, modelAlias, field, value, negated, buildFieldRef);
+				else result = this.applyRelationOrderBy(result, model, modelAlias, field, fieldDef, value, negated, take, index);
+			}
+		});
+		return result;
+	}
+	applyRelationOrderBy(query, model, modelAlias, field, fieldDef, value, negated, take, index) {
+		const relationModel = fieldDef.type;
+		if (fieldDef.array) {
+			if (typeof value !== "object") throw createInvalidInputError(`invalid orderBy value for field "${field}"`);
+			if ("_count" in value) {
+				invariant(value._count === "asc" || value._count === "desc", "invalid orderBy value for field \"_count\"");
+				const sort = this.negateSort(value._count, negated);
+				return query.orderBy((eb) => {
+					const subQueryAlias = tmpAlias(`${modelAlias}$ob$${field}$ct`);
+					let subQuery = this.buildSelectModel(relationModel, subQueryAlias);
+					const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, subQueryAlias);
+					subQuery = subQuery.where(() => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
+					subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
+					return subQuery;
+				}, sort);
 			}
+			return query;
+		}
+		const joinAlias = tmpAlias(`${modelAlias}$ob$${index}`);
+		const joined = query.leftJoin(`${relationModel} as ${joinAlias}`, (join) => {
+			const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, joinAlias);
+			return join.on((eb) => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
 		});
+		return this.buildOrderBy(joined, relationModel, joinAlias, value, negated, take);
+	}
+	applyScalarOrderBy(query, model, modelAlias, field, value, negated, buildFieldRef) {
+		const fieldRef = buildFieldRef(model, field, modelAlias);
+		if (value === "asc" || value === "desc") return query.orderBy(fieldRef, this.negateSort(value, negated));
+		if (typeof value === "object" && "sort" in value && (value.sort === "asc" || value.sort === "desc")) {
+			const sort = this.negateSort(value.sort, negated);
+			if (value.nulls === "first" || value.nulls === "last") return this.buildOrderByField(query, fieldRef, sort, value.nulls);
+			else return query.orderBy(fieldRef, sort);
+		}
+		return query;
+	}
+	applyAggregationOrderBy(query, model, modelAlias, field, value, negated, buildFieldRef) {
+		invariant(typeof value === "object", `invalid orderBy value for field "${field}"`);
+		let result = query;
+		for (const [k, v] of Object.entries(value)) {
+			invariant(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
+			result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), this.negateSort(v, negated));
+		}
 		return result;
 	}
+	applyFuzzyRelevanceOrderBy(query, model, modelAlias, value, negated, buildFieldRef) {
+		invariant(typeof value === "object" && "fields" in value && "search" in value && "sort" in value, "invalid orderBy value for \"_fuzzyRelevance\"");
+		invariant(Array.isArray(value.fields) && value.fields.length > 0, "_fuzzyRelevance.fields must be a non-empty array");
+		invariant(value.sort === "asc" || value.sort === "desc", "invalid sort value for \"_fuzzyRelevance\"");
+		invariant(typeof value.search === "string" && value.search.length > 0, "_fuzzyRelevance.search must be a non-empty string");
+		const mode = value.mode ?? "simple";
+		invariant(mode === "simple" || mode === "word" || mode === "strictWord", "_fuzzyRelevance.mode must be \"simple\", \"word\" or \"strictWord\"");
+		const unaccent = value.unaccent ?? false;
+		invariant(typeof unaccent === "boolean", "_fuzzyRelevance.unaccent must be a boolean");
+		for (const fieldName of value.fields) invariant(requireField(this.schema, model, fieldName).fuzzy === true, `field "${fieldName}" is not fuzzy-searchable; add the \`@fuzzy\` attribute to use it in \`_fuzzyRelevance\``);
+		const fieldRefs = value.fields.map((f) => buildFieldRef(model, f, modelAlias));
+		return this.buildFuzzyRelevanceOrderBy(query, fieldRefs, value.search, this.negateSort(value.sort, negated), mode, unaccent);
+	}
+	applyFtsRelevanceOrderBy(query, model, modelAlias, value, negated, buildFieldRef) {
+		invariant(typeof value === "object" && "fields" in value && "search" in value && "sort" in value, "invalid orderBy value for \"_ftsRelevance\"");
+		invariant(Array.isArray(value.fields) && value.fields.length > 0, "_ftsRelevance.fields must be a non-empty array");
+		invariant(value.sort === "asc" || value.sort === "desc", "invalid sort value for \"_ftsRelevance\"");
+		invariant(typeof value.search === "string" && value.search.length > 0, "_ftsRelevance.search must be a non-empty string");
+		if (value.config !== void 0) invariant(typeof value.config === "string" && value.config.length > 0, "_ftsRelevance.config must be a non-empty string");
+		const config = value.config;
+		for (const fieldName of value.fields) invariant(requireField(this.schema, model, fieldName).fullText === true, `field "${fieldName}" is not full-text-searchable; add the \`@fullText\` attribute to use it in \`_ftsRelevance\``);
+		const fieldRefs = value.fields.map((f) => buildFieldRef(model, f, modelAlias));
+		return this.buildFtsRelevanceOrderBy(query, fieldRefs, value.search, config, this.negateSort(value.sort, negated));
+	}
 	buildSelectAllFields(model, query, omit, modelAlias) {
 		let result = query;
 		for (const fieldDef of getModelFields(this.schema, model, {
@@ -1224,6 +1314,27 @@ var BaseCrudDialect = class {
 	buildComparison(left, _leftFieldDef, op, right, _rightFieldDef) {
 		return this.eb(left, op, right);
 	}
+	/**
+	* Validate the user-provided fuzzy filter payload and apply defaults so dialects
+	* always receive a fully-resolved {@link FuzzyFilterOptions} value.
+	*/
+	normalizeFuzzyOptions(value) {
+		invariant(value !== null && typeof value === "object" && !Array.isArray(value), "fuzzy filter must be an object with at least a \"search\" field");
+		const raw = value;
+		invariant(typeof raw["search"] === "string" && raw["search"].length > 0, "fuzzy.search must be a non-empty string");
+		const mode = raw["mode"] ?? "simple";
+		invariant(mode === "simple" || mode === "word" || mode === "strictWord", "fuzzy.mode must be \"simple\", \"word\" or \"strictWord\"");
+		const threshold = raw["threshold"];
+		if (threshold !== void 0) invariant(typeof threshold === "number" && threshold >= 0 && threshold <= 1, "fuzzy.threshold must be a number between 0 and 1");
+		const unaccent = raw["unaccent"] ?? false;
+		invariant(typeof unaccent === "boolean", "fuzzy.unaccent must be a boolean");
+		return {
+			search: raw["search"],
+			mode,
+			threshold,
+			unaccent
+		};
+	}
 };
 //#endregion
 //#region src/client/crud/dialects/lateral-join-dialect-base.ts
@@ -1508,9 +1619,32 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
 		}
 		return result;
 	}
+	buildFuzzyFilter(_fieldRef, _options) {
+		throw createNotSupportedError("\"fuzzy\" filter is not supported by the \"mysql\" provider");
+	}
+	buildFuzzyRelevanceOrderBy(_query, _fieldRefs, _search, _sort, _mode, _unaccent) {
+		throw createNotSupportedError("\"_fuzzyRelevance\" ordering is not supported by the \"mysql\" provider");
+	}
+	buildFullTextFilter(_fieldRef, _payload) {
+		throw createNotSupportedError("\"fts\" filter is not supported by the \"mysql\" provider");
+	}
+	buildFtsRelevanceOrderBy(_query, _fieldRefs, _search, _config, _sort) {
+		throw createNotSupportedError("\"_ftsRelevance\" ordering is not supported by the \"mysql\" provider");
+	}
 };
 //#endregion
 //#region src/client/crud/dialects/postgresql.ts
+/**
+* Formats a JS `Date` as a Postgres TIME / TIMETZ literal (`HH:MM:SS.fff`,
+* optionally with `+ZZ:ZZ` for TIMETZ). Reads UTC components so the value
+* round-trips with ISO-input parsing — callers anchor time-only inputs to
+* the Unix epoch.
+*/
+function formatTimeOfDay(date, withTimezone) {
+	const pad = (n, w = 2) => String(n).padStart(w, "0");
+	const time = `${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}.${pad(date.getUTCMilliseconds(), 3)}`;
+	return withTimezone ? `${time}+00:00` : time;
+}
 var PostgresCrudDialect = class PostgresCrudDialect extends LateralJoinDialectBase {
 	static typeParserOverrideApplied = false;
 	zmodelToSqlTypeMap = {
@@ -1604,7 +1738,7 @@ var PostgresCrudDialect = class PostgresCrudDialect extends LateralJoinDialectBa
 	get insertIgnoreMethod() {
 		return "onConflict";
 	}
-	transformInput(value, type, forArrayField) {
+	transformInput(value, type, forArrayField, fieldDef) {
 		if (value === void 0) return value;
 		if (value instanceof JsonNullClass) return "null";
 		else if (value instanceof DbNullClass) return null;
@@ -1612,9 +1746,15 @@ var PostgresCrudDialect = class PostgresCrudDialect extends LateralJoinDialectBa
 		if (isTypeDef(this.schema, type)) if (typeof value !== "string") return JSON.stringify(value);
 		else return value;
 		else if (Array.isArray(value)) if (type === "Json" && !forArrayField) return JSON.stringify(value);
-		else return value.map((v) => this.transformInput(v, type, false));
+		else return value.map((v) => this.transformInput(v, type, false, fieldDef));
 		else switch (type) {
-			case "DateTime": return value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value;
+			case "DateTime": {
+				const date = value instanceof Date ? value : typeof value === "string" ? new Date(value) : null;
+				if (date === null || isNaN(date.getTime())) return value;
+				const dbAttrName = fieldDef?.attributes?.find((a) => a.name.startsWith("@db."))?.name;
+				if (dbAttrName === "@db.Time" || dbAttrName === "@db.Timetz") return formatTimeOfDay(date, dbAttrName === "@db.Timetz");
+				return date.toISOString();
+			}
 			case "Decimal": return value !== null ? value.toString() : value;
 			case "Json": if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
 			else return value;
@@ -1786,6 +1926,72 @@ var PostgresCrudDialect = class PostgresCrudDialect extends LateralJoinDialectBa
 			return ob;
 		});
 	}
+	/**
+	* Wraps an expression with `unaccent(lower(...))` or just `lower(...)` depending on
+	* whether the user opted into accent-insensitive matching. The lowering is always
+	* applied so trigram comparisons are case-insensitive on both sides.
+	*/
+	normalizeForTrigram(expr, applyUnaccent) {
+		return applyUnaccent ? sql`unaccent(lower(${expr}))` : sql`lower(${expr})`;
+	}
+	buildFuzzyFilter(fieldRef, options) {
+		const fieldExpr = this.normalizeForTrigram(fieldRef, options.unaccent);
+		const valueExpr = this.normalizeForTrigram(sql.val(options.search), options.unaccent);
+		if (options.threshold === void 0) switch (options.mode) {
+			case "simple": return sql`${fieldExpr} % ${valueExpr}`;
+			case "word": return sql`${valueExpr} <% ${fieldExpr}`;
+			case "strictWord": return sql`${valueExpr} <<% ${fieldExpr}`;
+		}
+		const threshold = sql.val(options.threshold);
+		switch (options.mode) {
+			case "simple": return sql`similarity(${fieldExpr}, ${valueExpr}) > ${threshold}`;
+			case "word": return sql`word_similarity(${valueExpr}, ${fieldExpr}) > ${threshold}`;
+			case "strictWord": return sql`strict_word_similarity(${valueExpr}, ${fieldExpr}) > ${threshold}`;
+		}
+	}
+	buildFuzzyRelevanceOrderBy(query, fieldRefs, search, sort, mode, unaccent) {
+		const valueExpr = this.normalizeForTrigram(sql.val(search), unaccent);
+		const buildSimilarity = (fieldRef) => {
+			const fieldExpr = this.normalizeForTrigram(fieldRef, unaccent);
+			switch (mode) {
+				case "simple": return sql`similarity(${fieldExpr}, ${valueExpr})`;
+				case "word": return sql`word_similarity(${valueExpr}, ${fieldExpr})`;
+				case "strictWord": return sql`strict_word_similarity(${valueExpr}, ${fieldExpr})`;
+			}
+		};
+		if (fieldRefs.length === 1) return query.orderBy(buildSimilarity(fieldRefs[0]), sort);
+		const similarities = fieldRefs.map((ref) => buildSimilarity(ref));
+		return query.orderBy(sql`GREATEST(${sql.join(similarities)})`, sort);
+	}
+	buildFullTextFilter(fieldRef, payload) {
+		const options = this.normalizeFullTextOptions(payload);
+		const query = sql.val(options.search);
+		if (options.config === void 0) return sql`to_tsvector(${fieldRef}) @@ to_tsquery(${query})`;
+		const cfg = sql.val(options.config);
+		return sql`to_tsvector(${cfg}::regconfig, ${fieldRef}) @@ to_tsquery(${cfg}::regconfig, ${query})`;
+	}
+	/**
+	* Validate the user-provided `fts` filter payload. When `config` is omitted
+	* it stays `undefined` so {@link buildFullTextFilter} can emit the no-regconfig
+	* SQL form and let Postgres fall back to `default_text_search_config`.
+	*/
+	normalizeFullTextOptions(value) {
+		invariant(value !== null && typeof value === "object" && !Array.isArray(value), "fts filter must be an object with at least a \"search\" field");
+		const raw = value;
+		invariant(typeof raw["search"] === "string" && raw["search"].length > 0, "fts.search must be a non-empty string");
+		if (raw["config"] !== void 0) invariant(typeof raw["config"] === "string" && raw["config"].length > 0, "fts.config must be a non-empty string");
+		return {
+			search: raw["search"],
+			config: raw["config"]
+		};
+	}
+	buildFtsRelevanceOrderBy(query, fieldRefs, search, config, sort) {
+		const q = sql.val(search);
+		const document = fieldRefs.length === 1 ? sql`coalesce(${fieldRefs[0]}, '')` : sql`concat_ws(' ', ${sql.join(fieldRefs)})`;
+		if (config === void 0) return query.orderBy(sql`ts_rank(to_tsvector(${document}), to_tsquery(${q}))`, sort);
+		const cfg = sql.val(config);
+		return query.orderBy(sql`ts_rank(to_tsvector(${cfg}::regconfig, ${document}), to_tsquery(${cfg}::regconfig, ${q}))`, sort);
+	}
 };
 //#endregion
 //#region src/client/crud/dialects/sqlite.ts
@@ -2003,6 +2209,18 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
 			return ob;
 		});
 	}
+	buildFuzzyFilter(_fieldRef, _options) {
+		throw createNotSupportedError("\"fuzzy\" filter is not supported by the \"sqlite\" provider");
+	}
+	buildFuzzyRelevanceOrderBy(_query, _fieldRefs, _search, _sort, _mode, _unaccent) {
+		throw createNotSupportedError("\"_fuzzyRelevance\" ordering is not supported by the \"sqlite\" provider");
+	}
+	buildFullTextFilter(_fieldRef, _payload) {
+		throw createNotSupportedError("\"fts\" filter is not supported by the \"sqlite\" provider");
+	}
+	buildFtsRelevanceOrderBy(_query, _fieldRefs, _search, _config, _sort) {
+		throw createNotSupportedError("\"_ftsRelevance\" ordering is not supported by the \"sqlite\" provider");
+	}
 };
 //#endregion
 //#region src/client/crud/dialects/index.ts
@@ -2058,6 +2276,33 @@ function createQuerySchemaFactory(clientOrSchema, options) {
 	return new ZodSchemaFactory(clientOrSchema, options);
 }
 /**
+* Builds a `DateTime` value schema that accepts a `Date` object or any string
+* the JS `Date` constructor parses, and coerces it to a `Date`. ISO datetime,
+* ISO date, and time-only strings (e.g. `"09:00:00"` for `@db.Time` fields,
+* anchored to the Unix epoch) are the documented happy paths; other formats
+* accepted by `new Date(...)` also pass through, mirroring Prisma's pre-3.5
+* behaviour. Strings the engine can't parse fall through and are rejected by
+* `z.date()` with the standard error.
+*
+* @see https://github.com/zenstackhq/zenstack/issues/2631
+*/
+function coercedDateTimeSchema() {
+	return z.preprocess((val) => {
+		if (typeof val !== "string") return val;
+		if (/^\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d\d(?::\d\d)?)?$/.test(val)) {
+			const hasTz = val.endsWith("Z") || /[+-]\d\d(?::\d\d)?$/.test(val);
+			const d = /* @__PURE__ */ new Date(`1970-01-01T${val}${hasTz ? "" : "Z"}`);
+			return isNaN(d.getTime()) ? val : d;
+		}
+		const d = new Date(val);
+		return isNaN(d.getTime()) ? val : d;
+	}, z.union([
+		z.iso.datetime(),
+		z.iso.date(),
+		z.date()
+	]));
+}
+/**
 * Factory class responsible for creating and caching Zod schemas for ORM input validation.
 */
 var ZodSchemaFactory = class {
@@ -2226,7 +2471,7 @@ var ZodSchemaFactory = class {
 		const typeDef = getTypeDef(this.schema, type);
 		invariant(typeDef, `Type definition "${type}" not found in schema`);
 		const schema = z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
-			let fieldSchema = this.makeScalarSchema(def.type);
+			let fieldSchema = isTypeDef(this.schema, def.type) ? z.lazy(() => this.makeTypeDefSchema(def.type)) : this.makeScalarSchema(def.type);
 			if (def.array) fieldSchema = fieldSchema.array();
 			if (def.optional) fieldSchema = fieldSchema.nullish();
 			return [field, fieldSchema];
@@ -2270,7 +2515,7 @@ var ZodSchemaFactory = class {
 					if (Object.keys(enumDef.values).length > 0) fieldSchema = this.makeEnumFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array, withAggregations, allowedFilterKinds);
 				} else if (fieldDef.array) fieldSchema = this.makeArrayFilterSchema(fieldDef.type, allowedFilterKinds);
 				else if (this.isTypeDefType(fieldDef.type)) fieldSchema = this.makeTypedJsonFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array, allowedFilterKinds);
-				else fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations, allowedFilterKinds);
+				else fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations, allowedFilterKinds, !!fieldDef.fuzzy, !!fieldDef.fullText);
 			}
 			if (fieldSchema) fields[field] = fieldSchema.optional();
 		}
@@ -2399,8 +2644,8 @@ var ZodSchemaFactory = class {
 		const filteredOperators = this.trimFilterOperators(operators, allowedFilterKinds);
 		return z.strictObject(filteredOperators);
 	}
-	makePrimitiveFilterSchema(type, optional, withAggregations, allowedFilterKinds) {
-		return match(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Json", () => this.makeJsonFilterSchema(optional, allowedFilterKinds)).with("Unsupported", () => z.never()).exhaustive();
+	makePrimitiveFilterSchema(type, optional, withAggregations, allowedFilterKinds, withFuzzy = false, withFullText = false) {
+		return match(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds, withFuzzy, withFullText)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Json", () => this.makeJsonFilterSchema(optional, allowedFilterKinds)).with("Unsupported", () => z.never()).exhaustive();
 	}
 	makeJsonValueSchema() {
 		const schema = z.union([
@@ -2442,11 +2687,7 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeDateTimeValueSchema() {
-		const schema = z.union([
-			z.iso.datetime(),
-			z.iso.date(),
-			z.date()
-		]);
+		const schema = coercedDateTimeSchema();
 		this.registerSchema("DateTime", schema);
 		return schema;
 	}
@@ -2542,8 +2783,8 @@ var ZodSchemaFactory = class {
 		})}`, schema);
 		return schema;
 	}
-	makeStringFilterSchema(optional, withAggregations, allowedFilterKinds) {
-		const baseComponents = this.makeCommonPrimitiveFilterComponents(z.string(), optional, () => z.lazy(() => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)), void 0, withAggregations ? [
+	makeStringFilterSchema(optional, withAggregations, allowedFilterKinds, withFuzzy = false, withFullText = false) {
+		const baseComponents = this.makeCommonPrimitiveFilterComponents(z.string(), optional, () => z.lazy(() => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds, withFuzzy, withFullText)), void 0, withAggregations ? [
 			"_count",
 			"_min",
 			"_max"
@@ -2552,6 +2793,8 @@ var ZodSchemaFactory = class {
 			startsWith: z.string().optional(),
 			endsWith: z.string().optional(),
 			contains: z.string().optional(),
+			...withFuzzy && this.providerSupportsFuzzySearch ? { fuzzy: this.makeFuzzyFilterSchema().optional() } : {},
+			...withFullText && this.providerSupportsFullTextSearch ? { fts: this.makeFullTextFilterSchema().optional() } : {},
 			...this.providerSupportsCaseSensitivity ? { mode: this.makeStringModeSchema().optional() } : {}
 		};
 		const filteredStringOperators = this.trimFilterOperators(stringSpecificOperators, allowedFilterKinds);
@@ -2560,16 +2803,35 @@ var ZodSchemaFactory = class {
 			...filteredStringOperators
 		};
 		const schema = this.createUnionFilterSchema(z.string(), optional, allComponents, allowedFilterKinds);
+		const featureSuffix = `${withFuzzy ? "Fuzzy" : ""}${withFullText ? "FullText" : ""}`;
 		this.registerSchema(`StringFilter${this.filterSchemaSuffix({
 			optional,
 			allowedFilterKinds,
 			withAggregations
-		})}`, schema);
+		})}${featureSuffix}`, schema);
 		return schema;
 	}
 	makeStringModeSchema() {
 		return z.union([z.literal("default"), z.literal("insensitive")]);
 	}
+	makeFuzzyFilterSchema() {
+		return z.strictObject({
+			search: z.string().min(1),
+			mode: z.union([
+				z.literal("simple"),
+				z.literal("word"),
+				z.literal("strictWord")
+			]).default("simple"),
+			threshold: z.number().min(0).max(1).optional(),
+			unaccent: z.boolean().default(false)
+		});
+	}
+	makeFullTextFilterSchema() {
+		return z.strictObject({
+			search: z.string().min(1),
+			config: z.string().min(1).optional()
+		});
+	}
 	makeSelectSchema(model, options) {
 		const fields = {};
 		for (const [field, fieldDef] of this.getModelFields(model)) if (fieldDef.relation) {
@@ -2670,7 +2932,7 @@ var ZodSchemaFactory = class {
 			}).optional();
 		} else if (fieldDef.optional) fields[field] = z.union([sort, z.strictObject({
 			sort,
-			nulls: z.union([z.literal("first"), z.literal("last")])
+			nulls: z.union([z.literal("first"), z.literal("last")]).optional()
 		})]).optional();
 		else fields[field] = sort.optional();
 		if (WithAggregation) for (const agg of [
@@ -2680,6 +2942,29 @@ var ZodSchemaFactory = class {
 			"_min",
 			"_max"
 		]) fields[agg] = z.lazy(() => this.makeOrderBySchema(model, true, false, options).optional());
+		if (this.providerSupportsFuzzySearch) {
+			const fuzzyFieldNames = this.getModelFields(model).filter(([, def]) => !def.relation && def.type === "String" && def.fuzzy === true).map(([name]) => name);
+			if (fuzzyFieldNames.length > 0) fields["_fuzzyRelevance"] = z.strictObject({
+				fields: z.array(z.enum(fuzzyFieldNames)).min(1),
+				search: z.string(),
+				mode: z.union([
+					z.literal("simple"),
+					z.literal("word"),
+					z.literal("strictWord")
+				]).default("simple"),
+				unaccent: z.boolean().default(false),
+				sort
+			}).optional();
+		}
+		if (this.providerSupportsFullTextSearch) {
+			const fullTextFieldNames = this.getModelFields(model).filter(([, def]) => !def.relation && def.type === "String" && def.fullText === true).map(([name]) => name);
+			if (fullTextFieldNames.length > 0) fields["_ftsRelevance"] = z.strictObject({
+				fields: z.array(z.enum(fullTextFieldNames)).min(1),
+				search: z.string().min(1),
+				config: z.string().min(1).optional(),
+				sort
+			}).optional();
+		}
 		const schema = refineAtMostOneKey(z.strictObject(fields));
 		let schemaId = `${model}OrderBy`;
 		if (withRelation) schemaId += "WithRelation";
@@ -3181,6 +3466,12 @@ var ZodSchemaFactory = class {
 	get providerSupportsCaseSensitivity() {
 		return this.schema.provider.type === "postgresql";
 	}
+	get providerSupportsFullTextSearch() {
+		return this.schema.provider.type === "postgresql";
+	}
+	get providerSupportsFuzzySearch() {
+		return this.schema.provider.type === "postgresql";
+	}
 	/**
 	* Gets the effective set of allowed FilterKind values for a specific model and field.
 	* Respects the precedence: model[field] > model.$all > $all[field] > $all.$all.
@@ -3342,6 +3633,8 @@ __decorate([
 		Object,
 		Boolean,
 		Boolean,
+		Object,
+		Object,
 		Object
 	]),
 	__decorateMetadata("design:returntype", void 0)
@@ -3411,6 +3704,8 @@ __decorate([
 	__decorateMetadata("design:paramtypes", [
 		Boolean,
 		Boolean,
+		Object,
+		Object,
 		Object
 	]),
 	__decorateMetadata("design:returntype", typeof (_ref10 = typeof ZodType !== "undefined" && ZodType) === "function" ? _ref10 : Object)
@@ -3900,7 +4195,7 @@ var BaseOperationHandler = class {
 		return new this.constructor(client, this.model, this.inputValidator);
 	}
 	get hasPolicyEnabled() {
-		return this.options.plugins?.some((plugin) => plugin.constructor.name === "PolicyPlugin");
+		return this.options.plugins?.some((plugin) => plugin.id === "policy") ?? false;
 	}
 	requireModel(model) {
 		return requireModel(this.schema, model);
@@ -4001,8 +4296,8 @@ var BaseOperationHandler = class {
 		const postCreateRelations = {};
 		for (const [field, value] of Object.entries(data)) {
 			const fieldDef = this.requireField(model, field);
-			if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) if (fieldDef.array && value && typeof value === "object" && "set" in value && Array.isArray(value.set)) createFields[field] = this.dialect.transformInput(value.set, fieldDef.type, true);
-			else createFields[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
+			if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) if (fieldDef.array && value && typeof value === "object" && "set" in value && Array.isArray(value.set)) createFields[field] = this.dialect.transformInput(value.set, fieldDef.type, true, fieldDef);
+			else createFields[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array, fieldDef);
 			else if (!getManyToManyRelation(this.schema, model, field) && fieldDef.relation?.fields && fieldDef.relation?.references) {
 				const fkValues = await this.processOwnedRelationForCreate(kysely, fieldDef, value);
 				for (let i = 0; i < fieldDef.relation.fields.length; i++) createFields[fieldDef.relation.fields[i]] = fkValues[fieldDef.relation.references[i]];
@@ -4059,7 +4354,7 @@ var BaseOperationHandler = class {
 		});
 		const discriminatorField = getDiscriminatorField(this.schema, model);
 		invariant(discriminatorField, `Base model "${model}" must have a discriminator field`);
-		thisCreateFields[discriminatorField] = forModel;
+		thisCreateFields[discriminatorField] = getDelegateDiscriminatorValue(this.schema, forModel);
 		const baseEntity = await this.create(kysely, model, thisCreateFields, void 0, true);
 		const idValues = extractIdFields(baseEntity, this.schema, model);
 		Object.assign(remainingFields, idValues);
@@ -4202,7 +4497,7 @@ var BaseOperationHandler = class {
 			for (const [name, value] of Object.entries(item)) {
 				const fieldDef = this.requireField(model, name);
 				invariant(!fieldDef.relation, "createMany does not support relations");
-				newItem[name] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
+				newItem[name] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array, fieldDef);
 			}
 			if (fromRelation) for (const { fk, pk } of relationKeyPairs) newItem[fk] = fromRelation.ids[pk];
 			return this.fillGeneratedAndDefaultValues(modelDef, newItem);
@@ -4218,7 +4513,7 @@ var BaseOperationHandler = class {
 				if (Object.keys(item).length === allPassedFields.length) continue;
 				for (const field of allPassedFields) if (!(field in item)) {
 					const fieldDef = this.requireField(model, field);
-					if (fieldDef.default !== void 0 && fieldDef.default !== null && typeof fieldDef.default !== "object") item[field] = this.dialect.transformInput(fieldDef.default, fieldDef.type, !!fieldDef.array);
+					if (fieldDef.default !== void 0 && fieldDef.default !== null && typeof fieldDef.default !== "object") item[field] = this.dialect.transformInput(fieldDef.default, fieldDef.type, !!fieldDef.array, fieldDef);
 				}
 			}
 		}
@@ -4251,7 +4546,7 @@ var BaseOperationHandler = class {
 				if (this.getField(model, field)) thisCreateFields[field] = value;
 				else remainingFields[field] = value;
 			});
-			thisCreateFields[discriminatorField] = forModel;
+			thisCreateFields[discriminatorField] = getDelegateDiscriminatorValue(this.schema, forModel);
 			thisCreateRows.push(thisCreateFields);
 			remainingFieldRows.push(remainingFields);
 		}
@@ -4281,15 +4576,15 @@ var BaseOperationHandler = class {
 			if (!(field in data)) {
 				if (typeof fieldDef?.default === "object" && "kind" in fieldDef.default) {
 					const generated = this.evalGenerator(fieldDef.default);
-					if (generated !== void 0) values[field] = this.dialect.transformInput(generated, fieldDef.type, !!fieldDef.array);
-				} else if (fieldDef?.updatedAt) values[field] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false);
+					if (generated !== void 0) values[field] = this.dialect.transformInput(generated, fieldDef.type, !!fieldDef.array, fieldDef);
+				} else if (fieldDef?.updatedAt) values[field] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false, fieldDef);
 				else if (fieldDef?.default !== void 0) {
 					let value = fieldDef.default;
 					if (fieldDef.type === "Json") {
 						if (fieldDef.array && Array.isArray(value)) value = value.map((v) => typeof v === "string" ? JSON.parse(v) : v);
 						else if (typeof value === "string") value = JSON.parse(value);
 					}
-					values[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
+					values[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array, fieldDef);
 				}
 			}
 		}
@@ -4339,7 +4634,7 @@ var BaseOperationHandler = class {
 			const ignoredFields = new Set(typeof fieldDef.updatedAt === "boolean" ? [] : fieldDef.updatedAt.ignore);
 			if (Object.keys(data).some((field) => (isScalarField(this.schema, modelDef.name, field) || isForeignKeyField(this.schema, modelDef.name, field)) && !ignoredFields.has(field))) {
 				if (finalData === data) finalData = clone(data);
-				finalData[fieldName] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false);
+				finalData[fieldName] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false, fieldDef);
 				autoUpdatedFields.push(fieldName);
 			}
 		}
@@ -4443,7 +4738,7 @@ var BaseOperationHandler = class {
 		const fieldDef = this.requireField(model, field);
 		if (this.isNumericIncrementalUpdate(fieldDef, data[field])) return this.transformIncrementalUpdate(model, field, fieldDef, data[field]);
 		if (fieldDef.array && typeof data[field] === "object" && !Array.isArray(data[field]) && data[field]) return this.transformScalarListUpdate(model, field, fieldDef, data[field]);
-		return this.dialect.transformInput(data[field], fieldDef.type, !!fieldDef.array);
+		return this.dialect.transformInput(data[field], fieldDef.type, !!fieldDef.array, fieldDef);
 	}
 	isNumericIncrementalUpdate(fieldDef, value) {
 		if (!this.isNumericField(fieldDef)) return false;
@@ -4471,7 +4766,7 @@ var BaseOperationHandler = class {
 	transformIncrementalUpdate(model, field, fieldDef, payload) {
 		invariant(Object.keys(payload).length === 1, "Only one of \"set\", \"increment\", \"decrement\", \"multiply\", or \"divide\" can be provided");
 		const key = Object.keys(payload)[0];
-		const value = this.dialect.transformInput(payload[key], fieldDef.type, false);
+		const value = this.dialect.transformInput(payload[key], fieldDef.type, false, fieldDef);
 		const eb = expressionBuilder();
 		const fieldRef = this.dialect.fieldRef(model, field);
 		return match(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
@@ -4481,7 +4776,7 @@ var BaseOperationHandler = class {
 	transformScalarListUpdate(model, field, fieldDef, payload) {
 		invariant(Object.keys(payload).length === 1, "Only one of \"set\", \"push\" can be provided");
 		const key = Object.keys(payload)[0];
-		const value = this.dialect.transformInput(payload[key], fieldDef.type, true);
+		const value = this.dialect.transformInput(payload[key], fieldDef.type, true, fieldDef);
 		const eb = expressionBuilder();
 		const fieldRef = this.dialect.fieldRef(model, field);
 		return match(key).with("set", () => value).with("push", () => {
@@ -6892,12 +7187,21 @@ var ClientImpl = class ClientImpl {
 			});
 		}
 	}
+	getPromiseCallback(promise) {
+		invariant(promise.cb, "Invalid ZenStackPromise, missing cb property");
+		const cb = promise.cb;
+		invariant(typeof cb === "function", "Invalid ZenStackPromise, cb property is not a function");
+		return promise.cb;
+	}
 	async sequentialTransaction(arg, options) {
 		const execute = async (tx) => {
 			const txClient = new ClientImpl(this.schema, this.$options, this);
 			txClient.kysely = tx;
 			const result = [];
-			for (const promise of arg) result.push(await promise.cb(txClient));
+			for (const promise of arg) {
+				const cb = this.getPromiseCallback(promise);
+				result.push(await cb(txClient));
+			}
 			return result;
 		};
 		if (this.kysely.isTransaction) return execute(this.kysely);
@@ -7684,6 +7988,15 @@ var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
 	visitCollate(node) {
 		this.defaultVisit(node);
 	}
+	visitAlterType(node) {
+		this.defaultVisit(node);
+	}
+	visitAddValue(node) {
+		this.defaultVisit(node);
+	}
+	visitRenameValue(node) {
+		this.defaultVisit(node);
+	}
 };
 //#endregion
 //#region src/utils/schema-utils.ts
@@ -7743,6 +8056,6 @@ var MatchingExpressionVisitor = class extends ExpressionVisitor {
 	}
 };
 //#endregion
-export { AllCrudOperations, AllReadOperations, AllWriteOperations, AnyNull, AnyNullClass, BaseCrudDialect, CRUD, CRUD_EXT, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, DbNull, DbNullClass, InputValidator, JsonNull, JsonNullClass, kysely_utils_exports as KyselyUtils, ORMError, ORMErrorReason, query_utils_exports as QueryUtils, RejectedByPolicyReason, schema_utils_exports as SchemaUtils, TransactionIsolationLevel, ZenStackClient, createQuerySchemaFactory, definePlugin, getCrudDialect };
+export { AllCrudOperations, AllReadOperations, AllWriteOperations, AnyNull, AnyNullClass, BaseCrudDialect, CRUD, CRUD_EXT, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, DbNull, DbNullClass, ExtQueryArgsMarker, ExtResultMarker, InputValidator, JsonNull, JsonNullClass, kysely_utils_exports as KyselyUtils, ORMError, ORMErrorReason, query_utils_exports as QueryUtils, RejectedByPolicyReason, schema_utils_exports as SchemaUtils, TransactionIsolationLevel, ZenStackClient, createQuerySchemaFactory, definePlugin, getCrudDialect };
 
 //# sourceMappingURL=index.mjs.map