@memberjunction/codegen-lib 5.31.0 → 5.33.0

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

@@ -6,11 +6,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var PostgreSQLCodeGenProvider_1;
 import { EntityInfo } from '@memberjunction/core';
-import { RegisterClass } from '@memberjunction/global';
+import { RegisterClass, UUIDsEqual } from '@memberjunction/global';
 import { CodeGenDatabaseProvider, CRUDType, } from '../../codeGenDatabaseProvider.js';
 import { configInfo } from '../../../Config/config.js';
 import { logError } from '../../../Misc/status_logging.js';
 import { PostgreSQLDialect } from '@memberjunction/sql-dialect';
+import { shouldIncludeFieldInParams, useJsonArgShape, } from '@memberjunction/generic-database-provider';
+import { POSTGRESQL_PROCEDURE_PARAM_LIMIT } from '@memberjunction/postgresql-dataprovider';
 import * as fs from 'fs';
 import path from 'path';
 import { executeWithFallback } from './viewFallback.js';
@@ -19,6 +21,10 @@ const pgDialect = new PostgreSQLDialect();
  * PostgreSQL implementation of the CodeGen database provider.
  * Generates PostgreSQL-native DDL for views, CRUD functions, triggers, indexes,
  * full-text search, permissions, and other database objects.
+ *
+ * Registered with `MJGlobal.ClassFactory` against the canonical `'postgresql'`
+ * platform key — `SQLCodeGenBase` resolves this provider via
+ * `ClassFactory.CreateInstance(CodeGenDatabaseProvider, configInfo.dbPlatform)`.
  */
 let PostgreSQLCodeGenProvider = class PostgreSQLCodeGenProvider extends CodeGenDatabaseProvider {
     static { PostgreSQLCodeGenProvider_1 = this; }
@@ -55,25 +61,43 @@ let PostgreSQLCodeGenProvider = class PostgreSQLCodeGenProvider extends CodeGenD
     }
     // ─── BASE VIEWS ──────────────────────────────────────────────────────
     /**
-     * Generates a PostgreSQL `CREATE OR REPLACE VIEW` statement for an entity's base view.
+     * Generates a PostgreSQL view-regeneration block 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.
+     * **Two-path emission (try-then-fallback).** The output wraps `CREATE OR REPLACE VIEW`
+     * in a `DO $$ ... EXCEPTION WHEN invalid_table_definition THEN DROP VIEW ... CASCADE;
+     * EXECUTE vsql; END $$` block. Why:
+     *
+     *   - Happy path: `CREATE OR REPLACE VIEW` succeeds (new column list is a prefix of
+     *     the existing one plus optional trailing additions). Zero destruction. No
+     *     dependent views, functions, triggers, or grants are touched.
+     *
+     *   - Sad path: PG raises SQLSTATE `42P16 invalid_table_definition` for any column
+     *     rename / reorder / type change / removal. The exception handler runs
+     *     `DROP VIEW ... CASCADE` and re-executes the CREATE. Dependent codegen-managed
+     *     functions (spCreate/spUpdate/spDelete returning `SETOF vwFoo`) and dependent
+     *     views are CASCADE-dropped — they are regenerated later in the same codegen
+     *     output stream, so by the end of the run all dependents are restored to the new
+     *     shape. GRANTs on the view itself are also lost on the CASCADE; codegen always
+     *     re-emits permissions immediately after the view, so they come back too.
+     *
+     * The runtime-apply path also calls this, so the live DB applies the same DO block.
+     * `executeWithFallback` (the runtime helper) becomes a no-op for these statements
+     * because the DO block handles 42P16 internally — but it still runs as a safety net
+     * for any other failure modes.
      *
-     * 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.
+     * **What this DOES NOT preserve on the sad path:** non-codegen-managed dependent
+     * objects (e.g. a hand-written sproc against this view that codegen doesn't know
+     * about). Those would be CASCADE-dropped and not restored. MJ codegen-generated
+     * sprocs cover all standard CRUD pathways; bespoke sprocs against base views are
+     * extremely rare in practice. If a project does have them, they need to be re-applied
+     * after a 42P16 fallback fires.
+     *
+     * This pattern matches the v5.30.x fix migration `V202604282300` — which used the
+     * same DO/EXCEPTION construct to recreate `vwEntityPermissions` after the unquoted
+     * RoleName alias bug — proving the pattern is production-tested.
      *
      * Permissions are handled separately by sql_codegen.ts via generateViewPermissions().
      */
@@ -85,6 +109,17 @@ let PostgreSQLCodeGenProvider = class PostgreSQLCodeGenProvider extends CodeGenD
         const selectParts = this.buildBaseViewSelectParts(context, alias);
         const fromParts = this.buildBaseViewFromParts(context, entity, alias);
         const quotedView = pgDialect.QuoteSchema(entity.SchemaName, viewName);
