@memberjunction/codegen-lib 5.30.1 → 5.31.0

package/dist/Database/providers/postgresql/PostgreSQLCodeGenProvider.js

@@ -9,10 +9,11 @@ import { EntityInfo } from '@memberjunction/core';
 import { RegisterClass } from '@memberjunction/global';
 import { CodeGenDatabaseProvider, CRUDType, } from '../../codeGenDatabaseProvider.js';
 import { configInfo } from '../../../Config/config.js';
-import { logError, logWarning } from '../../../Misc/status_logging.js';
+import { logError } from '../../../Misc/status_logging.js';
 import { PostgreSQLDialect } from '@memberjunction/sql-dialect';
 import * as fs from 'fs';
 import path from 'path';
+import { executeWithFallback } from './viewFallback.js';
 const pgDialect = new PostgreSQLDialect();
 /**
  * PostgreSQL implementation of the CodeGen database provider.
@@ -57,6 +58,24 @@ let PostgreSQLCodeGenProvider = class PostgreSQLCodeGenProvider extends CodeGenD
      * Generates a PostgreSQL `CREATE OR REPLACE VIEW` statement for an entity's base view.
      * Includes all base table columns, parent/related field joins, and root field lateral
      * joins. Applies a soft-delete `WHERE` filter when the entity uses soft deletes.
+     *
+     * **Non-destructive strategy.** Historically this method emitted
+     * `DROP VIEW IF EXISTS ... CASCADE;` before the CREATE, which let it handle every
+     * column-signature change — but also silently destroyed any dependent view, function,
+     * trigger, or GRANT on the view. When a later statement (or subsequent entity in the
+     * same run) failed, half the database's objects could be gone with no error surfaced.
+     *
+     * We now emit just `CREATE OR REPLACE VIEW`, which PostgreSQL accepts when the new
+     * column list is a prefix of the existing one plus optional trailing additions. Any
+     * incompatible change (rename, reorder, type change, removed column) fails with
+     * SQLSTATE `42P16 invalid_table_definition`. That error is intentionally allowed to
+     * propagate up through `executeSQLFileViaShell` → the per-entity batch loop → and is
+     * surfaced as a real regeneration failure. A follow-up pass will add a capture-drop-
+     * restore fallback for 42P16 that preserves dependents via `pg_depend` and
+     * `pg_get_viewdef` / `pg_get_functiondef`. Until that lands, 42P16 on PG is loud and
+     * actionable instead of silent and destructive.
+     *
+     * Permissions are handled separately by sql_codegen.ts via generateViewPermissions().
      */
     generateBaseView(context) {
         const { entity } = context;
@@ -65,7 +84,7 @@ let PostgreSQLCodeGenProvider = class PostgreSQLCodeGenProvider extends CodeGenD
         const whereClause = this.buildSoftDeleteWhereClause(entity, alias);
         const selectParts = this.buildBaseViewSelectParts(context, alias);
         const fromParts = this.buildBaseViewFromParts(context, entity, alias);
-        // Permissions are handled separately by sql_codegen.ts via generateViewPermissions()
+        const quotedView = pgDialect.QuoteSchema(entity.SchemaName, viewName);
         return `
 ------------------------------------------------------------
 ----- BASE VIEW FOR ENTITY:      ${entity.Name}
@@ -73,7 +92,7 @@ let PostgreSQLCodeGenProvider = class PostgreSQLCodeGenProvider extends CodeGenD
 -----               BASE TABLE:  ${entity.BaseTable}
 -----               PRIMARY KEY: ${entity.PrimaryKeys.map((pk) => pk.Name).join(', ')}
 ------------------------------------------------------------
-CREATE OR REPLACE VIEW ${pgDialect.QuoteSchema(entity.SchemaName, viewName)}
+CREATE OR REPLACE VIEW ${quotedView}
 AS
 SELECT
     ${selectParts}
@@ -83,6 +102,31 @@ ${whereClause};
 `;
     }
     // ─── CRUD CREATE ─────────────────────────────────────────────────────
