@warlock.js/cascade 4.6.0 → 4.7.0

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
 	*/
@@ -13035,7 +13132,10 @@ var MongoDbDriver = class {
 	* @throws {Error} If transaction fails, is explicitly rolled back, or replica set not configured
 	*/
 	async transaction(fn, options) {
-		if (databaseTransactionContext.hasActiveTransaction()) throw new Error("Nested transaction() calls are not supported. Use beginTransaction() with savepoints for advanced transaction patterns.");
+		const ctx = { rollback(reason) {
+			throw new TransactionRollbackError(reason);
+		} };
+		if (databaseTransactionContext.hasActiveTransaction()) return fn(ctx);
 		await this.ensureReplicaSetAvailable();
 		const session = this.getClientInstance().startSession();
 		try {
@@ -13045,9 +13145,7 @@ var MongoDbDriver = class {
 			});
 			databaseTransactionContext.enter({ session });
 			try {
-				const result = await fn({ rollback(reason) {
-					throw new TransactionRollbackError(reason);
-				} });
+				const result = await fn(ctx);
 				await session.commitTransaction();
 				return result;
 			} catch (error) {
@@ -13158,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.
 	*/
@@ -14518,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.
 	*/
@@ -14687,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;
@@ -14717,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(" ");
 	}
 	/**
@@ -15707,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. */
@@ -15751,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);
 	}
