@memberjunction/codegen-lib 3.4.0 → 4.1.0

package/dist/Database/manage-metadata.js

@@ -1,102 +1,76 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManageMetadataBase = exports.ValidatorResult = void 0;
-const sql = __importStar(require("mssql"));
-const config_1 = require("../Config/config");
-const core_1 = require("@memberjunction/core");
-const status_logging_1 = require("../Misc/status_logging");
-const sql_1 = require("./sql");
-const advanced_generation_1 = require("../Misc/advanced_generation");
-const global_1 = require("@memberjunction/global");
-const uuid_1 = require("uuid");
-const fs = __importStar(require("fs"));
-const path_1 = __importDefault(require("path"));
-const sql_logging_1 = require("../Misc/sql_logging");
-class ValidatorResult {
-    entityName = "";
-    fieldName;
-    sourceCheckConstraint = "";
-    functionText = "";
-    functionName = "";
-    functionDescription = "";
-    /**
-     * The ID value in the Generated Codes entity that was created for this validator.
-     */
-    generatedCodeId = "";
-    /**
-     * The ID for the AI Model that was used to generate the code
-     */
-    aiModelID = "";
-    wasGenerated = true;
-    success = false;
+import sql from 'mssql';
+import { configInfo, currentWorkingDirectory, getSettingValue, mj_core_schema, outputDir } from '../Config/config.js';
+import { CodeNameFromString, EntityInfo, ExtractActualDefaultValue, LogError, LogStatus, Metadata, SeverityType } from "@memberjunction/core";
+import { logError, logMessage, logStatus } from "../Misc/status_logging.js";
+import { SQLUtilityBase } from "./sql.js";
+import { AdvancedGeneration } from "../Misc/advanced_generation.js";
+import { SQLParser } from "@memberjunction/core-entities-server";
+import { convertCamelCaseToHaveSpaces, generatePluralName, MJGlobal, stripTrailingChars } from "@memberjunction/global";
+import { v4 as uuidv4 } from 'uuid';
+import * as fs from 'fs';
+import path from 'path';
+import { SQLLogging } from "../Misc/sql_logging.js";
+export class ValidatorResult {
+    constructor() {
+        this.entityName = "";
+        this.sourceCheckConstraint = "";
+        this.functionText = "";
+        this.functionName = "";
+        this.functionDescription = "";
+        /**
+         * The ID value in the Generated Codes entity that was created for this validator.
+         */
+        this.generatedCodeId = "";
+        /**
+         * The ID for the AI Model that was used to generate the code
+         */
+        this.aiModelID = "";
+        this.wasGenerated = true;
+        this.success = false;
+    }
 }
-exports.ValidatorResult = ValidatorResult;
 /**
  * Base class for managing metadata within the CodeGen system. This class can be sub-classed to extend/override base class functionality. Make sure to use the RegisterClass decorator from the @memberjunction/global package
  * to properly register your subclass with a priority of 1+ to ensure it gets instantiated.
  */
-class ManageMetadataBase {
-    _sqlUtilityObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(sql_1.SQLUtilityBase);
+export class ManageMetadataBase {
+    constructor() {
+        this._sqlUtilityObject = MJGlobal.Instance.ClassFactory.CreateInstance(SQLUtilityBase);
+    }
     get SQLUtilityObject() {
         return this._sqlUtilityObject;
     }
-    static _newEntityList = [];
+    static { this._newEntityList = []; }
     /**
      * Globally scoped list of entities that have been created during the metadata management process.
      */
     static get newEntityList() {
         return this._newEntityList;
     }
-    static _modifiedEntityList = [];
+    static { this._modifiedEntityList = []; }
     /**
      * Globally scoped list of entities that have been modified during the metadata management process.
      */
     static get modifiedEntityList() {
         return this._modifiedEntityList;
     }
-    static _generatedValidators = [];
+    static { this._generatedValidators = []; }
     /**
      * Globally scoped list of validators that have been generated during the metadata management process.
      */
     static get generatedValidators() {
         return this._generatedValidators;
     }
-    static _softPKFKConfigCache = null;
-    static _softPKFKConfigPath = '';
+    static { this._softPKFKConfigCache = null; }
+    static { this._softPKFKConfigPath = ''; }
     /**
      * Loads and caches the soft PK/FK configuration from the additionalSchemaInfo file.
      * The file is only loaded once per session to avoid repeated I/O.
      */
     static getSoftPKFKConfig() {
         // Return cached config if path hasn't changed
-        const configPath = config_1.configInfo.additionalSchemaInfo
-            ? path_1.default.join(config_1.currentWorkingDirectory, config_1.configInfo.additionalSchemaInfo)
+        const configPath = configInfo.additionalSchemaInfo
+            ? path.join(currentWorkingDirectory, configInfo.additionalSchemaInfo)
             : '';
         if (this._softPKFKConfigCache !== null && this._softPKFKConfigPath === configPath) {
             return this._softPKFKConfigCache;
@@ -119,79 +93,330 @@ class ManageMetadataBase {
             return null;
         }
     }
+    /**
+     * Extracts a flat array of table configs from the config file, handling both formats:
+     *   1. Schema-as-key (template format): { "dbo": [{ "TableName": "Orders", ... }] }
+     *   2. Flat tables array (legacy format): { "Tables": [{ "SchemaName": "dbo", "TableName": "Orders", ... }] }
+     * Returns a normalized array where each entry has SchemaName, TableName, PrimaryKey[], and ForeignKeys[].
+     */
+    extractTablesFromConfig(config) {
+        const results = [];
+        // Check for flat "Tables" array format first
+        if (Array.isArray(config.Tables)) {
+            for (const table of config.Tables) {
+                const t = table;
+                results.push({
+                    SchemaName: t.SchemaName || 'dbo',
+                    TableName: t.TableName,
+                    PrimaryKey: t.PrimaryKey || [],
+                    ForeignKeys: t.ForeignKeys || [],
+                });
+            }
+            return results;
+        }
+        // Schema-as-key format: iterate over keys, skip metadata and special section keys
+        const metadataKeys = new Set(['$schema', 'description', 'version', 'VirtualEntities', 'ISARelationships', 'Tables']);
+        for (const key of Object.keys(config)) {
+            if (metadataKeys.has(key))
+                continue;
+            const schemaName = key;
+            const tables = config[key];
+            if (!Array.isArray(tables))
+                continue;
+            for (const table of tables) {
+                const t = table;
+                results.push({
+                    SchemaName: schemaName,
+                    TableName: t.TableName,
+                    PrimaryKey: t.PrimaryKey || [],
+                    ForeignKeys: t.ForeignKeys || [],
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Extracts VirtualEntities array from the additionalSchemaInfo config file.
+     * The config may contain a top-level "VirtualEntities" key with an array of
+     * virtual entity definitions.
+     */
+    extractVirtualEntitiesFromConfig(config) {
+        const virtualEntities = config.VirtualEntities;
+        if (!Array.isArray(virtualEntities))
+            return [];
+        return virtualEntities.map((ve) => ({
+            ViewName: ve.ViewName,
+            SchemaName: ve.SchemaName || undefined,
+            EntityName: ve.EntityName || undefined,
+            Description: ve.Description || undefined,
+            PrimaryKey: Array.isArray(ve.PrimaryKey) ? ve.PrimaryKey : undefined,
+            ForeignKeys: Array.isArray(ve.ForeignKeys) ? ve.ForeignKeys : undefined,
+        }));
+    }
+    /**
+     * Extracts ISARelationships array from the additionalSchemaInfo config file.
+     * The config may contain a top-level "ISARelationships" key with an array of
+     * parent-child relationship definitions.
+     */
+    extractISARelationshipsFromConfig(config) {
+        const relationships = config.ISARelationships;
+        if (!Array.isArray(relationships))
+            return [];
+        return relationships.map((rel) => ({
+            ChildEntity: rel.ChildEntity,
+            ParentEntity: rel.ParentEntity,
+            SchemaName: rel.SchemaName || undefined,
+        }));
+    }
+    /**
+     * Processes IS-A relationship configurations from the additionalSchemaInfo config.
+     * For each configured relationship, looks up both entities by name (or by table name
+     * within the given schema) and sets Entity.ParentID on the child entity.
+     * Must run AFTER entities are created but BEFORE manageParentEntityFields().
+     */
+    async processISARelationshipConfig(pool) {
+        const config = ManageMetadataBase.getSoftPKFKConfig();
+        if (!config)
+            return { success: true, updatedCount: 0 };
+        const relationships = this.extractISARelationshipsFromConfig(config);
+        if (relationships.length === 0)
+            return { success: true, updatedCount: 0 };
+        let updatedCount = 0;
+        const schema = mj_core_schema();
+        for (const rel of relationships) {
+            try {
+                // Look up the parent entity — try by Name first, then by BaseTable within the given schema
+                const parentResult = await pool.request()
+                    .input('ParentName', rel.ParentEntity)
+                    .input('SchemaName', rel.SchemaName || null)
+                    .query(`
+                  SELECT TOP 1 ID, Name
+                  FROM [${schema}].vwEntities
+                  WHERE Name = @ParentName
+                     OR (BaseTable = @ParentName AND (@SchemaName IS NULL OR SchemaName = @SchemaName))
+                  ORDER BY CASE WHEN Name = @ParentName THEN 0 ELSE 1 END
+               `);
+                if (parentResult.recordset.length === 0) {
+                    logError(`    > IS-A config: parent entity "${rel.ParentEntity}" not found — skipping`);
+                    continue;
+                }
+                const parentId = parentResult.recordset[0].ID;
+                const parentName = parentResult.recordset[0].Name;
+                // Look up the child entity — same strategy
+                const childResult = await pool.request()
+                    .input('ChildName', rel.ChildEntity)
+                    .input('SchemaName', rel.SchemaName || null)
+                    .query(`
+                  SELECT TOP 1 ID, Name, ParentID
+                  FROM [${schema}].vwEntities
+                  WHERE Name = @ChildName
+                     OR (BaseTable = @ChildName AND (@SchemaName IS NULL OR SchemaName = @SchemaName))
+                  ORDER BY CASE WHEN Name = @ChildName THEN 0 ELSE 1 END
+               `);
+                if (childResult.recordset.length === 0) {
+                    logError(`    > IS-A config: child entity "${rel.ChildEntity}" not found — skipping`);
+                    continue;
+                }
+                const childId = childResult.recordset[0].ID;
+                const childName = childResult.recordset[0].Name;
+                const existingParentId = childResult.recordset[0].ParentID;
+                // Skip if already set correctly
+                if (existingParentId === parentId) {
+                    logStatus(`    > IS-A: "${childName}" already has ParentID set to "${parentName}", skipping`);
+                    continue;
+                }
+                // Set ParentID on the child entity
+                await pool.request()
+                    .input('ParentID', parentId)
+                    .input('ChildID', childId)
+                    .query(`UPDATE [${schema}].Entity SET ParentID = @ParentID WHERE ID = @ChildID`);
+                if (existingParentId) {
+                    logStatus(`    > IS-A: Updated "${childName}" ParentID from previous value to "${parentName}"`);
+                }
+                else {
+                    logStatus(`    > IS-A: Set "${childName}" ParentID to "${parentName}"`);
+                }
+                updatedCount++;
+            }
+            catch (err) {
+                const errMessage = err instanceof Error ? err.message : String(err);
+                logError(`    > IS-A config: Failed to set ParentID for "${rel.ChildEntity}": ${errMessage}`);
+            }
+        }
+        return { success: true, updatedCount };
+    }
+    /**
+     * Processes virtual entity configurations from the additionalSchemaInfo config.
+     * For each configured virtual entity, checks if it already exists and creates
+     * it if not. Uses the spCreateVirtualEntity stored procedure.
+     * Must run BEFORE manageVirtualEntities() so newly created entities get field-synced.
+     */
+    async processVirtualEntityConfig(pool, currentUser) {
+        const config = ManageMetadataBase.getSoftPKFKConfig();
+        if (!config)
+            return { success: true, createdCount: 0 };
+        const virtualEntities = this.extractVirtualEntitiesFromConfig(config);
+        if (virtualEntities.length === 0)
+            return { success: true, createdCount: 0 };
+        let createdCount = 0;
+        const schema = mj_core_schema();
+        for (const ve of virtualEntities) {
+            const viewSchema = ve.SchemaName || schema;
+            const viewName = ve.ViewName;
+            const entityName = ve.EntityName || this.deriveEntityNameFromView(viewName);
+            const pkField = ve.PrimaryKey?.[0] || 'ID';
+            // Check if entity already exists for this view
+            const existsResult = await pool.request()
+                .input('ViewName', viewName)
+                .input('SchemaName', viewSchema)
+                .query(`SELECT ID FROM [${schema}].vwEntities WHERE BaseView = @ViewName AND SchemaName = @SchemaName`);
+            if (existsResult.recordset.length > 0) {
+                logStatus(`    > Virtual entity "${entityName}" already exists for view [${viewSchema}].[${viewName}], skipping creation`);
+                continue;
+            }
+            // Verify the view actually exists in the database
+            const viewExistsResult = await pool.request()
+                .input('ViewName', viewName)
+                .input('SchemaName', viewSchema)
+                .query(`SELECT 1 FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = @ViewName AND TABLE_SCHEMA = @SchemaName`);
+            if (viewExistsResult.recordset.length === 0) {
+                logError(`    > View [${viewSchema}].[${viewName}] does not exist — skipping virtual entity creation for "${entityName}"`);
+                continue;
+            }
+            // Create the virtual entity via the stored procedure
+            try {
+                const createResult = await pool.request()
+                    .input('Name', entityName)
+                    .input('BaseView', viewName)
+                    .input('SchemaName', viewSchema)
+                    .input('PrimaryKeyFieldName', pkField)
+                    .input('Description', ve.Description || null)
+                    .execute(`[${schema}].spCreateVirtualEntity`);
+                const newEntityId = createResult.recordset?.[0]?.['']
+                    || createResult.recordset?.[0]?.ID
+                    || createResult.recordset?.[0]?.Column0;
+                logStatus(`    > Created virtual entity "${entityName}" (ID: ${newEntityId}) for view [${viewSchema}].[${viewName}]`);
+                createdCount++;
+                // Add virtual entity to the application for its schema and set default permissions
+                // (same logic as table-backed entities)
+                if (newEntityId) {
+                    await this.addEntityToApplicationForSchema(pool, newEntityId, entityName, viewSchema, currentUser);
+                    await this.addDefaultPermissionsForEntity(pool, newEntityId, entityName);
+                }
+            }
+            catch (err) {
+                const errMessage = err instanceof Error ? err.message : String(err);
+                logError(`    > Failed to create virtual entity "${entityName}": ${errMessage}`);
+            }
+        }
+        return { success: true, createdCount };
+    }
+    /**
+     * Derives an entity name from a view name by removing common prefixes (vw, v_)
+     * and converting to a human-friendly format.
+     */
+    deriveEntityNameFromView(viewName) {
+        let name = viewName;
+        // Remove common view prefixes
+        if (name.startsWith('vw'))
+            name = name.substring(2);
+        else if (name.startsWith('v_'))
+            name = name.substring(2);
+        // Add spaces before capital letters (PascalCase → "Pascal Case")
+        name = name.replace(/([a-z])([A-Z])/g, '$1 $2');
+        return name.trim();
+    }
     /**
      * Primary function to manage metadata within the CodeGen system. This function will call a series of sub-functions to manage the metadata.
      * @param pool - the ConnectionPool object to use for querying and updating the database
      * @returns
      */
     async manageMetadata(pool, currentUser) {
-        const md = new core_1.Metadata();
-        const excludeSchemas = config_1.configInfo.excludeSchemas ? config_1.configInfo.excludeSchemas : [];
+        const md = new Metadata();
+        const excludeSchemas = configInfo.excludeSchemas ? configInfo.excludeSchemas : [];
         let bSuccess = true;
         let start = new Date();
-        (0, status_logging_1.logStatus)('   Creating new entities...');
+        logStatus('   Creating new entities...');
         if (!await this.createNewEntities(pool, currentUser)) {
-            (0, status_logging_1.logError)('   Error creating new entities');
+            logError('   Error creating new entities');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`    > Created new entities in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        logStatus(`    > Created new entities in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, status_logging_1.logStatus)('   Updating existing entities...');
+        logStatus('   Updating existing entities...');
         if (!await this.updateExistingEntitiesFromSchema(pool, excludeSchemas)) {
-            (0, status_logging_1.logError)('   Error updating existing entities');
+            logError('   Error updating existing entities');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`    > Updated existing entities in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        logStatus(`    > Updated existing entities in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, status_logging_1.logStatus)('   Scanning for tables that were deleted where entity metadata still exists...');
+        logStatus('   Scanning for tables that were deleted where entity metadata still exists...');
         if (!await this.checkAndRemoveMetadataForDeletedTables(pool, excludeSchemas)) {
-            (0, status_logging_1.logError)('   Error removing metadata for tables that were removed');
+            logError('   Error removing metadata for tables that were removed');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`    > Removed metadata for deleted tables in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        logStatus(`    > Removed metadata for deleted tables in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, status_logging_1.logStatus)('   Recompiling base views...');
-        const sqlUtility = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(sql_1.SQLUtilityBase);
-        const adminSchema = (0, config_1.getSettingValue)('mj_core_schema', '__mj');
-        const schemasToExclude = (0, config_1.getSettingValue)('recompile_mj_views', true)
+        logStatus('   Recompiling base views...');
+        const sqlUtility = MJGlobal.Instance.ClassFactory.CreateInstance(SQLUtilityBase);
+        const adminSchema = getSettingValue('mj_core_schema', '__mj');
+        const schemasToExclude = getSettingValue('recompile_mj_views', true)
             ? excludeSchemas.filter((s) => s !== adminSchema)
             : excludeSchemas;
         if (!await sqlUtility.recompileAllBaseViews(pool, schemasToExclude, true, ManageMetadataBase._newEntityList /*exclude the newly created entities from the above step the first time we run as those views don't exist yet*/)) {
-            (0, status_logging_1.logMessage)('   Warning: Non-Fatal error recompiling base views', core_1.SeverityType.Warning, false);
+            logMessage('   Warning: Non-Fatal error recompiling base views', SeverityType.Warning, false);
             // many times the former versions of base views will NOT succesfully recompile, so don't consider that scenario to be a
             // failure for this entire function
         }
-        (0, status_logging_1.logStatus)(`    > Recompiled base views in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        logStatus(`    > Recompiled base views in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, status_logging_1.logStatus)('   Managing entity fields...');
+        logStatus('   Managing entity fields...');
         // note that we skip Advanced Generation here because we do it again later when the manageSQLScriptsAndExecution occurs in SQLCodeGen class
         if (!await this.manageEntityFields(pool, excludeSchemas, false, false, currentUser, true)) {
-            (0, status_logging_1.logError)('   Error managing entity fields');
+            logError('   Error managing entity fields');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`    > Managed entity fields in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        logStatus(`    > Managed entity fields in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, status_logging_1.logStatus)('   Managing entity relationships...');
+        logStatus('   Managing entity relationships...');
         if (!await this.manageEntityRelationships(pool, excludeSchemas, md)) {
-            (0, status_logging_1.logError)('   Error managing entity relationships');
+            logError('   Error managing entity relationships');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`    > Managed entity relationships in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        logStatus(`    > Managed entity relationships in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         if (ManageMetadataBase.newEntityList.length > 0) {
             await this.generateNewEntityDescriptions(pool, md, currentUser); // don't pass excludeSchemas becuase by definition this is the NEW entities we created
         }
+        // Config-driven virtual entity creation — run BEFORE manageVirtualEntities
+        // so newly created entities get their fields synced in the next step
+        const vecResult = await this.processVirtualEntityConfig(pool, currentUser);
+        if (vecResult.createdCount > 0) {
+            logStatus(`    > Created ${vecResult.createdCount} virtual entit${vecResult.createdCount === 1 ? 'y' : 'ies'} from config`);
+            // Refresh metadata so manageVirtualEntities can find the newly-created entities
+            // in the cache — otherwise EntityByName() returns null and field sync is silently skipped
+            const md = new Metadata();
+            await md.Refresh();
+        }
         const veResult = await this.manageVirtualEntities(pool);
         if (!veResult.success) {
-            (0, status_logging_1.logError)('   Error managing virtual entities');
+            logError('   Error managing virtual entities');
             bSuccess = false;
         }
+        // LLM-assisted virtual entity field decoration — identify PKs, FKs, and descriptions
+        await this.decorateVirtualEntitiesWithLLM(pool, currentUser);
+        // Config-driven IS-A relationship setup — set ParentID on child entities
+        // Must run AFTER entities exist but BEFORE manageEntityFields() which calls manageParentEntityFields()
+        const isaConfigResult = await this.processISARelationshipConfig(pool);
+        if (isaConfigResult.updatedCount > 0) {
+            logStatus(`    > Set ParentID on ${isaConfigResult.updatedCount} IS-A child entit${isaConfigResult.updatedCount === 1 ? 'y' : 'ies'} from config`);
+        }
         start = new Date();
-        (0, status_logging_1.logStatus)('   Syncing schema info from database...');
+        logStatus('   Syncing schema info from database...');
         if (!await this.updateSchemaInfoFromDatabase(pool, excludeSchemas)) {
-            (0, status_logging_1.logError)('   Error syncing schema info');
+            logError('   Error syncing schema info');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`    > Synced schema info in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        logStatus(`    > Synced schema info in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         return bSuccess;
     }
     async manageVirtualEntities(pool) {
@@ -199,7 +424,7 @@ class ManageMetadataBase {
         // virtual entities are records defined in the entity metadata and do NOT define a distinct base table
         // but they do specify a base view. We DO NOT generate a base view for a virtual entity, we simply use it to figure
         // out the fields that should be in the entity definition and add/update/delete the entity definition to match what's in the view when this runs
-        const sql = `SELECT * FROM [${(0, config_1.mj_core_schema)()}].vwEntities WHERE VirtualEntity = 1`;
+        const sql = `SELECT * FROM [${mj_core_schema()}].vwEntities WHERE VirtualEntity = 1`;
         const virtualEntitiesResult = await pool.request().query(sql);
         const virtualEntities = virtualEntitiesResult.recordset;
         let anyUpdates = false;
@@ -209,7 +434,7 @@ class ManageMetadataBase {
                 const { success, updatedEntity } = await this.manageSingleVirtualEntity(pool, ve);
                 anyUpdates = anyUpdates || updatedEntity;
                 if (!success) {
-                    (0, status_logging_1.logError)(`   Error managing virtual entity ${ve.Name}`);
+                    logError(`   Error managing virtual entity ${ve.Name}`);
                     bSuccess = false;
                 }
             }
@@ -240,7 +465,7 @@ class ManageMetadataBase {
             if (veFields && veFields.length > 0) {
                 // we have 1+ fields, now loop through them and process each one
                 // first though, remove any fields that are no longer in the view
-                const md = new core_1.Metadata();
+                const md = new Metadata();
                 const entity = md.EntityByName(virtualEntity.Name);
                 if (entity) {
                     const removeList = [];
@@ -249,7 +474,7 @@ class ManageMetadataBase {
                         removeList.push(f.ID);
                     }
                     if (removeList.length > 0) {
-                        const sqlRemove = `DELETE FROM [${(0, config_1.mj_core_schema)()}].EntityField WHERE ID IN (${removeList.map(removeId => `'${removeId}'`).join(',')})`;
+                        const sqlRemove = `DELETE FROM [${mj_core_schema()}].EntityField WHERE ID IN (${removeList.map(removeId => `'${removeId}'`).join(',')})`;
                         // this removes the fields that shouldn't be there anymore
                         await this.LogSQLAndExecute(pool, sqlRemove, `SQL text to remove fields from entity ${virtualEntity.Name}`);
                         bUpdated = true;
@@ -263,7 +488,7 @@ class ManageMetadataBase {
                         const { success, updatedField } = await this.manageSingleVirtualEntityField(pool, virtualEntity, vef, i + 1, !hasPkey && i === 0);
                         bUpdated = bUpdated || updatedField;
                         if (!success) {
-                            (0, status_logging_1.logError)(`Error managing virtual entity field ${vef.FieldName} for virtual entity ${virtualEntity.Name}`);
+                            logError(`Error managing virtual entity field ${vef.FieldName} for virtual entity ${virtualEntity.Name}`);
                             bSuccess = false;
                         }
                     }
@@ -271,13 +496,13 @@ class ManageMetadataBase {
             }
             if (bUpdated) {
                 // finally make sure we update the UpdatedAt field for the entity if we made changes to its fields
-                const sqlUpdate = `UPDATE [${(0, config_1.mj_core_schema)()}].Entity SET [${core_1.EntityInfo.UpdatedAtFieldName}]=GETUTCDATE() WHERE ID='${virtualEntity.ID}'`;
+                const sqlUpdate = `UPDATE [${mj_core_schema()}].Entity SET [${EntityInfo.UpdatedAtFieldName}]=GETUTCDATE() WHERE ID='${virtualEntity.ID}'`;
                 await this.LogSQLAndExecute(pool, sqlUpdate, `SQL text to update virtual entity updated date for ${virtualEntity.Name}`);
             }
             return { success: bSuccess, updatedEntity: bUpdated };
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return { success: false, updatedEntity: bUpdated };
         }
     }
@@ -285,7 +510,7 @@ class ManageMetadataBase {
         // this protected checks to see if the field exists in the entity definition, and if not, adds it
         // if it exist it updates the entity field to match the view's data type and nullability attributes
         // first, get the entity definition
-        const md = new core_1.Metadata();
+        const md = new Metadata();
         const entity = md.EntityByName(virtualEntity.Name);
         let newEntityFieldUUID = null;
         let didUpdate = false;
@@ -302,7 +527,7 @@ class ManageMetadataBase {
                     field.Sequence !== fieldSequence) {
                     // the field needs to be updated, so update it
                     const sqlUpdate = `UPDATE
-                                    [${(0, config_1.mj_core_schema)()}].EntityField
+                                    [${mj_core_schema()}].EntityField
                                   SET
                                     Sequence=${fieldSequence},
                                     Type='${veField.Type}',
@@ -320,7 +545,7 @@ class ManageMetadataBase {
             else {
                 // this means that we do NOT have a match so the field does not exist in the entity definition, so we need to add it
                 newEntityFieldUUID = this.createNewUUID();
-                const sqlAdd = `INSERT INTO [${(0, config_1.mj_core_schema)()}].EntityField (
+                const sqlAdd = `INSERT INTO [${mj_core_schema()}].EntityField (
                                       ID, EntityID, Name, Type, AllowsNull,
                                       Length, Precision, Scale,
                                       Sequence, IsPrimaryKey, IsUnique )
@@ -334,6 +559,480 @@ class ManageMetadataBase {
         }
         return { success: true, updatedField: didUpdate, newFieldID: newEntityFieldUUID };
     }
+    /**
+     * Iterates over all virtual entities and applies LLM-assisted field decoration
+     * to identify primary keys, foreign keys, and field descriptions.
+     * Only runs if the VirtualEntityFieldDecoration advanced generation feature is enabled.
+     * Idempotent: skips entities that already have soft PK/FK annotations.
+     */
+    async decorateVirtualEntitiesWithLLM(pool, currentUser) {
+        const ag = new AdvancedGeneration();
+        if (!ag.featureEnabled('VirtualEntityFieldDecoration')) {
+            return; // Feature not enabled, nothing to do
+        }
+        const md = new Metadata();
+        const virtualEntities = md.Entities.filter(e => e.VirtualEntity);
+        if (virtualEntities.length === 0) {
+            return;
+        }
+        // Pre-build available entities list once (shared across all virtual entity decorations)
+        const availableEntities = md.Entities
+            .filter(e => !e.VirtualEntity && e.PrimaryKeys.length > 0)
+            .map(e => ({
+            Name: e.Name,
+            SchemaName: e.SchemaName,
+            BaseTable: e.BaseTable,
+            PrimaryKeyField: e.PrimaryKeys[0]?.Name || 'ID'
+        }));
+        logStatus(`   Decorating virtual entity fields with LLM (${virtualEntities.length} entities)...`);
+        let decoratedCount = 0;
+        let skippedCount = 0;
+        // Process in batches of up to 5 in parallel for better throughput
+        const batchSize = 5;
+        for (let i = 0; i < virtualEntities.length; i += batchSize) {
+            const batch = virtualEntities.slice(i, i + batchSize);
+            const results = await Promise.all(batch.map(entity => this.decorateSingleVirtualEntityWithLLM(pool, entity, ag, currentUser, availableEntities)));
+            for (const result of results) {
+                if (result.decorated) {
+                    decoratedCount++;
+                }
+                else if (result.skipped) {
+                    skippedCount++;
+                }
+            }
+        }
+        if (decoratedCount > 0 || skippedCount > 0) {
+            logStatus(`    > LLM field decoration: ${decoratedCount} decorated, ${skippedCount} skipped (already annotated)`);
+        }
+    }
+    /**
+     * Applies LLM-assisted field decoration to a single virtual entity.
+     * Parses the view SQL to identify source entities, enriches the LLM prompt with their
+     * field metadata (descriptions, categories), then applies PKs, FKs, descriptions, and categories.
+     * @returns Whether the entity was decorated, skipped, or encountered an error.
+     */
+    async decorateSingleVirtualEntityWithLLM(pool, entity, ag, currentUser, availableEntities) {
+        try {
+            // Idempotency check: if entity already has soft PK or soft FK annotations, skip
+            // unless forceRegenerate option is enabled on this feature
+            const feature = ag.getFeature('VirtualEntityFieldDecoration');
+            const forceRegenerate = feature?.options?.find(o => o.name === 'forceRegenerate')?.value === true;
+            const hasSoftAnnotations = entity.Fields.some(f => f.IsSoftPrimaryKey || f.IsSoftForeignKey);
+            if (hasSoftAnnotations && !forceRegenerate) {
+                return { decorated: false, skipped: true };
+            }
+            // Get view definition from SQL Server
+            const viewDefSQL = `SELECT OBJECT_DEFINITION(OBJECT_ID('[${entity.SchemaName}].[${entity.BaseView}]')) AS ViewDef`;
+            const viewDefResult = await pool.request().query(viewDefSQL);
+            const viewDefinition = viewDefResult.recordset[0]?.ViewDef;
+            if (!viewDefinition) {
+                logStatus(`         Could not get view definition for ${entity.SchemaName}.${entity.BaseView} — skipping LLM decoration`);
+                return { decorated: false, skipped: false };
+            }
+            // Parse the view SQL to identify referenced tables, then resolve to entities
+            const sourceEntities = this.buildSourceEntityContext(viewDefinition);
+            // Build field info for the prompt
+            const fields = entity.Fields.map(f => ({
+                Name: f.Name,
+                Type: f.Type,
+                Length: f.Length,
+                AllowsNull: f.AllowsNull,
+                IsPrimaryKey: f.IsPrimaryKey,
+                RelatedEntityName: f.RelatedEntity || null
+            }));
+            // Call the LLM with enriched source entity context
+            const result = await ag.decorateVirtualEntityFields(entity.Name, entity.SchemaName, entity.BaseView, viewDefinition, entity.Description || '', fields, availableEntities, sourceEntities, currentUser);
+            if (!result) {
+                return { decorated: false, skipped: false };
+            }
+            // Apply results to EntityField records
+            const schema = mj_core_schema();
+            let anyUpdated = false;
+            // Apply primary keys
+            anyUpdated = await this.applyLLMPrimaryKeys(pool, entity, result.primaryKeys, schema) || anyUpdated;
+            // Apply foreign keys
+            anyUpdated = await this.applyLLMForeignKeys(pool, entity, result.foreignKeys, schema) || anyUpdated;
+            // Apply field descriptions
+            anyUpdated = await this.applyLLMFieldDescriptions(pool, entity, result.fieldDescriptions, schema) || anyUpdated;
+            // Apply categories using the shared methods (same stability rules as regular entities)
+            anyUpdated = await this.applyVEFieldCategories(pool, entity, result) || anyUpdated;
+            if (anyUpdated) {
+                const sqlUpdate = `UPDATE [${schema}].Entity SET [${EntityInfo.UpdatedAtFieldName}]=GETUTCDATE() WHERE ID='${entity.ID}'`;
+                await this.LogSQLAndExecute(pool, sqlUpdate, `Update entity timestamp for ${entity.Name} after LLM decoration`);
+            }
+            return { decorated: anyUpdated, skipped: false };
+        }
+        catch (e) {
+            logError(`   Error decorating virtual entity ${entity.Name} with LLM: ${e}`);
+            return { decorated: false, skipped: false };
+        }
+    }
+    /**
+     * Parses a view definition SQL and resolves referenced tables to MJ entities.
+     * Returns enriched source entity context (all fields with descriptions and categories)
+     * for the LLM to use when decorating virtual entity fields.
+     */
+    buildSourceEntityContext(viewDefinition) {
+        const parseResult = SQLParser.Parse(viewDefinition);
+        const md = new Metadata();
+        const sourceEntities = [];
+        const seen = new Set();
+        for (const tableRef of parseResult.Tables) {
+            // Match against MJ entities by BaseTable/BaseView + SchemaName
+            const matchingEntity = md.Entities.find(e => (e.BaseTable.toLowerCase() === tableRef.TableName.toLowerCase() ||
+                e.BaseView.toLowerCase() === tableRef.TableName.toLowerCase()) &&
+                e.SchemaName.toLowerCase() === tableRef.SchemaName.toLowerCase());
+            if (matchingEntity && !seen.has(matchingEntity.ID)) {
+                seen.add(matchingEntity.ID);
+                sourceEntities.push({
+                    Name: matchingEntity.Name,
+                    Description: matchingEntity.Description || '',
+                    Fields: matchingEntity.Fields.map(f => ({
+                        Name: f.Name,
+                        Type: f.Type,
+                        Description: f.Description || '',
+                        Category: f.Category || null,
+                        IsPrimaryKey: f.IsPrimaryKey,
+                        IsForeignKey: !!(f.RelatedEntityID)
+                    }))
+                });
+            }
+        }
+        return sourceEntities;
+    }
+    /**
+     * Applies category assignments from VE decoration results using the shared category methods.
+     * Loads field records from DB (needs ID, Name, Category, AutoUpdateCategory, AutoUpdateDisplayName)
+     * then delegates to the shared methods.
+     */
+    async applyVEFieldCategories(pool, entity, result) {
+        // Check if the LLM returned any category data
+        const hasCategories = result.fieldDescriptions?.some(fd => fd.category);
+        if (!hasCategories) {
+            return false;
+        }
+        // Load VE EntityField rows from DB (we need the ID and auto-update flags)
+        const schema = mj_core_schema();
+        const fieldsSQL = `
+         SELECT ID, Name, Category, AutoUpdateCategory, AutoUpdateDisplayName
+         FROM [${schema}].EntityField
+         WHERE EntityID = '${entity.ID}'
+      `;
+        const fieldsResult = await pool.request().query(fieldsSQL);
+        const dbFields = fieldsResult.recordset;
+        if (dbFields.length === 0)
+            return false;
+        // Convert VE decoration field descriptions into the format expected by applyFieldCategories
+        const fieldCategories = result.fieldDescriptions
+            .filter(fd => fd.category)
+            .map(fd => ({
+            fieldName: fd.fieldName,
+            category: fd.category,
+            displayName: fd.displayName || undefined,
+            extendedType: fd.extendedType,
+            codeType: fd.codeType
+        }));
+        if (fieldCategories.length === 0)
+            return false;
+        const existingCategories = this.buildExistingCategorySet(dbFields);
+        await this.applyFieldCategories(pool, entity.ID, dbFields, fieldCategories, existingCategories);
+        // Apply entity icon if provided
+        if (result.entityIcon) {
+            await this.applyEntityIcon(pool, entity.ID, result.entityIcon);
+        }
+        // Apply category info settings if provided
+        if (result.categoryInfo && Object.keys(result.categoryInfo).length > 0) {
+            await this.applyCategoryInfoSettings(pool, entity.ID, result.categoryInfo);
+        }
+        logStatus(`         Applied categories for VE ${entity.Name} (${fieldCategories.length} fields)`);
+        return true;
+    }
+    /**
+     * Applies LLM-identified primary keys to entity fields.
+     * Sets IsPrimaryKey=1 and IsSoftPrimaryKey=1 for identified fields.
+     * First clears any default PK that was set by field-sync (field #1 fallback).
+     * All SQL updates are batched into a single execution for performance.
+     */
+    async applyLLMPrimaryKeys(pool, entity, primaryKeys, schema) {
+        if (!primaryKeys || primaryKeys.length === 0) {
+            return false;
+        }
+        // Validate that all identified PK fields exist on the entity
+        const validPKs = primaryKeys.filter(pk => entity.Fields.some(f => f.Name.toLowerCase() === pk.toLowerCase()));
+        if (validPKs.length === 0) {
+            return false;
+        }
+        // Build batched SQL: clear default PK + set all LLM-identified PKs
+        const sqlStatements = [];
+        // Clear existing default PK (field #1 fallback) before applying LLM-identified PKs
+        sqlStatements.push(`UPDATE [${schema}].[EntityField]
+                        SET IsPrimaryKey=0, IsUnique=0
+                        WHERE EntityID='${entity.ID}' AND IsPrimaryKey=1 AND IsSoftPrimaryKey=0`);
+        // Set LLM-identified PKs
+        for (const pk of validPKs) {
+            sqlStatements.push(`UPDATE [${schema}].[EntityField]
+                         SET IsPrimaryKey=1, IsUnique=1, IsSoftPrimaryKey=1
+                         WHERE EntityID='${entity.ID}' AND Name='${pk}'`);
+            logStatus(`         ✓ Set PK for ${entity.Name}.${pk} (LLM-identified)`);
+        }
+        await this.LogSQLAndExecute(pool, sqlStatements.join('\n'), `Set LLM-identified PKs for ${entity.Name}: ${validPKs.join(', ')}`);
+        return true;
+    }
+    /**
+     * Applies LLM-identified foreign keys to entity fields.
+     * Sets RelatedEntityID, RelatedEntityFieldName, and IsSoftForeignKey=1.
+     * Only applies high and medium confidence FKs.
+     * All SQL updates are batched into a single execution for performance.
+     */
+    async applyLLMForeignKeys(pool, entity, foreignKeys, schema) {
+        if (!foreignKeys || foreignKeys.length === 0) {
+            return false;
+        }
+        const md = new Metadata();
+        const sqlStatements = [];
+        for (const fk of foreignKeys) {
+            // Only apply high/medium confidence
+            if (fk.confidence !== 'high' && fk.confidence !== 'medium') {
+                continue;
+            }
+            // Validate that the field exists on this entity
+            const field = entity.Fields.find(f => f.Name.toLowerCase() === fk.fieldName.toLowerCase());
+            if (!field) {
+                continue;
+            }
+            // Skip if field already has a FK set (config-defined takes precedence)
+            if (field.RelatedEntityID) {
+                continue;
+            }
+            // Look up the related entity by name
+            const relatedEntity = md.EntityByName(fk.relatedEntityName);
+            if (!relatedEntity) {
+                logStatus(`         ⚠️  LLM FK: related entity '${fk.relatedEntityName}' not found for ${entity.Name}.${fk.fieldName}`);
+                continue;
+            }
+            sqlStatements.push(`UPDATE [${schema}].[EntityField]
+                         SET RelatedEntityID='${relatedEntity.ID}',
+                             RelatedEntityFieldName='${fk.relatedFieldName}',
+                             IsSoftForeignKey=1
+                         WHERE EntityID='${entity.ID}' AND Name='${field.Name}'`);
+            logStatus(`         ✓ Set FK for ${entity.Name}.${field.Name} → ${fk.relatedEntityName}.${fk.relatedFieldName} (${fk.confidence}, LLM)`);
+        }
+        if (sqlStatements.length === 0) {
+            return false;
+        }
+        await this.LogSQLAndExecute(pool, sqlStatements.join('\n'), `Set LLM-identified FKs for ${entity.Name}`);
+        return true;
+    }
+    /**
+     * Applies LLM-generated field descriptions to entity fields that lack descriptions.
+     * All SQL updates are batched into a single execution for performance.
+     */
+    async applyLLMFieldDescriptions(pool, entity, fieldDescriptions, schema) {
+        if (!fieldDescriptions || fieldDescriptions.length === 0) {
+            return false;
+        }
+        const sqlStatements = [];
+        for (const fd of fieldDescriptions) {
+            const field = entity.Fields.find(f => f.Name.toLowerCase() === fd.fieldName.toLowerCase());
+            if (!field) {
+                continue;
+            }
+            // Only apply if field doesn't already have a description
+            if (field.Description && field.Description.trim().length > 0) {
+                continue;
+            }
+            const escapedDescription = fd.description.replace(/'/g, "''");
+            let setClauses = `Description='${escapedDescription}'`;
+            // Apply extended type if provided and valid
+            if (fd.extendedType) {
+                const validExtendedType = this.validateExtendedType(fd.extendedType);
+                if (validExtendedType) {
+                    setClauses += `, ExtendedType='${validExtendedType}'`;
+                }
+            }
+            sqlStatements.push(`UPDATE [${schema}].[EntityField]
+                         SET ${setClauses}
+                         WHERE EntityID='${entity.ID}' AND Name='${field.Name}'`);
+        }
+        if (sqlStatements.length === 0) {
+            return false;
+        }
+        await this.LogSQLAndExecute(pool, sqlStatements.join('\n'), `Set LLM-generated descriptions for ${entity.Name} (${sqlStatements.length} fields)`);
+        return true;
+    }
+    /**
+     * Valid values for EntityField.ExtendedType, plus common LLM aliases mapped to valid values.
+     */
+    static { this.VALID_EXTENDED_TYPES = new Set([
+        'Code', 'Email', 'FaceTime', 'Geo', 'MSTeams', 'Other', 'SIP', 'SMS', 'Skype', 'Tel', 'URL', 'WhatsApp', 'ZoomMtg'
+    ]); }
+    static { this.EXTENDED_TYPE_ALIASES = {
+        'phone': 'Tel',
+        'telephone': 'Tel',
+        'website': 'URL',
+        'link': 'URL',
+        'hyperlink': 'URL',
+        'mail': 'Email',
+        'e-mail': 'Email',
+        'text': 'SMS',
+        'location': 'Geo',
+        'address': 'Geo',
+        'teams': 'MSTeams',
+        'facetime': 'FaceTime',
+        'zoom': 'ZoomMtg',
+        'whatsapp': 'WhatsApp',
+        'skype': 'Skype',
+    }; }
+    /**
+     * Validates an LLM-suggested ExtendedType against the allowed values in EntityField.
+     * Returns the valid value (case-corrected) or null if invalid.
+     */
+    validateExtendedType(suggested) {
+        // Direct match (case-insensitive)
+        for (const valid of ManageMetadataBase.VALID_EXTENDED_TYPES) {
+            if (valid.toLowerCase() === suggested.toLowerCase()) {
+                return valid;
+            }
+        }
+        // Check aliases
+        const alias = ManageMetadataBase.EXTENDED_TYPE_ALIASES[suggested.toLowerCase()];
+        if (alias) {
+            return alias;
+        }
+        return null;
+    }
+    /**
+     * Manages virtual EntityField records for IS-A parent entity fields.
+     * For each entity with ParentID set (IS-A child), creates/updates virtual field records
+     * that mirror the parent entity's base table fields (excluding PKs, timestamps, and virtual fields).
+     * Runs collision detection to prevent child table columns from shadowing parent fields.
+     */
+    async manageParentEntityFields(pool) {
+        let bSuccess = true;
+        let anyUpdates = false;
+        const md = new Metadata();
+        const childEntities = md.Entities.filter(e => e.IsChildType);
+        if (childEntities.length === 0) {
+            return { success: true, anyUpdates: false };
+        }
+        logStatus(`   Processing IS-A parent fields for ${childEntities.length} child entit${childEntities.length === 1 ? 'y' : 'ies'}...`);
+        for (const childEntity of childEntities) {
+            try {
+                const { success, updated } = await this.manageSingleEntityParentFields(pool, childEntity);
+                anyUpdates = anyUpdates || updated;
+                if (!success) {
+                    logError(`   Error managing IS-A parent fields for ${childEntity.Name}`);
+                    bSuccess = false;
+                }
+            }
+            catch (e) {
+                logError(`   Exception managing IS-A parent fields for ${childEntity.Name}: ${e}`);
+                bSuccess = false;
+            }
+        }
+        return { success: bSuccess, anyUpdates };
+    }
+    /**
+     * Creates/updates virtual EntityField records for a single child entity's parent fields.
+     * Detects field name collisions between child's own base table columns and parent fields.
+     */
+    async manageSingleEntityParentFields(pool, childEntity) {
+        let bUpdated = false;
+        // Get all parent fields: non-PK, non-__mj_, non-virtual from each parent in chain
+        const parentFields = childEntity.AllParentFields;
+        if (parentFields.length === 0) {
+            return { success: true, updated: false };
+        }
+        // Get child's own (non-virtual) field names for collision detection
+        const childOwnFieldNames = new Set(childEntity.Fields.filter(f => !f.IsVirtual).map(f => f.Name.toLowerCase()));
+        for (const parentField of parentFields) {
+            // Collision detection: child's own base table column has same name as parent field.
+            // This uses in-memory metadata which filters to non-virtual (base table) fields only.
+            if (childOwnFieldNames.has(parentField.Name.toLowerCase())) {
+                logError(`   FIELD COLLISION: Entity '${childEntity.Name}' has its own column '${parentField.Name}' ` +
+                    `that conflicts with IS-A parent field '${parentField.Name}' from '${parentField.Entity}'. ` +
+                    `Rename the child column to resolve this collision. Skipping IS-A field sync for this entity.`);
+                return { success: false, updated: false };
+            }
+            // Check the DATABASE for existing field record — in-memory metadata may be stale
+            // (e.g. createNewEntityFieldsFromSchema may have already added this field from the view)
+            const existsResult = await pool.request()
+                .input('EntityID', childEntity.ID)
+                .input('FieldName', parentField.Name)
+                .query(`SELECT ID, IsVirtual, Type, Length, Precision, Scale, AllowsNull, AllowUpdateAPI
+                    FROM [${mj_core_schema()}].EntityField
+                    WHERE EntityID = @EntityID AND Name = @FieldName`);
+            if (existsResult.recordset.length > 0) {
+                // Field already exists — update it to ensure it's marked as a virtual IS-A field
+                const existingRow = existsResult.recordset[0];
+                const needsUpdate = !existingRow.IsVirtual ||
+                    existingRow.Type?.trim().toLowerCase() !== parentField.Type.trim().toLowerCase() ||
+                    existingRow.Length !== parentField.Length ||
+                    existingRow.Precision !== parentField.Precision ||
+                    existingRow.Scale !== parentField.Scale ||
+                    existingRow.AllowsNull !== parentField.AllowsNull ||
+                    !existingRow.AllowUpdateAPI;
+                if (needsUpdate) {
+                    const sqlUpdate = `UPDATE [${mj_core_schema()}].EntityField
+                  SET IsVirtual=1,
+                      Type='${parentField.Type}',
+                      Length=${parentField.Length},
+                      Precision=${parentField.Precision},
+                      Scale=${parentField.Scale},
+                      AllowsNull=${parentField.AllowsNull ? 1 : 0},
+                      AllowUpdateAPI=1
+                  WHERE ID='${existingRow.ID}'`;
+                    await this.LogSQLAndExecute(pool, sqlUpdate, `Update IS-A parent field ${parentField.Name} on ${childEntity.Name}`);
+                    bUpdated = true;
+                }
+            }
+            else {
+                // Create new virtual field record for this parent field
+                const newFieldID = this.createNewUUID();
+                // Use high sequence — will be reordered by updateExistingEntityFieldsFromSchema
+                const sequence = 100000 + parentFields.indexOf(parentField);
+                const sqlInsert = `INSERT INTO [${mj_core_schema()}].EntityField (
+                  ID, EntityID, Name, Type, AllowsNull,
+                  Length, Precision, Scale,
+                  Sequence, IsVirtual, AllowUpdateAPI,
+                  IsPrimaryKey, IsUnique)
+               VALUES (
+                  '${newFieldID}', '${childEntity.ID}', '${parentField.Name}',
+                  '${parentField.Type}', ${parentField.AllowsNull ? 1 : 0},
+                  ${parentField.Length}, ${parentField.Precision}, ${parentField.Scale},
+                  ${sequence}, 1, 1, 0, 0)`;
+                await this.LogSQLAndExecute(pool, sqlInsert, `Create IS-A parent field ${parentField.Name} on ${childEntity.Name}`);
+                bUpdated = true;
+            }
+        }
+        // Remove stale IS-A parent virtual fields no longer in the parent chain.
+        // IS-A parent fields are identified by IsVirtual=true AND AllowUpdateAPI=true.
+        const currentParentFieldNames = new Set(parentFields.map(f => f.Name.toLowerCase()));
+        const staleFields = childEntity.Fields.filter(f => f.IsVirtual && f.AllowUpdateAPI &&
+            !f.IsPrimaryKey && !f.Name.startsWith('__mj_') &&
+            !currentParentFieldNames.has(f.Name.toLowerCase()));
+        for (const staleField of staleFields) {
+            const sqlDelete = `DELETE FROM [${mj_core_schema()}].EntityField WHERE ID='${staleField.ID}'`;
+            await this.LogSQLAndExecute(pool, sqlDelete, `Remove stale IS-A parent field ${staleField.Name} from ${childEntity.Name}`);
+            bUpdated = true;
+        }
+        if (bUpdated) {
+            const sqlUpdate = `UPDATE [${mj_core_schema()}].Entity SET [${EntityInfo.UpdatedAtFieldName}]=GETUTCDATE() WHERE ID='${childEntity.ID}'`;
+            await this.LogSQLAndExecute(pool, sqlUpdate, `Update entity timestamp for ${childEntity.Name} after IS-A field sync`);
+        }
+        return { success: true, updated: bUpdated };
+    }
+    /**
+     * Checks if an existing virtual parent field record needs to be updated to match the parent field.
+     */
+    parentFieldNeedsUpdate(existing, parentField) {
+        return existing.Type.trim().toLowerCase() !== parentField.Type.trim().toLowerCase() ||
+            existing.Length !== parentField.Length ||
+            existing.Precision !== parentField.Precision ||
+            existing.Scale !== parentField.Scale ||
+            existing.AllowsNull !== parentField.AllowsNull ||
+            !existing.AllowUpdateAPI;
+    }
     /**
      * This method creates and updates relationships in the metadata based on foreign key relationships in the database.
      * @param pool
@@ -370,16 +1069,16 @@ class ManageMetadataBase {
         try {
             // STEP 1 - search for all foreign keys in the vwEntityFields view, we use the RelatedEntityID field to determine our FKs
             const sSQL = `SELECT *
-                       FROM ${(0, config_1.mj_core_schema)()}.vwEntityFields
+                       FROM ${mj_core_schema()}.vwEntityFields
                        WHERE
                              RelatedEntityID IS NOT NULL AND
                              IsVirtual = 0 AND
-                             EntityID NOT IN (SELECT ID FROM ${(0, config_1.mj_core_schema)()}.Entity WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
+                             EntityID NOT IN (SELECT ID FROM ${mj_core_schema()}.Entity WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
                        ORDER BY RelatedEntityID`;
             const entityFieldsResult = await pool.request().query(sSQL);
             const entityFields = entityFieldsResult.recordset;
             // Get the relationship counts for each entity
-            const sSQLRelationshipCount = `SELECT EntityID, COUNT(*) AS Count FROM ${(0, config_1.mj_core_schema)()}.EntityRelationship GROUP BY EntityID`;
+            const sSQLRelationshipCount = `SELECT EntityID, COUNT(*) AS Count FROM ${mj_core_schema()}.EntityRelationship GROUP BY EntityID`;
             const relationshipCountsResult = await pool.request().query(sSQLRelationshipCount);
             const relationshipCounts = relationshipCountsResult.recordset;
             const relationshipCountMap = new Map();
@@ -387,7 +1086,7 @@ class ManageMetadataBase {
                 relationshipCountMap.set(rc.EntityID, rc.Count);
             }
             // get all relationships in one query for performance improvement
-            const sSQLRelationship = `SELECT * FROM ${(0, config_1.mj_core_schema)()}.EntityRelationship`;
+            const sSQLRelationship = `SELECT * FROM ${mj_core_schema()}.EntityRelationship`;
             const allRelationshipsResult = await pool.request().query(sSQLRelationship);
             const allRelationships = allRelationshipsResult.recordset;
             // Function to process a batch of entity fields
@@ -406,11 +1105,11 @@ class ManageMetadataBase {
                         batchSQL += `
    IF NOT EXISTS (
       SELECT 1
-      FROM [${(0, config_1.mj_core_schema)()}].EntityRelationship
+      FROM [${mj_core_schema()}].EntityRelationship
       WHERE ID = '${newEntityRelationshipUUID}'
    )
    BEGIN
-      INSERT INTO ${(0, config_1.mj_core_schema)()}.EntityRelationship (ID, EntityID, RelatedEntityID, RelatedEntityJoinField, Type, BundleInAPI, DisplayInForm, DisplayName, Sequence)
+      INSERT INTO ${mj_core_schema()}.EntityRelationship (ID, EntityID, RelatedEntityID, RelatedEntityJoinField, Type, BundleInAPI, DisplayInForm, DisplayName, Sequence)
                               VALUES ('${newEntityRelationshipUUID}', '${f.RelatedEntityID}', '${f.EntityID}', '${f.Name}', 'One To Many', 1, 1, '${e.Name}', ${sequence});
    END
                               `;
@@ -430,7 +1129,7 @@ class ManageMetadataBase {
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -442,7 +1141,7 @@ class ManageMetadataBase {
      */
     async checkAndRemoveMetadataForDeletedTables(pool, excludeSchemas) {
         try {
-            const sql = `SELECT * FROM ${(0, config_1.mj_core_schema)()}.vwEntitiesWithMissingBaseTables WHERE VirtualEntity=0`;
+            const sql = `SELECT * FROM ${mj_core_schema()}.vwEntitiesWithMissingBaseTables WHERE VirtualEntity=0`;
             const entitiesResult = await pool.request().query(sql);
             const entities = entitiesResult.recordset;
             if (entities && entities.length > 0) {
@@ -453,7 +1152,7 @@ class ManageMetadataBase {
                     try {
                         const sqlDelete = `__mj.spDeleteEntityWithCoreDependencies @EntityID='${e.ID}'`;
                         await this.LogSQLAndExecute(pool, sqlDelete, `SQL text to remove entity ${e.Name}`);
-                        (0, status_logging_1.logStatus)(`      > Removed metadata for table ${e.SchemaName}.${e.BaseTable}`);
+                        logStatus(`      > Removed metadata for table ${e.SchemaName}.${e.BaseTable}`);
                         // next up we need to remove the spCreate, spDelete, spUpdate, BaseView, and FullTextSearchFunction, if provided.
                         // We only remoe these artifcacts when they are generated which is info we have in the BaseViewGenerated, spCreateGenerated, etc. fields
                         await this.checkDropSQLObject(pool, e.BaseViewGenerated, 'view', e.SchemaName, e.BaseView);
@@ -463,17 +1162,17 @@ class ManageMetadataBase {
                         await this.checkDropSQLObject(pool, e.FullTextSearchFunctionGenerated, 'function', e.SchemaName, e.FullTextSearchFunction);
                     }
                     catch (ex) {
-                        (0, status_logging_1.logError)(`Error removing metadata for entity ${ex.Name}, error: ${ex}`);
+                        logError(`Error removing metadata for entity ${ex.Name}, error: ${ex}`);
                     }
                 }
                 // if we get here we now need to refresh our metadata object
-                const md = new core_1.Metadata();
+                const md = new Metadata();
                 await md.Refresh();
             }
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -487,23 +1186,23 @@ class ManageMetadataBase {
                 const sqlDelete = `IF OBJECT_ID('[${schemaName}].[${name}]', '${objectTypeCode}') IS NOT NULL\n    DROP ${upperType} [${schemaName}].[${name}]`;
                 await this.LogSQLAndExecute(pool, sqlDelete, `SQL text to remove ${type} ${schemaName}.${name}`);
                 // next up, we need to clean up the cache of saved DB objects that may exist for this entity in the appropriate sub-directory.
-                const sqlOutputDir = (0, config_1.outputDir)('SQL', true);
+                const sqlOutputDir = outputDir('SQL', true);
                 if (sqlOutputDir) {
                     // now do the same thing for the /schema directory within the provided directory
                     const fType = type === 'procedure' ? 'sp' : type === 'view' ? 'view' : 'full_text_search_function';
-                    const filePath = path_1.default.join(sqlOutputDir, this.SQLUtilityObject.getDBObjectFileName(fType, schemaName, name, false, true));
-                    const filePathPermissions = path_1.default.join(sqlOutputDir, this.SQLUtilityObject.getDBObjectFileName(fType, schemaName, name, true, true));
+                    const filePath = path.join(sqlOutputDir, this.SQLUtilityObject.getDBObjectFileName(fType, schemaName, name, false, true));
+                    const filePathPermissions = path.join(sqlOutputDir, this.SQLUtilityObject.getDBObjectFileName(fType, schemaName, name, true, true));
                     // if the files exist, delete them
                     if (fs.existsSync(filePath))
                         fs.unlinkSync(filePath);
                     if (fs.existsSync(filePathPermissions))
                         fs.unlinkSync(filePathPermissions);
                 }
-                (0, status_logging_1.logStatus)(`         > Removed ${type} ${schemaName}.${name}`);
+                logStatus(`         > Removed ${type} ${schemaName}.${name}`);
             }
         }
         catch (e) {
-            (0, status_logging_1.logError)(`         > Error removing ${type} ${schemaName}.${name}, error: ${e}`);
+            logError(`         > Error removing ${type} ${schemaName}.${name}, error: ${e}`);
         }
     }
     /**
@@ -529,72 +1228,90 @@ class ManageMetadataBase {
         if (!skipCreatedAtUpdatedAtDeletedAtFieldValidation) {
             if (!await this.ensureCreatedAtUpdatedAtFieldsExist(pool, excludeSchemas) ||
                 !await this.ensureDeletedAtFieldsExist(pool, excludeSchemas)) {
-                (0, status_logging_1.logError)(`Error ensuring ${core_1.EntityInfo.CreatedAtFieldName}, ${core_1.EntityInfo.UpdatedAtFieldName} and ${core_1.EntityInfo.DeletedAtFieldName} fields exist`);
+                logError(`Error ensuring ${EntityInfo.CreatedAtFieldName}, ${EntityInfo.UpdatedAtFieldName} and ${EntityInfo.DeletedAtFieldName} fields exist`);
                 bSuccess = false;
             }
-            (0, status_logging_1.logStatus)(`      Ensured ${core_1.EntityInfo.CreatedAtFieldName}/${core_1.EntityInfo.UpdatedAtFieldName}/${core_1.EntityInfo.DeletedAtFieldName} fields exist in ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
+            logStatus(`      Ensured ${EntityInfo.CreatedAtFieldName}/${EntityInfo.UpdatedAtFieldName}/${EntityInfo.DeletedAtFieldName} fields exist in ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
         }
         const step1StartTime = new Date();
         if (!await this.deleteUnneededEntityFields(pool, excludeSchemas)) {
-            (0, status_logging_1.logError)('Error deleting unneeded entity fields');
+            logError('Error deleting unneeded entity fields');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`      Deleted unneeded entity fields in ${(new Date().getTime() - step1StartTime.getTime()) / 1000} seconds`);
+        logStatus(`      Deleted unneeded entity fields in ${(new Date().getTime() - step1StartTime.getTime()) / 1000} seconds`);
         // AN: 14-June-2025 - See note below about the new order of these steps, this must
         // happen before we update existing entity fields from schema.
         const step2StartTime = new Date();
         if (!await this.createNewEntityFieldsFromSchema(pool)) { // has its own internal filtering for exclude schema/table so don't pass in
-            (0, status_logging_1.logError)('Error creating new entity fields from schema');
+            logError('Error creating new entity fields from schema');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`      Created new entity fields from schema in ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
+        logStatus(`      Created new entity fields from schema in ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
         // AN: 14-June-2025 - we are now running this AFTER we create new entity fields from schema
         // which results in the same pattern of behavior as migrations where we first create new fields
         // with VERY HIGH sequence numbers (e.g. 100,000 above what they will be approx) and then
         // we align them properly in sequential order from 1+ via this method below.
         const step3StartTime = new Date();
         if (!await this.updateExistingEntityFieldsFromSchema(pool, excludeSchemas)) {
-            (0, status_logging_1.logError)('Error updating existing entity fields from schema');
+            logError('Error updating existing entity fields from schema');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`      Updated existing entity fields from schema in ${(new Date().getTime() - step3StartTime.getTime()) / 1000} seconds`);
+        logStatus(`      Updated existing entity fields from schema in ${(new Date().getTime() - step3StartTime.getTime()) / 1000} seconds`);
         // Apply soft PK/FK configuration if config file exists
         const stepConfigStartTime = new Date();
         if (!await this.applySoftPKFKConfig(pool)) {
-            (0, status_logging_1.logError)('Error applying soft PK/FK configuration');
+            logError('Error applying soft PK/FK configuration');
+        }
+        logStatus(`      Applied soft PK/FK configuration in ${(new Date().getTime() - stepConfigStartTime.getTime()) / 1000} seconds`);
+        // CRITICAL: Refresh metadata to pick up soft PK/FK flags
+        // Without this, downstream SQL and TypeScript generation will fail
+        // because entity.Fields and entity.PrimaryKeys won't reflect the updated flags
+        if (configInfo.additionalSchemaInfo) {
+            logStatus('      Refreshing metadata after applying soft PK/FK configuration...');
+            const md = new Metadata();
+            await md.Refresh();
+            logStatus('      Metadata refresh complete');
+        }
+        // IS-A parent field sync: create/update virtual EntityField records for parent chain fields
+        // Must run AFTER metadata refresh so it sees current soft PK/FK flags
+        const stepISAStartTime = new Date();
+        const isaResult = await this.manageParentEntityFields(pool);
+        if (!isaResult.success) {
+            logError('Error managing IS-A parent entity fields');
+            bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`      Applied soft PK/FK configuration in ${(new Date().getTime() - stepConfigStartTime.getTime()) / 1000} seconds`);
+        logStatus(`      Managed IS-A parent entity fields in ${(new Date().getTime() - stepISAStartTime.getTime()) / 1000} seconds`);
         const step4StartTime = new Date();
         if (!await this.setDefaultColumnWidthWhereNeeded(pool, excludeSchemas)) {
-            (0, status_logging_1.logError)('Error setting default column width where needed');
+            logError('Error setting default column width where needed');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`      Set default column width where needed in ${(new Date().getTime() - step4StartTime.getTime()) / 1000} seconds`);
+        logStatus(`      Set default column width where needed in ${(new Date().getTime() - step4StartTime.getTime()) / 1000} seconds`);
         const step5StartTime = new Date();
         if (!await this.updateEntityFieldDisplayNameWhereNull(pool, excludeSchemas)) {
-            (0, status_logging_1.logError)('Error updating entity field display name where null');
+            logError('Error updating entity field display name where null');
             bSuccess = false;
         }
-        (0, status_logging_1.logStatus)(`      Updated entity field display name where null in ${(new Date().getTime() - step5StartTime.getTime()) / 1000} seconds`);
+        logStatus(`      Updated entity field display name where null in ${(new Date().getTime() - step5StartTime.getTime()) / 1000} seconds`);
         if (!skipEntityFieldValues) {
             const step6StartTime = new Date();
-            (0, status_logging_1.logStatus)(`      Starting to manage entity field values...`);
+            logStatus(`      Starting to manage entity field values...`);
             if (!await this.manageEntityFieldValuesAndValidatorFunctions(pool, excludeSchemas, currentUser, false)) {
-                (0, status_logging_1.logError)('Error managing entity field values');
+                logError('Error managing entity field values');
                 bSuccess = false;
             }
-            (0, status_logging_1.logStatus)(`      Managed entity field values in ${(new Date().getTime() - step6StartTime.getTime()) / 1000} seconds`);
+            logStatus(`      Managed entity field values in ${(new Date().getTime() - step6StartTime.getTime()) / 1000} seconds`);
         }
         // Advanced Generation - Smart field identification and form layout
         if (!skipAdvancedGeneration) {
             const step7StartTime = new Date();
             if (!await this.applyAdvancedGeneration(pool, excludeSchemas, currentUser)) {
-                (0, status_logging_1.logError)('Error applying advanced generation features');
+                logError('Error applying advanced generation features');
                 // Don't fail the entire process - advanced generation is optional
             }
-            (0, status_logging_1.logStatus)(`      Applied advanced generation features in ${(new Date().getTime() - step7StartTime.getTime()) / 1000} seconds`);
+            logStatus(`      Applied advanced generation features in ${(new Date().getTime() - step7StartTime.getTime()) / 1000} seconds`);
         }
-        (0, status_logging_1.logStatus)(`      Total time to manage entity fields: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
+        logStatus(`      Total time to manage entity fields: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
         return bSuccess;
     }
     /**
@@ -605,7 +1322,7 @@ class ManageMetadataBase {
             const sqlEntities = `SELECT
                                  *
                               FROM
-                                 [${(0, config_1.mj_core_schema)()}].vwEntities
+                                 [${mj_core_schema()}].vwEntities
                               WHERE
                                  VirtualEntity=0 AND
                                  DeleteType='Soft' AND
@@ -620,21 +1337,21 @@ class ManageMetadataBase {
                          FROM INFORMATION_SCHEMA.COLUMNS
                          WHERE
                          ${entities.map((e) => `(TABLE_SCHEMA='${e.SchemaName}' AND TABLE_NAME='${e.BaseTable}')`).join(' OR ')}
-                         AND COLUMN_NAME='${core_1.EntityInfo.DeletedAtFieldName}'`;
+                         AND COLUMN_NAME='${EntityInfo.DeletedAtFieldName}'`;
                 const resultResult = await pool.request().query(sql);
                 const result = resultResult.recordset;
                 for (const e of entities) {
                     const eResult = result.filter((r) => r.TABLE_NAME === e.BaseTable && r.TABLE_SCHEMA === e.SchemaName); // get just the fields for this entity
-                    const deletedAt = eResult.find((r) => r.COLUMN_NAME.trim().toLowerCase() === core_1.EntityInfo.DeletedAtFieldName.trim().toLowerCase());
+                    const deletedAt = eResult.find((r) => r.COLUMN_NAME.trim().toLowerCase() === EntityInfo.DeletedAtFieldName.trim().toLowerCase());
                     // now, if we have the fields, we need to check the default value and update if necessary
-                    const fieldResult = await this.ensureSpecialDateFieldExistsAndHasCorrectDefaultValue(pool, e, core_1.EntityInfo.DeletedAtFieldName, deletedAt, true);
+                    const fieldResult = await this.ensureSpecialDateFieldExistsAndHasCorrectDefaultValue(pool, e, EntityInfo.DeletedAtFieldName, deletedAt, true);
                     overallResult = overallResult && fieldResult;
                 }
             }
             return overallResult;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -646,76 +1363,86 @@ class ManageMetadataBase {
      */
     async applySoftPKFKConfig(pool) {
         // Check if additionalSchemaInfo is configured in mj.config.cjs
-        if (!config_1.configInfo.additionalSchemaInfo) {
+        if (!configInfo.additionalSchemaInfo) {
             // No additional schema info configured - this is fine, it's optional
             return true;
         }
-        const configPath = path_1.default.join(config_1.currentWorkingDirectory, config_1.configInfo.additionalSchemaInfo);
+        const configPath = path.join(currentWorkingDirectory, configInfo.additionalSchemaInfo);
         if (!fs.existsSync(configPath)) {
-            (0, status_logging_1.logStatus)(`         ⚠️  additionalSchemaInfo configured but file not found: ${configPath}`);
+            logStatus(`         ⚠️  additionalSchemaInfo configured but file not found: ${configPath}`);
             return true;
         }
         try {
-            (0, status_logging_1.logStatus)(`         Found ${config_1.configInfo.additionalSchemaInfo}, applying soft PK/FK configuration...`);
+            logStatus(`         Found ${configInfo.additionalSchemaInfo}, applying soft PK/FK configuration...`);
             const config = ManageMetadataBase.getSoftPKFKConfig();
             let totalPKs = 0;
             let totalFKs = 0;
-            const schema = (0, config_1.mj_core_schema)();
-            for (const table of config.tables || []) {
+            const schema = mj_core_schema();
+            // Config supports two formats:
+            //   1. Schema-as-key (template format): { "dbo": [{ "TableName": "Orders", ... }] }
+            //   2. Flat tables array (legacy format): { "tables": [{ "SchemaName": "dbo", "TableName": "Orders", ... }] }
+            // Both use PascalCase property names.
+            const tables = this.extractTablesFromConfig(config);
+            for (const table of tables) {
+                const tableSchema = table.SchemaName;
+                const tableName = table.TableName;
                 // Look up entity ID (SELECT query - no need to log to migration file)
-                const entityLookupSQL = `SELECT ID FROM [${schema}].[Entity] WHERE SchemaName = '${table.schemaName}' AND BaseTable = '${table.tableName}'`;
+                const entityLookupSQL = `SELECT ID FROM [${schema}].[Entity] WHERE SchemaName = '${tableSchema}' AND BaseTable = '${tableName}'`;
                 const entityResult = await pool.request().query(entityLookupSQL);
                 if (entityResult.recordset.length === 0) {
-                    (0, status_logging_1.logStatus)(`         ⚠️  Entity not found for ${table.schemaName}.${table.tableName} - skipping`);
+                    logStatus(`         ⚠️  Entity not found for ${tableSchema}.${tableName} - skipping`);
                     continue;
                 }
                 const entityId = entityResult.recordset[0].ID;
                 // Process primary keys - set BOTH IsPrimaryKey = 1 AND IsSoftPrimaryKey = 1
                 // IsPrimaryKey is the source of truth, IsSoftPrimaryKey protects it from schema sync
-                if (table.primaryKeys && table.primaryKeys.length > 0) {
-                    for (const pk of table.primaryKeys) {
+                const primaryKeys = table.PrimaryKey || [];
+                if (primaryKeys.length > 0) {
+                    for (const pk of primaryKeys) {
                         const sSQL = `UPDATE [${schema}].[EntityField]
-                                SET ${core_1.EntityInfo.UpdatedAtFieldName}=GETUTCDATE(),
+                                SET ${EntityInfo.UpdatedAtFieldName}=GETUTCDATE(),
                                     [IsPrimaryKey] = 1,
                                     [IsSoftPrimaryKey] = 1
-                                WHERE [EntityID] = '${entityId}' AND [Name] = '${pk.fieldName}'`;
-                        const result = await this.LogSQLAndExecute(pool, sSQL, `Set soft PK for ${table.schemaName}.${table.tableName}.${pk.fieldName}`);
+                                WHERE [EntityID] = '${entityId}' AND [Name] = '${pk.FieldName}'`;
+                        const result = await this.LogSQLAndExecute(pool, sSQL, `Set soft PK for ${tableSchema}.${tableName}.${pk.FieldName}`);
                         if (result !== null) {
-                            (0, status_logging_1.logStatus)(`         ✓ Set IsPrimaryKey=1, IsSoftPrimaryKey=1 for ${table.tableName}.${pk.fieldName}`);
+                            logStatus(`         ✓ Set IsPrimaryKey=1, IsSoftPrimaryKey=1 for ${tableName}.${pk.FieldName}`);
                             totalPKs++;
                         }
                     }
                 }
                 // Process foreign keys - set RelatedEntityID, RelatedEntityFieldName, and IsSoftForeignKey = 1
-                if (table.foreignKeys && table.foreignKeys.length > 0) {
-                    for (const fk of table.foreignKeys) {
+                const foreignKeys = table.ForeignKeys || [];
+                if (foreignKeys.length > 0) {
+                    for (const fk of foreignKeys) {
+                        const fkSchema = fk.SchemaName || tableSchema;
                         // Look up related entity ID (SELECT query - no need to log to migration file)
-                        const relatedLookupSQL = `SELECT ID FROM [${schema}].[Entity] WHERE SchemaName = '${fk.relatedSchema}' AND BaseTable = '${fk.relatedTable}'`;
+                        const relatedLookupSQL = `SELECT ID FROM [${schema}].[Entity] WHERE SchemaName = '${fkSchema}' AND BaseTable = '${fk.RelatedTable}'`;
                         const relatedEntityResult = await pool.request().query(relatedLookupSQL);
                         if (relatedEntityResult.recordset.length === 0) {
-                            (0, status_logging_1.logStatus)(`         ⚠️  Related entity not found for ${fk.relatedSchema}.${fk.relatedTable} - skipping FK ${fk.fieldName}`);
+                            logStatus(`         ⚠️  Related entity not found for ${fkSchema}.${fk.RelatedTable} - skipping FK ${fk.FieldName}`);
                             continue;
                         }
                         const relatedEntityId = relatedEntityResult.recordset[0].ID;
                         const sSQL = `UPDATE [${schema}].[EntityField]
-                                SET ${core_1.EntityInfo.UpdatedAtFieldName}=GETUTCDATE(),
+                                SET ${EntityInfo.UpdatedAtFieldName}=GETUTCDATE(),
                                     [RelatedEntityID] = '${relatedEntityId}',
-                                    [RelatedEntityFieldName] = '${fk.relatedField}',
+                                    [RelatedEntityFieldName] = '${fk.RelatedField}',
                                     [IsSoftForeignKey] = 1
-                                WHERE [EntityID] = '${entityId}' AND [Name] = '${fk.fieldName}'`;
-                        const result = await this.LogSQLAndExecute(pool, sSQL, `Set soft FK for ${table.schemaName}.${table.tableName}.${fk.fieldName} → ${fk.relatedTable}.${fk.relatedField}`);
+                                WHERE [EntityID] = '${entityId}' AND [Name] = '${fk.FieldName}'`;
+                        const result = await this.LogSQLAndExecute(pool, sSQL, `Set soft FK for ${tableSchema}.${tableName}.${fk.FieldName} → ${fk.RelatedTable}.${fk.RelatedField}`);
                         if (result !== null) {
-                            (0, status_logging_1.logStatus)(`         ✓ Set soft FK for ${table.tableName}.${fk.fieldName} → ${fk.relatedTable}.${fk.relatedField}`);
+                            logStatus(`         ✓ Set soft FK for ${tableName}.${fk.FieldName} → ${fk.RelatedTable}.${fk.RelatedField}`);
                             totalFKs++;
                         }
                     }
                 }
             }
-            (0, status_logging_1.logStatus)(`         Applied ${totalPKs} soft PK(s) and ${totalFKs} soft FK(s) from configuration`);
+            logStatus(`         Applied ${totalPKs} soft PK(s) and ${totalFKs} soft FK(s) from configuration`);
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(`Error applying soft PK/FK configuration: ${e}`);
+            logError(`Error applying soft PK/FK configuration: ${e}`);
             return false;
         }
     }
@@ -730,7 +1457,7 @@ class ManageMetadataBase {
             const sqlEntities = `SELECT
                                  *
                               FROM
-                                 [${(0, config_1.mj_core_schema)()}].vwEntities
+                                 [${mj_core_schema()}].vwEntities
                               WHERE
                                  VirtualEntity = 0 AND
                                  TrackRecordChanges = 1 AND
@@ -746,24 +1473,24 @@ class ManageMetadataBase {
                                        FROM INFORMATION_SCHEMA.COLUMNS
                                        WHERE
                                           ${entities.map((e) => `(TABLE_SCHEMA='${e.SchemaName}' AND TABLE_NAME='${e.BaseTable}')`).join(' OR ')}
-                                       AND COLUMN_NAME IN ('${core_1.EntityInfo.CreatedAtFieldName}','${core_1.EntityInfo.UpdatedAtFieldName}')`;
+                                       AND COLUMN_NAME IN ('${EntityInfo.CreatedAtFieldName}','${EntityInfo.UpdatedAtFieldName}')`;
                 const resultResult = await pool.request().query(sqlCreatedUpdated);
                 const result = resultResult.recordset;
                 for (const e of entities) {
                     // result has both created at and updated at fields, so filter on the result for each and do what we need to based on that
                     const eResult = result.filter((r) => r.TABLE_NAME === e.BaseTable && r.TABLE_SCHEMA === e.SchemaName); // get just the fields for this entity
-                    const createdAt = eResult.find((r) => r.COLUMN_NAME.trim().toLowerCase() === core_1.EntityInfo.CreatedAtFieldName.trim().toLowerCase());
-                    const updatedAt = eResult.find((r) => r.COLUMN_NAME.trim().toLowerCase() === core_1.EntityInfo.UpdatedAtFieldName.trim().toLowerCase());
+                    const createdAt = eResult.find((r) => r.COLUMN_NAME.trim().toLowerCase() === EntityInfo.CreatedAtFieldName.trim().toLowerCase());
+                    const updatedAt = eResult.find((r) => r.COLUMN_NAME.trim().toLowerCase() === EntityInfo.UpdatedAtFieldName.trim().toLowerCase());
                     // now, if we have the fields, we need to check the default value and update if necessary
-                    const fieldResult = await this.ensureSpecialDateFieldExistsAndHasCorrectDefaultValue(pool, e, core_1.EntityInfo.CreatedAtFieldName, createdAt, false) &&
-                        await this.ensureSpecialDateFieldExistsAndHasCorrectDefaultValue(pool, e, core_1.EntityInfo.UpdatedAtFieldName, updatedAt, false);
+                    const fieldResult = await this.ensureSpecialDateFieldExistsAndHasCorrectDefaultValue(pool, e, EntityInfo.CreatedAtFieldName, createdAt, false) &&
+                        await this.ensureSpecialDateFieldExistsAndHasCorrectDefaultValue(pool, e, EntityInfo.UpdatedAtFieldName, updatedAt, false);
                     overallResult = overallResult && fieldResult;
                 }
             }
             return overallResult;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -799,7 +1526,7 @@ class ManageMetadataBase {
                     // field that is NOT NULL
                     if (!allowNull) {
                         const defaultValue = currentFieldData.COLUMN_DEFAULT;
-                        const realDefaultValue = (0, core_1.ExtractActualDefaultValue)(defaultValue);
+                        const realDefaultValue = ExtractActualDefaultValue(defaultValue);
                         if (!realDefaultValue || realDefaultValue.trim().toLowerCase() !== 'getutcdate()') {
                             await this.dropAndCreateDefaultConstraintForSpecialDateField(pool, entity, fieldName);
                         }
@@ -810,7 +1537,7 @@ class ManageMetadataBase {
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -819,11 +1546,11 @@ class ManageMetadataBase {
      */
     async createDefaultConstraintForSpecialDateField(pool, entity, fieldName) {
         try {
-            const sqlAddDefaultConstraint = `ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] ADD CONSTRAINT DF_${entity.SchemaName}_${(0, core_1.CodeNameFromString)(entity.BaseTable)}_${fieldName} DEFAULT GETUTCDATE() FOR [${fieldName}]`;
+            const sqlAddDefaultConstraint = `ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] ADD CONSTRAINT DF_${entity.SchemaName}_${CodeNameFromString(entity.BaseTable)}_${fieldName} DEFAULT GETUTCDATE() FOR [${fieldName}]`;
             await this.LogSQLAndExecute(pool, sqlAddDefaultConstraint, `SQL text to add default constraint for special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
         }
     }
     /**
@@ -867,7 +1594,7 @@ class ManageMetadataBase {
             await this.LogSQLAndExecute(pool, sqlDropDefaultConstraint, `SQL text to drop default existing default constraints in entity ${entity.SchemaName}.${entity.BaseTable}`);
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
         }
     }
     /**
@@ -879,18 +1606,18 @@ class ManageMetadataBase {
      */
     async generateNewEntityDescriptions(pool, md, currentUser) {
         // for the list of new entities, go through and attempt to generate new entity descriptions
-        const ag = new advanced_generation_1.AdvancedGeneration();
+        const ag = new AdvancedGeneration();
         if (ag.featureEnabled('EntityDescriptions')) {
             // we have the feature enabled, so let's loop through the new entities and generate descriptions for them
             for (let e of ManageMetadataBase.newEntityList) {
-                const dataResult = await pool.request().query(`SELECT * FROM [${(0, config_1.mj_core_schema)()}].vwEntities WHERE Name = '${e}'`);
+                const dataResult = await pool.request().query(`SELECT * FROM [${mj_core_schema()}].vwEntities WHERE Name = '${e}'`);
                 const data = dataResult.recordset;
-                const fieldsResult = await pool.request().query(`SELECT * FROM [${(0, config_1.mj_core_schema)()}].vwEntityFields WHERE EntityID='${data[0].ID}'`);
+                const fieldsResult = await pool.request().query(`SELECT * FROM [${mj_core_schema()}].vwEntityFields WHERE EntityID='${data[0].ID}'`);
                 const fields = fieldsResult.recordset;
                 // Use new API to generate entity description
                 const result = await ag.generateEntityDescription(e, data[0].BaseTable, fields.map((f) => ({ Name: f.Name, Type: f.Type, IsNullable: f.AllowsNull, Description: f.Description })), currentUser);
                 if (result?.entityDescription && result.entityDescription.length > 0) {
-                    const sSQL = `UPDATE [${(0, config_1.mj_core_schema)()}].Entity SET Description = '${result.entityDescription}' WHERE Name = '${e}'`;
+                    const sSQL = `UPDATE [${mj_core_schema()}].Entity SET Description = '${result.entityDescription}' WHERE Name = '${e}'`;
                     await this.LogSQLAndExecute(pool, sSQL, `SQL text to update entity description for entity ${e}`);
                 }
                 else {
@@ -912,9 +1639,9 @@ class ManageMetadataBase {
             const sql = `SELECT
                         ef.ID, ef.Name
                       FROM
-                        [${(0, config_1.mj_core_schema)()}].vwEntityFields ef
+                        [${mj_core_schema()}].vwEntityFields ef
                       INNER JOIN
-                        [${(0, config_1.mj_core_schema)()}].vwEntities e
+                        [${mj_core_schema()}].vwEntities e
                       ON
                         ef.EntityID = e.ID
                       WHERE
@@ -927,16 +1654,16 @@ class ManageMetadataBase {
             const fields = fieldsResult.recordset;
             if (fields && fields.length > 0)
                 for (const field of fields) {
-                    const sDisplayName = (0, global_1.stripTrailingChars)((0, global_1.convertCamelCaseToHaveSpaces)(field.Name), 'ID', true).trim();
+                    const sDisplayName = stripTrailingChars(convertCamelCaseToHaveSpaces(field.Name), 'ID', true).trim();
                     if (sDisplayName.length > 0 && sDisplayName.toLowerCase().trim() !== field.Name.toLowerCase().trim()) {
-                        const sSQL = `UPDATE [${(0, config_1.mj_core_schema)()}].EntityField SET ${core_1.EntityInfo.UpdatedAtFieldName}=GETUTCDATE(), DisplayName = '${sDisplayName}' WHERE ID = '${field.ID}'`;
+                        const sSQL = `UPDATE [${mj_core_schema()}].EntityField SET ${EntityInfo.UpdatedAtFieldName}=GETUTCDATE(), DisplayName = '${sDisplayName}' WHERE ID = '${field.ID}'`;
                         await this.LogSQLAndExecute(pool, sSQL, `SQL text to update display name for field ${field.Name}`);
                     }
                 }
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -950,12 +1677,12 @@ class ManageMetadataBase {
      */
     async setDefaultColumnWidthWhereNeeded(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC ${(0, config_1.mj_core_schema)()}.spSetDefaultColumnWidthWhereNeeded @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = `EXEC ${mj_core_schema()}.spSetDefaultColumnWidthWhereNeeded @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
             await this.LogSQLAndExecute(pool, sSQL, `SQL text to set default column width where needed`, true);
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -977,7 +1704,7 @@ class ManageMetadataBase {
       EntityID,
       ISNULL(MAX(Sequence), 0) AS MaxSequence
    FROM
-      [${(0, config_1.mj_core_schema)()}].EntityField
+      [${mj_core_schema()}].EntityField
    GROUP BY
       EntityID
 ),
@@ -996,9 +1723,9 @@ NumberedRows AS (
       sf.AllowsNull,
       sf.DefaultValue,
       sf.AutoIncrement,
-      IIF(sf.IsVirtual = 1, 0, IIF(sf.FieldName = '${core_1.EntityInfo.CreatedAtFieldName}' OR
-                                   sf.FieldName = '${core_1.EntityInfo.UpdatedAtFieldName}' OR
-                                   sf.FieldName = '${core_1.EntityInfo.DeletedAtFieldName}' OR
+      IIF(sf.IsVirtual = 1, 0, IIF(sf.FieldName = '${EntityInfo.CreatedAtFieldName}' OR
+                                   sf.FieldName = '${EntityInfo.UpdatedAtFieldName}' OR
+                                   sf.FieldName = '${EntityInfo.DeletedAtFieldName}' OR
                                    pk.ColumnName IS NOT NULL, 0, 1)) AllowUpdateAPI,
       sf.IsVirtual,
       e.RelationshipDefaultDisplayType,
@@ -1020,34 +1747,34 @@ NumberedRows AS (
          END,
       ROW_NUMBER() OVER (PARTITION BY sf.EntityID, sf.FieldName ORDER BY (SELECT NULL)) AS rn
    FROM
-      [${(0, config_1.mj_core_schema)()}].vwSQLColumnsAndEntityFields sf
+      [${mj_core_schema()}].vwSQLColumnsAndEntityFields sf
    LEFT OUTER JOIN
       MaxSequences ms
    ON
       sf.EntityID = ms.EntityID
    LEFT OUTER JOIN
-      [${(0, config_1.mj_core_schema)()}].Entity e
+      [${mj_core_schema()}].Entity e
    ON
       sf.EntityID = e.ID
    LEFT OUTER JOIN
-      [${(0, config_1.mj_core_schema)()}].vwForeignKeys fk
+      [${mj_core_schema()}].vwForeignKeys fk
    ON
       sf.FieldName = fk.[column] AND
       e.BaseTable = fk.[table] AND
       e.SchemaName = fk.[schema_name]
    LEFT OUTER JOIN
-      [${(0, config_1.mj_core_schema)()}].Entity re -- Related Entity
+      [${mj_core_schema()}].Entity re -- Related Entity
    ON
       re.BaseTable = fk.referenced_table AND
       re.SchemaName = fk.[referenced_schema]
    LEFT OUTER JOIN
-      [${(0, config_1.mj_core_schema)()}].vwTablePrimaryKeys pk
+      [${mj_core_schema()}].vwTablePrimaryKeys pk
    ON
       e.BaseTable = pk.TableName AND
       sf.FieldName = pk.ColumnName AND
       e.SchemaName = pk.SchemaName
    LEFT OUTER JOIN
-      [${(0, config_1.mj_core_schema)()}].vwTableUniqueKeys uk
+      [${mj_core_schema()}].vwTableUniqueKeys uk
    ON
       e.BaseTable = uk.TableName AND
       sf.FieldName = uk.ColumnName AND
@@ -1088,22 +1815,22 @@ NumberedRows AS (
         const isPrimaryKey = n.FieldName?.trim().toLowerCase() === 'id';
         const isForeignKey = n.RelatedEntityID && n.RelatedEntityID.length > 0; // Foreign keys have RelatedEntityID set
         const isNameField = n.FieldName?.trim().toLowerCase() === 'name' || n.IsNameField;
-        const isEarlySequence = n.Sequence <= config_1.configInfo.newEntityDefaults?.IncludeFirstNFieldsAsDefaultInView;
+        const isEarlySequence = n.Sequence <= configInfo.newEntityDefaults?.IncludeFirstNFieldsAsDefaultInView;
         const bDefaultInView = (isNameField || isEarlySequence) && !isPrimaryKey && !isForeignKey;
         const escapedDescription = n.Description ? `'${n.Description.replace(/'/g, "''")}'` : 'NULL';
         let fieldDisplayName = '';
         switch (n.FieldName.trim().toLowerCase()) {
-            case core_1.EntityInfo.CreatedAtFieldName.trim().toLowerCase():
+            case EntityInfo.CreatedAtFieldName.trim().toLowerCase():
                 fieldDisplayName = "Created At";
                 break;
-            case core_1.EntityInfo.UpdatedAtFieldName.trim().toLowerCase():
+            case EntityInfo.UpdatedAtFieldName.trim().toLowerCase():
                 fieldDisplayName = "Updated At";
                 break;
-            case core_1.EntityInfo.DeletedAtFieldName.trim().toLowerCase():
+            case EntityInfo.DeletedAtFieldName.trim().toLowerCase():
                 fieldDisplayName = "Deleted At";
                 break;
             default:
-                fieldDisplayName = (0, global_1.convertCamelCaseToHaveSpaces)(n.FieldName).trim();
+                fieldDisplayName = convertCamelCaseToHaveSpaces(n.FieldName).trim();
                 break;
         }
         const parsedDefaultValue = this.parseDefaultValue(n.DefaultValue);
@@ -1112,13 +1839,13 @@ NumberedRows AS (
         // in the above we are setting quotedDefaultValue to NULL if the parsed default value is an empty string or the string 'NULL' (case insensitive)
         return `
       IF NOT EXISTS (
-         SELECT 1 FROM [${(0, config_1.mj_core_schema)()}].EntityField 
+         SELECT 1 FROM [${mj_core_schema()}].EntityField 
          WHERE ID = '${newEntityFieldUUID}'  OR 
                (EntityID = '${n.EntityID}' AND Name = '${n.FieldName}')
          -- check to make sure we're not inserting a duplicate entity field metadata record
       )
       BEGIN
-         INSERT INTO [${(0, config_1.mj_core_schema)()}].EntityField
+         INSERT INTO [${mj_core_schema()}].EntityField
          (
             ID,
             EntityID,
@@ -1219,7 +1946,7 @@ NumberedRows AS (
                         }
                         catch (e) {
                             // this is here so we can catch the error for debug. We want the transaction to die
-                            (0, status_logging_1.logError)(`Error inserting new entity field. SQL: \n${sSQLInsert}`);
+                            logError(`Error inserting new entity field. SQL: \n${sSQLInsert}`);
                             throw e;
                         }
                     }
@@ -1237,7 +1964,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1250,20 +1977,20 @@ NumberedRows AS (
      */
     async updateEntityFieldRelatedEntityNameFieldMap(pool, entityFieldID, relatedEntityNameFieldMap) {
         try {
-            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spUpdateEntityFieldRelatedEntityNameFieldMap
+            const sSQL = `EXEC [${mj_core_schema()}].spUpdateEntityFieldRelatedEntityNameFieldMap
          @EntityFieldID='${entityFieldID}',
          @RelatedEntityNameFieldMap='${relatedEntityNameFieldMap}'`;
             await this.LogSQLAndExecute(pool, sSQL, `SQL text to update entity field related entity name field map for entity field ID ${entityFieldID}`);
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
     async updateExistingEntitiesFromSchema(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spUpdateExistingEntitiesFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = `EXEC [${mj_core_schema()}].spUpdateExistingEntitiesFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
             const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to update existing entities from schema`, true);
             // result contains the updated entities, and there is a property of each row called Name which has the entity name that was modified
             // add these to the modified entity list if they're not already in there
@@ -1273,7 +2000,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1288,7 +2015,7 @@ NumberedRows AS (
     }
     async updateExistingEntityFieldsFromSchema(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spUpdateExistingEntityFieldsFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = `EXEC [${mj_core_schema()}].spUpdateExistingEntityFieldsFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
             const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to update existing entity fields from schema`, true);
             // result contains the updated entity fields
             // there is a field in there called EntityName. Get a distinct list of entity names from this and add them
@@ -1299,7 +2026,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1313,21 +2040,21 @@ NumberedRows AS (
      */
     async updateSchemaInfoFromDatabase(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spUpdateSchemaInfoFromDatabase @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = `EXEC [${mj_core_schema()}].spUpdateSchemaInfoFromDatabase @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
             const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to sync schema info from database schemas`, true);
             if (result && result.length > 0) {
-                (0, status_logging_1.logStatus)(`   > Updated/created ${result.length} SchemaInfo records`);
+                logStatus(`   > Updated/created ${result.length} SchemaInfo records`);
             }
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
     async deleteUnneededEntityFields(pool, excludeSchemas) {
         try {
-            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spDeleteUnneededEntityFields @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            const sSQL = `EXEC [${mj_core_schema()}].spDeleteUnneededEntityFields @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
             const result = await this.LogSQLAndExecute(pool, sSQL, `SQL text to delete unneeded entity fields`, true);
             // result contains the DELETED entity fields
             // there is a field in there called Entity. Get a distinct list of entity names from this and add them
@@ -1338,7 +2065,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1349,13 +2076,13 @@ NumberedRows AS (
             // for the field and sync that up with the EntityFieldValue table. If it is not a simple series of OR statements, we will not be able to parse it and we'll
             // just ignore it.
             const filter = excludeSchemas && excludeSchemas.length > 0 ? ` WHERE SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})` : '';
-            const sSQL = `SELECT * FROM [${(0, config_1.mj_core_schema)()}].vwEntityFieldsWithCheckConstraints${filter}`;
+            const sSQL = `SELECT * FROM [${mj_core_schema()}].vwEntityFieldsWithCheckConstraints${filter}`;
             const resultResult = await pool.request().query(sSQL);
             const result = resultResult.recordset;
-            const efvSQL = `SELECT * FROM [${(0, config_1.mj_core_schema)()}].EntityFieldValue`;
+            const efvSQL = `SELECT * FROM [${mj_core_schema()}].EntityFieldValue`;
             const allEntityFieldValuesResult = await pool.request().query(efvSQL);
             const allEntityFieldValues = allEntityFieldValuesResult.recordset;
-            const efSQL = `SELECT * FROM [${(0, config_1.mj_core_schema)()}].vwEntityFields ORDER BY EntityID, Sequence`;
+            const efSQL = `SELECT * FROM [${mj_core_schema()}].vwEntityFields ORDER BY EntityID, Sequence`;
             const allEntityFieldsResult = await pool.request().query(efSQL);
             const allEntityFields = allEntityFieldsResult.recordset;
             const generationPromises = [];
@@ -1377,11 +2104,11 @@ NumberedRows AS (
                             await this.syncEntityFieldValues(pool, r.EntityFieldID, parsedValues, allEntityFieldValues);
                             // finally, make sure the ValueListType column within the EntityField table is set to "List" because for check constraints we only allow the values specified in the list.
                             // check to see if the ValueListType is already set to "List", if not, update it
-                            const sSQLCheck = `SELECT ValueListType FROM [${(0, config_1.mj_core_schema)()}].EntityField WHERE ID='${r.EntityFieldID}'`;
+                            const sSQLCheck = `SELECT ValueListType FROM [${mj_core_schema()}].EntityField WHERE ID='${r.EntityFieldID}'`;
                             const checkResultResult = await pool.request().query(sSQLCheck);
                             const checkResult = checkResultResult.recordset;
                             if (checkResult && checkResult.length > 0 && checkResult[0].ValueListType.trim().toLowerCase() !== 'list') {
-                                const sSQL = `UPDATE [${(0, config_1.mj_core_schema)()}].EntityField SET ValueListType='List' WHERE ID='${r.EntityFieldID}'`;
+                                const sSQL = `UPDATE [${mj_core_schema()}].EntityField SET ValueListType='List' WHERE ID='${r.EntityFieldID}'`;
                                 await this.LogSQLAndExecute(pool, sSQL, `SQL text to update ValueListType for entity field ID ${r.EntityFieldID}`);
                             }
                         }
@@ -1392,8 +2119,8 @@ NumberedRows AS (
                     else {
                         // if we get here that means we don't have a simple condition in the check constraint that the RegEx could parse. If Advanced Generation is enabled, we will
                         // attempt to use an LLM to do things fancier now
-                        if (config_1.configInfo.advancedGeneration?.enableAdvancedGeneration &&
-                            config_1.configInfo.advancedGeneration?.features.find(f => f.name === 'ParseCheckConstraints' && f.enabled)) {
+                        if (configInfo.advancedGeneration?.enableAdvancedGeneration &&
+                            configInfo.advancedGeneration?.features.find(f => f.name === 'ParseCheckConstraints' && f.enabled)) {
                             // the user has the feature turned on, let's generate a description of the constraint and then build a Validate function for the constraint 
                             // run this in parallel
                             generationPromises.push(this.runValidationGeneration(r, allEntityFields, !skipDBUpdate, currentUser));
@@ -1403,8 +2130,8 @@ NumberedRows AS (
             }
             // now for the table level constraints run the process for advanced generation
             for (const r of tableLevelResults) {
-                if (config_1.configInfo.advancedGeneration?.enableAdvancedGeneration &&
-                    config_1.configInfo.advancedGeneration?.features.find(f => f.name === 'ParseCheckConstraints' && f.enabled)) {
+                if (configInfo.advancedGeneration?.enableAdvancedGeneration &&
+                    configInfo.advancedGeneration?.features.find(f => f.name === 'ParseCheckConstraints' && f.enabled)) {
                     // the user has the feature turned on, let's generate a description of the constraint and then build a Validate function for the constraint 
                     // run this in parallel
                     generationPromises.push(this.runValidationGeneration(r, allEntityFields, !skipDBUpdate, currentUser));
@@ -1415,7 +2142,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1430,7 +2157,7 @@ NumberedRows AS (
             return await this.manageEntityFieldValuesAndValidatorFunctions(pool, [], currentUser, true);
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1476,9 +2203,9 @@ NumberedRows AS (
             }
         }
         try {
-            if (generateNewCode && config_1.configInfo.advancedGeneration?.enableAdvancedGeneration && config_1.configInfo.advancedGeneration?.features.find(f => f.name === 'ParseCheckConstraints' && f.enabled)) {
+            if (generateNewCode && configInfo.advancedGeneration?.enableAdvancedGeneration && configInfo.advancedGeneration?.features.find(f => f.name === 'ParseCheckConstraints' && f.enabled)) {
                 // feature is enabled, so let's call the AI to generate a function for us
-                const ag = new advanced_generation_1.AdvancedGeneration();
+                const ag = new AdvancedGeneration();
                 const entityFieldListInfo = allEntityFields.filter(item => item.Entity.trim().toLowerCase() === data.EntityName.trim().toLowerCase()).map(item => `   * ${item.Name} - ${item.Type}${item.AllowsNull ? ' (nullable)' : ' (not null)'}`).join('\n');
                 // Use new API to parse check constraint
                 const result = await ag.parseCheckConstraint(constraintDefinition, entityFieldListInfo, generatedValidationFunctionName, currentUser);
@@ -1491,12 +2218,12 @@ NumberedRows AS (
                     returnResult.success = true;
                 }
                 else {
-                    (0, status_logging_1.logError)(`Error generating field validator function from check constraint for entity ${entityName} and field ${fieldName}. LLM returned invalid result.`);
+                    logError(`Error generating field validator function from check constraint for entity ${entityName} and field ${fieldName}. LLM returned invalid result.`);
                 }
             }
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
         }
         finally {
             return returnResult;
@@ -1515,7 +2242,7 @@ NumberedRows AS (
                 for (const ev of existingValues) {
                     if (!possibleValues.find(v => v === ev.Value)) {
                         // delete the value from the database
-                        const sSQLDelete = `DELETE FROM [${(0, config_1.mj_core_schema)()}].EntityFieldValue WHERE ID='${ev.ID}'`;
+                        const sSQLDelete = `DELETE FROM [${mj_core_schema()}].EntityFieldValue WHERE ID='${ev.ID}'`;
                         await this.LogSQLAndExecute(ds, sSQLDelete, `SQL text to delete entity field value ID ${ev.ID}`);
                         numRemoved++;
                     }
@@ -1525,9 +2252,9 @@ NumberedRows AS (
                 for (const v of possibleValues) {
                     if (!existingValues.find((ev) => ev.Value === v)) {
                         // Generate a UUID for this new EntityFieldValue record
-                        const newId = (0, uuid_1.v4)();
+                        const newId = uuidv4();
                         // add the value to the database with explicit ID
-                        const sSQLInsert = `INSERT INTO [${(0, config_1.mj_core_schema)()}].EntityFieldValue
+                        const sSQLInsert = `INSERT INTO [${mj_core_schema()}].EntityFieldValue
                                        (ID, EntityFieldID, Sequence, Value, Code)
                                     VALUES
                                        ('${newId}', '${entityFieldID}', ${1 + possibleValues.indexOf(v)}, '${v}', '${v}')`;
@@ -1541,7 +2268,7 @@ NumberedRows AS (
                     const ev = existingValues.find((ev) => ev.Value === v);
                     if (ev && ev.Sequence !== 1 + possibleValues.indexOf(v)) {
                         // update the sequence to match the order in the possible values list, if it doesn't already match
-                        const sSQLUpdate = `UPDATE [${(0, config_1.mj_core_schema)()}].EntityFieldValue SET Sequence=${1 + possibleValues.indexOf(v)} WHERE ID='${ev.ID}'`;
+                        const sSQLUpdate = `UPDATE [${mj_core_schema()}].EntityFieldValue SET Sequence=${1 + possibleValues.indexOf(v)} WHERE ID='${ev.ID}'`;
                         await this.LogSQLAndExecute(ds, sSQLUpdate, `SQL text to update entity field value sequence`);
                         numUpdated++;
                     }
@@ -1555,7 +2282,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1614,9 +2341,9 @@ NumberedRows AS (
     createExcludeTablesAndSchemasFilter(fieldPrefix) {
         let sExcludeTables = '';
         let sExcludeSchemas = '';
-        if (config_1.configInfo.excludeTables) {
-            for (let i = 0; i < config_1.configInfo.excludeTables.length; ++i) {
-                const t = config_1.configInfo.excludeTables[i];
+        if (configInfo.excludeTables) {
+            for (let i = 0; i < configInfo.excludeTables.length; ++i) {
+                const t = configInfo.excludeTables[i];
                 sExcludeTables += (sExcludeTables.length > 0 ? ' AND ' : '') +
                     (t.schema.indexOf('%') > -1 ? ` NOT ( ${fieldPrefix}SchemaName LIKE '${t.schema}'` :
                         ` NOT ( ${fieldPrefix}SchemaName = '${t.schema}'`);
@@ -1624,9 +2351,9 @@ NumberedRows AS (
                     ` AND ${fieldPrefix}TableName = '${t.table}') `);
             }
         }
-        if (config_1.configInfo.excludeSchemas) {
-            for (let i = 0; i < config_1.configInfo.excludeSchemas.length; ++i) {
-                const s = config_1.configInfo.excludeSchemas[i];
+        if (configInfo.excludeSchemas) {
+            for (let i = 0; i < configInfo.excludeSchemas.length; ++i) {
+                const s = configInfo.excludeSchemas[i];
                 sExcludeSchemas += (sExcludeSchemas.length > 0 ? ' AND ' : '') +
                     (s.indexOf('%') > -1 ? `${fieldPrefix}SchemaName NOT LIKE '${s}'` : `${fieldPrefix}SchemaName <> '${s}'`);
             }
@@ -1638,11 +2365,11 @@ NumberedRows AS (
     }
     async createNewEntities(pool, currentUser) {
         try {
-            const sSQL = `SELECT * FROM [${(0, config_1.mj_core_schema)()}].vwSQLTablesAndEntities WHERE EntityID IS NULL ` + this.createExcludeTablesAndSchemasFilter('');
+            const sSQL = `SELECT * FROM [${mj_core_schema()}].vwSQLTablesAndEntities WHERE EntityID IS NULL ` + this.createExcludeTablesAndSchemasFilter('');
             const newEntitiesResult = await pool.request().query(sSQL);
             const newEntities = newEntitiesResult.recordset;
             if (newEntities && newEntities.length > 0) {
-                const md = new core_1.Metadata();
+                const md = new Metadata();
                 const transaction = new sql.Transaction(pool);
                 await transaction.begin();
                 try {
@@ -1659,14 +2386,14 @@ NumberedRows AS (
                 }
                 if (ManageMetadataBase.newEntityList.length > 0) {
                     // only do this if we actually created new entities
-                    (0, core_1.LogStatus)(`   Done creating entities, refreshing metadata to reflect new entities...`);
+                    LogStatus(`   Done creating entities, refreshing metadata to reflect new entities...`);
                     await md.Refresh(); // refresh now since we've added some new entities
                 }
             }
             return true; // if we get here, we succeeded
         }
         catch (e) {
-            (0, core_1.LogError)(e);
+            LogError(e);
             return false;
         }
     }
@@ -1675,14 +2402,14 @@ NumberedRows AS (
         // criteria:
         // 1) entity has a field that is a primary key
         // validate all of these factors by getting the sql from SQL Server and check the result, if failure, shouldCreate=false and generate validation message, otherwise return empty validation message and true for shouldCreate.
-        const query = `EXEC ${core_1.Metadata.Provider.ConfigData.MJCoreSchemaName}.spGetPrimaryKeyForTable @TableName='${newEntity.TableName}', @SchemaName='${newEntity.SchemaName}'`;
+        const query = `EXEC ${Metadata.Provider.ConfigData.MJCoreSchemaName}.spGetPrimaryKeyForTable @TableName='${newEntity.TableName}', @SchemaName='${newEntity.SchemaName}'`;
         try {
             const resultResult = await ds.request().query(query);
             const result = resultResult.recordset;
             if (result.length === 0) {
                 // No database PK constraint found - check if there's a soft PK defined in config
                 if (this.hasSoftPrimaryKeyInConfig(newEntity.SchemaName, newEntity.TableName)) {
-                    (0, status_logging_1.logStatus)(`         ✓ No database PK for ${newEntity.SchemaName}.${newEntity.TableName}, but soft PK found in config - allowing entity creation`);
+                    logStatus(`         ✓ No database PK for ${newEntity.SchemaName}.${newEntity.TableName}, but soft PK found in config - allowing entity creation`);
                     return { shouldCreate: true, validationMessage: '' };
                 }
                 return { shouldCreate: false, validationMessage: "No primary key found" };
@@ -1700,35 +2427,35 @@ NumberedRows AS (
      */
     hasSoftPrimaryKeyInConfig(schemaName, tableName) {
         // Check if additionalSchemaInfo is configured
-        if (!config_1.configInfo.additionalSchemaInfo) {
+        if (!configInfo.additionalSchemaInfo) {
             return false;
         }
-        const configPath = path_1.default.join(config_1.currentWorkingDirectory, config_1.configInfo.additionalSchemaInfo);
+        const configPath = path.join(currentWorkingDirectory, configInfo.additionalSchemaInfo);
         if (!fs.existsSync(configPath)) {
-            (0, status_logging_1.logStatus)(`         [Soft PK Check] Config file not found at: ${configPath}`);
+            logStatus(`         [Soft PK Check] Config file not found at: ${configPath}`);
             return false;
         }
         try {
             const config = ManageMetadataBase.getSoftPKFKConfig();
             if (!config || !config.tables) {
-                (0, status_logging_1.logStatus)(`         [Soft PK Check] Config file found but no tables array`);
+                logStatus(`         [Soft PK Check] Config file found but no tables array`);
                 return false;
             }
             const tableConfig = config.tables.find((t) => t.schemaName?.toLowerCase() === schemaName?.toLowerCase() &&
                 t.tableName?.toLowerCase() === tableName?.toLowerCase());
             const found = Boolean(tableConfig?.primaryKeys && tableConfig.primaryKeys.length > 0);
             if (!found) {
-                (0, status_logging_1.logStatus)(`         [Soft PK Check] No config found for ${schemaName}.${tableName} (config has ${config.tables.length} tables)`);
+                logStatus(`         [Soft PK Check] No config found for ${schemaName}.${tableName} (config has ${config.tables.length} tables)`);
             }
             return found;
         }
         catch (e) {
-            (0, status_logging_1.logStatus)(`         [Soft PK Check] Error reading config: ${e}`);
+            logStatus(`         [Soft PK Check] Error reading config: ${e}`);
             return false;
         }
     }
     async createNewEntityName(newEntity, currentUser) {
-        const ag = new advanced_generation_1.AdvancedGeneration();
+        const ag = new AdvancedGeneration();
         if (ag.featureEnabled('EntityNames')) {
             return this.newEntityNameWithAdvancedGeneration(ag, newEntity, currentUser);
         }
@@ -1768,8 +2495,8 @@ NumberedRows AS (
         }
     }
     simpleNewEntityName(schemaName, tableName) {
-        const convertedTableName = (0, global_1.convertCamelCaseToHaveSpaces)(tableName);
-        const pluralName = (0, global_1.generatePluralName)(convertedTableName, { capitalizeFirstLetterOnly: true });
+        const convertedTableName = convertCamelCaseToHaveSpaces(tableName);
+        const pluralName = generatePluralName(convertedTableName, { capitalizeFirstLetterOnly: true });
         return this.markupEntityName(schemaName, pluralName);
     }
     /**
@@ -1789,18 +2516,18 @@ NumberedRows AS (
         }
     }
     getNewEntityNameRule(schemaName) {
-        const rule = config_1.configInfo.newEntityDefaults?.NameRulesBySchema?.find(r => {
+        const rule = configInfo.newEntityDefaults?.NameRulesBySchema?.find(r => {
             let schemaNameToUse = r.SchemaName;
             if (schemaNameToUse?.trim().toLowerCase() === '${mj_core_schema}') {
                 // markup for this is to be replaced with the mj_core_schema() config
-                schemaNameToUse = (0, config_1.mj_core_schema)();
+                schemaNameToUse = mj_core_schema();
             }
             return schemaNameToUse.trim().toLowerCase() === schemaName.trim().toLowerCase();
         });
         return rule;
     }
     createNewUUID() {
-        return (0, uuid_1.v4)();
+        return uuidv4();
     }
     async createNewEntity(pool, newEntity, md, currentUser) {
         try {
@@ -1816,7 +2543,7 @@ NumberedRows AS (
                     // the generated name is already in place, so we need another name
                     suffix = '__' + newEntity.SchemaName;
                     newEntityName = newEntityName + suffix;
-                    (0, core_1.LogError)(`   >>>> WARNING: Entity name already exists, so using ${newEntityName} instead. If you did not intend for this, please rename the ${newEntity.SchemaName}.${newEntity.TableName} table in the database.`);
+                    LogError(`   >>>> WARNING: Entity name already exists, so using ${newEntityName} instead. If you did not intend for this, please rename the ${newEntity.SchemaName}.${newEntity.TableName} table in the database.`);
                 }
                 const isNewSchema = await this.isSchemaNew(pool, newEntity.SchemaName);
                 const newEntityID = this.createNewUUID();
@@ -1828,7 +2555,7 @@ NumberedRows AS (
                 // next, check if this entity is in a schema that is new (e.g. no other entities have been added to this schema yet), if so and if
                 // our config option is set to create new applications from new schemas, then create a new application for this schema
                 let apps;
-                if (isNewSchema && config_1.configInfo.newSchemaDefaults.CreateNewApplicationWithSchemaName) {
+                if (isNewSchema && configInfo.newSchemaDefaults.CreateNewApplicationWithSchemaName) {
                     // new schema and config option is to create a new application from the schema name so do that
                     // check to see if the app already exists
                     apps = await this.getApplicationIDForSchema(pool, newEntity.SchemaName);
@@ -1840,7 +2567,7 @@ NumberedRows AS (
                             apps = [newAppID];
                         }
                         else {
-                            (0, core_1.LogError)(`   >>>> ERROR: Unable to create new application for schema ${newEntity.SchemaName}`);
+                            LogError(`   >>>> ERROR: Unable to create new application for schema ${newEntity.SchemaName}`);
                         }
                         await md.Refresh(); // refresh now since we've added a new application, not super efficient to do this for each new application but that won't happen super
                         // often so not a huge deal, would be more efficient do this in batch after all new apps are created but that would be an over optimization IMO
@@ -1851,12 +2578,12 @@ NumberedRows AS (
                     apps = await this.getApplicationIDForSchema(pool, newEntity.SchemaName);
                 }
                 if (apps && apps.length > 0) {
-                    if (config_1.configInfo.newEntityDefaults.AddToApplicationWithSchemaName) {
+                    if (configInfo.newEntityDefaults.AddToApplicationWithSchemaName) {
                         // only do this if the configuration setting is set to add new entities to applications for schema names
                         for (const appUUID of apps) {
-                            const sSQLInsertApplicationEntity = `INSERT INTO ${(0, config_1.mj_core_schema)()}.ApplicationEntity
+                            const sSQLInsertApplicationEntity = `INSERT INTO ${mj_core_schema()}.ApplicationEntity
                                        (ApplicationID, EntityID, Sequence) VALUES
-                                       ('${appUUID}', '${newEntityID}', (SELECT ISNULL(MAX(Sequence),0)+1 FROM ${(0, config_1.mj_core_schema)()}.ApplicationEntity WHERE ApplicationID = '${appUUID}'))`;
+                                       ('${appUUID}', '${newEntityID}', (SELECT ISNULL(MAX(Sequence),0)+1 FROM ${mj_core_schema()}.ApplicationEntity WHERE ApplicationID = '${appUUID}'))`;
                             await this.LogSQLAndExecute(pool, sSQLInsertApplicationEntity, `SQL generated to add new entity ${newEntityName} to application ID: '${appUUID}'`);
                         }
                     }
@@ -1866,38 +2593,38 @@ NumberedRows AS (
                 }
                 else {
                     // this is an error condition, we should have an application for this schema, if we don't, log an error, non fatal, but should be logged
-                    (0, core_1.LogError)(`   >>>> ERROR: Unable to add new entity ${newEntityName} to an application because an Application record for schema ${newEntity.SchemaName} does not exist.`);
+                    LogError(`   >>>> ERROR: Unable to add new entity ${newEntityName} to an application because no Application has SchemaAutoAddNewEntities='${newEntity.SchemaName}'. To fix this, update an existing Application record or create a new one with SchemaAutoAddNewEntities='${newEntity.SchemaName}'.`);
                 }
                 // next up, we need to check if we're configured to add permissions for new entities, and if so, add them
-                if (config_1.configInfo.newEntityDefaults.PermissionDefaults && config_1.configInfo.newEntityDefaults.PermissionDefaults.AutoAddPermissionsForNewEntities) {
+                if (configInfo.newEntityDefaults.PermissionDefaults && configInfo.newEntityDefaults.PermissionDefaults.AutoAddPermissionsForNewEntities) {
                     // we are asked to add permissions for new entities, so do that by looping through the permissions and adding them
-                    const permissions = config_1.configInfo.newEntityDefaults.PermissionDefaults.Permissions;
+                    const permissions = configInfo.newEntityDefaults.PermissionDefaults.Permissions;
                     for (const p of permissions) {
                         const RoleID = md.Roles.find(r => r.Name.trim().toLowerCase() === p.RoleName.trim().toLowerCase())?.ID;
                         if (RoleID) {
-                            const sSQLInsertPermission = `INSERT INTO ${(0, config_1.mj_core_schema)()}.EntityPermission
+                            const sSQLInsertPermission = `INSERT INTO ${mj_core_schema()}.EntityPermission
                                                    (EntityID, RoleID, CanRead, CanCreate, CanUpdate, CanDelete) VALUES
                                                    ('${newEntityID}', '${RoleID}', ${p.CanRead ? 1 : 0}, ${p.CanCreate ? 1 : 0}, ${p.CanUpdate ? 1 : 0}, ${p.CanDelete ? 1 : 0})`;
                             await this.LogSQLAndExecute(pool, sSQLInsertPermission, `SQL generated to add new permission for entity ${newEntityName} for role ${p.RoleName}`);
                         }
                         else
-                            (0, core_1.LogError)(`   >>>> ERROR: Unable to find Role ID for role ${p.RoleName} to add permissions for new entity ${newEntityName}`);
+                            LogError(`   >>>> ERROR: Unable to find Role ID for role ${p.RoleName} to add permissions for new entity ${newEntityName}`);
                     }
                 }
-                (0, core_1.LogStatus)(`   Created new entity ${newEntityName} for table ${newEntity.SchemaName}.${newEntity.TableName}`);
+                LogStatus(`   Created new entity ${newEntityName} for table ${newEntity.SchemaName}.${newEntity.TableName}`);
             }
             else {
-                (0, core_1.LogStatus)(`   Skipping new entity ${newEntity.TableName} because it doesn't qualify to be created. Reason: ${validationMessage}`);
+                LogStatus(`   Skipping new entity ${newEntity.TableName} because it doesn't qualify to be created. Reason: ${validationMessage}`);
                 return;
             }
         }
         catch (e) {
-            (0, core_1.LogError)(`Failed to create new entity ${newEntity?.TableName}`);
+            LogError(`Failed to create new entity ${newEntity?.TableName}`);
         }
     }
     async isSchemaNew(pool, schemaName) {
         // check to see if there are any entities in the db with this schema name
-        const sSQL = `SELECT COUNT(*) AS Count FROM [${(0, config_1.mj_core_schema)()}].Entity WHERE SchemaName = '${schemaName}'`;
+        const sSQL = `SELECT COUNT(*) AS Count FROM [${mj_core_schema()}].Entity WHERE SchemaName = '${schemaName}'`;
         const resultResult = await pool.request().query(sSQL);
         const result = resultResult.recordset;
         return result && result.length > 0 ? result[0].Count === 0 : true;
@@ -1925,26 +2652,26 @@ NumberedRows AS (
                 .replace(/[^a-z0-9-]/g, '') // remove special chars
                 .replace(/-+/g, '-') // collapse multiple hyphens
                 .replace(/^-|-$/g, ''); // trim hyphens from start/end
-            const sSQL = `INSERT INTO [${(0, config_1.mj_core_schema)()}].Application (ID, Name, Description, SchemaAutoAddNewEntities, Path, AutoUpdatePath)
+            const sSQL = `INSERT INTO [${mj_core_schema()}].Application (ID, Name, Description, SchemaAutoAddNewEntities, Path, AutoUpdatePath)
                        VALUES ('${appID}', '${appName}', 'Generated for schema', '${schemaName}', '${path}', 1)`;
             await this.LogSQLAndExecute(pool, sSQL, `SQL generated to create new application ${appName}`);
-            (0, core_1.LogStatus)(`Created new application ${appName} with Path: ${path}`);
+            LogStatus(`Created new application ${appName} with Path: ${path}`);
             return appID;
         }
         catch (e) {
-            (0, core_1.LogError)(`Failed to create new application ${appName} for schema ${schemaName}`, null, e);
+            LogError(`Failed to create new application ${appName} for schema ${schemaName}`, null, e);
             return null;
         }
     }
     async applicationExists(pool, applicationName) {
-        const sSQL = `SELECT ID FROM [${(0, config_1.mj_core_schema)()}].Application WHERE Name = '${applicationName}'`;
+        const sSQL = `SELECT ID FROM [${mj_core_schema()}].Application WHERE Name = '${applicationName}'`;
         const resultResult = await pool.request().query(sSQL);
         const result = resultResult.recordset;
         return result && result.length > 0 ? result[0].ID.length > 0 : false;
     }
     async getApplicationIDForSchema(pool, schemaName) {
         // get all the apps each time from DB as we might be adding, don't use Metadata here for that reason
-        const sSQL = `SELECT ID, Name, SchemaAutoAddNewEntities FROM [${(0, config_1.mj_core_schema)()}].vwApplications`;
+        const sSQL = `SELECT ID, Name, SchemaAutoAddNewEntities FROM [${mj_core_schema()}].vwApplications`;
         const resultResult = await pool.request().query(sSQL);
         const result = resultResult.recordset;
         if (!result || result.length === 0) {
@@ -1963,11 +2690,68 @@ NumberedRows AS (
             return apps.map((a) => a.ID);
         }
     }
+    /**
+     * Adds a newly created entity to the application(s) that match its schema name.
+     * If no application exists for the schema and config allows it, creates one.
+     * Shared by both table-backed entity creation and virtual entity creation.
+     */
+    async addEntityToApplicationForSchema(pool, entityId, entityName, schemaName, currentUser) {
+        let apps = await this.getApplicationIDForSchema(pool, schemaName);
+        // If no app exists and config says to create one for new schemas, create it
+        if ((!apps || apps.length === 0) && configInfo.newSchemaDefaults.CreateNewApplicationWithSchemaName) {
+            const appUUID = this.createNewUUID();
+            const newAppID = await this.createNewApplication(pool, appUUID, schemaName, schemaName, currentUser);
+            if (newAppID) {
+                apps = [newAppID];
+                const md = new Metadata();
+                await md.Refresh();
+            }
+            else {
+                LogError(`   >>>> ERROR: Unable to create new application for schema ${schemaName}`);
+            }
+        }
+        if (apps && apps.length > 0) {
+            if (configInfo.newEntityDefaults.AddToApplicationWithSchemaName) {
+                for (const appUUID of apps) {
+                    const sSQLInsert = `INSERT INTO ${mj_core_schema()}.ApplicationEntity
+                                    (ApplicationID, EntityID, Sequence) VALUES
+                                    ('${appUUID}', '${entityId}', (SELECT ISNULL(MAX(Sequence),0)+1 FROM ${mj_core_schema()}.ApplicationEntity WHERE ApplicationID = '${appUUID}'))`;
+                    await this.LogSQLAndExecute(pool, sSQLInsert, `SQL generated to add entity ${entityName} to application ID: '${appUUID}'`);
+                }
+            }
+        }
+        else {
+            LogError(`   >>>> WARNING: No application found for schema ${schemaName} to add entity ${entityName}`);
+        }
+    }
+    /**
+     * Adds default permissions for a newly created entity based on config settings.
+     * Shared by both table-backed entity creation and virtual entity creation.
+     */
+    async addDefaultPermissionsForEntity(pool, entityId, entityName) {
+        if (!configInfo.newEntityDefaults.PermissionDefaults?.AutoAddPermissionsForNewEntities) {
+            return;
+        }
+        const md = new Metadata();
+        const permissions = configInfo.newEntityDefaults.PermissionDefaults.Permissions;
+        for (const p of permissions) {
+            const RoleID = md.Roles.find(r => r.Name.trim().toLowerCase() === p.RoleName.trim().toLowerCase())?.ID;
+            if (RoleID) {
+                const sSQLInsert = `INSERT INTO ${mj_core_schema()}.EntityPermission
+                                 (EntityID, RoleID, CanRead, CanCreate, CanUpdate, CanDelete) VALUES
+                                 ('${entityId}', '${RoleID}', ${p.CanRead ? 1 : 0}, ${p.CanCreate ? 1 : 0}, ${p.CanUpdate ? 1 : 0}, ${p.CanDelete ? 1 : 0})`;
+                await this.LogSQLAndExecute(pool, sSQLInsert, `SQL generated to add permission for entity ${entityName} for role ${p.RoleName}`);
+            }
+            else {
+                LogError(`   >>>> ERROR: Unable to find Role ID for role ${p.RoleName} to add permissions for entity ${entityName}`);
+            }
+        }
+    }
     createNewEntityInsertSQL(newEntityUUID, newEntityName, newEntity, newEntitySuffix, newEntityDisplayName) {
-        const newEntityDefaults = config_1.configInfo.newEntityDefaults;
+        const newEntityDefaults = configInfo.newEntityDefaults;
         const newEntityDescriptionEscaped = newEntity.Description ? `'${newEntity.Description.replace(/'/g, "''")}` : null;
         const sSQLInsert = `
-      INSERT INTO [${(0, config_1.mj_core_schema)()}].Entity (
+      INSERT INTO [${mj_core_schema()}].Entity (
          ID,
          Name,
          DisplayName,
@@ -1994,7 +2778,7 @@ NumberedRows AS (
          ${newEntityDescriptionEscaped ? newEntityDescriptionEscaped : 'NULL' /*if no description, then null*/},
          ${newEntitySuffix && newEntitySuffix.length > 0 ? `'${newEntitySuffix}'` : 'NULL'},
          '${newEntity.TableName}',
-         'vw${(0, global_1.generatePluralName)(newEntity.TableName, { capitalizeFirstLetterOnly: true }) + (newEntitySuffix && newEntitySuffix.length > 0 ? newEntitySuffix : '')}',
+         'vw${generatePluralName(newEntity.TableName, { capitalizeFirstLetterOnly: true }) + (newEntitySuffix && newEntitySuffix.length > 0 ? newEntitySuffix : '')}',
          '${newEntity.SchemaName}',
          1,
          ${newEntityDefaults.AllowUserSearchAPI === undefined ? 1 : newEntityDefaults.AllowUserSearchAPI ? 1 : 0}
@@ -2015,7 +2799,7 @@ NumberedRows AS (
      */
     async applyAdvancedGeneration(pool, excludeSchemas, currentUser) {
         try {
-            const ag = new advanced_generation_1.AdvancedGeneration();
+            const ag = new AdvancedGeneration();
             if (!ag.enabled) {
                 return true;
             }
@@ -2024,13 +2808,13 @@ NumberedRows AS (
             // Otherwise, only process new or modified entities
             let entitiesToProcess = [];
             let whereClause = '';
-            if (config_1.configInfo.forceRegeneration?.enabled) {
+            if (configInfo.forceRegeneration?.enabled) {
                 // Force regeneration mode - process all entities (or filtered by entityWhereClause)
-                (0, status_logging_1.logStatus)(`      Force regeneration enabled - processing all entities...`);
+                logStatus(`      Force regeneration enabled - processing all entities...`);
                 whereClause = 'e.VirtualEntity = 0';
-                if (config_1.configInfo.forceRegeneration.entityWhereClause && config_1.configInfo.forceRegeneration.entityWhereClause.trim().length > 0) {
-                    whereClause += ` AND (${config_1.configInfo.forceRegeneration.entityWhereClause})`;
-                    (0, status_logging_1.logStatus)(`         Filtered by: ${config_1.configInfo.forceRegeneration.entityWhereClause}`);
+                if (configInfo.forceRegeneration.entityWhereClause && configInfo.forceRegeneration.entityWhereClause.trim().length > 0) {
+                    whereClause += ` AND (${configInfo.forceRegeneration.entityWhereClause})`;
+                    logStatus(`         Filtered by: ${configInfo.forceRegeneration.entityWhereClause}`);
                 }
                 whereClause += ` AND e.SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})`;
             }
@@ -2046,7 +2830,7 @@ NumberedRows AS (
                 if (entitiesToProcess.length === 0) {
                     return true;
                 }
-                (0, status_logging_1.logStatus)(`      Advanced Generation enabled, processing ${entitiesToProcess.length} entities...`);
+                logStatus(`      Advanced Generation enabled, processing ${entitiesToProcess.length} entities...`);
                 whereClause = `e.VirtualEntity = 0 AND e.Name IN (${entitiesToProcess.map(name => `'${name}'`).join(',')}) AND e.SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})`;
             }
             // Get entity details for entities that need processing
@@ -2056,9 +2840,10 @@ NumberedRows AS (
                e.Name,
                e.Description,
                e.SchemaName,
-               e.BaseTable
+               e.BaseTable,
+               e.ParentID
             FROM
-               [${(0, config_1.mj_core_schema)()}].vwEntities e
+               [${mj_core_schema()}].vwEntities e
             WHERE
                ${whereClause}
             ORDER BY
@@ -2089,9 +2874,11 @@ NumberedRows AS (
                ef.AutoUpdateCategory,
                ef.AutoUpdateDisplayName,
                ef.EntityIDFieldName,
-               ef.RelatedEntity
+               ef.RelatedEntity,
+               ef.IsVirtual,
+               ef.AllowUpdateAPI
             FROM
-               [${(0, config_1.mj_core_schema)()}].vwEntityFields ef
+               [${mj_core_schema()}].vwEntityFields ef
             WHERE
                ef.EntityID IN (${entityIds})
             ORDER BY
@@ -2107,7 +2894,7 @@ NumberedRows AS (
                es.Name,
                es.Value
             FROM
-               [${(0, config_1.mj_core_schema)()}].EntitySetting es
+               [${mj_core_schema()}].EntitySetting es
             WHERE
                es.EntityID IN (${entityIds})
                AND es.Name IN ('FieldCategoryIcons', 'FieldCategoryInfo')
@@ -2130,7 +2917,7 @@ NumberedRows AS (
             return await this.processEntitiesBatched(pool, entities, allFields, ag, currentUser);
         }
         catch (error) {
-            (0, status_logging_1.logError)(`Advanced Generation failed: ${error}`);
+            logError(`Advanced Generation failed: ${error}`);
             return false;
         }
     }
@@ -2158,12 +2945,12 @@ NumberedRows AS (
                 }
                 else {
                     errorCount++;
-                    (0, status_logging_1.logError)(`         Error processing entity: ${result.reason}`);
+                    logError(`         Error processing entity: ${result.reason}`);
                 }
             }
-            (0, status_logging_1.logStatus)(`      Progress: ${processedCount}/${entities.length} entities processed`);
+            logStatus(`      Progress: ${processedCount}/${entities.length} entities processed`);
         }
-        (0, status_logging_1.logStatus)(`      Advanced Generation complete: ${processedCount} entities processed, ${errorCount} errors`);
+        logStatus(`      Advanced Generation complete: ${processedCount} entities processed, ${errorCount} errors`);
         return errorCount === 0;
     }
     /**
@@ -2194,18 +2981,82 @@ NumberedRows AS (
         // Form Layout Generation
         // Only run if at least one field allows auto-update
         if (fields.some((f) => f.AutoUpdateCategory)) {
+            // Build IS-A parent chain context if this entity has a parent
+            const parentChainContext = this.buildParentChainContext(entity, fields);
             const layoutAnalysis = await ag.generateFormLayout({
                 Name: entity.Name,
                 Description: entity.Description,
                 SchemaName: entity.SchemaName,
                 Settings: entity.Settings,
-                Fields: fields
+                Fields: fields,
+                ...parentChainContext
             }, currentUser, isNewEntity);
             if (layoutAnalysis) {
                 await this.applyFormLayout(pool, entity.ID, fields, layoutAnalysis, isNewEntity);
-                (0, status_logging_1.logStatus)(`         Applied form layout for ${entity.Name}`);
+                logStatus(`         Applied form layout for ${entity.Name}`);
+            }
+        }
+    }
+    /**
+     * Builds IS-A parent chain context for an entity, computing which parent each
+     * inherited field originates from. Used to provide the LLM with inheritance
+     * awareness during form layout generation.
+     *
+     * Returns an empty object for entities without parents, so it can be safely spread
+     * into the entity object passed to generateFormLayout().
+     */
+    buildParentChainContext(entity, fields) {
+        if (!entity.ParentID) {
+            return {};
+        }
+        // Walk the IS-A chain using in-memory metadata
+        const md = new Metadata();
+        const allEntities = md.Entities;
+        const parentChain = [];
+        const visited = new Set();
+        let currentParentID = entity.ParentID;
+        while (currentParentID) {
+            if (visited.has(currentParentID))
+                break; // circular reference guard
+            visited.add(currentParentID);
+            const parentEntity = allEntities.find(e => e.ID === currentParentID);
+            if (!parentEntity)
+                break;
+            parentChain.push({ entityID: parentEntity.ID, entityName: parentEntity.Name });
+            currentParentID = parentEntity.ParentID ?? null;
+        }
+        if (parentChain.length === 0) {
+            return {};
+        }
+        // Annotate each field with its source parent (if inherited)
+        // An IS-A inherited field is: IsVirtual=true, AllowUpdateAPI=true, not PK, not __mj_
+        for (const field of fields) {
+            if (field.IsVirtual && field.AllowUpdateAPI && !field.IsPrimaryKey && !field.Name.startsWith('__mj_')) {
+                const sourceParent = this.findFieldSourceParent(field.Name, parentChain, allEntities);
+                if (sourceParent) {
+                    field.InheritedFromEntityID = sourceParent.entityID;
+                    field.InheritedFromEntityName = sourceParent.entityName;
+                }
             }
         }
+        return { ParentChain: parentChain, IsChildEntity: true };
+    }
+    /**
+     * For an inherited field, walks the parent chain to find which specific parent entity
+     * originally defines this field (by matching non-virtual fields on each parent).
+     */
+    findFieldSourceParent(fieldName, parentChain, allEntities) {
+        for (const parent of parentChain) {
+            const parentEntity = allEntities.find(e => e.ID === parent.entityID);
+            if (!parentEntity)
+                continue;
+            // Check if this parent has a non-virtual field with this name
+            const hasField = parentEntity.Fields.some(f => f.Name === fieldName && !f.IsVirtual);
+            if (hasField) {
+                return parent;
+            }
+        }
+        return null;
     }
     /**
      * Apply smart field identification results to entity fields
@@ -2216,26 +3067,26 @@ NumberedRows AS (
         const nameField = fields.find(f => f.Name === result.nameField);
         if (nameField && nameField.AutoUpdateIsNameField && nameField.ID) {
             sqlStatements.push(`
-            UPDATE [${(0, config_1.mj_core_schema)()}].EntityField
+            UPDATE [${mj_core_schema()}].EntityField
             SET IsNameField = 1
             WHERE ID = '${nameField.ID}'
             AND AutoUpdateIsNameField = 1
          `);
         }
         else if (!nameField) {
-            (0, status_logging_1.logError)(`Smart field identification returned invalid nameField: '${result.nameField}' not found in entity fields`);
+            logError(`Smart field identification returned invalid nameField: '${result.nameField}' not found in entity fields`);
         }
         // Find all default in view fields (one or more)
         const defaultInViewFields = fields.filter(f => result.defaultInView.includes(f.Name) && f.AutoUpdateDefaultInView && f.ID);
         // Warn about any fields that weren't found
         const missingFields = result.defaultInView.filter(name => !fields.some(f => f.Name === name));
         if (missingFields.length > 0) {
-            (0, status_logging_1.logError)(`Smart field identification returned invalid defaultInView fields: ${missingFields.join(', ')} not found in entity`);
+            logError(`Smart field identification returned invalid defaultInView fields: ${missingFields.join(', ')} not found in entity`);
         }
         // Build update statements for all default in view fields
         for (const field of defaultInViewFields) {
             sqlStatements.push(`
-            UPDATE [${(0, config_1.mj_core_schema)()}].EntityField
+            UPDATE [${mj_core_schema()}].EntityField
             SET DefaultInView = 1
             WHERE ID = '${field.ID}'
             AND AutoUpdateDefaultInView = 1
@@ -2247,12 +3098,12 @@ NumberedRows AS (
             // Warn about any fields that weren't found
             const missingSearchableFields = result.searchableFields.filter(name => !fields.some(f => f.Name === name));
             if (missingSearchableFields.length > 0) {
-                (0, status_logging_1.logError)(`Smart field identification returned invalid searchableFields: ${missingSearchableFields.join(', ')} not found in entity`);
+                logError(`Smart field identification returned invalid searchableFields: ${missingSearchableFields.join(', ')} not found in entity`);
             }
             // Build update statements for all searchable fields
             for (const field of searchableFields) {
                 sqlStatements.push(`
-               UPDATE [${(0, config_1.mj_core_schema)()}].EntityField
+               UPDATE [${mj_core_schema()}].EntityField
                SET IncludeInUserSearchAPI = 1
                WHERE ID = '${field.ID}'
                AND AutoUpdateIncludeInUserSearchAPI = 1
@@ -2266,7 +3117,8 @@ NumberedRows AS (
         }
     }
     /**
-     * Apply form layout generation results to set category on entity fields
+     * Apply form layout generation results to set category on entity fields.
+     * Delegates to shared methods for category assignment, icon, and category info persistence.
      * @param pool Database connection pool
      * @param entityId Entity ID to update
      * @param fields Entity fields
@@ -2274,17 +3126,47 @@ NumberedRows AS (
      * @param isNewEntity If true, apply entityImportance; if false, skip it
      */
     async applyFormLayout(pool, entityId, fields, result, isNewEntity = false) {
-        // Collect all SQL statements for batch execution
-        const sqlStatements = [];
-        // Build set of existing categories from fields for enforcement
+        const existingCategories = this.buildExistingCategorySet(fields);
+        await this.applyFieldCategories(pool, entityId, fields, result.fieldCategories, existingCategories);
+        if (result.entityIcon) {
+            await this.applyEntityIcon(pool, entityId, result.entityIcon);
+        }
+        // Resolve categoryInfo from new or legacy format
+        const categoryInfoToStore = result.categoryInfo ||
+            (result.categoryIcons ?
+                Object.fromEntries(Object.entries(result.categoryIcons).map(([cat, icon]) => [cat, { icon, description: '' }])) : null);
+        if (categoryInfoToStore) {
+            await this.applyCategoryInfoSettings(pool, entityId, categoryInfoToStore);
+        }
+        if (isNewEntity && result.entityImportance) {
+            await this.applyEntityImportance(pool, entityId, result.entityImportance);
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Shared category / icon / settings persistence methods
+    // Used by both the regular entity pipeline and VE decoration pipeline
+    // ─────────────────────────────────────────────────────────────────
+    /**
+     * Builds a set of existing category names from entity fields.
+     * Used to enforce category stability (prevent renaming).
+     */
+    buildExistingCategorySet(fields) {
         const existingCategories = new Set();
         for (const field of fields) {
             if (field.Category && field.Category.trim() !== '') {
                 existingCategories.add(field.Category);
             }
         }
-        // Assign category to each field
-        for (const fieldCategory of result.fieldCategories) {
+        return existingCategories;
+    }
+    /**
+     * Applies category, display name, extended type, and code type to entity fields.
+     * Enforces stability rules: fields with existing categories cannot move to NEW categories.
+     * All SQL updates are batched into a single execution for performance.
+     */
+    async applyFieldCategories(pool, entityId, fields, fieldCategories, existingCategories) {
+        const sqlStatements = [];
+        for (const fieldCategory of fieldCategories) {
             const field = fields.find(f => f.Name === fieldCategory.fieldName);
             if (field && field.AutoUpdateCategory && field.ID) {
                 // Override category to "System Metadata" for __mj_ fields (system audit fields)
@@ -2293,158 +3175,126 @@ NumberedRows AS (
                     category = 'System Metadata';
                 }
                 // ENFORCEMENT: Prevent category renaming
-                // If field already has a category, only allow:
-                // 1. Keeping the same category
-                // 2. Moving to another EXISTING category
-                // New categories are only allowed for fields that don't already have a category
-                const fieldHasExistingCategory = field.Category && field.Category.trim() !== '';
-                const categoryIsExisting = existingCategories.has(category);
-                const categoryIsNew = !categoryIsExisting;
+                const fieldHasExistingCategory = field.Category != null && field.Category.trim() !== '';
+                const categoryIsNew = !existingCategories.has(category);
                 if (fieldHasExistingCategory && categoryIsNew) {
-                    // LLM is trying to move an existing field to a brand new category
-                    // This could be an attempt to rename a category - reject it
-                    (0, status_logging_1.logStatus)(`         Rejected category change for field '${field.Name}': cannot move from existing category '${field.Category}' to new category '${category}'. Keeping original category.`);
-                    category = field.Category; // Keep the original category
+                    logStatus(`         Rejected category change for field '${field.Name}': cannot move from existing category '${field.Category}' to new category '${category}'. Keeping original category.`);
+                    category = field.Category;
                 }
-                // Build SET clause with all available metadata
                 const setClauses = [
                     `Category = '${category.replace(/'/g, "''")}'`,
                     `GeneratedFormSection = 'Category'`
                 ];
-                // Add DisplayName if provided and field allows auto-update
                 if (fieldCategory.displayName && field.AutoUpdateDisplayName) {
                     setClauses.push(`DisplayName = '${fieldCategory.displayName.replace(/'/g, "''")}'`);
                 }
-                // Add ExtendedType if provided
                 if (fieldCategory.extendedType !== undefined) {
-                    const extendedType = fieldCategory.extendedType === null ? 'NULL' : `'${fieldCategory.extendedType.replace(/'/g, "''")}'`;
+                    const extendedType = fieldCategory.extendedType === null ? 'NULL' : `'${String(fieldCategory.extendedType).replace(/'/g, "''")}'`;
                     setClauses.push(`ExtendedType = ${extendedType}`);
                 }
-                // Add CodeType if provided
                 if (fieldCategory.codeType !== undefined) {
-                    const codeType = fieldCategory.codeType === null ? 'NULL' : `'${fieldCategory.codeType.replace(/'/g, "''")}'`;
+                    const codeType = fieldCategory.codeType === null ? 'NULL' : `'${String(fieldCategory.codeType).replace(/'/g, "''")}'`;
                     setClauses.push(`CodeType = ${codeType}`);
                 }
-                const updateSQL = `UPDATE [${(0, config_1.mj_core_schema)()}].EntityField
+                sqlStatements.push(`UPDATE [${mj_core_schema()}].EntityField
    SET ${setClauses.join(',\n       ')}
    WHERE ID = '${field.ID}'
-   AND AutoUpdateCategory = 1`;
-                sqlStatements.push(updateSQL);
+   AND AutoUpdateCategory = 1`);
             }
             else if (!field) {
-                (0, status_logging_1.logError)(`Form layout generation returned invalid fieldName: '${fieldCategory.fieldName}' not found in entity`);
+                logError(`Form layout returned invalid fieldName: '${fieldCategory.fieldName}' not found in entity`);
             }
         }
-        // Execute all field updates in one batch
         if (sqlStatements.length > 0) {
-            const combinedSQL = sqlStatements.join('\n');
-            await this.LogSQLAndExecute(pool, combinedSQL, `Set categories for ${sqlStatements.length} fields`, false);
-        }
-        // Store entity icon if provided and entity doesn't already have one
-        if (result.entityIcon && result.entityIcon.trim().length > 0) {
-            // Check if entity already has an icon
-            const checkEntitySQL = `
-            SELECT Icon FROM [${(0, config_1.mj_core_schema)()}].Entity
-            WHERE ID = '${entityId}'
-         `;
-            const entityCheck = await pool.request().query(checkEntitySQL);
-            if (entityCheck.recordset.length > 0) {
-                const currentIcon = entityCheck.recordset[0].Icon;
-                // Only update if entity doesn't have an icon set
-                if (!currentIcon || currentIcon.trim().length === 0) {
-                    const escapedIcon = result.entityIcon.replace(/'/g, "''");
-                    const updateEntitySQL = `
-                  UPDATE [${(0, config_1.mj_core_schema)()}].Entity
-                  SET Icon = '${escapedIcon}',
-                      __mj_UpdatedAt = GETUTCDATE()
-                  WHERE ID = '${entityId}'
-               `;
-                    await this.LogSQLAndExecute(pool, updateEntitySQL, `Set entity icon to ${result.entityIcon}`, false);
-                    (0, status_logging_1.logStatus)(`  ✓ Set entity icon: ${result.entityIcon}`);
-                }
-            }
+            await this.LogSQLAndExecute(pool, sqlStatements.join('\n'), `Set categories for ${sqlStatements.length} fields`, false);
         }
-        // Store category info (icons + descriptions) in EntitySetting if provided
-        // Use the new categoryInfo format, with backwards compatibility for categoryIcons
-        const categoryInfoToStore = result.categoryInfo ||
-            (result.categoryIcons ?
-                // Convert legacy format: { icon: string } -> { icon, description: '' }
-                Object.fromEntries(Object.entries(result.categoryIcons).map(([cat, icon]) => [cat, { icon, description: '' }])) : null);
-        if (categoryInfoToStore && Object.keys(categoryInfoToStore).length > 0) {
-            const infoJSON = JSON.stringify(categoryInfoToStore).replace(/'/g, "''");
-            // First check if new format setting already exists
-            const checkNewSQL = `
-            SELECT ID FROM [${(0, config_1.mj_core_schema)()}].EntitySetting
-            WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'
-         `;
-            const existingNew = await pool.request().query(checkNewSQL);
-            if (existingNew.recordset.length > 0) {
-                // Update existing setting
+    }
+    /**
+     * Sets the entity icon if the entity doesn't already have one.
+     */
+    async applyEntityIcon(pool, entityId, entityIcon) {
+        if (!entityIcon || entityIcon.trim().length === 0)
+            return;
+        const checkSQL = `SELECT Icon FROM [${mj_core_schema()}].Entity WHERE ID = '${entityId}'`;
+        const entityCheck = await pool.request().query(checkSQL);
+        if (entityCheck.recordset.length > 0) {
+            const currentIcon = entityCheck.recordset[0].Icon;
+            if (!currentIcon || currentIcon.trim().length === 0) {
+                const escapedIcon = entityIcon.replace(/'/g, "''");
                 const updateSQL = `
-               UPDATE [${(0, config_1.mj_core_schema)()}].EntitySetting
-               SET Value = '${infoJSON}',
-                   __mj_UpdatedAt = GETUTCDATE()
-               WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'
-            `;
-                await this.LogSQLAndExecute(pool, updateSQL, `Update FieldCategoryInfo setting for entity`, false);
-            }
-            else {
-                // Insert new setting
-                const newId = (0, uuid_1.v4)();
-                const insertSQL = `
-               INSERT INTO [${(0, config_1.mj_core_schema)()}].EntitySetting (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
-               VALUES ('${newId}', '${entityId}', 'FieldCategoryInfo', '${infoJSON}', GETUTCDATE(), GETUTCDATE())
+               UPDATE [${mj_core_schema()}].Entity
+               SET Icon = '${escapedIcon}', __mj_UpdatedAt = GETUTCDATE()
+               WHERE ID = '${entityId}'
             `;
-                await this.LogSQLAndExecute(pool, insertSQL, `Insert FieldCategoryInfo setting for entity`, false);
-            }
-            // Also update legacy FieldCategoryIcons for backwards compatibility
-            // Extract just icons from categoryInfo
-            const iconsOnly = {};
-            for (const [category, info] of Object.entries(categoryInfoToStore)) {
-                if (info && typeof info === 'object' && 'icon' in info) {
-                    iconsOnly[category] = info.icon;
-                }
+                await this.LogSQLAndExecute(pool, updateSQL, `Set entity icon to ${entityIcon}`, false);
+                logStatus(`  Set entity icon: ${entityIcon}`);
             }
-            const iconsJSON = JSON.stringify(iconsOnly).replace(/'/g, "''");
-            const checkLegacySQL = `
-            SELECT ID FROM [${(0, config_1.mj_core_schema)()}].EntitySetting
+        }
+    }
+    /**
+     * Upserts FieldCategoryInfo (new format) and FieldCategoryIcons (legacy format) in EntitySetting.
+     */
+    async applyCategoryInfoSettings(pool, entityId, categoryInfo) {
+        if (!categoryInfo || Object.keys(categoryInfo).length === 0)
+            return;
+        const infoJSON = JSON.stringify(categoryInfo).replace(/'/g, "''");
+        // Upsert FieldCategoryInfo (new format)
+        const checkNewSQL = `SELECT ID FROM [${mj_core_schema()}].EntitySetting WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'`;
+        const existingNew = await pool.request().query(checkNewSQL);
+        if (existingNew.recordset.length > 0) {
+            await this.LogSQLAndExecute(pool, `
+            UPDATE [${mj_core_schema()}].EntitySetting
+            SET Value = '${infoJSON}', __mj_UpdatedAt = GETUTCDATE()
+            WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'
+         `, `Update FieldCategoryInfo setting for entity`, false);
+        }
+        else {
+            const newId = uuidv4();
+            await this.LogSQLAndExecute(pool, `
+            INSERT INTO [${mj_core_schema()}].EntitySetting (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
+            VALUES ('${newId}', '${entityId}', 'FieldCategoryInfo', '${infoJSON}', GETUTCDATE(), GETUTCDATE())
+         `, `Insert FieldCategoryInfo setting for entity`, false);
+        }
+        // Also upsert legacy FieldCategoryIcons for backwards compatibility
+        const iconsOnly = {};
+        for (const [category, info] of Object.entries(categoryInfo)) {
+            if (info && typeof info === 'object' && 'icon' in info) {
+                iconsOnly[category] = info.icon;
+            }
+        }
+        const iconsJSON = JSON.stringify(iconsOnly).replace(/'/g, "''");
+        const checkLegacySQL = `SELECT ID FROM [${mj_core_schema()}].EntitySetting WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryIcons'`;
+        const existingLegacy = await pool.request().query(checkLegacySQL);
+        if (existingLegacy.recordset.length > 0) {
+            await this.LogSQLAndExecute(pool, `
+            UPDATE [${mj_core_schema()}].EntitySetting
+            SET Value = '${iconsJSON}', __mj_UpdatedAt = GETUTCDATE()
             WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryIcons'
-         `;
-            const existingLegacy = await pool.request().query(checkLegacySQL);
-            if (existingLegacy.recordset.length > 0) {
-                const updateSQL = `
-               UPDATE [${(0, config_1.mj_core_schema)()}].EntitySetting
-               SET Value = '${iconsJSON}',
-                   __mj_UpdatedAt = GETUTCDATE()
-               WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryIcons'
-            `;
-                await this.LogSQLAndExecute(pool, updateSQL, `Update FieldCategoryIcons setting for entity (legacy format)`, false);
-            }
-            else {
-                const newId = (0, uuid_1.v4)();
-                const insertSQL = `
-               INSERT INTO [${(0, config_1.mj_core_schema)()}].EntitySetting (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
-               VALUES ('${newId}', '${entityId}', 'FieldCategoryIcons', '${iconsJSON}', GETUTCDATE(), GETUTCDATE())
-            `;
-                await this.LogSQLAndExecute(pool, insertSQL, `Insert FieldCategoryIcons setting for entity (legacy format)`, false);
-            }
+         `, `Update FieldCategoryIcons setting (legacy)`, false);
         }
-        // Apply entity importance analysis to ApplicationEntity records ONLY for NEW entities
-        // For existing entities, preserve admin's decision
-        if (isNewEntity && result.entityImportance) {
-            const defaultForNewUser = result.entityImportance.defaultForNewUser ? 1 : 0;
-            // Update all ApplicationEntity records for this entity
-            const updateAppEntitySQL = `
-            UPDATE [${(0, config_1.mj_core_schema)()}].ApplicationEntity
-            SET DefaultForNewUser = ${defaultForNewUser},
-                __mj_UpdatedAt = GETUTCDATE()
-            WHERE EntityID = '${entityId}'
-         `;
-            await this.LogSQLAndExecute(pool, updateAppEntitySQL, `Set DefaultForNewUser=${defaultForNewUser} for NEW entity based on AI analysis (category: ${result.entityImportance.entityCategory}, confidence: ${result.entityImportance.confidence})`, false);
-            (0, status_logging_1.logStatus)(`  ✓ Entity importance (NEW Entity): ${result.entityImportance.entityCategory} (defaultForNewUser: ${result.entityImportance.defaultForNewUser}, confidence: ${result.entityImportance.confidence})`);
-            (0, status_logging_1.logStatus)(`    Reasoning: ${result.entityImportance.reasoning}`);
+        else {
+            const newId = uuidv4();
+            await this.LogSQLAndExecute(pool, `
+            INSERT INTO [${mj_core_schema()}].EntitySetting (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
+            VALUES ('${newId}', '${entityId}', 'FieldCategoryIcons', '${iconsJSON}', GETUTCDATE(), GETUTCDATE())
+         `, `Insert FieldCategoryIcons setting (legacy)`, false);
         }
     }
+    /**
+     * Applies entity importance analysis to ApplicationEntity records.
+     * Only called for NEW entities to set DefaultForNewUser.
+     */
+    async applyEntityImportance(pool, entityId, importance) {
+        const defaultForNewUser = importance.defaultForNewUser ? 1 : 0;
+        const updateSQL = `
+         UPDATE [${mj_core_schema()}].ApplicationEntity
+         SET DefaultForNewUser = ${defaultForNewUser}, __mj_UpdatedAt = GETUTCDATE()
+         WHERE EntityID = '${entityId}'
+      `;
+        await this.LogSQLAndExecute(pool, updateSQL, `Set DefaultForNewUser=${defaultForNewUser} for NEW entity (category: ${importance.entityCategory}, confidence: ${importance.confidence})`, false);
+        logStatus(`  Entity importance (NEW Entity): ${importance.entityCategory} (defaultForNewUser: ${importance.defaultForNewUser}, confidence: ${importance.confidence})`);
+        logStatus(`    Reasoning: ${importance.reasoning}`);
+    }
     /**
      * Executes the given SQL query using the given ConnectionPool object.
      * If the appendToLogFile parameter is true, the query will also be appended to the log file.
@@ -2456,8 +3306,7 @@ NumberedRows AS (
      * @returns - The result of the query execution.
      */
     async LogSQLAndExecute(pool, query, description, isRecurringScript = false) {
-        return await sql_logging_1.SQLLogging.LogSQLAndExecute(pool, query, description, isRecurringScript);
+        return await SQLLogging.LogSQLAndExecute(pool, query, description, isRecurringScript);
     }
 }
-exports.ManageMetadataBase = ManageMetadataBase;
 //# sourceMappingURL=manage-metadata.js.map