+    /**
+     * Emits a `DO` block that drops every existing overload of `<schema>.<fnName>`.
+     * Run before each `CREATE OR REPLACE FUNCTION` to prevent PG's "function name is
+     * not unique" error when the parameter list grows (e.g. a new column adds a new
+     * `DEFAULT NULL` parameter — old + new overloads become call-ambiguous and PG
+     * refuses both `CREATE OR REPLACE` and any caller dispatch). Iterating overloads
+     * via `pg_proc` is the only way to drop without knowing the exact prior signature.
+     */
+    generateDropAllOverloadsBlock(schemaName, fnName) {
+        // Single quotes inside the DO block need to escape the surrounding quoting.
+        // We use dollar-quoted strings to keep the body readable.
+        return `DO $do$
+DECLARE r RECORD;
+BEGIN
+    FOR r IN SELECT oid::regprocedure AS sig
+             FROM pg_proc
+             WHERE proname = '${fnName}'
+               AND pronamespace = '${schemaName}'::regnamespace
+    LOOP
+        EXECUTE 'DROP FUNCTION ' || r.sig::text;
+    END LOOP;
+END
+$do$;
+`;
+    }
     /**
      * Generates a PostgreSQL `CREATE OR REPLACE FUNCTION` for inserting a new record.
      * The function accepts typed parameters for each writable field, performs an `INSERT`
@@ -90,25 +134,36 @@ ${whereClause};
      * `RETURN QUERY SELECT`. Handles auto-increment PKs (using `RETURNING ... INTO`),
      * UUID PKs (with `COALESCE` to gen_random_uuid()), and composite PKs. Also emits
      * `GRANT EXECUTE` permissions for authorized roles.
+     *
+     * Prepends a DROP-all-overloads block (see `generateDropAllOverloadsBlock`) so
+     * adding/removing a column doesn't trigger PG's overload-ambiguity error.
      */
     generateCRUDCreate(entity) {
         const fnName = this.getCRUDRoutineName(entity, CRUDType.Create);
         const viewName = this.getBaseViewName(entity);
         const paramString = this.generateCRUDParamString(entity.Fields, false);
         const permissions = this.generateCRUDPermissions(entity, fnName, CRUDType.Create);
-        const insertColumns = this.generateInsertFieldString(entity, entity.Fields, '', false);
-        const insertValues = this.generateInsertFieldString(entity, entity.Fields, 'p_', false);
         const firstKey = entity.FirstPrimaryKey;
+        // For UUID PKs and AutoIncrement PKs, the strategy below adds the PK
+        // column manually (with v_new_id or RETURNING). Excluding it from the
+        // auto-generated insertColumns/insertValues avoids the column appearing
+        // twice in the INSERT statement.
+        const pkType = firstKey.Type.toLowerCase().trim();
+        const pkHandledByStrategy = firstKey.AutoIncrement ||
+            ((pkType === 'uniqueidentifier' || pkType === 'uuid') && entity.PrimaryKeys.length === 1);
+        const insertColumns = this.generateInsertFieldString(entity, entity.Fields, '', pkHandledByStrategy);
+        const insertValues = this.generateInsertFieldString(entity, entity.Fields, 'p_', pkHandledByStrategy);
         const strategy = this.buildCreateInsertStrategy(entity, firstKey, insertColumns, insertValues);
         return `
 ------------------------------------------------------------
 ----- CREATE FUNCTION FOR ${entity.BaseTable}
 ------------------------------------------------------------
+${this.generateDropAllOverloadsBlock(entity.SchemaName, fnName)}
 CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(
     ${paramString}
 ) RETURNS SETOF ${pgDialect.QuoteSchema(entity.SchemaName, viewName)} AS $$
 DECLARE
-    v_new_id ${firstKey.SQLFullType};
+    v_new_id ${this.mapSQLType(firstKey.SQLFullType)};
 BEGIN
     ${strategy.preInsert}INSERT INTO ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)}
         (
@@ -149,6 +204,7 @@ ${permissions}
 ------------------------------------------------------------
 ----- UPDATE FUNCTION FOR ${entity.BaseTable}
 ------------------------------------------------------------
+${this.generateDropAllOverloadsBlock(entity.SchemaName, fnName)}
 CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(
     ${paramString}
 ) RETURNS SETOF ${pgDialect.QuoteSchema(entity.SchemaName, viewName)} AS $$
@@ -192,16 +248,18 @@ ${trigger}
         const fnName = this.getCRUDRoutineName(entity, CRUDType.Delete);
         const permissions = this.generateCRUDPermissions(entity, fnName, CRUDType.Delete);
         const { paramDecl, deleteBody, returnType, returnStatement } = this.buildDeleteStrategy(entity, cascadeSQL);
+        const needsRecordVar = cascadeSQL.includes('v_rec');
         return `
 ------------------------------------------------------------
 ----- DELETE FUNCTION FOR ${entity.BaseTable}
 ------------------------------------------------------------
+${this.generateDropAllOverloadsBlock(entity.SchemaName, fnName)}
 CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(
     ${paramDecl}
 ) RETURNS ${returnType} AS $$
 #variable_conflict use_column
 DECLARE
-    v_affected_count INTEGER;
+    v_affected_count INTEGER;${needsRecordVar ? '\n    v_rec RECORD;' : ''}
 BEGIN
 ${cascadeSQL}
 ${deleteBody}
@@ -235,7 +293,7 @@ ${permissions}
 CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, trigFnName)}()
 RETURNS TRIGGER AS $$
 BEGIN
