@warlock.js/cascade 4.6.1 → 4.8.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to `@warlock.js/cascade` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 4.7.0
+
+### Added
+
+- `lockForUpdate({ skipLocked?, noWait? })` — row locking on SELECT (`FOR UPDATE [SKIP LOCKED | NOWAIT]`), the concurrent job-queue claim shape; Postgres-only, the MongoDB driver throws
+- `DatabaseDriverContract.supportsSqlSerialization` — capability flag (default `true`); `false` routes the MigrationRunner through direct migration-driver execution
+
+### Fixed
+
+- Postgres model-level `sum`/`avg`/`min`/`max`/`distinct`/`countDistinct`/`pluck`/`value` no longer return `0`/`undefined` — the hydration callback is reset before reading, matching MongoDB
+- Postgres `Model.findAndUpdate` / `Model.atomic` now update every matching row instead of one arbitrary row (a hidden `LIMIT 1`; MongoDB was already multi-row)
+- Postgres query-builder `update()` / `unset()` now honor the chained `where` filter — previously they updated the whole table
+- Postgres query-builder `deleteOne()` deletes exactly one row — the internal `limit(1)` was silently ignored, deleting every matching row
+- Postgres pivot `detach(ids)` (and `sync` / `toggle`) works — the driver translates Mongo-style filter operators (`$in`, `$nin`, `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`) instead of binding the operator object literally
+- CHECK constraints are no longer silently dropped on the MigrationRunner SQL path — the Postgres serializer emits `ADD CONSTRAINT ... CHECK` for `this.check(...)` and column `.check(...)`
+- MongoDB `with()` eager loading is no longer a silent no-op — `get()` runs the relation loader, same wiring as Postgres
+- MongoDB pipelines order `$match` before `$project` (SQL semantics), so `select()` before `where()` no longer strips the filter column and returns `[]` — fixes pivot `attach` de-duplication and `sync` / `toggle` deltas
+- The MigrationRunner works on MongoDB — migrations execute directly through the migration driver; `exportSQL` stays SQL-only with a clear unsupported error
+- MongoDB `dropIndex(table, name)` honors the literal index name — the string form is no longer rewritten to `<name>_1` (the columns-array form keeps the convention name)
+- `addGlobalScope` / `addLocalScope` register per-subclass — a scope added on one model (e.g. a soft-delete `notDeleted`) no longer leaks onto every other model
+
 ## 4.6.1
 
 ### Fixed

package/cjs/index.cjs

