@memberjunction/codegen-lib 3.3.0 → 4.0.0

package/dist/Database/manage-metadata.js

@@ -1,165 +1,170 @@
-"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 { 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 { 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 = configInfo.additionalSchemaInfo
+            ? path.join(currentWorkingDirectory, configInfo.additionalSchemaInfo)
+            : '';
+        if (this._softPKFKConfigCache !== null && this._softPKFKConfigPath === configPath) {
+            return this._softPKFKConfigCache;
+        }
+        // Cache miss or path changed - reload from disk
+        if (!configPath || !fs.existsSync(configPath)) {
+            this._softPKFKConfigCache = null;
+            this._softPKFKConfigPath = configPath;
+            return null;
+        }
+        try {
+            const configContent = fs.readFileSync(configPath, 'utf-8');
+            this._softPKFKConfigCache = JSON.parse(configContent);
+            this._softPKFKConfigPath = configPath;
+            return this._softPKFKConfigCache;
+        }
+        catch (e) {
+            this._softPKFKConfigCache = null;
+            this._softPKFKConfigPath = configPath;
+            return null;
+        }
+    }
     /**
      * 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
         }
         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;
         }
         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) {
@@ -167,7 +172,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;
@@ -177,7 +182,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;
                 }
             }
@@ -208,7 +213,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 = [];
@@ -217,7 +222,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;
@@ -231,7 +236,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;
                         }
                     }
@@ -239,13 +244,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 };
         }
     }
@@ -253,7 +258,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;
@@ -270,7 +275,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}',
@@ -288,7 +293,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 )
@@ -338,16 +343,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();
@@ -355,7 +360,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
@@ -374,11 +379,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
                               `;
@@ -398,7 +403,7 @@ class ManageMetadataBase {
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -410,7 +415,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) {
@@ -421,7 +426,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);
@@ -431,17 +436,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;
         }
     }
@@ -455,23 +460,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}`);
         }
     }
     /**
@@ -497,66 +502,72 @@ 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)) {
+            logError('Error applying soft PK/FK configuration');
+        }
+        logStatus(`      Applied soft PK/FK configuration in ${(new Date().getTime() - stepConfigStartTime.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;
     }
     /**
@@ -567,7 +578,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
@@ -582,21 +593,102 @@ 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;
+        }
+    }
+    /**
+     * Applies soft PK/FK configuration from a JSON file specified in mj.config.cjs (additionalSchemaInfo property).
+     * For soft PKs: Sets BOTH IsPrimaryKey=1 AND IsSoftPrimaryKey=1 (IsPrimaryKey is source of truth, IsSoftPrimaryKey protects from schema sync).
+     * For soft FKs: Sets RelatedEntityID/RelatedEntityFieldName + IsSoftForeignKey=1 (RelatedEntityID is source of truth, IsSoftForeignKey protects from schema sync).
+     * All UPDATE statements are logged to migration files via LogSQLAndExecute() for CI/CD traceability.
+     */
+    async applySoftPKFKConfig(pool) {
+        // Check if additionalSchemaInfo is configured in mj.config.cjs
+        if (!configInfo.additionalSchemaInfo) {
+            // No additional schema info configured - this is fine, it's optional
+            return true;
+        }
+        const configPath = path.join(currentWorkingDirectory, configInfo.additionalSchemaInfo);
+        if (!fs.existsSync(configPath)) {
+            logStatus(`         ⚠️  additionalSchemaInfo configured but file not found: ${configPath}`);
+            return true;
+        }
+        try {
+            logStatus(`         Found ${configInfo.additionalSchemaInfo}, applying soft PK/FK configuration...`);
+            const config = ManageMetadataBase.getSoftPKFKConfig();
+            let totalPKs = 0;
+            let totalFKs = 0;
+            const schema = mj_core_schema();
+            for (const table of config.tables || []) {
+                // 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 entityResult = await pool.request().query(entityLookupSQL);
+                if (entityResult.recordset.length === 0) {
+                    logStatus(`         ⚠️  Entity not found for ${table.schemaName}.${table.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 sSQL = `UPDATE [${schema}].[EntityField]
+                                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}`);
+                        if (result !== null) {
+                            logStatus(`         ✓ Set IsPrimaryKey=1, IsSoftPrimaryKey=1 for ${table.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) {
+                        // 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 relatedEntityResult = await pool.request().query(relatedLookupSQL);
+                        if (relatedEntityResult.recordset.length === 0) {
+                            logStatus(`         ⚠️  Related entity not found for ${fk.relatedSchema}.${fk.relatedTable} - skipping FK ${fk.fieldName}`);
+                            continue;
+                        }
+                        const relatedEntityId = relatedEntityResult.recordset[0].ID;
+                        const sSQL = `UPDATE [${schema}].[EntityField]
+                                SET ${EntityInfo.UpdatedAtFieldName}=GETUTCDATE(),
+                                    [RelatedEntityID] = '${relatedEntityId}',
+                                    [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}`);
+                        if (result !== null) {
+                            logStatus(`         ✓ Set soft FK for ${table.tableName}.${fk.fieldName} → ${fk.relatedTable}.${fk.relatedField}`);
+                            totalFKs++;
+                        }
+                    }
+                }
+            }
+            logStatus(`         Applied ${totalPKs} soft PK(s) and ${totalFKs} soft FK(s) from configuration`);
+            return true;
+        }
+        catch (e) {
+            logError(`Error applying soft PK/FK configuration: ${e}`);
             return false;
         }
     }
