@memberjunction/codegen-lib 6.1.0-edge.2 → 6.1.0-edge.4

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

@@ -4,14 +4,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var PostgreSQLCodeGenProvider_1;
 import { EntityInfo, ResolveStartupMode, SetProvider, StartupManager } from '@memberjunction/core';
 import { RegisterClass, UUIDsEqual } from '@memberjunction/global';
 import { CodeGenDatabaseProvider, CRUDType, } from '../../codeGenDatabaseProvider.js';
 import { configInfo, mj_core_schema } from '../../../Config/config.js';
 import { logError, startSpinner, succeedSpinner } from '../../../Misc/status_logging.js';
 import { buildMetadataSupportObjectsSQL } from './metadataSupportObjects.js';
-import { PostgreSQLDialect } from '@memberjunction/sql-dialect';
+import { PostgreSQLDialect, AutoQuotePostgreSQLIdentifiers, restarLayeredOuterView, buildCreateOrReplaceLayeredOuterViewSQL, LayeredOuterRestarError } from '@memberjunction/sql-dialect';
 import { shouldIncludeFieldInParams, useJsonArgShape, UserCache, } from '@memberjunction/generic-database-provider';
 import { POSTGRESQL_PROCEDURE_PARAM_LIMIT, PostgreSQLDataProvider, PostgreSQLProviderConfigData, } from '@memberjunction/postgresql-dataprovider';
 import { PGConnection, getPgConfig } from '../../../Config/pg-connection.js';