+        const schemaLit = entity.SchemaName.replace(/'/g, "''");
+        const viewNameLit = viewName.replace(/'/g, "''");
+        // Inner CREATE OR REPLACE statement (no trailing semicolon — embedded inside
+        // the DO block via dollar-quoted literal).
+        const createOrReplaceSQL = `CREATE OR REPLACE VIEW ${quotedView}
+AS
+SELECT
+    ${selectParts}
+FROM
+    ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} AS ${alias}${fromParts}
+${whereClause}`;
         return `
 ------------------------------------------------------------
 ----- BASE VIEW FOR ENTITY:      ${entity.Name}
@@ -92,13 +127,185 @@ let PostgreSQLCodeGenProvider = class PostgreSQLCodeGenProvider extends CodeGenD
 -----               BASE TABLE:  ${entity.BaseTable}
 -----               PRIMARY KEY: ${entity.PrimaryKeys.map((pk) => pk.Name).join(', ')}
 ------------------------------------------------------------
-CREATE OR REPLACE VIEW ${quotedView}
-AS
-SELECT
-    ${selectParts}
-FROM
-    ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} AS ${alias}${fromParts}
-${whereClause};
+DO $vw_regen$
+DECLARE
+  vsql CONSTANT TEXT := $vsql$${createOrReplaceSQL}$vsql$;
+  rec RECORD;
+BEGIN
+  EXECUTE vsql;
+EXCEPTION WHEN invalid_table_definition THEN
+  -- 42P16: column rename/reorder/type change. CREATE OR REPLACE can't handle
+  -- non-additive shape changes — must DROP CASCADE + recreate. CASCADE drops
+  -- every dependent view (anything that JOINs this view in its body), so we
+  -- capture each dependent's definition + grants BEFORE the drop and replay
+  -- them afterward (best-effort). Without this, on a fresh-DB replay where
+  -- one entity's wrapper triggers (e.g. vwAIModelTypes shape changed since
+  -- baseline V202605021056), CASCADE wipes downstream views (vwAIModels)
+  -- that the wrapper for this entity doesn't know how to recreate, and
+  -- those views stay permanently missing.
+  CREATE TEMP TABLE IF NOT EXISTS _vw_regen_deps (
+    schema_name TEXT,
+    view_name   TEXT,
+    relkind     CHAR(1),
+    definition  TEXT,
+    grants_sql  TEXT
+  ) ON COMMIT DROP;
+  DELETE FROM _vw_regen_deps;
+
+  -- Capture dependent FUNCTIONS too. CASCADE drops every function with
+  -- RETURNS SETOF <view> (the codegen-emitted spCreate/spUpdate/spDelete
+  -- pattern) when the target view is dropped. Without restoring them,
+  -- post-codegen CRUD validation reports those routines as missing —
+  -- e.g. "MJ: Recommendation Items → missing create routine
+  -- spCreateRecommendationItem" — even though the next codegen pass
+  -- emits them. The restored definitions are pg_get_functiondef() output
+  -- which is a complete CREATE OR REPLACE FUNCTION statement plus a
+  -- trailing semicolon; replaying them verbatim recreates the function
+  -- with its original body, parameter list, and return type.
+  CREATE TEMP TABLE IF NOT EXISTS _vw_regen_fn_deps (
+    schema_name TEXT,
+    fn_name     TEXT,
+    fn_oid      OID,
+    definition  TEXT
+  ) ON COMMIT DROP;
+  DELETE FROM _vw_regen_fn_deps;
+
+  -- Capture dependents. NOTES on the grants_sql build:
+  --   - Resolve role name via pg_get_userbyid(oid) — returns the bare,
+  --     unquoted role name (or 'unknown (OID=N)' if the oid no longer
+  --     exists). pg_get_userbyid is a public catalog function available to
+  --     every database user, including unprivileged accounts on managed
+  --     PostgreSQL services (Amazon RDS, Azure Database for PostgreSQL,
+  --     Cloud SQL) where pg_authid is restricted to the rds_superuser /
+  --     azure_pg_admin / cloudsqlsuperuser group. Earlier revisions joined
+  --     to pg_authid which works on self-hosted PG but fails with
+  --     "permission denied for table pg_authid" on managed services.
+  --   - The earlier (broken) approach cast (aclexplode).grantee::regrole::text
+  --     which RETURNS the role name pre-quoted when it contains uppercase
+  --     (e.g. cdp_Developer comes back already wrapped); calling quote_ident
+  --     on the already-quoted string double-wrapped and the GRANT failed at
+  --     replay with "role does not exist". Using
+  --     pg_get_userbyid returns a bare name and lets quote_ident wrap it
+  --     correctly exactly once.
+  --   - PUBLIC is grantee oid 0; pg_get_userbyid(0) returns 'unknown
+  --     (OID=0)' so handle the PUBLIC case explicitly and use it as the
+  --     literal 'PUBLIC' rather than quote_ident on the synthetic name.
+  INSERT INTO _vw_regen_deps (schema_name, view_name, relkind, definition, grants_sql)
+  SELECT DISTINCT
+      dn.nspname,
+      dc.relname,
+      dc.relkind,
+      pg_get_viewdef(dc.oid),
+      (SELECT string_agg(
+          'GRANT ' || g.privilege || ' ON ' || quote_ident(dn.nspname) || '.' || quote_ident(dc.relname) ||
+          ' TO ' || (CASE WHEN g.grantee_oid = 0 THEN 'PUBLIC' ELSE quote_ident(pg_get_userbyid(g.grantee_oid)) END) || ';',
+          E'\n')
+       FROM (
+           SELECT (aclexplode(dc.relacl)).grantee AS grantee_oid,
+                  (aclexplode(dc.relacl)).privilege_type AS privilege
+       ) g
+       WHERE g.privilege IN ('SELECT', 'INSERT', 'UPDATE', 'DELETE', 'TRUNCATE', 'REFERENCES', 'TRIGGER'))
+  FROM pg_depend d
+  JOIN pg_rewrite r ON r.oid = d.objid AND d.classid = 'pg_rewrite'::regclass
+  JOIN pg_class dc ON dc.oid = r.ev_class AND dc.relkind IN ('v', 'm')
+  JOIN pg_namespace dn ON dn.oid = dc.relnamespace
+  JOIN pg_class tc ON tc.oid = d.refobjid
+  JOIN pg_namespace tn ON tn.oid = tc.relnamespace
+  WHERE tn.nspname = '${schemaLit}'
+    AND tc.relname = '${viewNameLit}'
+    AND tc.relkind IN ('v', 'm')
+    AND dc.oid <> tc.oid;
+
+  -- Capture dependent functions. Two paths matter on PG:
+  --   1. Functions whose RETURN type references the view (RETURNS SETOF
+  --      <view>) — pg_depend records this as type=pg_type → pg_class.
+  --   2. Functions whose body references the view (used by sql functions
+  --      and by some plpgsql edge cases) — pg_depend records this as
+  --      pg_proc → pg_class.
+  -- pg_get_functiondef returns a complete CREATE OR REPLACE FUNCTION
+  -- statement that we replay verbatim. We DO include RETURNS-only
+  -- references because that's the dominant codegen pattern (sp* CRUD
+  -- functions all RETURNS SETOF the matching vwX).
+  INSERT INTO _vw_regen_fn_deps (schema_name, fn_name, fn_oid, definition)
+  SELECT DISTINCT
+      pn.nspname,
+      pp.proname,
+      pp.oid,
+      pg_get_functiondef(pp.oid)
+  FROM pg_depend d
+  JOIN pg_proc pp ON pp.oid = d.objid AND d.classid = 'pg_proc'::regclass
+  JOIN pg_namespace pn ON pn.oid = pp.pronamespace
+  JOIN pg_class tc ON tc.oid = d.refobjid
+  JOIN pg_namespace tn ON tn.oid = tc.relnamespace
+  WHERE tn.nspname = '${schemaLit}'
+    AND tc.relname = '${viewNameLit}'
+    AND tc.relkind IN ('v', 'm')
+  UNION
+  SELECT DISTINCT
+      pn.nspname,
+      pp.proname,
+      pp.oid,
+      pg_get_functiondef(pp.oid)
+  FROM pg_depend d
+  JOIN pg_type pt ON pt.oid = d.refobjid AND d.refclassid = 'pg_type'::regclass
+  JOIN pg_proc pp ON pp.prorettype = pt.oid OR pt.typrelid = pp.oid
+  JOIN pg_namespace pn ON pn.oid = pp.pronamespace
+  WHERE EXISTS (
+      SELECT 1 FROM pg_class tc
+      JOIN pg_namespace tn ON tn.oid = tc.relnamespace
+      WHERE tc.reltype = pt.oid
+        AND tn.nspname = '${schemaLit}'
+        AND tc.relname = '${viewNameLit}'
+        AND tc.relkind IN ('v', 'm')
+  );
+
+  DROP VIEW IF EXISTS ${quotedView} CASCADE;
+  EXECUTE vsql;
+
+  -- Replay captured dependents. Best-effort: log + continue on failure.
+  -- IMPORTANT: the CREATE VIEW and the GRANTs run in SEPARATE inner BEGIN
+  -- blocks. PL/pgSQL's BEGIN ... EXCEPTION creates an implicit savepoint
+  -- and rolls back EVERY statement in the block on any exception. If we
+  -- combined CREATE+GRANT in one block and a GRANT failed (e.g. role not
+  -- present in target environment), the just-recreated VIEW would also
+  -- get rolled back and stay missing — the exact failure mode this
+  -- wrapper exists to prevent.
+  FOR rec IN SELECT schema_name, view_name, relkind, definition, grants_sql FROM _vw_regen_deps LOOP
+    BEGIN
+      IF rec.relkind = 'm' THEN
+        EXECUTE 'CREATE MATERIALIZED VIEW ' || quote_ident(rec.schema_name) || '.' || quote_ident(rec.view_name) || ' AS ' || rec.definition;
+      ELSE
+        EXECUTE 'CREATE VIEW ' || quote_ident(rec.schema_name) || '.' || quote_ident(rec.view_name) || ' AS ' || rec.definition;
+      END IF;
+    EXCEPTION WHEN OTHERS THEN
+      RAISE NOTICE 'Best-effort restore skipped dependent %.%: %', rec.schema_name, rec.view_name, SQLERRM;
+    END;
+
+    IF rec.grants_sql IS NOT NULL THEN
+      BEGIN
+        EXECUTE rec.grants_sql;
+      EXCEPTION WHEN OTHERS THEN
+        RAISE NOTICE 'Best-effort grant restore skipped %.%: %', rec.schema_name, rec.view_name, SQLERRM;
+      END;
+    END IF;
+  END LOOP;
+
+  -- Replay captured dependent functions AFTER all dependent views are
+  -- restored — most codegen-emitted sp* functions reference both the
+  -- target view AND the dependent views in their bodies/return types.
+  -- Wrapped per-function in its own savepoint so a single failure
+  -- doesn't poison subsequent restores or the just-recreated target.
+  FOR rec IN SELECT schema_name, fn_name, definition FROM _vw_regen_fn_deps LOOP
+    BEGIN
+      EXECUTE rec.definition;
+    EXCEPTION WHEN OTHERS THEN
+      RAISE NOTICE 'Best-effort restore skipped dependent function %.%: %', rec.schema_name, rec.fn_name, SQLERRM;
+    END;
+  END LOOP;
+
+  DROP TABLE _vw_regen_deps;
+  DROP TABLE _vw_regen_fn_deps;
+END $vw_regen$;
 `;
     }
     // ─── CRUD CREATE ─────────────────────────────────────────────────────
@@ -125,6 +332,234 @@ BEGIN
     END LOOP;
 END
 $do$;
+`;
+    }
+    /**
+     * Returns true when this entity should emit JSON-arg sprocs (single `JSONB`
+     * parameter, key-presence semantics) for the given CRUD verb instead of the
+     * default typed-arg shape. Driven by PostgreSQL's hard 100-arg `FUNC_MAX_ARGS`
+     * ceiling — once a typed-arg sproc would project past `POSTGRESQL_PROCEDURE_PARAM_LIMIT`,
+     * we switch to JSON-arg.
+     *
+     * Calls the same `useJsonArgShape` predicate used by the runtime so codegen
+     * emit and runtime invocation cannot disagree (see `crudSprocFieldRules`
+     * in `@memberjunction/generic-database-provider`).
+     */
+    shouldUseJsonArgShape(entity, sprocType) {
+        return useJsonArgShape(entity, sprocType, POSTGRESQL_PROCEDURE_PARAM_LIMIT);
+    }
+    /**
+     * Returns the per-column JSON cast expression for the JSON-arg sproc body,
+     * e.g. `(p_data->>'PromptID')::UUID` or `(p_data->>'Status')` for plain text.
+     * The mapping mirrors `mapSQLType` but as JSON-extraction casts; types that
+     * don't need a cast (TEXT/VARCHAR) emit just the bare extraction. Binary
+     * (BYTEA) decodes from base64 string. JSON-typed columns use `->` (not
+     * `->>`) to keep the JSONB structure intact.
+     */
+    renderJsonExtractAndCast(field) {
+        const pgType = this.mapSQLType(field.SQLFullType).toUpperCase();
+        const fieldKey = `'${field.Name}'`;
+        // JSON / JSONB columns: keep structure via `p_data->'Field'`, no text cast.
+        if (pgType === 'JSONB' || pgType === 'JSON') {
+            return `(p_data->${fieldKey})::${pgType}`;
+        }
+        // Binary: caller serializes as base64-encoded string; sproc decodes.
+        if (pgType === 'BYTEA') {
+            return `decode(p_data->>${fieldKey}, 'base64')`;
+        }
+        // Plain text — no cast needed; PG returns TEXT from `->>`.
+        if (pgType === 'TEXT' || pgType.startsWith('VARCHAR') || pgType.startsWith('CHAR')) {
+            return `(p_data->>${fieldKey})`;
+        }
+        // Everything else (UUID, INTEGER, BIGINT, NUMERIC, BOOLEAN, TIMESTAMP[TZ], DATE, etc.)
+        // gets an explicit cast off the text extraction.
+        return `(p_data->>${fieldKey})::${pgType}`;
+    }
+    /**
+     * Generates the SET clause body for a JSON-arg UPDATE sproc — one `CASE WHEN
+     * p_data ? 'Field' THEN <cast> ELSE "Field" END` per writable column, plus
+     * the audit-timestamp assignment.
+     */
+    renderJsonArgUpdateSetClause(entity) {
+        const writableFields = entity.Fields.filter((f) => shouldIncludeFieldInParams(f, 'update') && !f.IsPrimaryKey);
+        const setClauses = writableFields.map((field) => {
+            const colName = pgDialect.QuoteIdentifier(field.Name);
+            const fieldKey = `'${field.Name}'`;
+            const cast = this.renderJsonExtractAndCast(field);
+            return `${colName} = CASE WHEN p_data ? ${fieldKey} THEN ${cast} ELSE ${colName} END`;
+        });
+        // __mj_UpdatedAt is always touched on UPDATE, never driven by p_data.
+        setClauses.push(`${pgDialect.QuoteIdentifier(EntityInfo.UpdatedAtFieldName)} = NOW()`);
+        return setClauses.join(',\n        ');
+    }
+    /**
+     * Generates the JSON-arg variant of `spUpdate*` for wide entities. Single
+     * `p_data JSONB` parameter; per-column `CASE WHEN p_data ? 'Field' THEN
+     * <cast> ELSE "Field" END` body. Key-absent leaves the column unchanged;
+     * key=null clears it; key=value sets it. Identity column (`ID`) is required
+     * in the payload; all other columns are optional.
+     */
+    generateCRUDUpdateJsonArg(entity) {
+        const fnName = this.getCRUDRoutineName(entity, CRUDType.Update);
+        const viewName = this.getBaseViewName(entity);
+        const permissions = this.generateCRUDPermissions(entity, fnName, CRUDType.Update);
+        const setClause = this.renderJsonArgUpdateSetClause(entity);
+        const trigger = this.generateTimestampTrigger(entity);
+        // PK lookup. Composite-PK entities aren't expected to hit JSON-arg in
+        // practice (no current wide entity has a composite PK), but the shape
+        // still needs to handle them — extract each PK from p_data and AND the
+        // WHERE clause.
+        const pkExtractions = entity.PrimaryKeys.map((pk) => `    v_${this.toSnakeCase(pk.CodeName)} ${this.mapSQLType(pk.SQLFullType)} := (p_data->>'${pk.Name}')::${this.mapSQLType(pk.SQLFullType)};`).join('\n');
+        const pkValidation = entity.PrimaryKeys.map((pk) => `p_data ? '${pk.Name}'`).join(' AND ');
+        const whereClause = entity.PrimaryKeys.map((pk) => `${pgDialect.QuoteIdentifier(pk.Name)} = v_${this.toSnakeCase(pk.CodeName)}`).join(' AND ');
+        return `
+------------------------------------------------------------
+----- UPDATE FUNCTION FOR ${entity.BaseTable} (JSON-arg shape)
+------------------------------------------------------------
+${this.generateDropAllOverloadsBlock(entity.SchemaName, fnName)}
+CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(p_data JSONB)
+RETURNS SETOF ${pgDialect.QuoteSchema(entity.SchemaName, viewName)}
+AS $$
+DECLARE
+${pkExtractions}
+    v_updated_count INTEGER;
+BEGIN
+    IF p_data IS NULL OR NOT (${pkValidation}) THEN
+        RAISE EXCEPTION '${fnName}: p_data must include ${entity.PrimaryKeys.map((pk) => `"${pk.Name}"`).join(', ')}';
+    END IF;
+
+    UPDATE ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)}
+    SET
+        ${setClause}
+    WHERE
+        ${whereClause};
+
+    GET DIAGNOSTICS v_updated_count = ROW_COUNT;
+
+    IF v_updated_count = 0 THEN
+        -- Nothing was updated, return empty result set
+        RETURN;
+    END IF;
+
+    -- Return the updated record from the base view
+    RETURN QUERY
+    SELECT * FROM ${pgDialect.QuoteSchema(entity.SchemaName, viewName)}
+    WHERE ${whereClause};
+END;
+$$ LANGUAGE plpgsql;
+${permissions}
+
+${trigger}
+`;
+    }
+    /**
+     * Generates the JSON-arg variant of `spCreate*` for wide entities. Single
+     * `p_data JSONB` parameter; uses `EXECUTE format(...)` to build the INSERT
+     * dynamically based on which keys are present in `p_data` so absent keys
+     * fall back to column DEFAULT (matching the typed-arg sproc's default-
+     * substitution behavior). Returns the newly created row from the base view.
+     *
+     * Single-UUID-PK entities auto-generate the PK if `p_data` doesn't include
+     * one (matching `gen_random_uuid()` default). Composite-PK entities require
+     * caller-supplied PKs.
+     */
+    generateCRUDCreateJsonArg(entity) {
+        const fnName = this.getCRUDRoutineName(entity, CRUDType.Create);
+        const viewName = this.getBaseViewName(entity);
+        const permissions = this.generateCRUDPermissions(entity, fnName, CRUDType.Create);
+        const firstKey = entity.FirstPrimaryKey;
+        const pkType = firstKey.Type.toLowerCase().trim();
+        const pkIsUuidSingle = (pkType === 'uniqueidentifier' || pkType === 'uuid') && entity.PrimaryKeys.length === 1;
+        const pkPgType = this.mapSQLType(firstKey.SQLFullType);
+        const pkColQuoted = pgDialect.QuoteIdentifier(firstKey.Name);
+        // Writable fields participating in the INSERT — exclude PK (handled
+        // separately so we can supply a generated UUID when key is absent),
+        // exclude virtual / special-date / non-API-writable.
+        const writableFields = entity.Fields.filter((f) => shouldIncludeFieldInParams(f, 'create') && !f.IsPrimaryKey);
+        // Per-field cast tokens for the dynamic INSERT. Built as a JS array so
+        // the sproc body iterates over (column-name, cast-expression) pairs at
+        // runtime to assemble the column / value lists from p_data keys.
+        //
+        // The cast expressions are emitted with `$1` (parameterized placeholder)
+        // instead of `p_data` because they end up inside an `EXECUTE v_sql USING
+        // p_data` call. PG's dynamic-SQL parser does NOT see the enclosing
+        // function's locals — `p_data` is unbound inside the dynamic SQL — so we
+        // bind it as `$1` and reference `($1->>'Field')` from inside the dynamic
+        // INSERT. This is the canonical safe pattern for dynamic SQL with values:
+        // values flow through the binding mechanism, never through string
+        // interpolation, so there's zero injection surface.
+        const fieldCastEntries = writableFields
+            .map((f) => {
+            const cast = this.renderJsonExtractAndCast(f).replace(/p_data/g, '$$1');
+            return `        WHEN '${f.Name}' THEN '${cast.replace(/'/g, "''")}'`;
+        })
+            .join('\n');
+        const fieldNamesArrayLiteral = writableFields.map((f) => `'${f.Name}'`).join(', ');
+        // ID resolution body: differs by PK strategy. Single-UUID PK is auto-
+        // generated when the caller doesn't supply one; everything else (composite,
+        // non-UUID) requires the caller to provide the key explicitly.
+        const idResolveBody = pkIsUuidSingle
+            ? `    IF p_data ? '${firstKey.Name}' THEN
+        v_id := (p_data->>'${firstKey.Name}')::${pkPgType};
+    ELSE
+        v_id := gen_random_uuid();
+    END IF;`
+            : `    IF NOT (p_data ? '${firstKey.Name}') THEN
+        RAISE EXCEPTION '${fnName}: p_data must include "${firstKey.Name}"';
+    END IF;
+    v_id := (p_data->>'${firstKey.Name}')::${pkPgType};`;
+        return `
+------------------------------------------------------------
+----- CREATE FUNCTION FOR ${entity.BaseTable} (JSON-arg shape)
+------------------------------------------------------------
+${this.generateDropAllOverloadsBlock(entity.SchemaName, fnName)}
+CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(p_data JSONB)
+RETURNS SETOF ${pgDialect.QuoteSchema(entity.SchemaName, viewName)}
+AS $$
+DECLARE
+    v_id ${pkPgType};
+    v_field_name TEXT;
+    v_cast_expr  TEXT;
+    v_col_list   TEXT;
+    v_val_list   TEXT;
+    v_sql        TEXT;
+BEGIN
+${idResolveBody}
+
+    v_col_list := quote_ident('${firstKey.Name.replace(/'/g, "''")}');
+    v_val_list := quote_literal(v_id) || '::${pkPgType}';
+
+    -- Build column / value lists from keys present in p_data. Absent keys are
+    -- omitted entirely so the column's DEFAULT applies (matching the typed-arg
+    -- sproc's default-substitution semantics).
+    FOREACH v_field_name IN ARRAY ARRAY[${fieldNamesArrayLiteral}]
+    LOOP
+        IF p_data ? v_field_name THEN
+            v_cast_expr := CASE v_field_name
+${fieldCastEntries}
+            END;
+            v_col_list := v_col_list || ', ' || quote_ident(v_field_name);
+            v_val_list := v_val_list || ', ' || v_cast_expr;
+        END IF;
+    END LOOP;
+
+    v_sql := format(
+        'INSERT INTO ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable).replace(/'/g, "''")} (%s) VALUES (%s)',
+        v_col_list,
+        v_val_list
+    );
+    -- USING p_data binds the cast expressions' \`$1\` placeholders to the
+    -- function's p_data argument. Without USING, dynamic SQL has no access to
+    -- the enclosing function's locals and the \`$1->>\` references would fail
+    -- with \`column "p_data" does not exist\`.
+    EXECUTE v_sql USING p_data;
+
+    RETURN QUERY
+    SELECT * FROM ${pgDialect.QuoteSchema(entity.SchemaName, viewName)}
+    WHERE ${pkColQuoted} = v_id;
+END;
+$$ LANGUAGE plpgsql;
+${permissions}
 `;
     }
     /**
@@ -137,8 +572,16 @@ $do$;
      *
      * Prepends a DROP-all-overloads block (see `generateDropAllOverloadsBlock`) so
      * adding/removing a column doesn't trigger PG's overload-ambiguity error.
+     *
+     * Wide entities (where `useJsonArgShape` returns true) emit a JSON-arg variant
+     * via `generateCRUDCreateJsonArg` — single `p_data JSONB` parameter, dynamic
+     * INSERT built from keys present in the payload. Same semantics; different
+     * wire shape needed because of PostgreSQL's 100-arg function ceiling.
      */
     generateCRUDCreate(entity) {
+        if (this.shouldUseJsonArgShape(entity, 'create')) {
+            return this.generateCRUDCreateJsonArg(entity);
+        }
         const fnName = this.getCRUDRoutineName(entity, CRUDType.Create);
         const viewName = this.getBaseViewName(entity);
         const paramString = this.generateCRUDParamString(entity.Fields, false);
@@ -192,6 +635,9 @@ ${permissions}
      * and emits `GRANT EXECUTE` permissions.
      */
     generateCRUDUpdate(entity) {
+        if (this.shouldUseJsonArgShape(entity, 'update')) {
+            return this.generateCRUDUpdateJsonArg(entity);
+        }
         const fnName = this.getCRUDRoutineName(entity, CRUDType.Update);
         const viewName = this.getBaseViewName(entity);
         const paramString = this.generateCRUDParamString(entity.Fields, true);
@@ -416,7 +862,7 @@ WHERE ${ftsColName} IS NULL;
         const primaryKey = entity.FirstPrimaryKey.Name;
         const primaryKeyType = this.mapSQLType(entity.FirstPrimaryKey.SQLFullType);
         const fieldName = field.Name;
-        const fnName = `fn_${this.toSnakeCase(entity.BaseTable)}_${this.toSnakeCase(fieldName)}_get_root_id`;
+        const fnName = this.getRootIDFunctionName(entity, field);
         return `
 ------------------------------------------------------------
 ----- ROOT ID FUNCTION FOR: ${entity.BaseTable}.${fieldName}
@@ -460,6 +906,22 @@ CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(
 $$ LANGUAGE sql STABLE;
 `;
     }
+    /**
+     * Produces the canonical name for the recursive root-finder helper function
+     * generated for self-referencing fields. The function definition and the
+     * view's LATERAL-JOIN reference must agree on this name (caller side calls
+     * via `generateRootFieldJoin`, definition via `generateRootIDFunction`).
+     *
+     * Note: this intentionally does NOT match the baseline-shipped PascalCase
+     * `fn{Table}{Field}_GetRootID` form, because the baseline returns
+     * `TABLE("RootID" type)` and the view callers expect a scalar — using the
+     * baseline name would clash with `cannot change return type of existing
+     * function`. The snake_case scalar form is codegen's own naming space and
+     * is consistent with how downstream views are emitted.
+     */
+    getRootIDFunctionName(entity, field) {
+        return `fn_${this.toSnakeCase(entity.BaseTable)}_${this.toSnakeCase(field.Name)}_get_root_id`;
+    }
     /** @inheritdoc */
     generateRootFieldSelect(_entity, field, alias) {
         const rootFieldName = `Root${field.Name}`;
@@ -471,7 +933,7 @@ $$ LANGUAGE sql STABLE;
      * `OUTER APPLY`) to call scalar functions inline within a view definition.
      */
     generateRootFieldJoin(entity, field, alias) {
-        const fnName = `fn_${this.toSnakeCase(entity.BaseTable)}_${this.toSnakeCase(field.Name)}_get_root_id`;
+        const fnName = this.getRootIDFunctionName(entity, field);
         const tableAlias = entity.BaseTableCodeName.charAt(0).toLowerCase();
         return `LEFT JOIN LATERAL (
     SELECT ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(${tableAlias}.${pgDialect.QuoteIdentifier(entity.FirstPrimaryKey.Name)}, ${tableAlias}.${pgDialect.QuoteIdentifier(field.Name)}) AS root_id
@@ -585,8 +1047,14 @@ END $$;
                 continue;
             // _Clear companion is emitted immediately before its main parameter
             // for nullable columns whose database default is non-NULL.
+            //
+            // Type was historically `bit DEFAULT 0` (a copy-paste from the
+            // SQL Server emitter). PG has no implicit cast from integer to
+            // its `bit` type, and `bit` here was meant to mean a boolean
+            // anyway — so the function compiles but every caller that passes
+            // `0`/`false` fails type-checking. Emit native PG `boolean DEFAULT FALSE`.
             if (!ef.IsPrimaryKey && this.needsClearCompanion(ef)) {
-                parts.push(`${dialect.ParameterRef(ef.CodeName + '_Clear')} bit${dialect.ParameterDefault('0')}`);
+                parts.push(`${dialect.ParameterRef(ef.CodeName + '_Clear')} ${dialect.BooleanParameterType()}${dialect.ParameterDefault(dialect.BooleanLiteral(false))}`);
                 foundDefault = true;
             }
             const isOptional = !this.isParamRequired(ef, isUpdate);
@@ -615,14 +1083,18 @@ END $$;
     // ─── ROUTINE NAMING ──────────────────────────────────────────────────
     /** @inheritdoc */
     getCRUDRoutineName(entity, type) {
-        const snakeTable = this.toSnakeCase(entity.BaseTableCodeName);
+        // Match the baseline-ported `sp{Verb}{TableCodeName}` convention (SQL Server
+        // names ported verbatim into PG). The runtime PostgreSQLDataProvider calls
+        // these names directly — diverging here (e.g. `fn_create_<snake>`) means new
+        // CodeGen runs leave functions the runtime can never find.
+        const tableCodeName = entity.BaseTableCodeName;
         switch (type) {
             case CRUDType.Create:
-                return entity.spCreate || `fn_create_${snakeTable}`;
+                return entity.spCreate || `spCreate${tableCodeName}`;
             case CRUDType.Update:
-                return entity.spUpdate || `fn_update_${snakeTable}`;
+                return entity.spUpdate || `spUpdate${tableCodeName}`;
             case CRUDType.Delete:
-                return entity.spDelete || `fn_delete_${snakeTable}`;
+                return entity.spDelete || `spDelete${tableCodeName}`;
         }
     }
     // ─── SQL HEADERS ─────────────────────────────────────────────────────
@@ -645,11 +1117,34 @@ END $$;
     }
     // ─── UTILITY ─────────────────────────────────────────────────────────
     /**
-     * Maps a SQL default value expression to its PostgreSQL equivalent. Translates
-     * SQL Server built-in functions (e.g., `NEWID()` to `gen_random_uuid()`,
-     * `GETUTCDATE()` to `NOW() AT TIME ZONE 'UTC'`), strips outer parentheses and
-     * surrounding single quotes, and re-applies quoting based on the {@link needsQuotes}
-     * flag. Returns `'NULL'` for empty or whitespace-only input.
+     * Renders a column DEFAULT expression for embedding in a generated SQL
+     * statement. Handles three cases:
+     *
+     * 1. **SS-style function defaults** — `NEWID()` → `gen_random_uuid()`,
+     *    `GETUTCDATE()` → `NOW() AT TIME ZONE 'UTC'`, etc. Mapped via the
+     *    `functionMap` table.
+     *
+     * 2. **PG typed-literal defaults** — values like `'Pending'::character
+     *    varying`, `'-1'::integer`, `'F51358F3-...'::uuid`, `'{}'::jsonb`
+     *    that PG returns from `information_schema.columns.column_default`.
+     *    These are already fully-formed PG expressions; pass through
+     *    verbatim. PG handles them natively in every context this method's
+     *    output appears (INSERT VALUES, COALESCE inside INSERT/UPDATE,
+     *    CASE-WHEN inside the clear-companion pattern).
+     *
+     *    The type name after `::` may be a single identifier OR multiple
+     *    words separated by spaces (`character varying`, `double precision`,
+     *    `time with time zone`, etc.). Without correctly matching multi-word
+     *    types, stripping the outer quotes and re-wrapping would produce
+     *    `'''Pending''::character varying'` — a string literal whose value
+     *    contains the cast syntax — and INSERTs would fail with "value too
+     *    long for type character varying(N)".
+     *
+     * 3. **Plain string defaults** — strip outer parens / quotes, then
+     *    optionally re-apply single-quote wrap (with `'` → `''` escaping)
+     *    based on the `needsQuotes` flag.
+     *
+     * Returns `'NULL'` for empty or whitespace-only input.
      */
     formatDefaultValue(defaultValue, needsQuotes) {
         if (!defaultValue || defaultValue.trim().length === 0)
@@ -680,13 +1175,48 @@ END $$;
         if (trimmedValue.startsWith('(') && trimmedValue.endsWith(')')) {
             trimmedValue = trimmedValue.substring(1, trimmedValue.length - 1);
         }
+        // PG returns typed-literal defaults from
+        // `information_schema.columns.column_default`, e.g.
+        // `'Pending'::character varying` or `'-1'::integer` or
+        // `'{}'::jsonb`. These are already fully-formed PG expressions and
+        // pass through verbatim — PG handles them natively in every context
+        // this method's output appears (INSERT VALUES, COALESCE inside
+        // INSERT/UPDATE, CASE-WHEN inside the clear-companion pattern).
+        // Empirically verified in PG 17 against `character varying`,
+        // `integer`, `uuid`, `bigint`, `double precision`, `boolean`, and
+        // `timestamp with time zone`.
+        //
+        // Stripping the leading-and-trailing quotes here is wrong: the value
+        // re-wrap downstream would produce `'''Pending''::character
+        // varying'` — a string literal whose content is the cast syntax —
+        // and INSERTs would fail with "value too long for type character
+        // varying(N)" because the literal is longer than the column.
+        //
+        // The type name after `::` may be a single identifier (`text`,
+        // `uuid`, `integer`) OR multiple words separated by spaces
+        // (`character varying`, `double precision`, `time with time zone`,
+        // `timestamp without time zone`, `bit varying`), optionally followed
+        // by a length parameter `(N)` and/or array suffix `[]`. The
+        // `\w+(?:\s+\w+)*` portion captures both single-word and multi-word
+        // type names. The original regex matched only single-identifier
+        // types and silently fell through to the broken re-wrap path for
+        // multi-word names — this fix extends the match without changing
+        // behavior for the cases the original regex already caught.
+        if (/^'.*'::\w+(?:\s+\w+)*(\s*\(\s*\d+\s*\))?(\s*\[\s*\])?$/.test(trimmedValue)) {
+            return trimmedValue;
+        }
         // Remove surrounding quotes for clean value
         let cleanValue = trimmedValue;
         if (cleanValue.startsWith("'") && cleanValue.endsWith("'")) {
             cleanValue = cleanValue.substring(1, cleanValue.length - 1);
         }
-        if (needsQuotes)
-            return `'${cleanValue}'`;
+        if (needsQuotes) {
+            // Single-quote-escape the cleaned value (SQL standard: '' → ').
+            // Without this, a default of `O'Brien` would re-emit as `'O'Brien'`
+            // which closes the literal at the apostrophe and then fails parsing.
+            const escaped = cleanValue.replace(/'/g, "''");
+            return `'${escaped}'`;
+        }
         return cleanValue;
     }
     /**
@@ -752,7 +1282,15 @@ END $$;
     addDefaultConstraintSQL(schema, tableName, columnName, defaultExpression) {
         const table = pgDialect.QuoteSchema(schema, tableName);
         const col = pgDialect.QuoteIdentifier(columnName);
-        return `ALTER TABLE ${table} ALTER COLUMN ${col} SET DEFAULT ${defaultExpression}`;
+        // Prepend SET CONSTRAINTS ALL IMMEDIATE so any deferred constraint
+        // trigger events queued by earlier INSERTs in the same migration
+        // transaction fire NOW, freeing the target table for ALTER. Without
+        // this, mid-migration ALTER TABLE on a table that received earlier
+        // INSERTs fails with `cannot ALTER TABLE because it has pending
+        // trigger events` — codegen interleaves INSERTs (data sync) and
+        // ALTER TABLE (default refresh) within a single Skyway-wrapped
+        // transaction so the queue must be flushed at the boundary.
+        return `SET CONSTRAINTS ALL IMMEDIATE;\nALTER TABLE ${table} ALTER COLUMN ${col} SET DEFAULT ${defaultExpression}`;
     }
     /**
      * Generates a PL/pgSQL `DO $$` block that drops both a named CHECK constraint (if one
@@ -763,7 +1301,12 @@ END $$;
     dropDefaultConstraintSQL(schema, tableName, columnName) {
         const table = pgDialect.QuoteSchema(schema, tableName);
         const col = pgDialect.QuoteIdentifier(columnName);
-        return `
+        // SET CONSTRAINTS ALL IMMEDIATE outside the DO block so it executes
+        // first; any deferred trigger events from earlier INSERTs in the
+        // same transaction fire NOW, clearing the queue before the ALTER
+        // TABLE inside this DO block runs. See addDefaultConstraintSQL for
+        // the rationale on why this is needed.
+        return `SET CONSTRAINTS ALL IMMEDIATE;
 DO $$
 DECLARE
    v_constraint_name TEXT;
@@ -807,7 +1350,7 @@ END $$`;
     COALESCE(character_maximum_length, 0) AS "Length",
     COALESCE(numeric_precision, 0) AS "Precision",
     COALESCE(numeric_scale, 0) AS "Scale",
-    CASE WHEN is_nullable = 'YES' THEN 1 ELSE 0 END AS "AllowsNull"
+    CASE WHEN is_nullable = 'YES' THEN TRUE ELSE FALSE END AS "AllowsNull"
 FROM information_schema.columns
 WHERE table_schema = '${schema}'
   AND table_name = '${viewName}'
@@ -890,6 +1433,11 @@ ORDER BY ordinal_position`;
         // PL/pgSQL control flow
         'NEW', 'OLD', 'FOUND', 'LOOP', 'WHILE', 'EXIT', 'CONTINUE',
         'ELSIF', 'ELSEIF', 'STRICT',
+        // Transaction / constraint control (used by SET CONSTRAINTS ALL IMMEDIATE
+        // emitted before ALTER TABLE so deferred trigger events flush). Without
+        // CONSTRAINTS / IMMEDIATE / DEFERRED in the keyword set, the tokenizer
+        // double-quotes them as identifiers and PG rejects the resulting SQL.
+        'CONSTRAINTS', 'IMMEDIATE', 'DEFERRED', 'SAVEPOINT', 'RELEASE',
         // SQL Server types
         'NVARCHAR', 'VARCHAR', 'UNIQUEIDENTIFIER', 'DATETIMEOFFSET', 'DATETIME', 'DATETIME2',
         'BIGINT', 'SMALLINT', 'TINYINT', 'FLOAT', 'REAL', 'DECIMAL', 'NUMERIC', 'MONEY',
@@ -1116,12 +1664,49 @@ WHERE p.prokind IN ('f', 'p')
         });
         await client.connect();
         try {
+            // PG-only: emit recursive-FK root-ID helpers ahead of the view.
+            //
+            // PG codegen intentionally uses snake_case scalar
+            // `fn_<table>_<field>_get_root_id` rather than the SS baseline's
+            // PascalCase table-returning `fn<Table><Field>_GetRootID` — see
+            // `getRootIDFunctionName`. The two names CAN'T coexist as the
+            // same function (different return type), so codegen owns its
+            // own snake_case namespace.
+            //
+            // Consequence: on a fresh PG database, the snake_case helpers
+            // don't exist until codegen has run successfully at least once.
+            // The `recompileAllBaseViews` → `regenerateFailedBaseViews`
+            // recovery path used to call `generateBaseView` directly with
+            // no helper emission, so customer first-run codegen against a
+            // managed PG (where only baseline PascalCase functions exist)
+            // hit `function fn_ai_agent_run_parent_run_id_get_root_id does
+            // not exist` when LATERAL JOINs in the regenerated view body
+            // resolved to the snake_case scalar form.
+            //
+            // SS doesn't have this problem because its codegen-generated
+            // helper name matches the baseline name — the baseline always
+            // satisfies the LATERAL JOIN. Hence the fix lives here, not
+            // in the dialect-agnostic recovery loop.
+            const recursiveFKs = entity.Fields.filter(f => f.RelatedEntityID != null && UUIDsEqual(f.RelatedEntityID, entity.ID));
+            for (const field of recursiveFKs) {
+                const fnSQL = this.generateRootIDFunction(entity, field);
+                if (fnSQL && fnSQL.trim().length > 0) {
+                    await client.query(fnSQL);
+                }
+            }
             await executeWithFallback({
                 client,
                 schema: entity.SchemaName,
                 viewName: entity.BaseView,
                 createOrReplaceSQL: viewSQL,
                 willRegenerate,
+                // Pass the base table so viewFallback can materialize a stub
+                // first if the view body has a self-reference and the view
+                // doesn't yet exist (e.g. vwRecordChanges joins to itself for
+                // parent lookup; if it was CASCADE-dropped earlier in the
+                // same codegen run, CREATE OR REPLACE can't resolve the
+                // self-reference until a placeholder exists).
+                baseTableQualified: pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable),
             });
         }
         finally {
@@ -1189,6 +1774,7 @@ WHERE p.prokind IN ('f', 'p')
                         viewName: opts.entity.BaseView,
                         createOrReplaceSQL: opts.viewSQL,
                         willRegenerate: opts.willRegenerate,
+                        baseTableQualified: pgDialect.QuoteSchema(opts.entity.SchemaName, opts.entity.BaseTable),
                     });
                 }
                 catch (e) {
@@ -1680,12 +2266,12 @@ numbered_rows AS (
       e."Name" AS "EntityName",
       re."ID" AS "RelatedEntityID",
       fk."referenced_column" AS "RelatedEntityFieldName",
-      CASE WHEN sf."FieldName" = 'Name' THEN 1 ELSE 0 END AS "IsNameField",
-      CASE WHEN pk."ColumnName" IS NOT NULL THEN 1 ELSE 0 END AS "IsPrimaryKey",
+      CASE WHEN sf."FieldName" = 'Name' THEN TRUE ELSE FALSE END AS "IsNameField",
+      CASE WHEN pk."ColumnName" IS NOT NULL THEN TRUE ELSE FALSE END AS "IsPrimaryKey",
       CASE
-            WHEN pk."ColumnName" IS NOT NULL THEN 1
-            WHEN uk."ColumnName" IS NOT NULL THEN 1
-            ELSE 0
+            WHEN pk."ColumnName" IS NOT NULL THEN TRUE
+            WHEN uk."ColumnName" IS NOT NULL THEN TRUE
+            ELSE FALSE
       END AS "IsUnique",
       ROW_NUMBER() OVER (PARTITION BY sf."EntityID", sf."FieldName" ORDER BY (SELECT NULL)) AS rn
    FROM
@@ -1716,12 +2302,12 @@ ORDER BY "EntityID", "Sequence";
      * Builds the CASE expression for AllowUpdateAPI in the pending entity fields query.
      */
     buildAllowUpdateAPICase() {
-        return `CASE WHEN sf."IsVirtual" = true THEN 0
-           WHEN sf."FieldName" = '${EntityInfo.CreatedAtFieldName}' THEN 0
-           WHEN sf."FieldName" = '${EntityInfo.UpdatedAtFieldName}' THEN 0
-           WHEN sf."FieldName" = '${EntityInfo.DeletedAtFieldName}' THEN 0
-           WHEN pk."ColumnName" IS NOT NULL THEN 0
-           ELSE 1
+        return `CASE WHEN sf."IsVirtual" = true THEN FALSE
+           WHEN sf."FieldName" = '${EntityInfo.CreatedAtFieldName}' THEN FALSE
+           WHEN sf."FieldName" = '${EntityInfo.UpdatedAtFieldName}' THEN FALSE
+           WHEN sf."FieldName" = '${EntityInfo.DeletedAtFieldName}' THEN FALSE
+           WHEN pk."ColumnName" IS NOT NULL THEN FALSE
+           ELSE TRUE
       END AS "AllowUpdateAPI"`;
     }
     /**
@@ -1748,11 +2334,12 @@ WHERE vf."IsVirtual" = true
       AND fk."RelatedEntityNameFieldMap" != ''
       AND LOWER(vf."Name") = LOWER(fk."RelatedEntityNameFieldMap"))
   )
-  AND vf."AllowsNull" != fk."AllowsNull"`;
+  AND vf."AllowsNull" != fk."AllowsNull";
+`;
     }
 };
 PostgreSQLCodeGenProvider = PostgreSQLCodeGenProvider_1 = __decorate([
-    RegisterClass(CodeGenDatabaseProvider, 'PostgreSQLCodeGenProvider')
+    RegisterClass(CodeGenDatabaseProvider, 'postgresql')
 ], PostgreSQLCodeGenProvider);
 export { PostgreSQLCodeGenProvider };
 //# sourceMappingURL=PostgreSQLCodeGenProvider.js.map