@@ -611,7 +703,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
@@ -627,24 +719,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;
         }
     }
@@ -680,7 +772,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);
                         }
@@ -691,7 +783,7 @@ class ManageMetadataBase {
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -700,11 +792,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);
         }
     }
     /**
@@ -748,7 +840,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);
         }
     }
     /**
@@ -760,18 +852,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 {
@@ -793,9 +885,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
@@ -808,16 +900,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;
         }
     }
@@ -831,12 +923,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;
         }
     }
@@ -858,7 +950,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
 ),
@@ -877,9 +969,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,
@@ -901,34 +993,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
@@ -969,22 +1061,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);
@@ -993,13 +1085,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,
@@ -1100,7 +1192,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;
                         }
                     }
@@ -1118,7 +1210,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1131,20 +1223,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
@@ -1154,7 +1246,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1169,7 +1261,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
@@ -1180,7 +1272,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1194,21 +1286,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
@@ -1219,7 +1311,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1230,13 +1322,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 = [];
@@ -1258,11 +1350,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}`);
                             }
                         }
@@ -1273,8 +1365,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));
@@ -1284,8 +1376,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));
@@ -1296,7 +1388,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1311,7 +1403,7 @@ NumberedRows AS (
             return await this.manageEntityFieldValuesAndValidatorFunctions(pool, [], currentUser, true);
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1357,9 +1449,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);
@@ -1372,12 +1464,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;
@@ -1396,7 +1488,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++;
                     }
@@ -1406,9 +1498,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}')`;
@@ -1422,7 +1514,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++;
                     }
@@ -1436,7 +1528,7 @@ NumberedRows AS (
             return true;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -1495,9 +1587,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}'`);
@@ -1505,9 +1597,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}'`);
             }
@@ -1519,11 +1611,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 {
@@ -1540,14 +1632,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;
         }
     }
@@ -1556,11 +1648,16 @@ 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)) {
+                    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" };
             }
             return { shouldCreate: true, validationMessage: '' };
@@ -1571,8 +1668,40 @@ NumberedRows AS (
             return { shouldCreate: false, validationMessage: errorMsg };
         }
     }
+    /**
+     * Checks if a table has a soft primary key defined in the additionalSchemaInfo JSON file (configured in mj.config.cjs)
+     */
+    hasSoftPrimaryKeyInConfig(schemaName, tableName) {
+        // Check if additionalSchemaInfo is configured
+        if (!configInfo.additionalSchemaInfo) {
+            return false;
+        }
+        const configPath = path.join(currentWorkingDirectory, configInfo.additionalSchemaInfo);
+        if (!fs.existsSync(configPath)) {
+            logStatus(`         [Soft PK Check] Config file not found at: ${configPath}`);
+            return false;
+        }
+        try {
+            const config = ManageMetadataBase.getSoftPKFKConfig();
+            if (!config || !config.tables) {
+                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) {
+                logStatus(`         [Soft PK Check] No config found for ${schemaName}.${tableName} (config has ${config.tables.length} tables)`);
+            }
+            return found;
+        }
+        catch (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);
         }