-    NEW.${EntityInfo.UpdatedAtFieldName} := NOW() AT TIME ZONE 'UTC';
+    NEW."${EntityInfo.UpdatedAtFieldName}" := NOW() AT TIME ZONE 'UTC';
     RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;
@@ -495,67 +553,64 @@ END $$;
      * to allow optional arguments, and PostgreSQL's requirement that all subsequent
      * parameters also have defaults once the first default appears is respected.
      */
+    /**
+     * PostgreSQL parameter types are mapped from the entity field's
+     * T-SQL `SQLFullType` (the metadata is canonically T-SQL) into the
+     * equivalent PostgreSQL type. SQL Server's base-class default would
+     * pass the type through unchanged, which would emit invalid PG
+     * function signatures.
+     */
+    renderParameterType(ef) {
+        return this.mapSQLType(ef.SQLFullType);
+    }
+    /**
+     * PostgreSQL override: same tolerant-SP shape as the base class, but
+     * with PG's "all params after the first DEFAULT must also have DEFAULTs"
+     * rule enforced. Once any parameter becomes optional (or a `_Clear`
+     * companion is emitted), every subsequent parameter is forced to
+     * `DEFAULT NULL` even if it would otherwise be required, because PG
+     * function signatures don't allow gaps between defaulted params.
+     *
+     * All decision logic and dialect-syntax bits route through the same
+     * base-class helpers / dialect methods used by SQL Server — the only
+     * thing that differs is the sticky-defaults walk.
+     */
     generateCRUDParamString(entityFields, isUpdate) {
+        const dialect = this.Dialect;
+        const nullDefault = dialect.ParameterDefault(dialect.NullLiteral);
         const parts = [];
         let foundDefault = false;
         for (const ef of entityFields) {
             if (!this.shouldIncludeFieldInParams(ef, isUpdate))
                 continue;
-            const paramName = `p_${this.toSnakeCase(ef.CodeName)}`;
-            const sqlType = this.mapSQLType(ef.SQLFullType);
-            let defaultVal = '';
-            if (!isUpdate && ef.IsPrimaryKey && !ef.AutoIncrement) {
-                defaultVal = ' DEFAULT NULL';
+            // _Clear companion is emitted immediately before its main parameter
+            // for nullable columns whose database default is non-NULL.
+            if (!ef.IsPrimaryKey && this.needsClearCompanion(ef)) {
+                parts.push(`${dialect.ParameterRef(ef.CodeName + '_Clear')} bit${dialect.ParameterDefault('0')}`);
                 foundDefault = true;
             }
-            else if (!isUpdate && ef.HasDefaultValue && !ef.AllowsNull) {
-                defaultVal = ' DEFAULT NULL';
+            const isOptional = !this.isParamRequired(ef, isUpdate);
+            // Sticky-defaults: once any param has a default, all subsequent params
+            // must also be defaulted in PG. We default them to NULL.
+            const needsStickyDefault = foundDefault && !isOptional;
+            const defaultClause = isOptional || needsStickyDefault ? nullDefault : '';
+            if (defaultClause)
                 foundDefault = true;
-            }
-            else if (!isUpdate && foundDefault) {
-                // PG requires all params after the first DEFAULT to also have DEFAULTs
-                defaultVal = ' DEFAULT NULL';
-            }
-            parts.push(`${paramName} ${sqlType}${defaultVal}`);
+            parts.push(`${dialect.ParameterRef(ef.CodeName)} ${this.renderParameterType(ef)}${defaultClause}`);
         }
         return parts.join(',\n    ');
     }
     /**
-     * Builds either the column name list or the value expression list for an INSERT
-     * statement, depending on whether {@link prefix} is empty (column names) or set
-     * (parameter values with `p_` prefix). Handles special date fields
-     * (`__mj_CreatedAt`, `__mj_UpdatedAt`) by substituting `NOW() AT TIME ZONE 'UTC'`
-     * and applies default-value COALESCE wrappers for fields with non-null defaults.
+     * PostgreSQL override of the INSERT default-value renderer to handle
+     * the BIT→BOOLEAN type-strictness gap. The base implementation passes
+     * the SQL Server-style default through unchanged, but PG's strict
+     * typing means `COALESCE(boolean_param, 0)` fails with "operator does
+     * not exist: boolean = integer". This override remaps `BIT` defaults
+     * (`0`/`1`) to `BOOLEAN` literals (`FALSE`/`TRUE`) when the field's
+     * underlying type is bit/boolean.
      */
-    generateInsertFieldString(entity, entityFields, prefix, excludePrimaryKey = false) {
-        const autoGeneratedPrimaryKey = entity.FirstPrimaryKey.AutoIncrement;
-        const parts = [];
-        for (const ef of entityFields) {
-            if (this.shouldSkipFieldForInsert(ef, autoGeneratedPrimaryKey, excludePrimaryKey))
-                continue;
-            if (prefix !== '' && ef.IsSpecialDateField) {
-                parts.push(this.getSpecialDateInsertValue(ef));
-            }
-            else if (prefix === '') {
-                // Column name side
-                parts.push(pgDialect.QuoteIdentifier(ef.Name));
-            }
-            else {
-                // Parameter value side
-                parts.push(this.getParameterInsertValue(ef, prefix));
-            }
-        }
-        return parts.join(',\n            ');
-    }
-    /** @inheritdoc */
-    generateUpdateFieldString(entityFields) {
-        const parts = [];
-        for (const ef of entityFields) {
-            if (ef.IsPrimaryKey || ef.IsVirtual || !ef.AllowUpdateAPI || ef.AutoIncrement || ef.IsSpecialDateField)
-                continue;
-            parts.push(`${pgDialect.QuoteIdentifier(ef.Name)} = p_${this.toSnakeCase(ef.CodeName)}`);
-        }
-        return parts.join(',\n        ');
+    formatInsertDefaultValue(ef) {
+        return this.formatBooleanCompatibleDefault(ef);
     }
     // ─── ROUTINE NAMING ──────────────────────────────────────────────────
     /** @inheritdoc */
@@ -844,8 +899,9 @@ ORDER BY ordinal_position`;
         'OBJECT_ID', 'SCOPE_IDENTITY',
         // Aggregate / scalar functions
         'COUNT', 'MAX', 'MIN', 'SUM', 'AVG', 'COALESCE', 'CAST', 'CONVERT', 'ISNULL',
-        'LEN', 'DATALENGTH', 'LOWER', 'UPPER', 'LTRIM', 'RTRIM', 'TRIM', 'REPLACE',
+        'LEN', 'LENGTH', 'DATALENGTH', 'LOWER', 'UPPER', 'LTRIM', 'RTRIM', 'TRIM', 'REPLACE',
         'SUBSTRING', 'CHARINDEX', 'PATINDEX', 'STUFF', 'CONCAT', 'FORMAT',
+        'LEFT', 'RIGHT', 'POSITION', 'OVERLAY', 'EXTRACT', 'GREATEST', 'LEAST',
         'DATEADD', 'DATEDIFF', 'DATEPART', 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE',
         'SECOND', 'NOW', 'CURRENT_TIMESTAMP',
         // PostgreSQL specific
@@ -985,16 +1041,22 @@ ORDER BY ordinal_position`;
         });
         try {
             await client.connect();
-            // Postgres can execute multi-statement scripts in a single query call.
-            // On error, the full batch rolls back to last savepoint; we log and continue.
+            // Postgres executes a multi-statement script in a single query call. A single
+            // statement error aborts the rest of the batch server-side (simple query
+            // protocol) — so silently converting that to `return true` hid real data loss:
+            // CodeGen-generated DROP VIEW CASCADE would succeed, the follow-up CREATE
+            // would fail, and the caller would believe everything was fine. Return false
+            // on error and log it as an error, not a warning, so the per-entity batching
+            // loops can aggregate and (in strict mode) halt the install.
             try {
                 await client.query(sql);
+                return true;
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
-                logWarning(`[CodeGen] SQL warning in ${path.basename(absoluteFilePath)}: ${msg.substring(0, 200)}`);
+                logError(`[CodeGen] SQL execution failed in ${path.basename(absoluteFilePath)}: ${msg.substring(0, 400)}`);
+                return false;
             }
-            return true;
         }
         catch (e) {
             logError(`[CodeGen] Failed to execute SQL file ${absoluteFilePath}: ${e instanceof Error ? e.message : e}`);
@@ -1007,6 +1069,175 @@ ORDER BY ordinal_position`;
             catch { /* best-effort cleanup */ }
         }
     }
+    /** @inheritdoc */
+    getRoutineNamesBySchemaSQL(schemas) {
+        if (schemas.length === 0)
+            return '';
+        // pg_proc holds every function (PL/pgSQL, SQL, C, etc.). prokind filters:
+        //   'f' = normal function, 'p' = procedure, 'a' = aggregate, 'w' = window.
+        // CodeGen emits 'f' (CRUD functions, root-ID TVFs, FTS functions) and 'p'
+        // is unused on PG today but cheap to include in case we add procedures later.
+        const inList = schemas.map(s => `'${s.replace(/'/g, "''")}'`).join(', ');
+        return `SELECT n.nspname AS schema_name, p.proname AS routine_name
+FROM pg_proc p
+JOIN pg_namespace n ON n.oid = p.pronamespace
+WHERE p.prokind IN ('f', 'p')
+  AND n.nspname IN (${inList});`;
+    }
+    /**
+     * PG-specific base-view regeneration with 42P16 recovery.
+     *
+     * Runs the provided `CREATE OR REPLACE VIEW` SQL through `executeWithFallback`
+     * on a dedicated connection: happy path issues the CREATE OR REPLACE directly,
+     * and only on SQLSTATE 42P16 does the capture/drop/recreate/restore dance fire
+     * inside a transaction that preserves every dependent view, function, grant,
+     * comment, and owner. See `viewFallback.ts` for the contract.
+     *
+     * `willRegenerate` is passed through so dependents CodeGen is about to rebuild
+     * in the same run are skipped at restore time (avoids restoring a stale
+     * captured definition against a newly-regenerated target).
+     */
+    async regenerateBaseView(entity, viewSQL, willRegenerate) {
+        const pgHost = process.env.PG_HOST ?? configInfo.dbHost;
+        const pgPort = Number(process.env.PG_PORT ?? configInfo.dbPort ?? 5432);
+        const pgDatabase = process.env.PG_DATABASE ?? configInfo.dbDatabase;
+        const pgUser = process.env.PG_USERNAME ?? configInfo.codeGenLogin;
+        const pgPassword = process.env.PG_PASSWORD ?? configInfo.codeGenPassword;
+        if (!pgUser || !pgPassword || !pgDatabase) {
+            throw new Error('PostgreSQL user, password, and database must be provided in the configuration or environment variables');
+        }
+        const pgModule = await import('pg');
+        const client = new pgModule.default.Client({
+            host: pgHost,
+            port: pgPort,
+            user: pgUser,
+            password: pgPassword,
+            database: pgDatabase,
+        });
+        await client.connect();
+        try {
+            await executeWithFallback({
+                client,
+                schema: entity.SchemaName,
+                viewName: entity.BaseView,
+                createOrReplaceSQL: viewSQL,
+                willRegenerate,
+            });
+        }
+        finally {
+            try {
+                await client.end();
+            }
+            catch { /* best-effort cleanup */ }
+        }
+    }
+    /**
+     * Phased per-entity execution for PG. Runs view → CRUD functions → view
+     * permissions against the target DB, guaranteeing phase 2 is skipped if
+     * phase 1 failed (so we never leave `fn_create_*` functions pointing at
+     * a missing or stale view's rowtype).
+     *
+     * Phase 1 routes through `executeWithFallback` so a 42P16 triggers the
+     * capture/drop/recreate/restore flow rather than blowing up. Phase 2 runs
+     * each CRUD function's CREATE individually — we do NOT concatenate them
+     * because node-pg's simple query protocol would then abort the whole
+     * batch on the first failure; running them separately gives a per-routine
+     * error signal. Phase 3 applies view-level GRANTs.
+     */
+    async executeEntityPhased(opts) {
+        const pgHost = process.env.PG_HOST ?? configInfo.dbHost;
+        const pgPort = Number(process.env.PG_PORT ?? configInfo.dbPort ?? 5432);
+        const pgDatabase = process.env.PG_DATABASE ?? configInfo.dbDatabase;
+        const pgUser = process.env.PG_USERNAME ?? configInfo.codeGenLogin;
+        const pgPassword = process.env.PG_PASSWORD ?? configInfo.codeGenPassword;
+        if (!pgUser || !pgPassword || !pgDatabase) {
+            throw new Error('PostgreSQL user, password, and database must be provided in the configuration or environment variables');
+        }
+        const pgModule = await import('pg');
+        const client = new pgModule.default.Client({
+            host: pgHost,
+            port: pgPort,
+            user: pgUser,
+            password: pgPassword,
+            database: pgDatabase,
+        });
+        await client.connect();
+        try {
+            // ── Phase 0: root-ID TVFs ────────────────────────────────────
+            // The base view references these helper functions; PG rejects
+            // CREATE VIEW with `function does not exist` if they aren't
+            // installed first. Run as a single batch — these are independent
+            // CREATE OR REPLACE FUNCTION statements separated by GO.
+            if (opts.tvfSQL && opts.tvfSQL.trim()) {
+                try {
+                    await client.query(opts.tvfSQL);
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        phase: 'tvf',
+                        error: e instanceof Error ? e : new Error(String(e)),
+                    };
+                }
+            }
+            // ── Phase 1: base view (fallback-aware for 42P16) ────────────
+            if (opts.viewSQL && opts.viewSQL.trim()) {
+                try {
+                    await executeWithFallback({
+                        client,
+                        schema: opts.entity.SchemaName,
+                        viewName: opts.entity.BaseView,
+                        createOrReplaceSQL: opts.viewSQL,
+                        willRegenerate: opts.willRegenerate,
+                    });
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        phase: 'view',
+                        error: e instanceof Error ? e : new Error(String(e)),
+                    };
+                }
+            }
+            // ── Phase 2: CRUD functions (skipped if phase 1 failed) ──────
+            // Run each CREATE FUNCTION separately so per-function errors
+            // don't abort the others via simple-query-protocol semantics.
+            for (const crudSQL of [opts.crudCreateSQL, opts.crudUpdateSQL, opts.crudDeleteSQL]) {
+                if (!crudSQL || !crudSQL.trim())
+                    continue;
+                try {
+                    await client.query(crudSQL);
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        phase: 'functions',
+                        error: e instanceof Error ? e : new Error(String(e)),
+                    };
+                }
+            }
+            // ── Phase 3: view permissions ────────────────────────────────
+            if (opts.viewPermSQL && opts.viewPermSQL.trim()) {
+                try {
+                    await client.query(opts.viewPermSQL);
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        phase: 'permissions',
+                        error: e instanceof Error ? e : new Error(String(e)),
+                    };
+                }
+            }
+            return { success: true, phase: null };
+        }
+        finally {
+            try {
+                await client.end();
+            }
+            catch { /* best-effort cleanup */ }
+        }
+    }
     // ═══════════════════════════════════════════════════════════════════════
     // PRIVATE HELPERS
     // ═══════════════════════════════════════════════════════════════════════
