@simtlix/simfinity-postgres 3.4.1 → 3.5.0

package/README.md

@@ -31,7 +31,7 @@ import { postgresPlugin } from '@simtlix/simfinity-postgres';
 const simfinity = createSQL({ plugin: postgresPlugin({ pool, schema: 'library' }) });
 ```
 
-Install `@simtlix/simfinity-sql@3.3.0` as a direct dependency when importing its factory. PostgreSQL 15 or later is the only supported SQL plugin. The [SQL package guide](https://github.com/simtlix/simfinity.js/tree/master/packages/sql) documents relational planning and the versioned plugin contract.
+Install `@simtlix/simfinity-sql@3.5.0` as a direct dependency when importing its factory. PostgreSQL 15 or later is the only supported SQL plugin. The [SQL package guide](https://github.com/simtlix/simfinity.js/tree/master/packages/sql) documents relational planning and the versioned plugin contract.
 
 Both factories permanently bind one pool and schema. The returned runtime supports registration, generated queries and mutations, middleware and scopes, controllers and validators, custom mutations, state machines, nested relationship writes, embedded reconstruction, and native PostgreSQL model handles. Native handles expose `findById`, `find`, `create`, `update`, and `delete`; they are not Mongoose models. `find(args, { session })` accepts the generated GraphQL list query arguments. Existing `pg.Pool` configuration and `pg.PoolClient` query interfaces remain compatible across both factories.
 
@@ -60,7 +60,7 @@ The module and every `createPostgres` instance expose the shared `auth`, `valida
 MCP integration is an independent opt-in and does not add MCP dependencies to PostgreSQL applications:
 
 ```sh
-npm install @simtlix/simfinity-mcp@3.3.0 @modelcontextprotocol/sdk@^1.13.0
+npm install @simtlix/simfinity-mcp@3.5.0 @modelcontextprotocol/sdk@^1.13.0
 ```
 
 ```javascript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simtlix/simfinity-postgres",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "description": "PostgreSQL GraphQL runtime and schema generation with foreign keys for Simfinity",
   "type": "module",
   "main": "./src/index.js",
@@ -27,11 +27,19 @@
     "directory": "packages/postgres"
   },
   "dependencies": {
-    "@simtlix/simfinity-core": "3.4.1",
-    "@simtlix/simfinity-sql": "3.4.1",
+    "@simtlix/simfinity-core": "3.5.0",
+    "@simtlix/simfinity-sql": "3.5.0",
     "pg": "^8.16.3"
   },
   "peerDependencies": {
     "graphql": "^16.11.0"
-  }
+  },
+  "keywords": [
+    "simfinity",
+    "graphql",
+    "postgresql",
+    "postgres",
+    "sql",
+    "nodejs"
+  ]
 }

package/src/plugin.js

@@ -31,7 +31,8 @@ export const postgresPlugin = (options) => ({
     begin: (client) => client.query('BEGIN ISOLATION LEVEL REPEATABLE READ'),
     commit: (client) => client.query('COMMIT'),
     rollback: (client) => client.query('ROLLBACK'),
-    release: (client) => client.release(),
+    // A release error makes pg-pool destroy a connection whose transaction may still be open.
+    release: (client, error) => client.release(error),
     isRetryable: (error) => ['40001', '40P01'].includes(error.code),
     normalizeError: normalizeDatabaseError,
   },

package/src/query/compiler.js

@@ -153,7 +153,11 @@ export const compileQuery = (models, database, plan, extra = null) => {
     }
     unsupported('Invalid query path');
   };
-  const predicate = (expression, operator, value) => {
+  /**
+   * WHERE rejects NULL and FALSE alike, so positive scalar filters use bare, index-friendly operators.
+   * Anything under a NOT (NE, NIN or a negated group) keeps the null-safe forms that never yield NULL.
+   */
+  const predicate = (expression, operator, value, negated = false) => {
     const { sql, field, type, list, vector } = expression;
     // Filters accept member names first; writes already receive internal enum values.
     const encodeFilter = (item) => {
@@ -164,8 +168,9 @@ export const compileQuery = (models, database, plan, extra = null) => {
       return encodeScalar(field, entry.value);
     };
     if (operator === 'LIKE' && field.scalar !== 'String') invalidValue('LIKE requires a string field');
-    const scalarBind = (item) => { const value = encodeFilter(item); return bind(expression.dateNumeric && value ? value.getTime() : value, type); };
-    const equality = (item) => {
+    const encodeValue = (item) => { const value = encodeFilter(item); return expression.dateNumeric && value ? value.getTime() : value; };
+    const scalarBind = (item) => bind(encodeValue(item), type);
+    const equality = (item, nullSafe = negated) => {
       if (Array.isArray(item)) {
         if (!field.list || vector) invalidValue('Array equality requires a scalar-list field');
         return `${sql} IS NOT DISTINCT FROM ${bind(item.map(encodeFilter), `${type}[]`)}`;
@@ -174,18 +179,26 @@ export const compileQuery = (models, database, plan, extra = null) => {
         const contains = `array_position(${sql}, ${scalarBind(item)}) IS NOT NULL`;
         return item == null ? `(${sql} IS NULL OR ${contains})` : contains;
       }
-      return item == null ? `${sql} IS NULL` : `${sql} IS NOT DISTINCT FROM ${scalarBind(item)}`;
+      if (item == null) return `${sql} IS NULL`;
+      return `${sql} ${nullSafe ? 'IS NOT DISTINCT FROM' : '='} ${scalarBind(item)}`;
     };
     if (operator === 'EQ') return equality(value);
     if (operator === 'NE') {
       if (!list && !Array.isArray(value)) return value == null ? `${sql} IS NOT NULL` : `${sql} IS DISTINCT FROM ${scalarBind(value)}`;
-      return `NOT (${equality(value)})`;
+      return `NOT (${equality(value, true)})`;
     }
     if (operator === 'IN' || operator === 'NIN') {
-      const expressionSQL = value.length ? `(${value.map(equality).join(' OR ')})` : 'FALSE';
-      return operator === 'IN' ? expressionSQL : value.length ? `NOT ${expressionSQL}` : 'TRUE';
+      if (!value.length) return operator === 'IN' ? 'FALSE' : 'TRUE';
+      let expressionSQL;
+      if (list) expressionSQL = `(${value.map((item) => equality(item)).join(' OR ')})`;
+      else {
+        // For scalar columns, one array parameter keeps large lists within the 65,535 bind limit.
+        const member = `${sql} = ANY (${bind(value.map(encodeValue), `${type}[]`)})`;
+        expressionSQL = negated || operator === 'NIN' ? `COALESCE(${member}, FALSE)` : member;
+      }
+      return operator === 'IN' ? expressionSQL : `NOT ${expressionSQL}`;
     }
-    if (operator === 'BTW') return `(${predicate(expression, 'GTE', value[0])} AND ${predicate(expression, 'LTE', value[1])})`;
+    if (operator === 'BTW') return `(${predicate(expression, 'GTE', value[0], negated)} AND ${predicate(expression, 'LTE', value[1], negated)})`;
     if (value == null || Array.isArray(value)) invalidValue(`${operator} requires a non-null scalar value`);
     const parameter = scalarBind(value);
     const compare = (left) => {
@@ -194,12 +207,14 @@ export const compileQuery = (models, database, plan, extra = null) => {
       }
       return `${left} ${{ LT: '<', LTE: '<=', GT: '>', GTE: '>=' }[operator]} ${parameter}`;
     };
-    return list ? `EXISTS (SELECT 1 FROM unnest(${sql}) v(value) WHERE ${compare('v.value')})` : `COALESCE(${compare(sql)}, FALSE)`;
+    if (list) return `EXISTS (SELECT 1 FROM unnest(${sql}) v(value) WHERE ${compare('v.value')})`;
+    return negated ? `COALESCE(${compare(sql)}, FALSE)` : compare(sql);
   };
-  const where = (node) => {
+  // A negation reaches every predicate below it, including those nested in AND/OR groups.
+  const where = (node, negated = false) => {
     if (!node) return 'TRUE';
-    if (node.kind === 'predicate') return `(${predicate(path(node.path), node.operator, node.value)})`;
-    return `(${node.terms.map(where).join(node.kind === 'and' ? ' AND ' : ' OR ')})`;
+    if (node.kind === 'predicate') return `(${predicate(path(node.path), node.operator, node.value, negated)})`;
+    return `(${node.terms.map((term) => where(term, negated)).join(node.kind === 'and' ? ' AND ' : ' OR ')})`;
   };
   let condition = where(plan.where);
   if (extra) {

package/src/schema/initialize.js

@@ -205,6 +205,7 @@ export const initializeDatabase = async (pool, description, { mode = 'create' }
   if (schema.startsWith('pg_') || schema === 'information_schema') throw new SimfinityError('System schemas cannot be managed', 'INVALID_DATABASE_SCHEMA', 400);
   const client = await pool.connect();
   const created = [];
+  let rollbackError;
   try {
     await client.query(mode === 'validate' ? 'BEGIN READ ONLY' : 'BEGIN');
     await client.query('SET LOCAL search_path = pg_catalog');
@@ -263,9 +264,10 @@ export const initializeDatabase = async (pool, description, { mode = 'create' }
     await client.query('COMMIT');
     return { mode, created };
   } catch (error) {
-    await client.query('ROLLBACK').catch(() => {});
+    try { await client.query('ROLLBACK'); } catch (failure) { rollbackError = failure; }
     throw error;
   } finally {
-    client.release();
+    // A failed ROLLBACK can leave the transaction open; the error makes pg-pool destroy the connection.
+    client.release(rollbackError);
   }
 };

package/types/index.d.ts

@@ -105,7 +105,8 @@ export interface DatabaseDescription {
 export interface DatabasePool {
   connect(): Promise<{
     query(sql: string, values?: unknown[]): Promise<{ rows: any[]; rowCount: number | null }>;
-    release(): void;
+    /** An error means the connection must be destroyed instead of reused. */
+    release(error?: unknown): void;
   }>;
 }
 export function describeDatabase(registrations: ModelRegistration[], options?: { schema?: string }): DatabaseDescription;