@@ -15875,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.
@@ -16458,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":
@@ -16513,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)}`;
@@ -16639,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";
@@ -16925,13 +17088,22 @@ var PostgresDriver = class {
 	*/
 	_syncAdapter;
 	/**
-	* Lookup set of column names that hold native PostgreSQL arrays
-	* (`JSONB[]`, `TEXT[]`, …) and must NOT be JSON-text encoded.
+	* Explicit, table-agnostic override list of column names that hold native
+	* PostgreSQL arrays (`JSONB[]`, `TEXT[]`, …) and must NOT be JSON-text
+	* encoded. Merged with (and superseded per-table by) the schema
+	* introspection below; kept as a manual escape hatch.
 	*
 	* @see PostgresPoolConfig.nativeArrayColumns
 	*/
 	_nativeArrayColumns;
 	/**
+	* Native-array columns discovered by introspecting the live schema on
+	* connect, keyed `table → { column, … }`. Authoritative and table-scoped, so
+	* a column that is `TEXT[]` in one table and `jsonb` in another is encoded
+	* correctly for each — no app configuration required.
+	*/
+	_introspectedArrayColumns = /* @__PURE__ */ new Map();
+	/**
 	* Create a new PostgreSQL driver instance.
 	*
 	* @param config - PostgreSQL connection configuration
@@ -16997,6 +17169,7 @@ var PostgresDriver = class {
 			(await this._pool.connect()).release();
 			_warlock_js_logger.log.success("database.postgres", "connection", `Connected to database ${_mongez_copper.colors.bold(_mongez_copper.colors.yellowBright(this.config.database))}`);
 			this._isConnected = true;
+			await this.loadNativeArrayColumns();
 			this.emit("connected");
 		} catch (error) {
 			_warlock_js_logger.log.fatal("database.postgres", "connection", "Failed to connect to database");
@@ -17033,13 +17206,15 @@ var PostgresDriver = class {
 	* that need special handling for PostgreSQL storage.
 	*
 	* @param data - The data object to serialize
+	* @param table - Optional table name; when given, columns introspected as
+	*   native arrays on that table are bound raw (see {@link serializeValue}).
 	* @returns Serialized data ready for PostgreSQL
 	*/
-	serialize(data) {
+	serialize(data, table) {
 		const serialized = {};
 		for (const [key, value] of Object.entries(data)) {
 			if (value === void 0) continue;
-			serialized[key] = this.serializeValue(key, value);
+			serialized[key] = this.serializeValue(key, value, table);
 		}
 		return serialized;
 	}
@@ -17059,36 +17234,87 @@ var PostgresDriver = class {
 	*   `JSON.stringify`. node-pg renders a raw JS array as a PostgreSQL array
 	*   literal `{...}` (and `[]` as `{}`), which a `json` / `jsonb` column
 	*   rejects — so we bind the value as JSON text instead, the form those
-	*   columns accept. Columns listed in `nativeArrayColumns` are exempt:
-	*   their raw array is passed through so node-pg emits the `{...}` literal
-	*   a genuine `JSONB[]` / `TEXT[]` column needs.
+	*   columns accept. Columns known to be native arrays — via schema
+	*   introspection or the `nativeArrayColumns` config — are exempt: their raw
+	*   array is passed through so node-pg emits the `{...}` literal a genuine
+	*   `JSONB[]` / `TEXT[]` column needs.
 	* - plain object → `JSON.stringify`. Equivalent to node-pg's own object
 	*   handling, made explicit so both write paths agree.
 	* - everything else (scalars: string, number, boolean, null) → untouched.
 	*
-	* Boundary note: the serializer has no access to the table schema, so it
-	* cannot tell a `json` / `jsonb` column from a native-array column purely
-	* from the value. `nativeArrayColumns` is the explicit, opt-in escape hatch
-	* for the latter. No `::jsonb` placeholder cast is added: a JSON-text string
-	* binds correctly to `json` / `jsonb` without one, and a blind cast would
-	* misfire on columns we cannot positively identify as jsonb.
+	* Distinguishing native-array from `json` / `jsonb` columns: a value alone
+	* can't tell them apart, so the driver introspects the live schema on connect
+	* (see {@link loadNativeArrayColumns}) and consults that per-table map here
+	* via {@link isNativeArrayColumn}. The explicit `nativeArrayColumns` config
+	* still works as a table-agnostic override. No `::jsonb` placeholder cast is
+	* added: a JSON-text string binds correctly to `json` / `jsonb` without one,
+	* and a blind cast would misfire on columns we cannot positively identify as
+	* jsonb.
 	*
-	* @param key - Column name (used to honour `nativeArrayColumns`)
+	* @param key - Column name (used to resolve native-array columns)
 	* @param value - The raw value to serialize (never `undefined`)
+	* @param table - Optional table name; enables the per-table native-array lookup
 	* @returns The value ready to bind as a query parameter
 	*/
-	serializeValue(key, value) {
+	serializeValue(key, value, table) {
 		if (value instanceof Date) return value.toISOString();
 		if (typeof value === "bigint") return value.toString();
 		if (Array.isArray(value)) {
 			if (value.length > 0 && value.every((v) => typeof v === "number")) return `[${value.join(",")}]`;
-			if (this._nativeArrayColumns.has(key)) return value;
+			if (this.isNativeArrayColumn(table, key)) return value;
 			return JSON.stringify(value);
 		}
 		if (typeof value === "object" && value !== null) return JSON.stringify(value);
 		return value;
 	}
 	/**
+	* Whether `column` on `table` is a native PostgreSQL array. True when the
+	* connect-time schema introspection saw it as `data_type = 'ARRAY'` for that
+	* table (authoritative, per-table), or when it's listed in the table-agnostic
+	* `nativeArrayColumns` config override.
+	*/
+	isNativeArrayColumn(table, column) {
+		if (table && this._introspectedArrayColumns.get(table)?.has(column)) return true;
+		return this._nativeArrayColumns.has(column);
+	}
+	/**
+	* Introspect the live schema for native-array columns so array values bind
+	* correctly with zero app configuration.
+	*
+	* A JS array must be bound two opposite ways depending on the column: as JSON
+	* text for a `json` / `jsonb` column, but as a raw array (which node-pg
+	* renders `{...}`) for a native `TEXT[]` / `JSONB[]` / `INTEGER[]` column. The
+	* serializer sees values, not types, so without this it JSON-stringifies
+	* every array — which a native-array column rejects with "malformed array
+	* literal". One `information_schema` query at connect, cached for the
+	* connection lifetime, removes the need to hand-list `nativeArrayColumns`.
+	*
+	* Best-effort: any failure (e.g. restricted catalog access) is logged and
+	* leaves the map empty so the config override still applies — it never blocks
+	* connect. A schema change made within a live connection isn't reflected
+	* until the next connect.
+	*/
+	async loadNativeArrayColumns() {
+		try {
+			const result = await this.query(`SELECT table_name, column_name
+         FROM information_schema.columns
+         WHERE table_schema = ANY (current_schemas(false))
+           AND data_type = 'ARRAY'`);
+			const map = /* @__PURE__ */ new Map();
+			for (const { table_name, column_name } of result.rows) {
+				let columns = map.get(table_name);
+				if (!columns) {
+					columns = /* @__PURE__ */ new Set();
+					map.set(table_name, columns);
+				}
+				columns.add(column_name);
+			}
+			this._introspectedArrayColumns = map;
+		} catch {
+			_warlock_js_logger.log.warn("database.postgres", "introspection", "Could not introspect native-array columns; using the nativeArrayColumns config only");
+		}
+	}
+	/**
 	* Get the dirty tracker for this driver.
 	*/
 	getDirtyTracker(data) {
@@ -17137,7 +17363,7 @@ var PostgresDriver = class {
 	* @returns The inserted document
 	*/
 	async insert(table, document, _options) {
-		const serialized = this.serialize(document);
+		const serialized = this.serialize(document, table);
 		const filteredData = Object.fromEntries(Object.entries(serialized).filter(([key, value]) => {
 			if (key === "id" && (value === null || value === void 0)) return false;
 			return true;
@@ -17164,7 +17390,7 @@ var PostgresDriver = class {
 		if (documents.length === 0) return [];
 		const allColumns = /* @__PURE__ */ new Set();
 		for (const doc of documents) {
-			const serialized = this.serialize(doc);
+			const serialized = this.serialize(doc, table);
 			Object.keys(serialized).forEach((key) => allColumns.add(key));
 		}
 		const columns = Array.from(allColumns);
@@ -17174,7 +17400,7 @@ var PostgresDriver = class {
 		const params = [];
 		let paramIndex = 1;
 		for (const doc of documents) {
-			const serialized = this.serialize(doc);
+			const serialized = this.serialize(doc, table);
 			const rowPlaceholders = [];
 			for (const col of columns) if (col in serialized) {
 				rowPlaceholders.push(this.dialect.placeholder(paramIndex++));
@@ -17241,7 +17467,7 @@ var PostgresDriver = class {
 	* @returns The replaced document or null
 	*/
 	async replace(table, filter, document, _options) {
-		const serialized = this.serialize(document);
+		const serialized = this.serialize(document, table);
 		const columns = Object.keys(serialized);
 		const values = Object.values(serialized);
 		const quotedTable = this.dialect.quoteIdentifier(table);
@@ -17263,7 +17489,7 @@ var PostgresDriver = class {
 	* @returns The upserted row
 	*/
 	async upsert(table, filter, document, options) {
-		const serialized = this.serialize(document);
+		const serialized = this.serialize(document, table);
 		const columns = Object.keys(serialized);
 		const values = Object.values(serialized);
 		if (columns.length === 0) throw new Error("Cannot upsert empty document");
@@ -17389,13 +17615,14 @@ var PostgresDriver = class {
 	* @throws {Error} If transaction fails or is explicitly rolled back
 	*/
 	async transaction(fn, options) {
-		if (databaseTransactionContext.hasActiveTransaction()) {}
+		const ctx = { rollback(reason) {
+			throw new TransactionRollbackError(reason);
+		} };
+		if (databaseTransactionContext.hasActiveTransaction()) return fn(ctx);
 		const tx = await this.beginTransaction(options);
 		databaseTransactionContext.enter({ session: tx.context });
 		try {
-			const result = await fn({ rollback(reason) {
-				throw new TransactionRollbackError(reason);
-			} });
+			const result = await fn(ctx);
 			await tx.commit();
 			return result;
 		} catch (error) {
@@ -17410,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
@@ -17418,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 };
 	}
 	/**
@@ -17521,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
@@ -17532,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);
@@ -17543,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
@@ -17557,7 +17848,7 @@ var PostgresDriver = class {
 		let paramIndex = 1;
 		if (update.$set) for (const [key, value] of Object.entries(update.$set)) {
 			setClauses.push(`${this.dialect.quoteIdentifier(key)} = ${this.dialect.placeholder(paramIndex++)}`);
-			params.push(value === void 0 ? value : this.serializeValue(key, value));
+			params.push(value === void 0 ? value : this.serializeValue(key, value, table));
 		}
 		if (update.$unset) for (const key of Object.keys(update.$unset)) setClauses.push(`${this.dialect.quoteIdentifier(key)} = NULL`);
 		if (update.$inc) for (const [key, amount] of Object.entries(update.$inc)) {
@@ -19382,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() {
@@ -21616,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 = [];
@@ -21713,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.");
@@ -21892,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());