@@ -30,7 +29,6 @@ const pgDialect = new PostgreSQLDialect();
  * `ClassFactory.CreateInstance(CodeGenDatabaseProvider, configInfo.dbPlatform)`.
  */
 let PostgreSQLCodeGenProvider = class PostgreSQLCodeGenProvider extends CodeGenDatabaseProvider {
-    static { PostgreSQLCodeGenProvider_1 = this; }
     /** @inheritdoc */
     get Dialect() {
         return pgDialect;
@@ -172,7 +170,6 @@ let PostgreSQLCodeGenProvider = class PostgreSQLCodeGenProvider extends CodeGenD
      */
     generateBaseView(context) {
         const { entity } = context;
-        this.assertLayeredBaseViewSupported(entity);
         // The GENERATED view — `GeneratedViewName` is BaseView unless the entity layers a custom view
         // over an inner generated one, in which case CodeGen writes the inner name. The CRUD
         // routines keep using getBaseViewName(): they return rows from the PUBLIC view, so a
@@ -382,6 +379,63 @@ EXCEPTION WHEN invalid_table_definition THEN
 END $vw_regen$;
 `;
     }
+    // ─── MATERIALIZATION ─────────────────────────────────────────────────
+    /**
+     * PostgreSQL materialized-table DDL. The create is **conditional** (`CREATE TABLE IF NOT
+     * EXISTS`) so a migration-provided `materialized_<name>` table with bespoke indexing is
+     * detected and reused rather than clobbered (plan §12). Emits the single-column surrogate
+     * PRIMARY KEY, which is itself the required unique index.
+     *
+     * PG dialect vs. SQL Server: double-quoted identifiers, `CREATE TABLE IF NOT EXISTS` in
+     * place of the `IF OBJECT_ID(...) IS NULL` guard, and the surrogate column carries PG's
+     * `GENERATED ALWAYS AS IDENTITY` clause (see {@link getMaterializedSurrogateColumnType}).
+     */
+    generateMaterializedTableSQL(schema, tableName, columns) {
+        // MJ entity-field metadata stores CANONICAL (SQL Server-flavored) type names — e.g. 'uniqueidentifier',
+        // 'nvarchar(50)' — regardless of the physical DB dialect. Every other PG DDL path maps these via
+        // mapSQLType (see spCreate/spUpdate generation); the materialized-table DDL must do the same, or a
+        // base-view/query materialization emits `... uniqueidentifier ...` and PG fails the CREATE TABLE with
+        // `type "uniqueidentifier" does not exist`, aborting the whole codegen run.
+        const colLines = columns.map((c) => `    ${pgDialect.QuoteIdentifier(c.Name)} ${this.mapSQLType(c.SQLType)} ${c.Nullable ? 'NULL' : 'NOT NULL'}`);
+        const pkCols = columns.filter((c) => c.IsPrimaryKey).map((c) => c.Name);
+        const pkClause = pkCols.length
+            ? `,\n    CONSTRAINT ${pgDialect.QuoteIdentifier(`PK_${tableName}`)} PRIMARY KEY (${pkCols
+                .map((n) => pgDialect.QuoteIdentifier(n))
+                .join(', ')})`
+            : '';
+        return `CREATE TABLE IF NOT EXISTS ${pgDialect.QuoteSchema(schema, tableName)} (
+${colLines.join(',\n')}${pkClause}
+);`;
+    }
+    /**
+     * PostgreSQL wrapper-view DDL — the stable read contract over the materialized table.
+     * Uses `CREATE OR REPLACE VIEW` so the same statement both creates the view and atomically
+     * repoints it at a freshly-built table during refresh (plan §11.2). The body is always
+     * `SELECT * FROM <table>` and the shadow table shares the column shape, so PG's
+     * `CREATE OR REPLACE` column-compatibility rule is satisfied on the swap.
+     */
+    generateMaterializedWrapperViewSQL(schema, viewName, tableName) {
+        return `CREATE OR REPLACE VIEW ${pgDialect.QuoteSchema(schema, viewName)}
+AS
+SELECT * FROM ${pgDialect.QuoteSchema(schema, tableName)};`;
+    }
+    /**
+     * PostgreSQL synthetic surrogate key: a SQL-standard auto-assigned identity column
+     * (`GENERATED ALWAYS AS IDENTITY`), `bigint` for headroom on large materialized sets.
+     * v1 full-rebuild only; the deterministic combined-key hashing in §5 replaces this in Phase 3.
+     */
+    getMaterializedSurrogateColumnType() {
+        return 'bigint GENERATED ALWAYS AS IDENTITY';
+    }
+    /**
+     * PostgreSQL KEYED surrogate key type: the combined-key SHA-256 hash the refresh writes comes from
+     * `encode(digest(…), 'hex')`, whose type is `text`, and the full rebuild's `CREATE TABLE AS` infers
+     * exactly that. Typing the minted entity's PK column `text` MATCHES the post-refresh physical column,
+     * avoiding the int-vs-hash divergence between CodeGen metadata and the rebuilt table.
+     */
+    getMaterializedHashSurrogateColumnType() {
+        return 'text';
+    }
     // ─── CRUD CREATE ─────────────────────────────────────────────────────
     /**
      * Emits a `DO` block that drops every existing overload of `<schema>.<fnName>`.
@@ -869,6 +923,26 @@ EXECUTE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, trigFnName)}();
         return (`CREATE INDEX IF NOT EXISTS ${pgDialect.QuoteIdentifier(indexName)}\n` +
             `    ON ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} (${pgDialect.QuoteIdentifier(f.Name)});`);
     }
+    softPrimaryKeyIndexPrefix() {
+        return 'idx_auto_mj_softpk_';
+    }
+    /**
+     * PostgreSQL will happily accept an unbounded `text` column in a btree key and then fail at
+     * INSERT time if a value exceeds roughly an eighth of a page — an error that surfaces long
+     * after the index was created, on whichever row happens to be too long. Treating unbounded
+     * columns as unindexable keeps the failure at generation time, where it names the column.
+     */
+    isIndexableKeyColumn(f) {
+        return f.Length !== -1;
+    }
+    formatCompositeIndexStatement(entity, fields, indexName) {
+        const cols = fields.map(f => pgDialect.QuoteIdentifier(f.Name)).join(', ');
+        return (`-- Index for the soft primary key (${fields.map(f => f.Name).join(', ')}) in table ${entity.BaseTable}.\n` +
+            `-- The key is metadata-only — no PRIMARY KEY constraint — so without this the per-record\n` +
+            `-- existence check on the create path scans the whole table.\n` +
+            `CREATE INDEX IF NOT EXISTS ${pgDialect.QuoteIdentifier(indexName)}\n` +
+            `    ON ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} (${cols});`);
+    }
     // ─── FULL-TEXT SEARCH ────────────────────────────────────────────────
     /**
      * Generates a complete PostgreSQL full-text search infrastructure for an entity.
@@ -955,7 +1029,231 @@ WHERE ${ftsColName} IS NULL;
      * the parent FK upward, capped at 100 levels to prevent infinite loops. Returns the
      * root record's primary key value.
      */
+    // ─── RECURSIVE HIERARCHY FUNCTIONS ──────────────────────────────────
+    /**
+     * Generates a PostgreSQL function returning a table of hierarchy metadata
+     * (RootID, Depth, Path, IsLeaf, ChildCount) for a self-referencing foreign key.
+     */
+    generateHierarchyMetaFunction(entity, field) {
+        if (entity.PrimaryKeys.length !== 1) {
+            throw new Error(`[Hierarchy] Entity '${entity.Name}' has ${entity.PrimaryKeys.length} primary key fields. MemberJunction hierarchy TVF generation requires a single-column primary key.`);
+        }
+        const primaryKey = entity.FirstPrimaryKey.Name;
+        const primaryKeyType = this.mapSQLType(entity.FirstPrimaryKey.SQLFullType);
+        const fieldName = field.Name;
+        const fnName = this.getHierarchyMetaFunctionName(entity, field);
+        return `
+------------------------------------------------------------
+----- HIERARCHY METADATA FUNCTION FOR: ${entity.BaseTable}.${fieldName}
+------------------------------------------------------------
+CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(
+    p_record_id ${primaryKeyType},
+    p_parent_id ${primaryKeyType}
+) RETURNS TABLE (
+    "RootID" ${primaryKeyType},
+    "Depth" INTEGER,
+    "Path" TEXT,
+    "IsLeaf" BOOLEAN,
+    "ChildCount" INTEGER
+) AS $$
+    WITH RECURSIVE cte_ancestors AS (
+        SELECT
+            ${pgDialect.QuoteIdentifier(primaryKey)},
+            ${pgDialect.QuoteIdentifier(fieldName)},
+            0 AS depth,
+            '/' || ${pgDialect.QuoteIdentifier(primaryKey)}::TEXT || '/' AS path
+        FROM
+            ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)}
+        WHERE
+            ${pgDialect.QuoteIdentifier(primaryKey)} = p_record_id
+
+        UNION ALL
+
+        SELECT
+            p.${pgDialect.QuoteIdentifier(primaryKey)},
+            p.${pgDialect.QuoteIdentifier(fieldName)},
+            c.depth + 1 AS depth,
+            '/' || p.${pgDialect.QuoteIdentifier(primaryKey)}::TEXT || c.path AS path
+        FROM
+            ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} p
+        INNER JOIN
+            cte_ancestors c ON p.${pgDialect.QuoteIdentifier(primaryKey)} = c.${pgDialect.QuoteIdentifier(fieldName)}
+        WHERE
+            c.depth < 100
+    )
+    SELECT
+        a.${pgDialect.QuoteIdentifier(primaryKey)} AS "RootID",
+        (SELECT MAX(depth) FROM cte_ancestors)::INTEGER AS "Depth",
+        (SELECT path FROM cte_ancestors ORDER BY depth DESC LIMIT 1)::TEXT AS "Path",
+        (NOT EXISTS (SELECT 1 FROM ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} WHERE ${pgDialect.QuoteIdentifier(fieldName)} = p_record_id))::BOOLEAN AS "IsLeaf",
+        (SELECT COUNT(1)::INTEGER FROM ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} WHERE ${pgDialect.QuoteIdentifier(fieldName)} = p_record_id) AS "ChildCount"
+    FROM
+        cte_ancestors a
+    WHERE
+        a.${pgDialect.QuoteIdentifier(fieldName)} IS NULL OR p_parent_id IS NULL
+    ORDER BY
+        a.depth DESC
+    LIMIT 1;
+$$ LANGUAGE sql STABLE;
+`;
+    }
+    /**
+     * Generates a PostgreSQL table-valued function returning all descendant records of a root node.
+     */
+    generateDescendantsFunction(entity, field) {
+        if (entity.PrimaryKeys.length !== 1) {
+            throw new Error(`[Hierarchy] Entity '${entity.Name}' has ${entity.PrimaryKeys.length} primary key fields. MemberJunction hierarchy TVF generation requires a single-column primary key.`);
+        }
+        const primaryKey = entity.FirstPrimaryKey.Name;
+        const primaryKeyType = this.mapSQLType(entity.FirstPrimaryKey.SQLFullType);
+        const fieldName = field.Name;
+        const fnName = this.getDescendantsFunctionName(entity, field);
+        return `
+------------------------------------------------------------
+----- DESCENDANTS FUNCTION FOR: ${entity.BaseTable}.${fieldName}
+------------------------------------------------------------
+CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(
+    p_root_id ${primaryKeyType},
+    p_max_depth INTEGER DEFAULT NULL
+) RETURNS TABLE (
+    "ID" ${primaryKeyType},
+    "Depth" INTEGER,
+    "Path" TEXT,
+    "IsLeaf" BOOLEAN,
+    "ChildCount" INTEGER
+) AS $$
+    WITH RECURSIVE cte_descendants AS (
+        SELECT
+            ${pgDialect.QuoteIdentifier(primaryKey)},
+            ${pgDialect.QuoteIdentifier(fieldName)},
+            0 AS relative_depth,
+            '/' || ${pgDialect.QuoteIdentifier(primaryKey)}::TEXT || '/' AS path
+        FROM
+            ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)}
+        WHERE
+            ${pgDialect.QuoteIdentifier(primaryKey)} = p_root_id
+
+        UNION ALL
+
+        SELECT
+            c.${pgDialect.QuoteIdentifier(primaryKey)},
+            c.${pgDialect.QuoteIdentifier(fieldName)},
+            p.relative_depth + 1 AS relative_depth,
+            p.path || c.${pgDialect.QuoteIdentifier(primaryKey)}::TEXT || '/' AS path
+        FROM
+            ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} c
+        INNER JOIN
+            cte_descendants p ON c.${pgDialect.QuoteIdentifier(fieldName)} = p.${pgDialect.QuoteIdentifier(primaryKey)}
+        WHERE
+            (p_max_depth IS NULL OR p.relative_depth < p_max_depth)
+            AND p.relative_depth < 100
+    )
+    SELECT
+        d.${pgDialect.QuoteIdentifier(primaryKey)} AS "ID",
+        d.relative_depth AS "Depth",
+        d.path AS "Path",
+        (NOT EXISTS (SELECT 1 FROM ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} WHERE ${pgDialect.QuoteIdentifier(fieldName)} = d.${pgDialect.QuoteIdentifier(primaryKey)}))::BOOLEAN AS "IsLeaf",
+        (SELECT COUNT(1)::INTEGER FROM ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} WHERE ${pgDialect.QuoteIdentifier(fieldName)} = d.${pgDialect.QuoteIdentifier(primaryKey)}) AS "ChildCount"
+    FROM
+        cte_descendants d;
+$$ LANGUAGE sql STABLE;
+`;
+    }
+    /**
+     * Generates a PostgreSQL table-valued function returning all ancestors of a node walking upward.
+     */
+    generateAncestorsFunction(entity, field) {
+        if (entity.PrimaryKeys.length !== 1) {
+            throw new Error(`[Hierarchy] Entity '${entity.Name}' has ${entity.PrimaryKeys.length} primary key fields. MemberJunction hierarchy TVF generation requires a single-column primary key.`);
+        }
+        const primaryKey = entity.FirstPrimaryKey.Name;
+        const primaryKeyType = this.mapSQLType(entity.FirstPrimaryKey.SQLFullType);
+        const fieldName = field.Name;
+        const fnName = this.getAncestorsFunctionName(entity, field);
+        return `
+------------------------------------------------------------
+----- ANCESTORS FUNCTION FOR: ${entity.BaseTable}.${fieldName}
+------------------------------------------------------------
+CREATE OR REPLACE FUNCTION ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(
+    p_record_id ${primaryKeyType}
+) RETURNS TABLE (
+    "ID" ${primaryKeyType},
+    "LevelUp" INTEGER,
+    "Path" TEXT
+) AS $$
+    WITH RECURSIVE cte_ancestors AS (
+        SELECT
+            ${pgDialect.QuoteIdentifier(primaryKey)},
+            ${pgDialect.QuoteIdentifier(fieldName)},
+            0 AS level_up,
+            '/' || ${pgDialect.QuoteIdentifier(primaryKey)}::TEXT || '/' AS path
+        FROM
+            ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)}
+        WHERE
+            ${pgDialect.QuoteIdentifier(primaryKey)} = p_record_id
+
+        UNION ALL
+
+        SELECT
+            p.${pgDialect.QuoteIdentifier(primaryKey)},
+            p.${pgDialect.QuoteIdentifier(fieldName)},
+            c.level_up + 1 AS level_up,
+            '/' || p.${pgDialect.QuoteIdentifier(primaryKey)}::TEXT || c.path AS path
+        FROM
+            ${pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable)} p
+        INNER JOIN
+            cte_ancestors c ON p.${pgDialect.QuoteIdentifier(primaryKey)} = c.${pgDialect.QuoteIdentifier(fieldName)}
+        WHERE
+            c.level_up < 100
+    )
+    SELECT
+        a.${pgDialect.QuoteIdentifier(primaryKey)} AS "ID",
+        a.level_up AS "LevelUp",
+        a.path AS "Path"
+    FROM
+        cte_ancestors a;
+$$ LANGUAGE sql STABLE;
+`;
+    }
+    getHierarchyMetaFunctionName(entity, field) {
+        return `fn_${this.toSnakeCase(entity.BaseTable)}_${this.toSnakeCase(field.Name)}_get_hierarchy_meta`;
+    }
+    getDescendantsFunctionName(entity, field) {
+        return `fn_${this.toSnakeCase(entity.BaseTable)}_${this.toSnakeCase(field.Name)}_get_descendants`;
+    }
+    getAncestorsFunctionName(entity, field) {
+        return `fn_${this.toSnakeCase(entity.BaseTable)}_${this.toSnakeCase(field.Name)}_get_ancestors`;
+    }
+    /** @inheritdoc */
+    generateHierarchyFieldSelect(_entity, field, alias) {
+        const rootFieldName = `Root${field.Name}`;
+        const depthFieldName = `${field.Name}Depth`;
+        const pathFieldName = `${field.Name}Path`;
+        const isLeafFieldName = `${field.Name}IsLeaf`;
+        const childCountFieldName = `${field.Name}ChildCount`;
+        return `${alias}."RootID" AS ${pgDialect.QuoteIdentifier(rootFieldName)},
+    ${alias}."Depth" AS ${pgDialect.QuoteIdentifier(depthFieldName)},
+    ${alias}."Path" AS ${pgDialect.QuoteIdentifier(pathFieldName)},
+    ${alias}."IsLeaf" AS ${pgDialect.QuoteIdentifier(isLeafFieldName)},
+    ${alias}."ChildCount" AS ${pgDialect.QuoteIdentifier(childCountFieldName)}`;
+    }
+    /**
+     * Generates a `LEFT JOIN LATERAL` clause that invokes the hierarchy metadata function
+     * for a self-referencing field.
+     */
+    generateHierarchyFieldJoin(entity, field, alias) {
+        const fnName = this.getHierarchyMetaFunctionName(entity, field);
+        const tableAlias = entity.BaseTableCodeName.charAt(0).toLowerCase();
+        return `LEFT JOIN LATERAL ${pgDialect.QuoteSchema(entity.SchemaName, fnName)}(${tableAlias}.${pgDialect.QuoteIdentifier(entity.FirstPrimaryKey.Name)}, ${tableAlias}.${pgDialect.QuoteIdentifier(field.Name)}) AS ${alias} ON true`;
+    }
+    /**
+     * Generates a PostgreSQL function that recursively calculates the root record ID for a
+     * self-referencing foreign key.
+     */
     generateRootIDFunction(entity, field) {
+        if (entity.PrimaryKeys.length !== 1) {
+            throw new Error(`[Hierarchy] Entity '${entity.Name}' has ${entity.PrimaryKeys.length} primary key fields. MemberJunction hierarchy TVF generation requires a single-column primary key.`);
+        }
         const primaryKey = entity.FirstPrimaryKey.Name;
         const primaryKeyType = this.mapSQLType(entity.FirstPrimaryKey.SQLFullType);
         const fieldName = field.Name;
@@ -1451,18 +1749,10 @@ ORDER BY ordinal_position`;
         return ['information_schema', 'pg_catalog', 'pg_toast', 'pg_temp_1', 'pg_toast_temp_1'];
     }
     /**
-     * PostgreSQL has no view-refresh mechanism, so this always returns `false`.
-     *
-     * NOT because PG views track their source automatically — they do not. PG expands `SELECT *`
-     * into an explicit column list at creation and freezes it; a view gains a new underlying column
-     * only when the view itself is recreated. CodeGen gets away without a refresh step because it
-     * emits every generated view with an explicit column list and re-issues `CREATE OR REPLACE` on
-     * every run, so the definition it controls is always current.
-     *
-     * That holds only for views CodeGen writes. A view CodeGen does not own — such as the
-     * application-owned outer view of a layered entity — has no mechanism here to re-resolve it, and
-     * `generateViewRefreshSQL` returning empty is a genuine no-op rather than a cheap one. This is
-     * why {@link generateBaseView} refuses layered entities outright on PostgreSQL.
+     * PostgreSQL has no `sp_refreshview`. Generated views are re-issued with
+     * `CREATE OR REPLACE` (or the 42P16 capture/DROP CASCADE path) every run, so
+     * they do not need a separate refresh step. Layered *outer* views are rebound
+     * via {@link generateLayeredOuterRebindSQL}, not this flag.
      */
     get NeedsViewRefresh() {
         return false;
@@ -1471,12 +1761,77 @@ ORDER BY ordinal_position`;
     generateViewRefreshSQL(_schema, _viewName) {
         return '';
     }
+    /**
+     * Restar `g.*` on the application-owned outer view. Invokes the catalog
+     * function shipped by the PG layered-views migration; no-op if the function
+     * is not installed yet (bootstrap before that migration).
+     */
+    generateLayeredOuterRebindSQL(entity) {
+        if (!entity.HasLayeredBaseView) {
+            return '';
+        }
+        let core = '__mj';
+        try {
+            core = (mj_core_schema() || '__mj').replace(/"/g, '""');
+        }
+        catch {
+            core = '__mj';
+        }
+        const schema = entity.SchemaName.replace(/'/g, "''");
+        const outer = entity.BaseView.replace(/'/g, "''");
+        const inner = entity.GeneratedViewName.replace(/'/g, "''");
+        return `SELECT "${core}"."spRebindLayeredOuterView"('${schema}', '${outer}', '${inner}');`;
+    }
+    /**
+     * After the inner generated view is current, restar the application-owned
+     * outer wrapper so `g.*` re-expands. No-op when the entity is not layered
+     * or the outer view does not exist yet (bootstrap pass).
+     */
+    async rebindLayeredOuterIfPresent(client, entity, willRegenerate) {
+        if (!entity.HasLayeredBaseView) {
+            return;
+        }
+        const schemaLit = entity.SchemaName.replace(/'/g, "''").replace(/"/g, '""');
+        const outerLit = entity.BaseView.replace(/'/g, "''").replace(/"/g, '""');
+        const innerLit = entity.GeneratedViewName.replace(/'/g, "''").replace(/"/g, '""');
+        const existsResult = await client.query(`SELECT to_regclass('"${schemaLit}"."${outerLit}"') IS NOT NULL AS present`);
+        if (!existsResult.rows?.[0]?.['present']) {
+            return;
+        }
+        const defResult = await client.query(this.getViewDefinitionSQL(entity.SchemaName, entity.BaseView));
+        const viewDefinition = String(defResult.rows?.[0]?.['ViewDefinition'] ?? defResult.rows?.[0]?.['viewdefinition'] ?? '');
+        if (!viewDefinition) {
+            throw new LayeredOuterRestarError(`Could not read pg_get_viewdef for layered outer view ${entity.SchemaName}.${entity.BaseView}`);
+        }
+        const colResult = await client.query(`SELECT a.attname AS "Name"
+             FROM pg_attribute a
+             JOIN pg_class c ON c.oid = a.attrelid
+             JOIN pg_namespace n ON n.oid = c.relnamespace
+             WHERE n.nspname = '${schemaLit}'
+               AND c.relname = '${innerLit}'
+               AND a.attnum > 0
+               AND NOT a.attisdropped
+             ORDER BY a.attnum`);
+        const innerColumns = (colResult.rows ?? []).map((r) => String(r['Name'] ?? r['name'] ?? ''));
+        const restarred = restarLayeredOuterView({
+            viewDefinition,
+            innerViewName: entity.GeneratedViewName,
+            innerColumns,
+        });
+        const createSQL = buildCreateOrReplaceLayeredOuterViewSQL(entity.SchemaName, entity.BaseView, restarred);
+        await executeWithFallback({
+            client,
+            schema: entity.SchemaName,
+            viewName: entity.BaseView,
+            createOrReplaceSQL: createSQL,
+            willRegenerate,
+        });
+    }
     /** @inheritdoc */
     generateIfViewExistsSQL(schema, viewName, innerSQL) {
-        // Reached only if a future change enables layering on PG; today generateBaseView throws
-        // first. Implemented properly regardless, so the guard is not a lie if that day comes.
+        // The outer view of a layered entity does not exist on the bootstrap pass.
         const escaped = innerSQL.replace(/'/g, "''");
-        const regclass = `${schema}.${viewName}`.replace(/'/g, "''");
+        const regclass = `"${schema.replace(/"/g, '""')}"."${viewName.replace(/"/g, '""')}"`.replace(/'/g, "''");
         return `DO $if_view_exists$
 BEGIN
   IF to_regclass('${regclass}') IS NOT NULL THEN
@@ -1499,107 +1854,18 @@ $if_view_exists$;
         return true;
     }
     // ─── METADATA MANAGEMENT: SQL QUOTING ────────────────────────────
-    /**
-     * SQL keywords that should NOT be quoted even when they match PascalCase patterns.
-     */
-    static { this._SQL_KEYWORDS = new Set([
-        // DML/DDL keywords
-        'SELECT', 'INSERT', 'INTO', 'UPDATE', 'DELETE', 'FROM', 'WHERE', 'AND', 'OR', 'NOT',
-        'JOIN', 'LEFT', 'RIGHT', 'INNER', 'OUTER', 'CROSS', 'FULL', 'ON', 'AS', 'SET',
-        'VALUES', 'NULL', 'LIKE', 'IN', 'EXISTS', 'BETWEEN', 'CASE', 'WHEN', 'THEN',
-        'ELSE', 'END', 'ORDER', 'BY', 'GROUP', 'HAVING', 'LIMIT', 'OFFSET', 'UNION',
-        'ALL', 'CREATE', 'ALTER', 'DROP', 'TABLE', 'INDEX', 'VIEW', 'EXEC', 'DECLARE',
-        'BEGIN', 'COMMIT', 'ROLLBACK', 'TRANSACTION', 'TRUE', 'FALSE', 'IS', 'ASC', 'DESC',
-        'DISTINCT', 'PRIMARY', 'KEY', 'FOREIGN', 'REFERENCES', 'CONSTRAINT', 'DEFAULT',
-        'IF', 'OBJECT', 'TOP', 'WITH', 'OVER', 'PARTITION', 'ROW_NUMBER', 'RANK',
-        'DENSE_RANK', 'LAG', 'LEAD', 'FIRST_VALUE', 'LAST_VALUE', 'ROWS', 'RANGE',
-        'PRECEDING', 'FOLLOWING', 'UNBOUNDED', 'CURRENT', 'ROW', 'FETCH', 'NEXT', 'ONLY',
-        'SCHEMA', 'CASCADE', 'RESTRICT', 'NO', 'ACTION', 'TRIGGER', 'FUNCTION', 'PROCEDURE',
-        'RETURNS', 'RETURN', 'EXECUTE', 'CALL', 'RAISE', 'NOTICE', 'EXCEPTION', 'PERFORM',
-        'GRANT', 'REVOKE', 'TO', 'USAGE', 'PRIVILEGES', 'OWNER',
-        // DDL sub-keywords
-        'ADD', 'COLUMN', 'DO', 'RENAME', 'COMMENT', 'UNIQUE', 'CHECK',
-        'CONFLICT', 'NOTHING', 'EXCLUDED', 'ZONE', 'AT', 'FOR', 'EACH', 'OF',
-        'BEFORE', 'AFTER', 'INSTEAD', 'USING', 'ANY', 'SOME',
-        'ENABLE', 'DISABLE', 'GENERATED', 'ALWAYS', 'IDENTITY',
-        'SECURITY', 'DEFINER', 'INVOKER', 'FORCE', 'COPY',
-        'TEMPORARY', 'TEMP', 'RECURSIVE', 'MATERIALIZED', 'CONCURRENTLY',
-        // 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',
-        'BIT', 'INT', 'TEXT', 'NTEXT', 'IMAGE', 'BINARY', 'VARBINARY', 'CHAR', 'NCHAR',
-        'XML', 'GEOGRAPHY', 'GEOMETRY', 'HIERARCHYID', 'SQL_VARIANT', 'SYSNAME',
-        'NEWSEQUENTIALID', 'NEWID', 'GETUTCDATE', 'GETDATE', 'SYSDATETIMEOFFSET',
-        'OBJECT_ID', 'SCOPE_IDENTITY',
-        // Aggregate / scalar functions
-        'COUNT', 'MAX', 'MIN', 'SUM', 'AVG', 'COALESCE', 'CAST', 'CONVERT', 'ISNULL',
-        '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
-        'BOOLEAN', 'SERIAL', 'BIGSERIAL', 'UUID', 'JSONB', 'JSON', 'ARRAY', 'TIMESTAMPTZ',
-        'TIMESTAMP', 'DATE', 'TIME', 'INTERVAL', 'CITEXT', 'INET', 'MACADDR',
-        'GEN_RANDOM_UUID', 'TO_CHAR', 'TO_DATE', 'TO_TIMESTAMP', 'TO_NUMBER',
-        'STRING_AGG', 'ARRAY_AGG', 'UNNEST', 'LATERAL', 'ILIKE',
-        'LANGUAGE', 'PLPGSQL', 'VOLATILE', 'STABLE', 'IMMUTABLE', 'SETOF', 'RECORD',
-        'INOUT', 'OUT', 'VARIADIC', 'PARALLEL', 'SAFE', 'UNSAFE',
-        // information_schema column names
-        'TABLE_SCHEMA', 'TABLE_NAME', 'TABLE_CATALOG', 'COLUMN_NAME', 'DATA_TYPE',
-        'IS_NULLABLE', 'COLUMN_DEFAULT', 'CHARACTER_MAXIMUM_LENGTH', 'NUMERIC_PRECISION',
-        'NUMERIC_SCALE', 'ORDINAL_POSITION', 'COLUMN_COMMENT',
-        // MJ SQL constructs
-        'INFORMATION_SCHEMA', 'COLUMNS', 'TABLES', 'ROUTINES',
-    ]); }
     /**
      * Quotes mixed-case identifiers in a SQL string for PostgreSQL compatibility.
-     * Uses a tokenizer approach to skip string literals, already-quoted identifiers,
-     * dollar-quoted blocks, and SQL keywords. Any remaining PascalCase word gets
-     * double-quoted to preserve case.
+     *
+     * The tokenizer lives in `@memberjunction/sql-dialect` and is shared with
+     * `PostgreSQLDataProvider.autoQuoteIdentifiers`, so codegen-time and runtime SQL are
+     * quoted by one implementation rather than two hand-synced copies. See
+     * {@link AutoQuotePostgreSQLIdentifiers} for the quoting rule and its rationale.
+     *
+     * @inheritdoc
      */
     quoteSQLForExecution(sql) {
-        const result = [];
-        let i = 0;
-        const len = sql.length;
-        while (i < len) {
-            const ch = sql[i];
-            if (ch === "'") {
-                i = this.skipSingleQuotedString(sql, i, len, result);
-                continue;
-            }
-            if (ch === '$') {
-                i = this.skipDollarQuotedBlock(sql, i, len, result);
-                continue;
-            }
-            if (ch === '"') {
-                i = this.skipDoubleQuotedIdentifier(sql, i, len, result);
-                continue;
-            }
-            if (ch === '[') {
-                i = this.skipBracketedIdentifier(sql, i, len, result);
-                continue;
-            }
-            if (ch === '@') {
-                i = this.skipAtParameter(sql, i, len, result);
-                continue;
-            }
-            if (/[a-zA-Z_]/.test(ch)) {
-                i = this.processWord(sql, i, len, result);
-                continue;
-            }
-            result.push(ch);
-            i++;
-        }
-        return result.join('');
+        return AutoQuotePostgreSQLIdentifiers(sql);
     }
     // ─── METADATA MANAGEMENT: DEFAULT VALUE PARSING ──────────────────
     /**
@@ -1757,6 +2023,18 @@ WHERE p.prokind IN ('f', 'p')
             // 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 metaSQL = this.generateHierarchyMetaFunction(entity, field);
+                if (metaSQL && metaSQL.trim().length > 0) {
+                    await client.query(metaSQL);
+                }
+                const descSQL = this.generateDescendantsFunction(entity, field);
+                if (descSQL && descSQL.trim().length > 0) {
+                    await client.query(descSQL);
+                }
+                const ancSQL = this.generateAncestorsFunction(entity, field);
+                if (ancSQL && ancSQL.trim().length > 0) {
+                    await client.query(ancSQL);
+                }
                 const fnSQL = this.generateRootIDFunction(entity, field);
                 if (fnSQL && fnSQL.trim().length > 0) {
                     await client.query(fnSQL);
@@ -1765,7 +2043,7 @@ WHERE p.prokind IN ('f', 'p')
             await executeWithFallback({
                 client,
                 schema: entity.SchemaName,
-                viewName: entity.BaseView,
+                viewName: entity.GeneratedViewName,
                 createOrReplaceSQL: viewSQL,
                 willRegenerate,
                 // Pass the base table so viewFallback can materialize a stub
@@ -1776,6 +2054,7 @@ WHERE p.prokind IN ('f', 'p')
                 // self-reference until a placeholder exists).
                 baseTableQualified: pgDialect.QuoteSchema(entity.SchemaName, entity.BaseTable),
             });
+            await this.rebindLayeredOuterIfPresent(client, entity, willRegenerate);
         }
         finally {
             client.release();
@@ -1822,11 +2101,12 @@ WHERE p.prokind IN ('f', 'p')
                     await executeWithFallback({
                         client,
                         schema: opts.entity.SchemaName,
-                        viewName: opts.entity.BaseView,
+                        viewName: opts.entity.GeneratedViewName,
                         createOrReplaceSQL: opts.viewSQL,
                         willRegenerate: opts.willRegenerate,
                         baseTableQualified: pgDialect.QuoteSchema(opts.entity.SchemaName, opts.entity.BaseTable),
                     });
+                    await this.rebindLayeredOuterIfPresent(client, opts.entity, opts.willRegenerate);
                 }
                 catch (e) {
                     return {
@@ -1947,38 +2227,6 @@ WHERE p.prokind IN ('f', 'p')
     getBaseViewName(entity) {
         return entity.BaseView || `vw_${this.toSnakeCase(entity.CodeName)}`;
     }
-    /**
-     * Refuses layered base views on PostgreSQL, where the arrangement cannot deliver what it
-     * promises.
-     *
-     * Layering exists so an application can add a computed column without inheriting — and then
-     * hand-maintaining — the generated view, the payoff being that a foreign key added later still
-     * shows up on its own. That payoff depends entirely on the application-owned outer view's
-     * `SELECT g.*` being re-resolved after the inner view regenerates. SQL Server does that with
-     * `sp_refreshview`. PostgreSQL expands `*` at creation and freezes it, offers no refresh
-     * equivalent, and CodeGen does not own the outer view, so nothing recreates it.
-     *
-     * The resulting behaviour is worse than plainly broken, it is intermittent: an ADDED column (the
-     * common case) leaves the outer view stale, because `CREATE OR REPLACE` on the inner view
-     * succeeds and never touches dependents. A column RENAME or type change raises 42P16, which
-     * sends CodeGen down the capture/`DROP CASCADE`/replay path — and that incidentally recreates
-     * the outer view, so it picks the new columns up. Same feature, opposite outcomes, decided by
-     * which kind of schema change happened to land that day.
-     *
-     * That is precisely the silent-staleness failure layering was built to eliminate, so this throws
-     * rather than documenting a footgun. Fully custom base views (`BaseViewGenerated = 0` with no
-     * `GeneratedBaseViewName`) are unaffected and keep working on PostgreSQL as before.
-     */
-    assertLayeredBaseViewSupported(entity) {
-        if (!entity.HasLayeredBaseView)
-            return;
-        throw new Error(`Entity "${entity.Name}" sets GeneratedBaseViewName = '${entity.GeneratedBaseViewName}', but layered ` +
-            `base views are not supported on PostgreSQL. PostgreSQL freezes a view's column list at creation and ` +
-            `has no sp_refreshview equivalent, so the application-owned view "${entity.BaseView}" would silently ` +
-            `stop gaining columns that the generated view underneath it picks up. Clear GeneratedBaseViewName and ` +
-            `use a fully custom base view (BaseViewGenerated = 0) instead, accepting that it must be ` +
-            `hand-maintained as the schema changes.`);
-    }
     /** Builds the WHERE clause for soft-delete filtering */
     buildSoftDeleteWhereClause(entity, alias) {
         if (entity.DeleteType === 'Soft') {
@@ -2232,102 +2480,6 @@ WHERE p.prokind IN ('f', 'p')
       AND tablename = '${tableName}'
       AND indexname = '${indexName}'`;
     }
-    // ─── TOKENIZER HELPERS (for quoteSQLForExecution) ────────────────
-    /** Skips a single-quoted string literal, handling escaped quotes ('') */
-    skipSingleQuotedString(sql, start, len, result) {
-        let j = start + 1;
-        while (j < len) {
-            if (sql[j] === "'" && j + 1 < len && sql[j + 1] === "'") {
-                j += 2;
-            }
-            else if (sql[j] === "'") {
-                j++;
-                break;
-            }
-            else {
-                j++;
-            }
-        }
-        result.push(sql.substring(start, j));
-        return j;
-    }
-    /** Skips a dollar-quoted block ($$ ... $$ or $tag$ ... $tag$) */
-    skipDollarQuotedBlock(sql, start, len, result) {
-        let tagEnd = start + 1;
-        if (tagEnd < len && sql[tagEnd] === '$') {
-            // Simple $$ tag
-            tagEnd = start + 2;
-        }
-        else {
-            // Look for $identifier$ pattern
-            while (tagEnd < len && /[a-zA-Z0-9_]/.test(sql[tagEnd]))
-                tagEnd++;
-            if (tagEnd < len && sql[tagEnd] === '$') {
-                tagEnd++;
-            }
-            else {
-                // Not a dollar-quote, just a $ character
-                result.push(sql[start]);
-                return start + 1;
-            }
-        }
-        const tag = sql.substring(start, tagEnd);
-        const closePos = sql.indexOf(tag, tagEnd);
-        if (closePos !== -1) {
-            const blockEnd = closePos + tag.length;
-            result.push(sql.substring(start, blockEnd));
-            return blockEnd;
-        }
-        // No closing tag found, pass through rest of string
-        result.push(sql.substring(start));
-        return len;
-    }
-    /** Skips an already double-quoted identifier */
-    skipDoubleQuotedIdentifier(sql, start, len, result) {
-        let j = start + 1;
-        while (j < len && sql[j] !== '"')
-            j++;
-        if (j < len)
-            j++;
-        result.push(sql.substring(start, j));
-        return j;
-    }
-    /** Skips a square-bracketed identifier (SQL Server style) */
-    skipBracketedIdentifier(sql, start, len, result) {
-        let j = start + 1;
-        while (j < len && sql[j] !== ']')
-            j++;
-        if (j < len)
-            j++;
-        result.push(sql.substring(start, j));
-        return j;
-    }
-    /** Skips an @-prefixed parameter */
-    skipAtParameter(sql, start, len, result) {
-        let j = start + 1;
-        while (j < len && /[a-zA-Z0-9_]/.test(sql[j]))
-            j++;
-        result.push(sql.substring(start, j));
-        return j;
-    }
-    /** Processes a word token - quotes it if it's a PascalCase identifier, not a keyword */
-    processWord(sql, start, len, result) {
-        let j = start + 1;
-        while (j < len && /[a-zA-Z0-9_]/.test(sql[j]))
-            j++;
-        const word = sql.substring(start, j);
-        const isKeyword = PostgreSQLCodeGenProvider_1._SQL_KEYWORDS.has(word.toUpperCase());
-        const startsUpper = /^[A-Z]/.test(word);
-        const isAllLower = word === word.toLowerCase();
-        const isMJInternal = word.startsWith('__mj_');
-        if (!isKeyword && !isAllLower && !isMJInternal && startsUpper) {
-            result.push(pgDialect.QuoteIdentifier(word));
-        }
-        else {
-            result.push(word);
-        }
-        return j;
-    }
     // ─── COMPLEX SQL GENERATION HELPERS ──────────────────────────────
     /**
      * Builds the full pending entity fields query for PostgreSQL.
@@ -2461,7 +2613,7 @@ WHERE vf."IsVirtual" = true
 `;
     }
 };
-PostgreSQLCodeGenProvider = PostgreSQLCodeGenProvider_1 = __decorate([
+PostgreSQLCodeGenProvider = __decorate([
     RegisterClass(CodeGenDatabaseProvider, 'postgresql')
 ], PostgreSQLCodeGenProvider);
 export { PostgreSQLCodeGenProvider };