@warlock.js/cascade 4.6.0 → 4.6.1

package/CHANGELOG.md

@@ -4,6 +4,13 @@ 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.6.1
+
+### Fixed
+
+- Native Postgres array columns (`TEXT[]` / `JSONB[]`, from `arrayText()` / `arrayJson()`) are now auto-detected by introspecting the schema on connect and bound as raw arrays — no more "malformed array literal" on insert and no need to hand-list `nativeArrayColumns` (which stays as an optional per-connection override, now consulted per-table)
+- `transaction()` now flat-nests: a nested `transaction()` joins the active one (same session, sees its uncommitted writes) instead of opening a second, independent transaction — fixes phantom foreign-key violations when a service that opens its own transaction is called inside an outer one (e.g. a seeder creating a row, then a service inserting a child that references it). MongoDB joins too, replacing its "nested not supported" throw
+
 ## 4.6.0
 
 ### Added

package/cjs/index.cjs

@@ -13035,7 +13035,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 +13048,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) {
@@ -16925,13 +16926,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 +17007,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 +17044,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 +17072,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 +17201,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 +17228,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 +17238,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 +17305,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 +17327,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 +17453,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) {
@@ -17557,7 +17622,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)) {