@@ -1612,8 +1741,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);
     }
     /**
@@ -1633,18 +1762,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 {
@@ -1660,7 +1789,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();
@@ -1672,7 +1801,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);
@@ -1684,7 +1813,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
@@ -1695,12 +1824,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}'`);
                         }
                     }
@@ -1710,91 +1839,85 @@ 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 an Application record for schema ${newEntity.SchemaName} does not exist.`);
                 }
                 // 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;
     }
     /**
-     * Creates a new application using the entity framework.
-     * This ensures the server-side entity extension is used, which handles:
-     * - Auto-generation of Path from Name (via ApplicationEntityServerEntity)
-     * - Any other server-side business logic
+     * Creates a new application using direct SQL INSERT to ensure it's captured in SQL logging.
+     * The Path field is auto-generated from Name using the same slug logic as ApplicationEntityServerEntity.
      *
-     * @param pool SQL connection pool (unused but kept for signature compatibility)
+     * @param pool SQL connection pool
      * @param appID Pre-generated UUID for the application
      * @param appName Name of the application
      * @param schemaName Schema name for SchemaAutoAddNewEntities
-     * @param currentUser Current user for entity operations
+     * @param currentUser Current user for entity operations (unused but kept for signature compatibility)
      * @returns The application ID if successful, null otherwise
      */
     async createNewApplication(pool, appID, appName, schemaName, currentUser) {
         try {
-            const md = new core_1.Metadata();
-            const app = await md.GetEntityObject('Applications', currentUser);
-            app.NewRecord();
-            app.ID = appID;
-            app.Name = appName;
-            app.Description = 'Generated for schema';
-            app.SchemaAutoAddNewEntities = schemaName;
-            // Path and AutoUpdatePath will be handled by the server-side entity extension
-            // which auto-generates Path from Name when AutoUpdatePath is true (default)
-            const saved = await app.Save();
-            if (saved) {
-                (0, core_1.LogStatus)(`Created new application ${appName} with Path: ${app.Path}`);
-                return appID;
-            }
-            else {
-                const errorMsg = app.LatestResult ? JSON.stringify(app.LatestResult) : 'Unknown error';
-                (0, core_1.LogError)(`Failed to save new application ${appName}: ${errorMsg}`);
-                return null;
-            }
+            // Generate Path from Name using slug conversion:
+            // 1. Convert to lowercase
+            // 2. Replace spaces with hyphens
+            // 3. Remove special characters (keep only alphanumeric and hyphens)
+            const path = appName
+                .toLowerCase()
+                .replace(/\s+/g, '-') // spaces to hyphens
+                .replace(/[^a-z0-9-]/g, '') // remove special chars
+                .replace(/-+/g, '-') // collapse multiple hyphens
+                .replace(/^-|-$/g, ''); // trim hyphens from start/end
+            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}`);
+            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) {
@@ -1814,10 +1937,10 @@ NumberedRows AS (
         }
     }
     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,
@@ -1844,7 +1967,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}
@@ -1865,7 +1988,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;
             }
@@ -1874,13 +1997,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(',')})`;
             }
@@ -1896,7 +2019,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
@@ -1908,7 +2031,7 @@ NumberedRows AS (
                e.SchemaName,
                e.BaseTable
             FROM
-               [${(0, config_1.mj_core_schema)()}].vwEntities e
+               [${mj_core_schema()}].vwEntities e
             WHERE
                ${whereClause}
             ORDER BY
@@ -1941,7 +2064,7 @@ NumberedRows AS (
                ef.EntityIDFieldName,
                ef.RelatedEntity
             FROM
-               [${(0, config_1.mj_core_schema)()}].vwEntityFields ef
+               [${mj_core_schema()}].vwEntityFields ef
             WHERE
                ef.EntityID IN (${entityIds})
             ORDER BY
@@ -1957,7 +2080,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')
@@ -1980,7 +2103,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;
         }
     }