@@ -4812,20 +4812,34 @@ async function restoreAllRecords(ModelClass, options) {
 
 //#endregion
 //#region ../@warlock.js/cascade/src/model/methods/scope-methods.ts
+/**
+* Give the model class its OWN scope map before mutating.
+*
+* The `globalScopes` / `localScopes` statics live on the base `Model`; without
+* this, `ModelClass.globalScopes.set(...)` from any subclass mutates the ONE
+* inherited Map and the scope leaks onto every other model (a soft-delete
+* `notDeleted` scope registered on `User` would filter `Post` too). The own
+* map snapshots the currently-inherited entries so parent scopes registered so
+* far are kept.
+*/
+function ownScopeMap(ModelClass, property) {
+	if (!Object.prototype.hasOwnProperty.call(ModelClass, property)) ModelClass[property] = new Map(ModelClass[property]);
+	return ModelClass[property];
+}
 function addGlobalModelScope(ModelClass, name, callback, options = {}) {
-	ModelClass.globalScopes.set(name, {
+	ownScopeMap(ModelClass, "globalScopes").set(name, {
 		callback,
 		timing: options.timing || "before"
 	});
 }
 function removeGlobalModelScope(ModelClass, name) {
-	ModelClass.globalScopes.delete(name);
+	ownScopeMap(ModelClass, "globalScopes").delete(name);
 }
 function addLocalModelScope(ModelClass, name, callback) {
-	ModelClass.localScopes.set(name, callback);
+	ownScopeMap(ModelClass, "localScopes").set(name, callback);
 }
 function removeLocalModelScope(ModelClass, name) {
-	ModelClass.localScopes.delete(name);
+	ownScopeMap(ModelClass, "localScopes").delete(name);
 }
 
 //#endregion
@@ -5417,11 +5431,17 @@ var Model = class Model {
 	/**
 	* Global scopes that are automatically applied to all queries.
 	* These scopes are inherited by child models.
+	*
+	* Registration via `addGlobalScope` is per-subclass: the registering class
+	* gets its own map (seeded with the entries inherited so far), so a scope
+	* added on one model never leaks onto sibling models.
 	*/
 	static globalScopes = /* @__PURE__ */ new Map();
 	/**
 	* Local scopes that can be manually applied to queries.
 	* These are reusable query snippets that developers opt into.
+	*
+	* Registration via `addLocalScope` is per-subclass, like `globalScopes`.
 	*/
 	static localScopes = /* @__PURE__ */ new Map();
 	/**
@@ -7868,12 +7888,15 @@ var MongoMigrationDriver = class {
 	/**
 	* Drop an index by name or columns.
 	*
+	* A string is the literal index name and is passed through untouched; a
+	* columns array resolves to the MongoDB convention name
+	* (`"column1_1_column2_1"`) those columns auto-name to.
+	*
 	* @param indexNameOrColumns - Index name (string) or columns array
 	*/
 	async dropIndex(table, indexNameOrColumns) {
 		const collection = this.db.collection(table);
-		if (!Array.isArray(indexNameOrColumns)) indexNameOrColumns = [indexNameOrColumns];
-		const indexName = indexNameOrColumns.map((col) => `${col}_1`).join("_");
+		const indexName = Array.isArray(indexNameOrColumns) ? indexNameOrColumns.map((col) => `${col}_1`).join("_") : indexNameOrColumns;
 		await collection.dropIndex(indexName);
 	}
 	/**
@@ -9209,6 +9232,25 @@ var QueryBuilder = class QueryBuilder {
 		return this.limit(value);
 	}
 	/**
+	* Lock the selected rows for update (`SELECT ... FOR UPDATE`).
+	*
+	* `skipLocked` skips rows other transactions hold locks on (concurrent
+	* queue-claim shape); `noWait` errors immediately instead of waiting. The
+	* two are mutually exclusive. Only meaningful inside a transaction.
+	*
+	* SQL drivers emit the locking clause; drivers without row locking
+	* (MongoDB) override this to throw.
+	*/
+	lockForUpdate(options) {
+		if (options?.skipLocked && options?.noWait) throw new Error("lockForUpdate: `skipLocked` and `noWait` are mutually exclusive.");
+		this.addOperation("lock", {
+			mode: "update",
+			skipLocked: options?.skipLocked ?? false,
+			noWait: options?.noWait ?? false
+		});
+		return this;
+	}
+	/**
 	* GROUP BY clause.
 	* @example q.groupBy("status")
 	* @example q.groupBy(["year", "month"])
@@ -9628,7 +9670,7 @@ var MongoQueryParser = class {
 		const pipeline = [];
 		let currentStage = null;
 		let currentBuffer = [];
-		for (const op of this.operations) if (op.mergeable && op.stage === currentStage) currentBuffer.push(op);
+		for (const op of this.orderStages(this.operations)) if (op.mergeable && op.stage === currentStage) currentBuffer.push(op);
 		else {
 			if (currentBuffer.length > 0) {
 				const builtStage = this.buildStage(currentStage, currentBuffer);
@@ -9663,6 +9705,38 @@ var MongoQueryParser = class {
 		return this.postProcessGroupStages(pipeline);
 	}
 	/**
+	* Reorder operations so filters run before projections, mirroring SQL
+	* semantics: in `select(...).where(...)`, the WHERE always applies to the
+	* source columns regardless of call order. Without this, a `$project` that
+	* strips the filter column would run before the `$match` and silently drop
+	* every document (`select(["a"]).where("b", x)` → `[]`).
+	*
+	* Only *mergeable* `$match` operations are hoisted, and only within a
+	* segment of neighboring mergeable `$match` / `$project` / `$sort`
+	* operations. Any other operation — `$group`, `$lookup`, `$limit`, `$skip`,
+	* `$setWindowFields`, or a non-mergeable op (raw escapes, having-style
+	* post-group matches, `$sample`) — is a barrier: nothing moves across it.
+	* So `groupBy(...).where(...)` still filters AFTER the group, and
+	* `limit(...)` / `random()` keep their call-order meaning.
+	*/
+	orderStages(operations) {
+		const reordered = [];
+		let segment = [];
+		const flushSegment = () => {
+			if (segment.length === 0) return;
+			reordered.push(...segment.filter((op) => op.stage === "$match"));
+			reordered.push(...segment.filter((op) => op.stage !== "$match"));
+			segment = [];
+		};
+		for (const op of operations) if (op.mergeable && (op.stage === "$match" || op.stage === "$project" || op.stage === "$sort")) segment.push(op);
+		else {
+			flushSegment();
+			reordered.push(op);
+		}
+		flushSegment();
+		return reordered;
+	}
+	/**
 	* Track field names for group stages that need _id renaming.
 	*/
 	trackGroupFieldNames(stage, operations, stageIndex) {
@@ -11894,6 +11968,14 @@ var MongoQueryBuilder = class MongoQueryBuilder extends QueryBuilder {
 		return cloned;
 	}
 	/**
+	* Row-level locking is a SQL capability — MongoDB has no
+	* `SELECT ... FOR UPDATE`. Throwing (instead of silently ignoring the call)
+	* keeps a queue-claim pattern from silently running unlocked.
+	*/
+	lockForUpdate() {
+		throw new Error("lockForUpdate() is not supported by the MongoDB driver — MongoDB has no row-level SELECT locking. Use an atomic claim instead (e.g. findOneAndUpdate with a reservation filter).");
+	}
+	/**
 	* Executes a callback with the query builder without breaking the chain.
 	* @param callback - Function to execute with the builder
 	*/
@@ -11928,6 +12010,7 @@ var MongoQueryBuilder = class MongoQueryBuilder extends QueryBuilder {
 			hydrateCallback: this.hydrateCallback
 		});
 		const hydratedRecords = this.hydrateCallback ? rawRecords.map(this.hydrateCallback) : rawRecords;
+		await this.applyEagerLoading(hydratedRecords);
 		if (this.fetchedCallback) await this.fetchedCallback(hydratedRecords, {
 			query: this,
 			rawRecords,
@@ -11936,6 +12019,20 @@ var MongoQueryBuilder = class MongoQueryBuilder extends QueryBuilder {
 		return hydratedRecords;
 	}
 	/**
+	* Run the RelationLoader against the fetched documents for every relation
+	* registered via `with()`. Mutates each model instance in place — attaches
+	* loaded relations onto `model.loadedRelations` and as direct properties.
+	*
+	* Skipped silently when `modelClass` is absent (raw driver-level
+	* `queryBuilder()` usage has no relations map to consult).
+	*/
+	async applyEagerLoading(records) {
+		if (!this.modelClass || this.eagerLoadRelations.size === 0 || records.length === 0) return;
+		const constraints = {};
+		for (const [name, constraint] of this.eagerLoadRelations) if (typeof constraint === "function") constraints[name] = constraint;
+		await new RelationLoader(records, this.modelClass).load([...this.eagerLoadRelations.keys()], constraints);
+	}
+	/**
 	* Execute the query and get first result
 	* This is different than `first` as first adds a `limit = 1` to the pipeline
 	*/
@@ -13159,6 +13256,11 @@ var MongoDbDriver = class {
 		return baseOptions;
 	}
 	/**
+	* MongoDB has no SQL dialect — the MigrationRunner executes migrations
+	* through the migration driver directly instead of Migration.toSQL().
+	*/
+	supportsSqlSerialization = false;
+	/**
 	* Return a SQL serializer for this driver's dialect.
 	* Not supported for MongoDB.
 	*/
@@ -14519,6 +14621,11 @@ var PostgresQueryParser = class PostgresQueryParser {
 	*/
 	isDistinct = false;
 	/**
+	* Row-locking clause (`FOR UPDATE [SKIP LOCKED | NOWAIT]`). Appended after
+	* LIMIT/OFFSET — the locking clause is last in PostgreSQL's SELECT grammar.
+	*/
+	lockClause = "";
+	/**
 	* Whether the query has any JOIN operations (pre-scanned before processing).
 	* Used by qualifyColumn() to decide whether to prefix columns with the main table.
 	*/
@@ -14688,6 +14795,13 @@ var PostgresQueryParser = class PostgresQueryParser {
 			case "offset":
 				this.offsetValue = data.value;
 				break;
+			case "lock": {
+				let clause = "FOR UPDATE";
+				if (data.skipLocked) clause += " SKIP LOCKED";
+				else if (data.noWait) clause += " NOWAIT";
+				this.lockClause = clause;
+				break;
+			}
 			case "distinct":
 				this.isDistinct = true;
 				break;
@@ -14718,6 +14832,7 @@ var PostgresQueryParser = class PostgresQueryParser {
 		if (this.orderClauses.length > 0) parts.push(`ORDER BY ${this.orderClauses.join(", ")}`);
 		const limitOffset = this.dialect.limitOffset(this.limitValue, this.offsetValue);
 		if (limitOffset) parts.push(limitOffset);
+		if (this.lockClause) parts.push(this.lockClause);
 		return parts.join(" ");
 	}
 	/**
@@ -15708,38 +15823,45 @@ var PostgresQueryBuilder = class PostgresQueryBuilder extends QueryBuilder {
 	/** SUM a numeric field. */
 	async sum(field) {
 		this.applyPendingScopes();
+		this.hydrateCallback = void 0;
 		const result = await this.selectRaw(`SUM(${field}) as sum`).first();
 		return parseFloat(result?.sum ?? "0");
 	}
 	/** AVG of a numeric field. */
 	async avg(field) {
 		this.applyPendingScopes();
+		this.hydrateCallback = void 0;
 		const result = await this.selectRaw(`AVG(${field}) as avg`).first();
 		return parseFloat(result?.avg ?? "0");
 	}
 	/** MIN of a numeric field. */
 	async min(field) {
 		this.applyPendingScopes();
+		this.hydrateCallback = void 0;
 		const result = await this.selectRaw(`MIN(${field}) as min`).first();
 		return parseFloat(result?.min ?? "0");
 	}
 	/** MAX of a numeric field. */
 	async max(field) {
 		this.applyPendingScopes();
+		this.hydrateCallback = void 0;
 		const result = await this.selectRaw(`MAX(${field}) as max`).first();
 		return parseFloat(result?.max ?? "0");
 	}
 	/** Get distinct values for a field. */
 	async distinct(field) {
+		this.hydrateCallback = void 0;
 		this.distinctValues(field);
 		return (await this.get()).map((row) => row[field]);
 	}
 	/** Get array of all values for a single field. */
 	async pluck(field) {
+		this.hydrateCallback = void 0;
 		return (await this.select([field]).get()).map((row) => row[field]);
 	}
 	/** Get a single scalar value. */
 	async value(field) {
+		this.hydrateCallback = void 0;
 		return (await this.select([field]).first())?.[field] ?? null;
 	}
 	/** Check whether any matching rows exist. */
@@ -15752,6 +15874,7 @@ var PostgresQueryBuilder = class PostgresQueryBuilder extends QueryBuilder {
 	}
 	/** COUNT DISTINCT a field. */
 	async countDistinct(field) {
+		this.hydrateCallback = void 0;
 		const result = await this.selectRaw(`COUNT(DISTINCT ${field}) as count`).first();
 		return parseInt(result?.count ?? "0", 10);
 	}
@@ -15876,21 +15999,49 @@ var PostgresQueryBuilder = class PostgresQueryBuilder extends QueryBuilder {
 		const deleteSql = `DELETE FROM ${this.driver.dialect.quoteIdentifier(this.table)} ${sql}`;
 		return (await this.driver.query(deleteSql, params)).rowCount ?? 0;
 	}
-	/** Delete the first matching row. */
+	/**
+	* Delete the first matching row. Wraps the filter in a ctid subquery —
+	* Postgres has no `DELETE ... LIMIT`, and `delete()`'s filter only reads
+	* `where*` ops, so a plain `limit(1)` would be silently ignored and every
+	* matching row deleted (MongoDB's deleteOne() is single-document).
+	*/
 	async deleteOne() {
-		return this.limit(1).delete();
+		this.applyPendingScopes();
+		const { sql: filterSql, params } = this.buildFilter();
+		const quotedTable = this.driver.dialect.quoteIdentifier(this.table);
+		const deleteSql = `DELETE FROM ${quotedTable} WHERE ctid IN (SELECT ctid FROM ${quotedTable} ${filterSql} LIMIT 1)`;
+		return (await this.driver.query(deleteSql, params)).rowCount ?? 0;
 	}
-	/** Update matching rows. */
+	/**
+	* Update matching rows. Honors every chained `where*` (and applied scopes)
+	* — without a filter the whole table is updated, matching SQL semantics.
+	*/
 	async update(fields) {
 		this.applyPendingScopes();
-		return (await this.driver.updateMany(this.table, {}, { $set: fields })).modifiedCount;
+		const { sql: filterSql, params: filterParams } = this.buildFilter();
+		const serialized = this.driver.serialize(fields, this.table);
+		let paramIndex = filterParams.length + 1;
+		const setClauses = [];
+		const setParams = [];
+		for (const [key, value] of Object.entries(serialized)) {
+			setClauses.push(`${this.driver.dialect.quoteIdentifier(key)} = ${this.driver.dialect.placeholder(paramIndex++)}`);
+			setParams.push(value);
+		}
+		if (setClauses.length === 0) throw new Error("No update operations specified");
+		const updateSql = `UPDATE ${this.driver.dialect.quoteIdentifier(this.table)} SET ${setClauses.join(", ")}` + (filterSql ? ` ${filterSql}` : "");
+		return (await this.driver.query(updateSql, [...filterParams, ...setParams])).rowCount ?? 0;
 	}
-	/** Unset fields from matching rows. */
+	/**
+	* Unset (NULL out) fields from matching rows. Honors every chained `where*`
+	* (and applied scopes), like `update()`.
+	*/
 	async unset(...fields) {
 		this.applyPendingScopes();
-		const updateObj = {};
-		for (const field of fields) updateObj[field] = 1;
-		return (await this.driver.updateMany(this.table, {}, { $unset: updateObj })).modifiedCount;
+		if (fields.length === 0) throw new Error("No update operations specified");
+		const { sql: filterSql, params: filterParams } = this.buildFilter();
+		const setClauses = fields.map((field) => `${this.driver.dialect.quoteIdentifier(field)} = NULL`);
+		const updateSql = `UPDATE ${this.driver.dialect.quoteIdentifier(this.table)} SET ${setClauses.join(", ")}` + (filterSql ? ` ${filterSql}` : "");
+		return (await this.driver.query(updateSql, filterParams)).rowCount ?? 0;
 	}
 	/**
 	* Return the SQL + bindings without executing.
@@ -16459,8 +16610,11 @@ var PostgresSQLSerializer = class extends SQLSerializer {
 			case "dropForeignKey": return this.dropForeignKey(table, operation.payload);
 			case "addPrimaryKey": return this.addPrimaryKey(table, operation.payload);
 			case "dropPrimaryKey": return this.dropPrimaryKey(table);
-			case "addCheck": return null;
-			case "dropCheck": return null;
+			case "addCheck": {
+				const payload = operation.payload;
+				return this.addCheck(table, payload.name, payload.expression);
+			}
+			case "dropCheck": return this.dropCheck(table, operation.payload);
 			case "createTimestamps": return this.createTimestamps(table);
 			case "rawStatement": return operation.payload;
 			case "setSchemaValidation":
@@ -16514,8 +16668,10 @@ var PostgresSQLSerializer = class extends SQLSerializer {
 			if (column.primary) sql += " PRIMARY KEY";
 			if (column.unique) sql += " UNIQUE";
 		}
-		if (column.type === "vector") return ["CREATE EXTENSION IF NOT EXISTS vector", sql];
-		return sql;
+		const statements = [sql];
+		if (column.checkConstraint) statements.push(this.addCheck(table, column.checkConstraint.name, column.checkConstraint.expression));
+		if (column.type === "vector") return ["CREATE EXTENSION IF NOT EXISTS vector", ...statements];
+		return statements.length === 1 ? statements[0] : statements;
 	}
 	dropColumn(table, column) {
 		return `ALTER TABLE ${this.dialect.quoteIdentifier(table)} DROP COLUMN ${this.dialect.quoteIdentifier(column)}`;
@@ -16640,6 +16796,12 @@ var PostgresSQLSerializer = class extends SQLSerializer {
 		const constraintName = `pk_${table}`;
 		return `ALTER TABLE ${quotedTable} DROP CONSTRAINT ${this.dialect.quoteIdentifier(constraintName)}`;
 	}
+	addCheck(table, name, expression) {
+		return `ALTER TABLE ${this.dialect.quoteIdentifier(table)} ADD CONSTRAINT ${this.dialect.quoteIdentifier(name)} CHECK (${expression})`;
+	}
+	dropCheck(table, name) {
+		return `ALTER TABLE ${this.dialect.quoteIdentifier(table)} DROP CONSTRAINT ${this.dialect.quoteIdentifier(name)}`;
+	}
 	mapForeignKeyAction(action) {
 		switch (action) {
 			case "cascade": return "CASCADE";
@@ -17475,6 +17637,9 @@ var PostgresDriver = class {
 	* Perform an atomic update operation.
 	*
 	* Builds and executes an UPDATE query for the given filter and operations.
+	* Updates EVERY matching row — the MongoDB driver's atomic() delegates to
+	* updateMany, and Model.findAndUpdate documents multi-row semantics, so the
+	* two drivers must agree.
 	*
 	* @param table - Target table name
 	* @param filter - Filter conditions
@@ -17483,7 +17648,7 @@ var PostgresDriver = class {
 	* @returns Update result
 	*/
 	async atomic(table, filter, operations, _options) {
-		const { sql, params } = this.buildUpdateQuery(table, filter, operations, 1);
+		const { sql, params } = this.buildUpdateQuery(table, filter, operations);
 		return { modifiedCount: (await this.query(sql, params)).rowCount ?? 0 };
 	}
 	/**
@@ -17586,6 +17751,13 @@ var PostgresDriver = class {
 	/**
 	* Build a simple WHERE clause from a filter object.
 	*
+	* Values are bound as plain equality, except Mongo-style operator objects
+	* (`{ $in: [...] }`, `{ $gt: 5 }`, ...) which are translated to their SQL
+	* equivalents — driver-level callers (e.g. pivot detach) build filters in
+	* that portable form. An unrecognized `$` operator throws instead of being
+	* bound literally, which would only surface as a cryptic type error from
+	* Postgres.
+	*
 	* @param filter - Filter conditions
 	* @param startParamIndex - Starting parameter index
 	* @returns Object with WHERE clause string and parameters
@@ -17597,6 +17769,49 @@ var PostgresDriver = class {
 		for (const [key, value] of Object.entries(filter)) {
 			const quotedKey = this.dialect.quoteIdentifier(key);
 			if (value === null) conditions.push(`${quotedKey} IS NULL`);
+			else if (this.isOperatorFilter(value)) for (const [operator, operand] of Object.entries(value)) switch (operator) {
+				case "$in":
+				case "$nin": {
+					const list = operand;
+					if (list.length === 0) {
+						conditions.push(operator === "$in" ? "FALSE" : "TRUE");
+						break;
+					}
+					const placeholders = list.map(() => this.dialect.placeholder(paramIndex++));
+					params.push(...list);
+					conditions.push(`${quotedKey} ${operator === "$in" ? "IN" : "NOT IN"} (${placeholders.join(", ")})`);
+					break;
+				}
+				case "$eq":
+					if (operand === null) conditions.push(`${quotedKey} IS NULL`);
+					else {
+						conditions.push(`${quotedKey} = ${this.dialect.placeholder(paramIndex++)}`);
+						params.push(operand);
+					}
+					break;
+				case "$ne":
+					if (operand === null) conditions.push(`${quotedKey} IS NOT NULL`);
+					else {
+						conditions.push(`${quotedKey} != ${this.dialect.placeholder(paramIndex++)}`);
+						params.push(operand);
+					}
+					break;
+				case "$gt":
+				case "$gte":
+				case "$lt":
+				case "$lte": {
+					const sqlOperator = {
+						$gt: ">",
+						$gte: ">=",
+						$lt: "<",
+						$lte: "<="
+					}[operator];
+					conditions.push(`${quotedKey} ${sqlOperator} ${this.dialect.placeholder(paramIndex++)}`);
+					params.push(operand);
+					break;
+				}
+				default: throw new Error(`Unsupported filter operator "${operator}" for column "${key}" on the Postgres driver.`);
+			}
 			else {
 				conditions.push(`${quotedKey} = ${this.dialect.placeholder(paramIndex++)}`);
 				params.push(value);
@@ -17608,6 +17823,17 @@ var PostgresDriver = class {
 		};
 	}
 	/**
+	* A filter value is an operator object when it is a plain object whose keys
+	* ALL start with `$`. Arrays, Dates, and value objects (e.g. jsonb equality
+	* payloads) keep their existing bind-as-value behavior.
+	*/
+	isOperatorFilter(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+		if (value instanceof Date || Buffer.isBuffer(value)) return false;
+		const keys = Object.keys(value);
+		return keys.length > 0 && keys.every((key) => key.startsWith("$"));
+	}
+	/**
 	* Build an UPDATE query from update operations.
 	*
 	* @param table - Target table name
@@ -19447,10 +19673,13 @@ var Migration = class {
 		return this.driver.driver.name;
 	}
 	/**
-	* Execute all pending operations.
+	* Execute all pending operations directly through the migration driver.
+	*
+	* SQL-capable drivers go through toSQL() + raw query execution instead
+	* (phase-ordering, dry-run, export). This path is how the MigrationRunner
+	* executes migrations on drivers WITHOUT SQL serialization (MongoDB), where
+	* each pending operation maps to a native driver command.
 	*
-	* @deprecated Use toSQL() instead — migrations now generate SQL rather than
-	* executing DDL directly through the driver.
 	* @internal
 	*/
 	async execute() {
@@ -21681,6 +21910,19 @@ var MigrationRunner = class {
 			_warlock_js_logger.log.warn("database", "migration", "Nothing to migrate.");
 			return results;
 		}
+		if (this.getDataSource().driver.supportsSqlSerialization === false) {
+			const batch = await this.getNextBatchNumber();
+			for (const MigrationClass of pending) {
+				const result = await this.runMigration(MigrationClass, "up", {
+					dryRun,
+					record,
+					batch
+				});
+				results.push(result);
+				if (!result.success) break;
+			}
+			return results;
+		}
 		_warlock_js_logger.log.info("database", "migration", `Found ${pending.length} pending migration(s). Generating SQL pool...`);
 		const nextBatch = await this.getNextBatchNumber();
 		const taggedStatements = [];
@@ -21778,6 +22020,7 @@ var MigrationRunner = class {
 	* By default, it exports all registered migrations. Use `pendingOnly: true` to export only pending ones.
 	*/
 	async exportSQL(options = {}) {
+		if (this.getDataSource().driver.supportsSqlSerialization === false) throw new Error("SQL export is not supported on this data source — its driver has no SQL dialect. Migrations on this driver execute native commands through the migration driver instead.");
 		const migrationsToExport = options.pendingOnly ? await this.getPendingMigrations() : this.migrations;
 		if (migrationsToExport.length === 0) {
 			_warlock_js_logger.log.warn("database", "migration", "No migrations to export.");
@@ -21957,17 +22200,25 @@ var MigrationRunner = class {
 				const shouldUseTransaction = migration.transactional ?? this.getDataSource().migrations?.transactional ?? driver.getDefaultTransactional();
 				if (direction === "up") await migration.up();
 				else await migration.down();
-				const sqlStatements = migration.toSQL();
 				const databaseDriver = this.getDataSource().driver;
-				if (shouldUseTransaction && databaseDriver.transaction) await databaseDriver.transaction(async () => {
+				const directExecution = databaseDriver.supportsSqlSerialization === false;
+				const sqlStatements = directExecution ? [] : migration.toSQL();
+				const applyMigration = async () => {
+					if (directExecution) {
+						await migration.execute();
+						return;
+					}
 					for (const sql of sqlStatements) await databaseDriver.query(sql);
+				};
+				if (shouldUseTransaction && databaseDriver.transaction) await databaseDriver.transaction(async () => {
+					await applyMigration();
 					if (record) if (direction === "up") {
 						const batch = options.batch ?? await this.getNextBatchNumber();
 						await this.recordMigration(name, batch, MigrationClass.createdAt ? parseCreatedAt(MigrationClass.createdAt) : /* @__PURE__ */ new Date());
 					} else await this.removeMigrationRecord(name);
 				});
 				else {
-					for (const sql of sqlStatements) await databaseDriver.query(sql);
+					await applyMigration();
 					if (record) if (direction === "up") {
 						const batch = options.batch ?? await this.getNextBatchNumber();
 						await this.recordMigration(name, batch, MigrationClass.createdAt ? parseCreatedAt(MigrationClass.createdAt) : /* @__PURE__ */ new Date());