@@ -1087,39 +1318,23 @@ ORDER BY ordinal_position`;
             joins.push(context.rootJoins);
         return joins.length > 0 ? '\n' + joins.join('\n') : '';
     }
-    /** Determines whether a field should be included in CRUD parameters */
-    shouldIncludeFieldInParams(ef, isUpdate) {
-        const autoGeneratedPrimaryKey = ef.AutoIncrement;
-        return ((ef.AllowUpdateAPI || (ef.IsPrimaryKey && isUpdate) || (ef.IsPrimaryKey && !autoGeneratedPrimaryKey && !isUpdate)) &&
-            !ef.IsVirtual &&
-            (!ef.IsPrimaryKey || !autoGeneratedPrimaryKey || isUpdate) &&
-            !ef.IsSpecialDateField);
-    }
-    /** Determines whether a field should be skipped for INSERT */
-    shouldSkipFieldForInsert(ef, autoGeneratedPrimaryKey, excludePrimaryKey) {
-        return ((excludePrimaryKey && ef.IsPrimaryKey) ||
-            (ef.IsPrimaryKey && autoGeneratedPrimaryKey) ||
-            ef.IsVirtual ||
-            !ef.AllowUpdateAPI ||
-            ef.AutoIncrement);
-    }
-    /** Gets the INSERT value for a special date field */
-    getSpecialDateInsertValue(ef) {
-        if (ef.IsCreatedAtField || ef.IsUpdatedAtField)
-            return "NOW() AT TIME ZONE 'UTC'";
-        return 'NULL'; // DeletedAt
-    }
-    /** Gets the parameter insert value, handling defaults */
-    getParameterInsertValue(ef, prefix) {
-        const paramName = `${prefix}${this.toSnakeCase(ef.CodeName)}`;
-        if (ef.HasDefaultValue && !ef.AllowsNull) {
-            const formattedDefault = this.formatDefaultValue(ef.DefaultValue, ef.NeedsQuotes);
-            if (ef.IsUniqueIdentifier) {
-                return `CASE WHEN ${paramName} = '00000000-0000-0000-0000-000000000000'::UUID THEN ${formattedDefault} ELSE COALESCE(${paramName}, ${formattedDefault}) END`;
-            }
-            return `COALESCE(${paramName}, ${formattedDefault})`;
+    /**
+     * Like formatDefaultValue, but maps SQL Server BIT defaults (0/1) to PG
+     * BOOLEAN literals (FALSE/TRUE) when the field type is bit/boolean.
+     * COALESCE() in PG is type-strict — passing `COALESCE(boolean_param, 0)`
+     * fails with "types boolean and integer cannot be matched".
+     */
+    formatBooleanCompatibleDefault(ef) {
+        const formatted = this.formatDefaultValue(ef.DefaultValue, ef.NeedsQuotes);
+        const fieldType = ef.Type.toLowerCase().trim();
+        if (fieldType === 'bit' || fieldType === 'boolean' || fieldType === 'bool') {
+            const t = formatted.trim().toLowerCase();
+            if (t === '0' || t === "'0'")
+                return 'FALSE';
+            if (t === '1' || t === "'1'")
+                return 'TRUE';
         }
-        return paramName;
+        return formatted;
     }
     /** Builds a WHERE clause using primary key fields with a parameter prefix */
     buildPrimaryKeyWhereClause(entity, prefix) {
@@ -1151,12 +1366,27 @@ ORDER BY ordinal_position`;
         }
         // Composite keys or non-auto, non-UUID PKs
         const selectWhere = entity.PrimaryKeys.map((k) => `${pgDialect.QuoteIdentifier(k.Name)} = p_${this.toSnakeCase(k.CodeName)}`).join(' AND ');
+        // Composite-PK tables: every PK column has AllowUpdateAPI=0, so generateInsertFieldString
+        // filters them all out. Prepend them to finalColumns/finalValues so the INSERT is valid.
+        // (The single-PK uniqueidentifier case is already handled above via v_new_id.)
+        let finalColumns = insertColumns;
+        let finalValues = insertValues;
+        if (entity.PrimaryKeys.length > 1) {
+            const pkColumns = entity.PrimaryKeys
+                .map((k) => pgDialect.QuoteIdentifier(k.Name))
+                .join(',\n            ');
+            const pkValues = entity.PrimaryKeys
+                .map((k) => `p_${this.toSnakeCase(k.CodeName)}`)
+                .join(',\n            ');
+            finalColumns = `${pkColumns},\n            ${insertColumns}`;
+            finalValues = `${pkValues},\n            ${insertValues}`;
+        }
         return {
             preInsert: '',
             returningClause: '',
             selectClause: `SELECT * FROM ${pgDialect.QuoteSchema(entity.SchemaName, viewName)}\n    WHERE ${selectWhere}`,
-            finalColumns: insertColumns,
-            finalValues: insertValues,
+            finalColumns,
+            finalValues,
         };
     }
     /** Builds the DELETE body and return type based on entity delete type */