@@ -2008,12 +2131,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;
     }
     /**
@@ -2053,7 +2176,7 @@ NumberedRows AS (
             }, 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}`);
             }
         }
     }
@@ -2066,26 +2189,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
@@ -2097,12 +2220,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
@@ -2153,7 +2276,7 @@ NumberedRows AS (
                 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.`);
+                    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
                 }
                 // Build SET clause with all available metadata
@@ -2175,14 +2298,14 @@ NumberedRows AS (
                     const codeType = fieldCategory.codeType === null ? 'NULL' : `'${fieldCategory.codeType.replace(/'/g, "''")}'`;
                     setClauses.push(`CodeType = ${codeType}`);
                 }
-                const updateSQL = `UPDATE [${(0, config_1.mj_core_schema)()}].EntityField
+                const updateSQL = `UPDATE [${mj_core_schema()}].EntityField
    SET ${setClauses.join(',\n       ')}
    WHERE ID = '${field.ID}'
    AND AutoUpdateCategory = 1`;
                 sqlStatements.push(updateSQL);
             }
             else if (!field) {
-                (0, status_logging_1.logError)(`Form layout generation returned invalid fieldName: '${fieldCategory.fieldName}' not found in entity`);
+                logError(`Form layout generation returned invalid fieldName: '${fieldCategory.fieldName}' not found in entity`);
             }
         }
         // Execute all field updates in one batch
@@ -2194,7 +2317,7 @@ NumberedRows AS (
         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
+            SELECT Icon FROM [${mj_core_schema()}].Entity
             WHERE ID = '${entityId}'
          `;
             const entityCheck = await pool.request().query(checkEntitySQL);
@@ -2204,13 +2327,13 @@ NumberedRows AS (
                 if (!currentIcon || currentIcon.trim().length === 0) {
                     const escapedIcon = result.entityIcon.replace(/'/g, "''");
                     const updateEntitySQL = `
-                  UPDATE [${(0, config_1.mj_core_schema)()}].Entity
+                  UPDATE [${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}`);
+                    logStatus(`  ✓ Set entity icon: ${result.entityIcon}`);
                 }
             }
         }
@@ -2224,14 +2347,14 @@ NumberedRows AS (
             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
+            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) {
                 // Update existing setting
                 const updateSQL = `
-               UPDATE [${(0, config_1.mj_core_schema)()}].EntitySetting
+               UPDATE [${mj_core_schema()}].EntitySetting
                SET Value = '${infoJSON}',
                    __mj_UpdatedAt = GETUTCDATE()
                WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'
@@ -2240,9 +2363,9 @@ NumberedRows AS (
             }
             else {
                 // Insert new setting
-                const newId = (0, uuid_1.v4)();
+                const newId = uuidv4();
                 const insertSQL = `
-               INSERT INTO [${(0, config_1.mj_core_schema)()}].EntitySetting (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
+               INSERT INTO [${mj_core_schema()}].EntitySetting (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
                VALUES ('${newId}', '${entityId}', 'FieldCategoryInfo', '${infoJSON}', GETUTCDATE(), GETUTCDATE())
             `;
                 await this.LogSQLAndExecute(pool, insertSQL, `Insert FieldCategoryInfo setting for entity`, false);
@@ -2257,13 +2380,13 @@ NumberedRows AS (
             }
             const iconsJSON = JSON.stringify(iconsOnly).replace(/'/g, "''");
             const checkLegacySQL = `
-            SELECT ID FROM [${(0, config_1.mj_core_schema)()}].EntitySetting
+            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) {
                 const updateSQL = `
-               UPDATE [${(0, config_1.mj_core_schema)()}].EntitySetting
+               UPDATE [${mj_core_schema()}].EntitySetting
                SET Value = '${iconsJSON}',
                    __mj_UpdatedAt = GETUTCDATE()
                WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryIcons'
@@ -2271,9 +2394,9 @@ NumberedRows AS (
                 await this.LogSQLAndExecute(pool, updateSQL, `Update FieldCategoryIcons setting for entity (legacy format)`, false);
             }
             else {
-                const newId = (0, uuid_1.v4)();
+                const newId = uuidv4();
                 const insertSQL = `
-               INSERT INTO [${(0, config_1.mj_core_schema)()}].EntitySetting (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
+               INSERT INTO [${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);
@@ -2285,14 +2408,14 @@ NumberedRows AS (
             const defaultForNewUser = result.entityImportance.defaultForNewUser ? 1 : 0;
             // Update all ApplicationEntity records for this entity
             const updateAppEntitySQL = `
-            UPDATE [${(0, config_1.mj_core_schema)()}].ApplicationEntity
+            UPDATE [${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}`);
+            logStatus(`  ✓ Entity importance (NEW Entity): ${result.entityImportance.entityCategory} (defaultForNewUser: ${result.entityImportance.defaultForNewUser}, confidence: ${result.entityImportance.confidence})`);
+            logStatus(`    Reasoning: ${result.entityImportance.reasoning}`);
         }
     }
     /**
@@ -2306,8 +2429,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