@memberjunction/codegen-lib 3.3.0 → 4.0.0

package/dist/Database/sql_codegen.js

@@ -1,45 +1,16 @@
-"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.SQLCodeGenBase = exports.SPType = void 0;
-const core_1 = require("@memberjunction/core");
-const status_logging_1 = require("../Misc/status_logging");
-const fs = __importStar(require("fs"));
-const path_1 = __importDefault(require("path"));
-const sql_1 = require("./sql");
-const config_1 = require("../Config/config");
-const manage_metadata_1 = require("./manage-metadata");
-const sqlserver_dataprovider_1 = require("@memberjunction/sqlserver-dataprovider");
-const util_1 = require("../Misc/util");
-const global_1 = require("@memberjunction/global");
-const sql_logging_1 = require("../Misc/sql_logging");
-const temp_batch_file_1 = require("../Misc/temp_batch_file");
-exports.SPType = {
+import { EntityInfo, Metadata } from '@memberjunction/core';
+import { logError, logStatus, logWarning, startSpinner, updateSpinner, succeedSpinner, failSpinner } from '../Misc/status_logging.js';
+import * as fs from 'fs';
+import path from 'path';
+import { SQLUtilityBase } from './sql.js';
+import { autoIndexForeignKeys, configInfo, customSqlScripts, dbDatabase, mjCoreSchema, MAX_INDEX_NAME_LENGTH } from '../Config/config.js';
+import { ManageMetadataBase } from './manage-metadata.js';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { combineFiles, logIf, sortBySequenceAndCreatedAt } from '../Misc/util.js';
+import { MJGlobal } from '@memberjunction/global';
+import { SQLLogging } from '../Misc/sql_logging.js';
+import { TempBatchFile } from '../Misc/temp_batch_file.js';
+export const SPType = {
     Create: 'Create',
     Update: 'Update',
     Delete: 'Delete',
@@ -49,53 +20,55 @@ exports.SPType = {
  * databases. The base class implements support for SQL Server. In future versions of MJ, we will break out an abstract base class that has the skeleton of the logic and then the SQL Server version will be a sub-class
  * of that abstract base class and other databases will be sub-classes of the abstract base class as well.
  */
-class SQLCodeGenBase {
-    _sqlUtilityObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(sql_1.SQLUtilityBase);
+export class SQLCodeGenBase {
+    constructor() {
+        this._sqlUtilityObject = MJGlobal.Instance.ClassFactory.CreateInstance(SQLUtilityBase);
+        /**
+         * Array of entity names that qualify for forced regeneration based on the whereClause filter
+         */
+        this.entitiesQualifiedForForcedRegeneration = [];
+        /**
+         * Flag indicating whether to filter entities for forced regeneration based on entityWhereClause
+         */
+        this.filterEntitiesQualifiedForRegeneration = false;
+        /**
+         * Tracks cascade delete dependencies between entities.
+         * Key: Entity ID whose update/delete SP is called by other entities' delete SPs
+         * Value: Set of Entity IDs that have CascadeDeletes=true and call this entity's update/delete SP
+         */
+        this.cascadeDeleteDependencies = new Map();
+        /**
+         * Tracks entities that need their delete stored procedures regenerated due to cascade dependencies
+         */
+        this.entitiesNeedingDeleteSPRegeneration = new Set();
+        /**
+         * Ordered list of entity IDs for delete SP regeneration (dependency order)
+         */
+        this.orderedEntitiesForDeleteSPRegeneration = [];
+    }
     get SQLUtilityObject() {
         return this._sqlUtilityObject;
     }
-    /**
-     * Array of entity names that qualify for forced regeneration based on the whereClause filter
-     */
-    entitiesQualifiedForForcedRegeneration = [];
-    /**
-     * Flag indicating whether to filter entities for forced regeneration based on entityWhereClause
-     */
-    filterEntitiesQualifiedForRegeneration = false;
-    /**
-     * Tracks cascade delete dependencies between entities.
-     * Key: Entity ID whose update/delete SP is called by other entities' delete SPs
-     * Value: Set of Entity IDs that have CascadeDeletes=true and call this entity's update/delete SP
-     */
-    cascadeDeleteDependencies = new Map();
-    /**
-     * Tracks entities that need their delete stored procedures regenerated due to cascade dependencies
-     */
-    entitiesNeedingDeleteSPRegeneration = new Set();
-    /**
-     * Ordered list of entity IDs for delete SP regeneration (dependency order)
-     */
-    orderedEntitiesForDeleteSPRegeneration = [];
     async manageSQLScriptsAndExecution(pool, entities, directory, currentUser) {
         try {
             // Build list of entities qualified for forced regeneration if entityWhereClause is provided
-            if (config_1.configInfo.forceRegeneration?.enabled && config_1.configInfo.forceRegeneration?.entityWhereClause) {
+            if (configInfo.forceRegeneration?.enabled && configInfo.forceRegeneration?.entityWhereClause) {
                 this.filterEntitiesQualifiedForRegeneration = true; // Enable filtering
                 try {
-                    const whereClause = config_1.configInfo.forceRegeneration.entityWhereClause;
+                    const whereClause = configInfo.forceRegeneration.entityWhereClause;
                     const query = `
                         SELECT Name 
-                        FROM [${config_1.mjCoreSchema}].[Entity] 
+                        FROM [${mjCoreSchema}].[Entity] 
                         WHERE ${whereClause}
                     `;
                     const result = await pool.request().query(query);
                     this.entitiesQualifiedForForcedRegeneration = result.recordset.map((r) => r.Name);
-                    (0, status_logging_1.logStatus)(`Force regeneration filter enabled: ${this.entitiesQualifiedForForcedRegeneration.length} entities qualified based on entityWhereClause: ${whereClause}`);
+                    logStatus(`Force regeneration filter enabled: ${this.entitiesQualifiedForForcedRegeneration.length} entities qualified based on entityWhereClause: ${whereClause}`);
                 }
                 catch (error) {
-                    (0, status_logging_1.logError)(`CRITICAL ERROR: Failed to execute forceRegeneration.entityWhereClause query: ${error}`);
-                    (0, status_logging_1.logError)(`WHERE clause: ${config_1.configInfo.forceRegeneration.entityWhereClause}`);
-                    (0, status_logging_1.logError)(`Stopping execution due to invalid entityWhereClause configuration`);
+                    logError(`CRITICAL ERROR: Failed to execute forceRegeneration.entityWhereClause query: ${error}`);
+                    logError(`WHERE clause: ${configInfo.forceRegeneration.entityWhereClause}`);
+                    logError(`Stopping execution due to invalid entityWhereClause configuration`);
                     throw new Error(`Invalid forceRegeneration.entityWhereClause: ${error}`);
                 }
             }
@@ -103,32 +76,32 @@ class SQLCodeGenBase {
             //          we have custom base views, need to have them defined before we do
             //          the rest as the generated stuff might use custom base views in compiled
             //          objects like spCreate for a given entity might reference the vw for that entity
-            (0, status_logging_1.startSpinner)('Running custom SQL scripts...');
+            startSpinner('Running custom SQL scripts...');
             const startTime = new Date();
             if (!await this.runCustomSQLScripts(pool, 'before-sql')) {
-                (0, status_logging_1.failSpinner)('Failed to run custom SQL scripts');
+                failSpinner('Failed to run custom SQL scripts');
                 return false;
             }
-            (0, status_logging_1.succeedSpinner)(`Custom SQL scripts completed (${(new Date().getTime() - startTime.getTime()) / 1000}s)`);
+            succeedSpinner(`Custom SQL scripts completed (${(new Date().getTime() - startTime.getTime()) / 1000}s)`);
             // ALWAYS use the first filter where we only include entities that have IncludeInAPI = 1
             // Entities are already sorted by name in PostProcessEntityMetadata (see providerBase.ts)
             const baselineEntities = entities.filter(e => e.IncludeInAPI);
-            const includedEntities = baselineEntities.filter(e => config_1.configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) === undefined); //only include entities that are NOT in the excludeSchemas list
-            const excludedEntities = baselineEntities.filter(e => config_1.configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) !== undefined); //only include entities that ARE in the excludeSchemas list in this array
+            const includedEntities = baselineEntities.filter(e => configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) === undefined); //only include entities that are NOT in the excludeSchemas list
+            const excludedEntities = baselineEntities.filter(e => configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) !== undefined); //only include entities that ARE in the excludeSchemas list in this array
             // Initialize temp batch files for each schema
             // These will be populated as SQL is generated and will be used for actual execution
             const schemas = Array.from(new Set(baselineEntities.map(e => e.SchemaName)));
-            temp_batch_file_1.TempBatchFile.initialize(directory, schemas);
+            TempBatchFile.initialize(directory, schemas);
             // STEP 1.5 - Check for cascade delete dependencies that require regeneration
-            (0, status_logging_1.startSpinner)('Analyzing cascade delete dependencies...');
+            startSpinner('Analyzing cascade delete dependencies...');
             await this.markEntitiesForCascadeDeleteRegeneration(pool, includedEntities);
-            (0, status_logging_1.succeedSpinner)('Cascade delete dependency analysis completed');
+            succeedSpinner('Cascade delete dependency analysis completed');
             // STEP 2(a) - clean out all *.generated.sql and *.permissions.generated.sql files from the directory
-            (0, status_logging_1.startSpinner)('Cleaning generated files...');
+            startSpinner('Cleaning generated files...');
             this.deleteGeneratedEntityFiles(directory, baselineEntities);
-            (0, status_logging_1.succeedSpinner)('Cleaned generated files');
+            succeedSpinner('Cleaned generated files');
             // STEP 2(b) - generate all the SQL files and execute them
-            (0, status_logging_1.startSpinner)(`Generating SQL for ${includedEntities.length} entities...`);
+            startSpinner(`Generating SQL for ${includedEntities.length} entities...`);
             const step2StartTime = new Date();
             // First, separate entities that need cascade delete regeneration from others
             const entitiesWithoutCascadeRegeneration = includedEntities.filter(e => !this.entitiesNeedingDeleteSPRegeneration.has(e.ID));
@@ -147,12 +120,12 @@ class SQLCodeGenBase {
                 enableSQLLoggingForNewOrModifiedEntities: true
             }); // enable sql logging for NEW entities....
             if (!genResult.Success) {
-                (0, status_logging_1.failSpinner)('Failed to generate entity SQL files');
+                failSpinner('Failed to generate entity SQL files');
                 return false;
             }
             // Generate SQL for cascade delete regenerations in dependency order (sequentially)
             if (entitiesForCascadeRegeneration.length > 0) {
-                (0, status_logging_1.updateSpinner)(`Regenerating ${entitiesForCascadeRegeneration.length} delete SPs in dependency order...`);
+                updateSpinner(`Regenerating ${entitiesForCascadeRegeneration.length} delete SPs in dependency order...`);
                 const cascadeGenResult = await this.generateAndExecuteEntitySQLToSeparateFiles({
                     pool,
                     entities: entitiesForCascadeRegeneration,
@@ -164,13 +137,13 @@ class SQLCodeGenBase {
                     enableSQLLoggingForNewOrModifiedEntities: true
                 });
                 if (!cascadeGenResult.Success) {
-                    (0, status_logging_1.failSpinner)('Failed to regenerate cascade delete SPs');
+                    failSpinner('Failed to regenerate cascade delete SPs');
                     return false;
                 }
                 genResult.Files.push(...cascadeGenResult.Files);
             }
             // STEP 2(c) - for the excludedEntities, while we don't want to generate SQL, we do want to generate the permissions files for them
-            (0, status_logging_1.updateSpinner)(`Generating permissions for ${excludedEntities.length} excluded entities...`);
+            updateSpinner(`Generating permissions for ${excludedEntities.length} excluded entities...`);
             const genResult2 = await this.generateAndExecuteEntitySQLToSeparateFiles({
                 pool,
                 entities: excludedEntities,
@@ -182,88 +155,88 @@ class SQLCodeGenBase {
                 enableSQLLoggingForNewOrModifiedEntities: false /*don't log this stuff, it is just permissions for excluded entities*/
             });
             if (!genResult2.Success) {
-                (0, status_logging_1.failSpinner)('Failed to generate permissions for excluded entities');
+                failSpinner('Failed to generate permissions for excluded entities');
                 return false;
             }
-            (0, status_logging_1.succeedSpinner)(`Entity generation completed (${(new Date().getTime() - step2StartTime.getTime()) / 1000}s)`);
+            succeedSpinner(`Entity generation completed (${(new Date().getTime() - step2StartTime.getTime()) / 1000}s)`);
             // STEP 2(d) now that we've generated the SQL, let's create a combined file in each schema sub-directory for convenience for a DBA
-            (0, status_logging_1.startSpinner)('Creating combined SQL files...');
+            startSpinner('Creating combined SQL files...');
             const allEntityFiles = this.createCombinedEntitySQLFiles(directory, baselineEntities);
-            (0, status_logging_1.succeedSpinner)(`Created combined SQL files for ${allEntityFiles.length} schemas`);
+            succeedSpinner(`Created combined SQL files for ${allEntityFiles.length} schemas`);
             // STEP 2(e) ---- FINALLY, we execute SQL in proper dependency order
             // Use temp batch files (which maintain CodeGen log order) if available, otherwise fall back to combined files
-            (0, status_logging_1.startSpinner)('Executing entity SQL files...');
+            startSpinner('Executing entity SQL files...');
             const step2eStartTime = new Date();
             let executionSuccess = false;
-            if (temp_batch_file_1.TempBatchFile.hasContent()) {
+            if (TempBatchFile.hasContent()) {
                 // Execute temp batch files in dependency order (matches CodeGen run log)
-                const tempFiles = temp_batch_file_1.TempBatchFile.getTempFilePaths();
-                (0, util_1.logIf)(config_1.configInfo?.verboseOutput ?? false, `Executing ${tempFiles.length} temp batch file(s) in dependency order`);
-                executionSuccess = await this.SQLUtilityObject.executeSQLFiles(tempFiles, config_1.configInfo?.verboseOutput ?? false);
+                const tempFiles = TempBatchFile.getTempFilePaths();
+                logIf(configInfo?.verboseOutput ?? false, `Executing ${tempFiles.length} temp batch file(s) in dependency order`);
+                executionSuccess = await this.SQLUtilityObject.executeSQLFiles(tempFiles, configInfo?.verboseOutput ?? false);
                 // Clean up temp files after execution
-                temp_batch_file_1.TempBatchFile.cleanup();
+                TempBatchFile.cleanup();
             }
             else {
                 // Fall back to combined files (for backward compatibility or if temp files weren't created)
-                (0, util_1.logIf)(config_1.configInfo?.verboseOutput ?? false, `Executing ${allEntityFiles.length} combined file(s)`);
-                executionSuccess = await this.SQLUtilityObject.executeSQLFiles(allEntityFiles, config_1.configInfo?.verboseOutput ?? false);
+                logIf(configInfo?.verboseOutput ?? false, `Executing ${allEntityFiles.length} combined file(s)`);
+                executionSuccess = await this.SQLUtilityObject.executeSQLFiles(allEntityFiles, configInfo?.verboseOutput ?? false);
             }
             if (!executionSuccess) {
-                (0, status_logging_1.failSpinner)('Failed to execute entity SQL files');
-                temp_batch_file_1.TempBatchFile.cleanup(); // Cleanup on error
+                failSpinner('Failed to execute entity SQL files');
+                TempBatchFile.cleanup(); // Cleanup on error
                 return false;
             }
             const step2eEndTime = new Date();
-            (0, status_logging_1.succeedSpinner)(`SQL execution completed (${(step2eEndTime.getTime() - step2eStartTime.getTime()) / 1000}s)`);
-            const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.ManageMetadataBase);
+            succeedSpinner(`SQL execution completed (${(step2eEndTime.getTime() - step2eStartTime.getTime()) / 1000}s)`);
+            const manageMD = MJGlobal.Instance.ClassFactory.CreateInstance(ManageMetadataBase);
             // STEP 3 - re-run the process to manage entity fields since the Step 1 and 2 above might have resulted in differences in base view columns compared to what we had at first
             // we CAN skip the entity field values part because that wouldn't change from the first time we ran it
             // Run advanced generation here in case new virtual fields added, so we do NOT run advanced geneartion in the main manageMetadata() call
-            (0, status_logging_1.startSpinner)('Managing entity fields metadata...');
-            if (!await manageMD.manageEntityFields(pool, config_1.configInfo.excludeSchemas, true, true, currentUser, false)) {
-                (0, status_logging_1.failSpinner)('Failed to manage entity fields');
+            startSpinner('Managing entity fields metadata...');
+            if (!await manageMD.manageEntityFields(pool, configInfo.excludeSchemas, true, true, currentUser, false)) {
+                failSpinner('Failed to manage entity fields');
                 return false;
             }
-            (0, status_logging_1.succeedSpinner)('Entity fields metadata updated');
+            succeedSpinner('Entity fields metadata updated');
             // no logStatus/timer for this because manageEntityFields() has its own internal logging for this including the total, so it is redundant to log it here
             // STEP 4- Apply permissions, executing all .permissions files
-            (0, status_logging_1.startSpinner)('Applying permissions...');
+            startSpinner('Applying permissions...');
             const step4StartTime = new Date();
             if (!await this.applyPermissions(pool, directory, baselineEntities)) {
-                (0, status_logging_1.failSpinner)('Failed to apply permissions');
+                failSpinner('Failed to apply permissions');
                 return false;
             }
-            (0, status_logging_1.succeedSpinner)(`Permissions applied (${(new Date().getTime() - step4StartTime.getTime()) / 1000}s)`);
+            succeedSpinner(`Permissions applied (${(new Date().getTime() - step4StartTime.getTime()) / 1000}s)`);
             // STEP 5 - execute any custom SQL scripts that should run afterwards
-            (0, status_logging_1.startSpinner)('Running post-generation SQL scripts...');
+            startSpinner('Running post-generation SQL scripts...');
             const step5StartTime = new Date();
             if (!await this.runCustomSQLScripts(pool, 'after-sql')) {
-                (0, status_logging_1.failSpinner)('Failed to run post-generation SQL scripts');
+                failSpinner('Failed to run post-generation SQL scripts');
                 return false;
             }
-            (0, status_logging_1.succeedSpinner)(`Post-generation scripts completed (${(new Date().getTime() - step5StartTime.getTime()) / 1000}s)`);
-            (0, status_logging_1.succeedSpinner)(`SQL CodeGen completed successfully (${((new Date().getTime() - startTime.getTime()) / 1000)}s total)`);
+            succeedSpinner(`Post-generation scripts completed (${(new Date().getTime() - step5StartTime.getTime()) / 1000}s)`);
+            succeedSpinner(`SQL CodeGen completed successfully (${((new Date().getTime() - startTime.getTime()) / 1000)}s total)`);
             // now - we need to tell our metadata object to refresh itself
-            const md = new core_1.Metadata();
+            const md = new Metadata();
             await md.Refresh();
             return true;
         }
         catch (err) {
-            (0, status_logging_1.logError)(err);
+            logError(err);
             // Clean up temp batch files on error
-            temp_batch_file_1.TempBatchFile.cleanup();
+            TempBatchFile.cleanup();
             return false;
         }
     }
     async runCustomSQLScripts(pool, when) {
         try {
-            const scripts = (0, config_1.customSqlScripts)(when);
+            const scripts = customSqlScripts(when);
             let bSuccess = true;
             if (scripts) {
                 for (let i = 0; i < scripts.length; ++i) {
                     const s = scripts[i];
                     if (!await this.SQLUtilityObject.executeSQLFile(s.scriptFile)) {
-                        (0, status_logging_1.logError)(`Error executing custom '${when}' SQL script ${s.scriptFile}`);
+                        logError(`Error executing custom '${when}' SQL script ${s.scriptFile}`);
                         bSuccess = false; // keep going if we have more scripts, but make sure we return false
                     }
                 }
@@ -271,7 +244,7 @@ class SQLCodeGenBase {
             return bSuccess;
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
             return false;
         }
     }
@@ -285,7 +258,7 @@ class SQLCodeGenBase {
                     const files = this.getEntityPermissionFileNames(e);
                     let innerSuccess = true;
                     for (const f of files) {
-                        const fullPath = path_1.default.join(directory, f);
+                        const fullPath = path.join(directory, f);
                         if (fs.existsSync(fullPath)) {
                             const fileBuffer = fs.readFileSync(fullPath);
                             const fileContents = fileBuffer.toString();
@@ -293,28 +266,28 @@ class SQLCodeGenBase {
                                 await pool.request().query(fileContents);
                             }
                             catch (e) {
-                                (0, status_logging_1.logError)(`Error executing permissions file ${fullPath} for entity ${e.Name}: ${e}`);
+                                logError(`Error executing permissions file ${fullPath} for entity ${e.Name}: ${e}`);
                                 innerSuccess = false;
                             }
                         }
                         else {
                             // we don't have the file, so we can't execute it, but we should log it as an error
                             // and then keep going
-                            (0, status_logging_1.logError)(`Permissions file ${fullPath} does not exist for entity ${e.Name}`);
+                            logError(`Permissions file ${fullPath} does not exist for entity ${e.Name}`);
                         }
                     }
                     return innerSuccess;
                 });
                 const results = await Promise.all(promises);
                 if (results.includes(false)) {
-                    (0, status_logging_1.logError)(`Error executing one or more permissions files in batch starting from index ${i}`);
+                    logError(`Error executing one or more permissions files in batch starting from index ${i}`);
                     bSuccess = false; // keep going, but will return false at the end
                 }
             }
             return bSuccess;
         }
         catch (err) {
-            (0, status_logging_1.logError)(err);
+            logError(err);
             return false;
         }
     }
@@ -337,7 +310,7 @@ class SQLCodeGenBase {
                 const promises = batch.map(async (e) => {
                     const pkeyField = e.Fields.find(f => f.IsPrimaryKey);
                     if (!pkeyField) {
-                        (0, status_logging_1.logError)(`SKIPPING ENTITY: Entity ${e.Name}, because it does not have a primary key field defined. A table must have a primary key defined to quality to be a MemberJunction entity`);
+                        logError(`SKIPPING ENTITY: Entity ${e.Name}, because it does not have a primary key field defined. A table must have a primary key defined to quality to be a MemberJunction entity`);
                         return { Success: false, Files: [] };
                     }
                     return this.generateAndExecuteSingleEntitySQLToSeparateFiles({
@@ -360,7 +333,7 @@ class SQLCodeGenBase {
             return { Success: !bFail, Files: files };
         }
         catch (err) {
-            (0, status_logging_1.logError)(err);
+            logError(err);
             return { Success: false, Files: files };
         }
     }
@@ -369,7 +342,7 @@ class SQLCodeGenBase {
             // for the schemas associated with the specified entities, clean out all the generated files
             const schemaNames = entities.map(e => e.SchemaName).filter((value, index, self) => self.indexOf(value) === index);
             for (const s of schemaNames) {
-                const fullPath = path_1.default.join(directory, s);
+                const fullPath = path.join(directory, s);
                 // now, within each schema directory, clean out all the generated files
                 // the generated files map this pattern: *.generated.sql or *.permissions.generated.sql
                 let stats;
@@ -383,14 +356,14 @@ class SQLCodeGenBase {
                 if (stats?.isDirectory()) {
                     const files = fs.readdirSync(fullPath).filter(f => f.endsWith('.generated.sql') || f.endsWith('.permissions.generated.sql'));
                     for (const f of files) {
-                        const filePath = path_1.default.join(fullPath, f);
+                        const filePath = path.join(fullPath, f);
                         fs.unlinkSync(filePath);
                     }
                 }
             }
         }
         catch (e) {
-            (0, status_logging_1.logError)(e);
+            logError(e);
         }
     }
     createCombinedEntitySQLFiles(directory, entities) {
@@ -399,12 +372,12 @@ class SQLCodeGenBase {
         const schemaNames = entities.map(e => e.SchemaName).filter((value, index, self) => self.indexOf(value) === index);
         for (const s of schemaNames) {
             // generate the all-entities.sql file and all-entities.permissions.sql file in each schema folder
-            const fullPath = path_1.default.join(directory, s);
+            const fullPath = path.join(directory, s);
             if (fs.statSync(fullPath).isDirectory()) {
-                (0, util_1.combineFiles)(fullPath, '_all_entities.sql', '*.generated.sql', true);
-                files.push(path_1.default.join(fullPath, '_all_entities.sql'));
-                (0, util_1.combineFiles)(fullPath, '_all_entities.permissions.sql', '*.permissions.generated.sql', true);
-                files.push(path_1.default.join(fullPath, '_all_entities.permissions.sql'));
+                combineFiles(fullPath, '_all_entities.sql', '*.generated.sql', true);
+                files.push(path.join(fullPath, '_all_entities.sql'));
+                combineFiles(fullPath, '_all_entities.permissions.sql', '*.permissions.generated.sql', true);
+                files.push(path.join(fullPath, '_all_entities.permissions.sql'));
             }
         }
         return files;
@@ -422,7 +395,7 @@ class SQLCodeGenBase {
                 return { Success: true, Files: files };
         }
         catch (err) {
-            (0, status_logging_1.logError)(err);
+            logError(err);
             return { Success: false, Files: [] };
         }
     }
@@ -431,28 +404,35 @@ class SQLCodeGenBase {
         let shouldLog = false;
         if (logSql) {
             // Check if entity is in new or modified lists
-            const isNewOrModified = !!manage_metadata_1.ManageMetadataBase.newEntityList.find(e => e === entity.Name) ||
-                !!manage_metadata_1.ManageMetadataBase.modifiedEntityList.find(e => e === entity.Name);
+            const isNewOrModified = !!ManageMetadataBase.newEntityList.find(e => e === entity.Name) ||
+                !!ManageMetadataBase.modifiedEntityList.find(e => e === entity.Name);
             // Check if entity is being regenerated due to cascade dependencies
             const isCascadeDependencyRegeneration = description.toLowerCase().includes('spdelete') &&
                 this.entitiesNeedingDeleteSPRegeneration.has(entity.ID);
             // Check if force regeneration is enabled for relevant SQL types
-            const isForceRegeneration = config_1.configInfo.forceRegeneration?.enabled && ((description.toLowerCase().includes('base view') && config_1.configInfo.forceRegeneration.baseViews) ||
-                (description.toLowerCase().includes('root id function') && config_1.configInfo.forceRegeneration.baseViews) || // TVFs are part of base view infrastructure
-                (description.toLowerCase().includes('spcreate') && config_1.configInfo.forceRegeneration.spCreate) ||
-                (description.toLowerCase().includes('spupdate') && config_1.configInfo.forceRegeneration.spUpdate) ||
-                (description.toLowerCase().includes('spdelete') && config_1.configInfo.forceRegeneration.spDelete) ||
-                (description.toLowerCase().includes('index') && config_1.configInfo.forceRegeneration.indexes) ||
-                (description.toLowerCase().includes('full text search') && config_1.configInfo.forceRegeneration.fullTextSearch) ||
-                (config_1.configInfo.forceRegeneration.allStoredProcedures &&
+            const isForceRegeneration = configInfo.forceRegeneration?.enabled && ((description.toLowerCase().includes('base view') && configInfo.forceRegeneration.baseViews) ||
+                (description.toLowerCase().includes('root id function') && configInfo.forceRegeneration.baseViews) || // TVFs are part of base view infrastructure
+                (description.toLowerCase().includes('spcreate') && configInfo.forceRegeneration.spCreate) ||
+                (description.toLowerCase().includes('spupdate') && configInfo.forceRegeneration.spUpdate) ||
+                (description.toLowerCase().includes('spdelete') && configInfo.forceRegeneration.spDelete) ||
+                (description.toLowerCase().includes('index') && configInfo.forceRegeneration.indexes) ||
+                (description.toLowerCase().includes('full text search') && configInfo.forceRegeneration.fullTextSearch) ||
+                (configInfo.forceRegeneration.allStoredProcedures &&
                     (description.toLowerCase().includes('spcreate') ||
                         description.toLowerCase().includes('spupdate') ||
                         description.toLowerCase().includes('spdelete'))));
+            // Check if entity has RelatedEntityJoinFields configured (requires view regeneration for metadata-only changes)
+            const hasRelatedEntityJoinFields = description.toLowerCase().includes('base view') &&
+                entity.Fields.some(f => f.RelatedEntityJoinFieldsConfig !== null);
             // Determine if we should log based on entity state and force regeneration settings
             if (isNewOrModified) {
                 // Always log new or modified entities
                 shouldLog = true;
             }
+            else if (hasRelatedEntityJoinFields) {
+                // Always regenerate base views for entities with RelatedEntityJoinFields configuration
+                shouldLog = true;
+            }
             else if (isCascadeDependencyRegeneration) {
                 // Always log cascade dependency regenerations
                 shouldLog = true;
@@ -471,11 +451,10 @@ class SQLCodeGenBase {
             }
         }
         if (shouldLog) {
-            sql_logging_1.SQLLogging.appendToSQLLogFile(sql, description);
-            // Also write to temp batch file for actual execution (matches CodeGen log order)
-            temp_batch_file_1.TempBatchFile.appendToTempBatchFile(sql, entity.SchemaName);
+            SQLLogging.appendToSQLLogFile(sql, description);
+            TempBatchFile.appendToTempBatchFile(sql, entity.SchemaName);
         }
-        (0, util_1.logIf)(config_1.configInfo.verboseOutput, `SQL Generated for ${entity.Name}: ${description}`);
+        logIf(configInfo.verboseOutput, `SQL Generated for ${entity.Name}: ${description}`);
     }
     async generateSingleEntitySQLToSeparateFiles(options) {
         const files = [];
@@ -484,18 +463,18 @@ class SQLCodeGenBase {
             if (options.writeFiles && !fs.existsSync(options.directory))
                 fs.mkdirSync(options.directory, { recursive: true });
             // now do the same thing for the /schema directory within the provided directory
-            const schemaDirectory = path_1.default.join(options.directory, options.entity.SchemaName);
+            const schemaDirectory = path.join(options.directory, options.entity.SchemaName);
             if (options.writeFiles && !fs.existsSync(schemaDirectory))
                 fs.mkdirSync(schemaDirectory, { recursive: true }); // create the directory if it doesn't exist
             let sRet = '';
             let permissionsSQL = '';
             // Indexes for Fkeys for the table
             if (!options.onlyPermissions) {
-                const shouldGenerateIndexes = (0, config_1.autoIndexForeignKeys)() || (config_1.configInfo.forceRegeneration?.enabled && config_1.configInfo.forceRegeneration?.indexes);
+                const shouldGenerateIndexes = autoIndexForeignKeys() || (configInfo.forceRegeneration?.enabled && configInfo.forceRegeneration?.indexes);
                 const indexSQL = shouldGenerateIndexes ? this.generateIndexesForForeignKeys(options.pool, options.entity) : ''; // generate indexes if auto-indexing is on OR force regeneration is enabled
                 const s = this.generateSingleEntitySQLFileHeader(options.entity, 'Index for Foreign Keys') + indexSQL;
                 if (options.writeFiles) {
-                    const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('index', options.entity.SchemaName, options.entity.BaseTable, false, true));
+                    const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('index', options.entity.SchemaName, options.entity.BaseTable, false, true));
                     this.logSQLForNewOrModifiedEntity(options.entity, s, 'Index for Foreign Keys for ' + options.entity.BaseTable, options.enableSQLLoggingForNewOrModifiedEntities);
                     fs.writeFileSync(filePath, s);
                     files.push(filePath);
@@ -517,7 +496,7 @@ class SQLCodeGenBase {
                         const functionName = `fn${options.entity.BaseTable}${field.Name}_GetRootID`;
                         const s = this.generateSingleEntitySQLFileHeader(options.entity, functionName) +
                             this.generateRootIDFunction(options.entity, field);
-                        const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('function', options.entity.SchemaName, functionName, false, true));
+                        const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('function', options.entity.SchemaName, functionName, false, true));
                         if (options.writeFiles) {
                             this.logSQLForNewOrModifiedEntity(options.entity, s, `Root ID Function SQL for ${options.entity.Name}.${field.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                             fs.writeFileSync(filePath, s);
@@ -529,7 +508,7 @@ class SQLCodeGenBase {
                 }
                 // Generate the base view (which may reference the TVFs created above)
                 const s = this.generateSingleEntitySQLFileHeader(options.entity, options.entity.BaseView) + await this.generateBaseView(options.pool, options.entity);
-                const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('view', options.entity.SchemaName, options.entity.BaseView, false, true));
+                const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('view', options.entity.SchemaName, options.entity.BaseView, false, true));
                 if (options.writeFiles) {
                     this.logSQLForNewOrModifiedEntity(options.entity, s, `Base View SQL for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                     fs.writeFileSync(filePath, s);
@@ -542,7 +521,7 @@ class SQLCodeGenBase {
             if (s.length > 0)
                 permissionsSQL += s + '\nGO\n';
             if (options.writeFiles) {
-                const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('view', options.entity.SchemaName, options.entity.BaseView, true, true));
+                const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('view', options.entity.SchemaName, options.entity.BaseView, true, true));
                 fs.writeFileSync(filePath, s);
                 this.logSQLForNewOrModifiedEntity(options.entity, s, `Base View Permissions SQL for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                 files.push(filePath);
@@ -553,25 +532,25 @@ class SQLCodeGenBase {
                 sRet += s + '\nGO\n';
             // CREATE SP
             if (options.entity.AllowCreateAPI && !options.entity.VirtualEntity) {
-                const spName = this.getSPName(options.entity, exports.SPType.Create);
+                const spName = this.getSPName(options.entity, SPType.Create);
                 // Only generate if spCreateGenerated is true (respects custom SPs where it's false)
                 // forceRegeneration only forces regeneration of SPs where spCreateGenerated=true
                 if (!options.onlyPermissions && options.entity.spCreateGenerated) {
                     // generate the create SP
                     const s = this.generateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPCreate(options.entity);
                     if (options.writeFiles) {
-                        const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, false, true));
+                        const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, false, true));
                         this.logSQLForNewOrModifiedEntity(options.entity, s, `spCreate SQL for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                         fs.writeFileSync(filePath, s);
                         files.push(filePath);
                     }
                     sRet += s + '\nGO\n';
                 }
-                const s = this.generateSPPermissions(options.entity, spName, exports.SPType.Create) + '\n\n';
+                const s = this.generateSPPermissions(options.entity, spName, SPType.Create) + '\n\n';
                 if (s.length > 0)
                     permissionsSQL += s + '\nGO\n';
                 if (options.writeFiles) {
-                    const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, true, true));
+                    const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, true, true));
                     this.logSQLForNewOrModifiedEntity(options.entity, s, `spCreate Permissions for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                     fs.writeFileSync(filePath, s);
                     files.push(filePath);
@@ -583,25 +562,25 @@ class SQLCodeGenBase {
             }
             // UPDATE SP
             if (options.entity.AllowUpdateAPI && !options.entity.VirtualEntity) {
-                const spName = this.getSPName(options.entity, exports.SPType.Update);
+                const spName = this.getSPName(options.entity, SPType.Update);
                 // Only generate if spUpdateGenerated is true (respects custom SPs where it's false)
                 // forceRegeneration only forces regeneration of SPs where spUpdateGenerated=true
                 if (!options.onlyPermissions && options.entity.spUpdateGenerated) {
                     // generate the update SP
                     const s = this.generateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPUpdate(options.entity);
                     if (options.writeFiles) {
-                        const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, false, true));
+                        const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, false, true));
                         fs.writeFileSync(filePath, s);
                         this.logSQLForNewOrModifiedEntity(options.entity, s, `spUpdate SQL for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                         files.push(filePath);
                     }
                     sRet += s + '\nGO\n';
                 }
-                const s = this.generateSPPermissions(options.entity, spName, exports.SPType.Update) + '\n\n';
+                const s = this.generateSPPermissions(options.entity, spName, SPType.Update) + '\n\n';
                 if (s.length > 0)
                     permissionsSQL += s + '\nGO\n';
                 if (options.writeFiles) {
-                    const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, true, true));
+                    const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, true, true));
                     this.logSQLForNewOrModifiedEntity(options.entity, s, `spUpdate Permissions for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                     fs.writeFileSync(filePath, s);
                     files.push(filePath);
@@ -613,7 +592,7 @@ class SQLCodeGenBase {
             }
             // DELETE SP
             if (options.entity.AllowDeleteAPI && !options.entity.VirtualEntity) {
-                const spName = this.getSPName(options.entity, exports.SPType.Delete);
+                const spName = this.getSPName(options.entity, SPType.Delete);
                 // Only generate if spDeleteGenerated is true (respects custom SPs where it's false)
                 // OR if this entity has cascade delete dependencies that require regeneration
                 // forceRegeneration only forces regeneration of SPs where spDeleteGenerated=true
@@ -622,22 +601,22 @@ class SQLCodeGenBase {
                         this.entitiesNeedingDeleteSPRegeneration.has(options.entity.ID))) {
                     // generate the delete SP
                     if (this.entitiesNeedingDeleteSPRegeneration.has(options.entity.ID)) {
-                        (0, status_logging_1.logStatus)(`  Regenerating ${spName} due to cascade dependency changes`);
+                        logStatus(`  Regenerating ${spName} due to cascade dependency changes`);
                     }
                     const s = this.generateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPDelete(options.entity);
                     if (options.writeFiles) {
-                        const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, false, true));
+                        const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, false, true));
                         this.logSQLForNewOrModifiedEntity(options.entity, s, `spDelete SQL for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                         fs.writeFileSync(filePath, s);
                         files.push(filePath);
                     }
                     sRet += s + '\nGO\n';
                 }
-                const s = this.generateSPPermissions(options.entity, spName, exports.SPType.Delete) + '\n\n';
+                const s = this.generateSPPermissions(options.entity, spName, SPType.Delete) + '\n\n';
                 if (s.length > 0)
                     permissionsSQL += s + '\nGO\n';
                 if (options.writeFiles) {
-                    const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, true, true));
+                    const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, true, true));
                     this.logSQLForNewOrModifiedEntity(options.entity, s, `spDelete Permissions for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                     fs.writeFileSync(filePath, s);
                     files.push(filePath);
@@ -648,12 +627,12 @@ class SQLCodeGenBase {
                     sRet += s + '\nGO\n';
             }
             // check to see if the options.entity supports full text search or not
-            if (options.entity.FullTextSearchEnabled || (config_1.configInfo.forceRegeneration?.enabled && config_1.configInfo.forceRegeneration?.fullTextSearch)) {
+            if (options.entity.FullTextSearchEnabled || (configInfo.forceRegeneration?.enabled && configInfo.forceRegeneration?.fullTextSearch)) {
                 // always generate the code so we can get the function name from the below function call
                 const ft = await this.generateEntityFullTextSearchSQL(options.pool, options.entity);
                 if (!options.onlyPermissions) {
                     // only write the actual sql out if we're not only generating permissions
-                    const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', options.entity.SchemaName, options.entity.BaseTable, false, true));
+                    const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', options.entity.SchemaName, options.entity.BaseTable, false, true));
                     if (options.writeFiles) {
                         this.logSQLForNewOrModifiedEntity(options.entity, ft.sql, `Full Text Search SQL for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                         fs.writeFileSync(filePath, ft.sql);
@@ -664,7 +643,7 @@ class SQLCodeGenBase {
                 const sP = this.generateFullTextSearchFunctionPermissions(options.entity, ft.functionName) + '\n\n';
                 if (sP.length > 0)
                     permissionsSQL += sP + '\nGO\n';
-                const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', options.entity.SchemaName, options.entity.BaseTable, true, true));
+                const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', options.entity.SchemaName, options.entity.BaseTable, true, true));
                 if (options.writeFiles) {
                     this.logSQLForNewOrModifiedEntity(options.entity, sP, `Full Text Search Permissions for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
                     fs.writeFileSync(filePath, sP);
@@ -678,17 +657,17 @@ class SQLCodeGenBase {
             return { sql: sRet, permissionsSQL: permissionsSQL, files: files };
         }
         catch (err) {
-            (0, status_logging_1.logError)(err);
+            logError(err);
             return null;
         }
     }
     getSPName(entity, type) {
         switch (type) {
-            case exports.SPType.Create:
+            case SPType.Create:
                 return entity.spCreate && entity.spCreate.length > 0 ? entity.spCreate : 'spCreate' + entity.BaseTableCodeName;
-            case exports.SPType.Update:
+            case SPType.Update:
                 return entity.spUpdate && entity.spUpdate.length > 0 ? entity.spUpdate : 'spUpdate' + entity.BaseTableCodeName;
-            case exports.SPType.Delete:
+            case SPType.Delete:
                 return entity.spDelete && entity.spDelete.length > 0 ? entity.spDelete : 'spDelete' + entity.BaseTableCodeName;
         }
     }
@@ -700,11 +679,11 @@ class SQLCodeGenBase {
         if (!entity.VirtualEntity) {
             // only add each SP file if the Allow flags are set to true, doesn't matter if the SPs are generated or not, we always generate permissions
             if (entity.AllowCreateAPI)
-                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, exports.SPType.Create), true, true));
+                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, SPType.Create), true, true));
             if (entity.AllowUpdateAPI)
-                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, exports.SPType.Update), true, true));
+                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, SPType.Update), true, true));
             if (entity.AllowDeleteAPI)
-                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, exports.SPType.Delete), true, true));
+                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, SPType.Delete), true, true));
         }
         if (entity.FullTextSearchEnabled)
             files.push(this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', entity.SchemaName, entity.BaseTable, true, true));
@@ -731,7 +710,7 @@ class SQLCodeGenBase {
                 sOutput += this.generateSPCreate(entity) + '\n\n';
             else
                 // custom SP, still generate the permissions
-                sOutput += this.generateSPPermissions(entity, entity.spCreate, exports.SPType.Create) + '\n\n';
+                sOutput += this.generateSPPermissions(entity, entity.spCreate, SPType.Create) + '\n\n';
         }
         if (entity.AllowUpdateAPI && !entity.VirtualEntity) {
             if (entity.spUpdateGenerated)
@@ -739,7 +718,7 @@ class SQLCodeGenBase {
                 sOutput += this.generateSPUpdate(entity) + '\n\n';
             else
                 // custom SP, still generate the permissions
-                sOutput += this.generateSPPermissions(entity, entity.spUpdate, exports.SPType.Update) + '\n\n';
+                sOutput += this.generateSPPermissions(entity, entity.spUpdate, SPType.Update) + '\n\n';
         }
         if (entity.AllowDeleteAPI && !entity.VirtualEntity) {
             if (entity.spDeleteGenerated)
@@ -747,7 +726,7 @@ class SQLCodeGenBase {
                 sOutput += this.generateSPDelete(entity) + '\n\n';
             else
                 // custom SP, still generate the permissions
-                sOutput += this.generateSPPermissions(entity, entity.spDelete, exports.SPType.Delete) + '\n\n';
+                sOutput += this.generateSPPermissions(entity, entity.spDelete, SPType.Delete) + '\n\n';
         }
         // check to see if the entity supports full text search or not
         if (entity.FullTextSearchEnabled) {
@@ -757,7 +736,7 @@ class SQLCodeGenBase {
     }
     async generateEntityFullTextSearchSQL(pool, entity) {
         let sql = '';
-        const catalogName = entity.FullTextCatalog && entity.FullTextCatalog.length > 0 ? entity.FullTextCatalog : config_1.dbDatabase + '_FullTextCatalog';
+        const catalogName = entity.FullTextCatalog && entity.FullTextCatalog.length > 0 ? entity.FullTextCatalog : dbDatabase + '_FullTextCatalog';
         if (entity.FullTextCatalogGenerated) {
             // this situation means we have a generated catalog and the user has provided a name specific to THIS entity
             sql += `                -- CREATE THE FULL TEXT CATALOG FOR THE ENTITY, IF NOT ALREADY CREATED
@@ -810,8 +789,8 @@ class SQLCodeGenBase {
                 throw new Error(`FullTextSearchFunctionGenerated is true for entity ${entity.Name}, but no fields are marked as FullTextSearchEnabled`);
             if (!entity.FullTextSearchFunction || entity.FullTextSearchFunction.length === 0) {
                 // update this in the DB
-                const md = new core_1.Metadata();
-                const u = sqlserver_dataprovider_1.UserCache.Instance.Users[0];
+                const md = new Metadata();
+                const u = UserCache.Instance.Users[0];
                 if (!u)
                     throw new Error('Could not find the first user in the cache, cant generate the full text search function without a user');
                 const e = await md.GetEntityObject('Entities', u);
@@ -900,8 +879,8 @@ class SQLCodeGenBase {
             if (f.RelatedEntity && f.RelatedEntity.length > 0) {
                 // we have an fkey, so generate the create index
                 let indexName = `IDX_AUTO_MJ_FKEY_${entity.BaseTableCodeName}_${f.CodeName}`; // use code names in case the table and/or field names have special characters or spaces/etc
-                if (indexName.length > config_1.MAX_INDEX_NAME_LENGTH)
-                    indexName = indexName.substring(0, config_1.MAX_INDEX_NAME_LENGTH); // truncate to max length if necessary
+                if (indexName.length > MAX_INDEX_NAME_LENGTH)
+                    indexName = indexName.substring(0, MAX_INDEX_NAME_LENGTH); // truncate to max length if necessary
                 if (sOutput.length > 0)
                     sOutput += '\n\n'; // do this way so we don't end up with a trailing newline at end of the string/file
                 sOutput += `-- Index for foreign key ${f.Name} in table ${entity.BaseTable}
@@ -1047,7 +1026,7 @@ GO
         const relatedFieldsJoinString = this.generateBaseViewJoins(entity, entity.Fields);
         const permissions = this.generateViewPermissions(entity);
         const whereClause = entity.DeleteType === 'Soft' ? `WHERE
-    ${classNameFirstChar}.[${core_1.EntityInfo.DeletedAtFieldName}] IS NULL
+    ${classNameFirstChar}.[${EntityInfo.DeletedAtFieldName}] IS NULL
 ` : '';
         // Detect recursive foreign keys and generate TVF joins and root field selects
         const recursiveFKs = this.detectRecursiveForeignKeys(entity);
@@ -1088,7 +1067,12 @@ ${whereClause}GO${permissions}
         const classNameFirstChar = entity.ClassName.charAt(0).toLowerCase();
         for (let i = 0; i < entityFields.length; i++) {
             const ef = entityFields[i];
-            if (ef.RelatedEntityID && ef.IncludeRelatedEntityNameFieldInBaseView && ef._RelatedEntityTableAlias) {
+            // Generate SQL JOIN for related entities that have configured join fields
+            // _RelatedEntityJoinFieldMappings is populated during field analysis if:
+            // - IncludeRelatedEntityNameFieldInBaseView is true (legacy), OR
+            // - RelatedEntityJoinFieldsConfig specifies fields to join
+            // This generates the JOIN clause; the actual field aliases are added separately in generateBaseViewFields()
+            if (ef.RelatedEntityID && ef._RelatedEntityJoinFieldMappings && ef._RelatedEntityJoinFieldMappings.length > 0 && ef._RelatedEntityTableAlias) {
                 sOutput += sOutput == '' ? '' : '\n';
                 sOutput += `${ef.AllowsNull ? 'LEFT OUTER' : 'INNER'} JOIN\n    ${'[' + ef.RelatedEntitySchemaName + '].'}[${ef._RelatedEntityNameFieldIsVirtual ? ef.RelatedEntityBaseView : ef.RelatedEntityBaseTable}] AS ${ef._RelatedEntityTableAlias}\n  ON\n    [${classNameFirstChar}].[${ef.Name}] = ${ef._RelatedEntityTableAlias}.[${ef.RelatedEntityFieldName}]`;
             }
@@ -1098,51 +1082,117 @@ ${whereClause}GO${permissions}
     async generateBaseViewRelatedFieldsString(pool, entityFields) {
         let sOutput = '';
         let fieldCount = 0;
-        const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.ManageMetadataBase);
-        // next get the fields that are related entities and have the IncludeRelatedEntityNameFieldInBaseView flag set to true
-        const qualifyingFields = entityFields.filter(f => f.RelatedEntityID && f.IncludeRelatedEntityNameFieldInBaseView);
+        const manageMD = MJGlobal.Instance.ClassFactory.CreateInstance(ManageMetadataBase);
+        const md = new Metadata();
+        const allGeneratedAliases = [];
+        // Get fields that are related entities with join field configuration.
+        //
+        // BACKWARD COMPATIBILITY LOGIC:
+        // This handles two cases:
+        // 1. Legacy behavior: IncludeRelatedEntityNameFieldInBaseView=true, no RelatedEntityJoinFieldsConfig
+        //    → Automatically defaults to { mode: 'extend' } and joins the related entity's NameField (as before)
+        // 2. New behavior: RelatedEntityJoinFieldsConfig specified
+        //    → Can 'extend' the NameField with additional fields, 'override' it completely, or 'disable' joins
+        //
+        // Result: _RelatedEntityJoinFieldMappings is populated with all fields to be joined from the related entity.
+        //         If both old and new configs are set, they work together (new fields extend or replace the NameField).
+        const qualifyingFields = entityFields.filter(f => f.RelatedEntityID && (f.IncludeRelatedEntityNameFieldInBaseView || f.RelatedEntityJoinFieldsConfig));
         for (const ef of qualifyingFields) {
-            const { nameField, nameFieldIsVirtual } = this.getIsNameFieldForSingleEntity(ef.RelatedEntity);
-            if (nameField !== '') {
-                // only add to the output, if we found a name field for the related entity.
-                ef._RelatedEntityTableAlias = ef.RelatedEntityClassName + '_' + ef.Name;
-                ef._RelatedEntityNameFieldIsVirtual = nameFieldIsVirtual;
-                // This next section generates a field name for the new virtual field and makes sure it doesn't collide with a field in the base table
-                const candidateName = this.stripID(ef.Name);
-                // Skip if candidateName is empty (e.g., field named exactly "ID")
-                // This happens in table-per-type inheritance where child.ID is FK to parent.ID
-                // stripID("ID") returns "" which would generate invalid SQL: AS []
-                if (candidateName.trim().length === 0) {
-                    (0, status_logging_1.logStatus)(`  Skipping related entity name field for ${ef.Name} in entity - stripID returned empty string (likely inheritance pattern)`);
-                    continue; // Skip this field entirely - no valid alias can be generated
+            const config = ef.RelatedEntityJoinFieldsConfig || { mode: 'extend' };
+            if (config.mode === 'disable') {
+                continue;
+            }
+            ef._RelatedEntityJoinFieldMappings = [];
+            let anyFieldIsVirtual = false;
+            // 1. Handle NameField (if not overridden)
+            // In 'extend' mode: include the NameField (backward compatible with IncludeRelatedEntityNameFieldInBaseView)
+            // In 'override' mode: skip the NameField, only use explicitly configured fields
+            if (config.mode !== 'override' && ef.IncludeRelatedEntityNameFieldInBaseView) {
+                const { nameField, nameFieldIsVirtual } = this.getIsNameFieldForSingleEntity(ef.RelatedEntity);
+                if (nameField !== '') {
+                    // only add to the output, if we found a name field for the related entity.
+                    ef._RelatedEntityTableAlias = ef.RelatedEntityClassName + '_' + ef.Name;
+                    // This next section generates a field name for the new virtual field and makes sure it doesn't collide with a field in the base table
+                    const candidateName = this.stripID(ef.Name);
+                    // Skip if candidateName is empty (e.g., field named exactly "ID")
+                    // This happens in table-per-type inheritance where child.ID is FK to parent.ID
+                    // stripID("ID") returns "" which would generate invalid SQL: AS []
+                    if (candidateName.trim().length === 0) {
+                        logStatus(`  Skipping related entity name field for ${ef.Name} in entity - stripID returned empty string (likely inheritance pattern)`);
+                    }
+                    else {
+                        // check to make sure candidateName is not already a field name in the base table (other than a virtual field of course, as that is what we're creating)
+                        // because if it is, we need to change it to something else
+                        const bFound = entityFields.find(f => f.IsVirtual === false && f.Name.trim().toLowerCase() === candidateName.trim().toLowerCase()) !== undefined ||
+                            allGeneratedAliases.some(a => a.toLowerCase() === candidateName.trim().toLowerCase());
+                        const safeAlias = bFound ? candidateName + '_Virtual' : candidateName;
+                        ef._RelatedEntityNameFieldMap = safeAlias;
+                        ef._RelatedEntityJoinFieldMappings.push({
+                            sourceField: nameField,
+                            alias: safeAlias,
+                            isVirtual: nameFieldIsVirtual
+                        });
+                        allGeneratedAliases.push(safeAlias);
+                        if (nameFieldIsVirtual)
+                            anyFieldIsVirtual = true;
+                        // check to see if the database already knows about the RelatedEntityNameFieldMap or not
+                        if (ef.RelatedEntityNameFieldMap === null ||
+                            ef.RelatedEntityNameFieldMap === undefined ||
+                            ef.RelatedEntityNameFieldMap.trim().length === 0) {
+                            // the database doesn't yet know about this RelatedEntityNameFieldMap, so we need to update it
+                            // first update the actul field in the metadata object so it can be used from this point forward
+                            // and it also reflects what the DB will hold
+                            ef.RelatedEntityNameFieldMap = ef._RelatedEntityNameFieldMap;
+                            // then update the database itself
+                            await manageMD.updateEntityFieldRelatedEntityNameFieldMap(pool, ef.ID, ef.RelatedEntityNameFieldMap);
+                        }
+                    }
                 }
-                // check to make sure candidateName is not already a field name in the base table (other than a virtual field of course, as that is what we're creating)
-                // because if it is, we need to change it to something else
-                const bFound = entityFields.find(f => f.IsVirtual === false && f.Name.trim().toLowerCase() === candidateName.trim().toLowerCase()) !== undefined;
-                if (bFound)
-                    ef._RelatedEntityNameFieldMap = candidateName + '_Virtual';
-                else
-                    ef._RelatedEntityNameFieldMap = candidateName;
-                // now we have a safe field name alias for the new virtual field in the _RelatedEntityNameFieldMap property, so use it...
-                sOutput += `${fieldCount === 0 ? '' : ','}\n    ${ef._RelatedEntityTableAlias}.[${nameField}] AS [${ef._RelatedEntityNameFieldMap}]`;
-                // check to see if the database already knows about the RelatedEntityNameFieldMap or not
-                if (ef.RelatedEntityNameFieldMap === null ||
-                    ef.RelatedEntityNameFieldMap === undefined ||
-                    ef.RelatedEntityNameFieldMap.trim().length === 0) {
-                    // the database doesn't yet know about this RelatedEntityNameFieldMap, so we need to update it
-                    // first update the actul field in the metadata object so it can be used from this point forward
-                    // and it also reflects what the DB will hold
-                    ef.RelatedEntityNameFieldMap = ef._RelatedEntityNameFieldMap;
-                    // then update the database itself
-                    await manageMD.updateEntityFieldRelatedEntityNameFieldMap(pool, ef.ID, ef.RelatedEntityNameFieldMap);
+            }
+            // 2. Handle configured additional fields
+            if (config.fields && config.fields.length > 0) {
+                const currentEntity = md.Entities.find(e => e.ID === ef.EntityID);
+                for (const fieldConfig of config.fields) {
+                    const fieldName = fieldConfig.field;
+                    const alias = fieldConfig.alias || this.generateDefaultAlias(ef.Name, fieldName);
+                    // Validate field exists on related entity
+                    if (!this.validateFieldExists(ef.RelatedEntity, fieldName)) {
+                        logError(`RelatedEntityJoinFields: Field '${fieldName}' not found on entity '${ef.RelatedEntity}' (FK: ${ef.Name})`);
+                        continue;
+                    }
+                    // Check for alias collisions
+                    if (currentEntity && this.hasAliasCollision(currentEntity, alias, allGeneratedAliases)) {
+                        logError(`RelatedEntityJoinFields: Alias '${alias}' for field '${fieldName}' would collide with an existing field or alias in entity '${currentEntity.Name}'`);
+                        continue;
+                    }
+                    // Get field metadata from related entity to check if virtual
+                    const relatedEntity = md.Entities.find(e => e.Name === ef.RelatedEntity);
+                    const relatedField = relatedEntity?.Fields.find(f => f.Name.toLowerCase() === fieldName.toLowerCase());
+                    const isVirtual = relatedField?.IsVirtual || false;
+                    ef._RelatedEntityJoinFieldMappings.push({
+                        sourceField: fieldName,
+                        alias: alias,
+                        isVirtual: isVirtual
+                    });
+                    allGeneratedAliases.push(alias);
+                    if (isVirtual)
+                        anyFieldIsVirtual = true;
+                }
+            }
+            // 3. Generate SQL for the mappings
+            if (ef._RelatedEntityJoinFieldMappings.length > 0) {
+                ef._RelatedEntityTableAlias = ef.RelatedEntityClassName + '_' + ef.Name;
+                ef._RelatedEntityNameFieldIsVirtual = anyFieldIsVirtual;
+                for (const mapping of ef._RelatedEntityJoinFieldMappings) {
+                    sOutput += `${fieldCount === 0 ? '' : ','}\n    ${ef._RelatedEntityTableAlias}.[${mapping.sourceField}] AS [${mapping.alias}]`;
+                    fieldCount++;
                 }
-                fieldCount++;
             }
         }
         return sOutput;
     }
     getIsNameFieldForSingleEntity(entityName) {
-        const md = new core_1.Metadata(); // use the full metadata entity list, not the filtered version that we receive
+        const md = new Metadata(); // use the full metadata entity list, not the filtered version that we receive
         const e = md.Entities.find(e => e.Name === entityName);
         if (e) {
             const ef = e.NameField;
@@ -1150,7 +1200,7 @@ ${whereClause}GO${permissions}
                 return { nameField: ef.Name, nameFieldIsVirtual: ef.IsVirtual };
         }
         else
-            (0, status_logging_1.logStatus)(`ERROR: Could not find entity with name ${entityName}`);
+            logStatus(`ERROR: Could not find entity with name ${entityName}`);
         return { nameField: '', nameFieldIsVirtual: false };
     }
     stripID(name) {
@@ -1159,13 +1209,40 @@ ${whereClause}GO${permissions}
         else
             return name;
     }
+    generateDefaultAlias(fkFieldName, relatedFieldName) {
+        const baseName = this.stripID(fkFieldName);
+        if (baseName.toLowerCase() === relatedFieldName.toLowerCase()) {
+            return baseName;
+        }
+        return baseName + relatedFieldName;
+    }
+    validateFieldExists(entityName, fieldName) {
+        const md = new Metadata();
+        const entity = md.Entities.find(e => e.Name === entityName);
+        if (!entity)
+            return false;
+        return entity.Fields.some(f => f.Name.toLowerCase() === fieldName.toLowerCase());
+    }
+    hasAliasCollision(entity, alias, generatedAliases) {
+        // Check against existing fields in the entity (non-virtual fields first)
+        if (entity.Fields.some(f => !f.IsVirtual && f.Name.toLowerCase() === alias.toLowerCase()))
+            return true;
+        // Check against other generated aliases in this view
+        if (generatedAliases.some(a => a.toLowerCase() === alias.toLowerCase()))
+            return true;
+        // Check against system fields
+        const systemFields = ['__mj_CreatedAt', '__mj_UpdatedAt', EntityInfo.DeletedAtFieldName];
+        if (systemFields.some(sf => sf?.toLowerCase() === alias.toLowerCase()))
+            return true;
+        return false;
+    }
     generateSPPermissions(entity, spName, type) {
         let sOutput = '';
         for (let i = 0; i < entity.Permissions.length; i++) {
             const ep = entity.Permissions[i];
-            if ((type == exports.SPType.Create && ep.CanCreate) ||
-                (type == exports.SPType.Update && ep.CanUpdate) ||
-                (type == exports.SPType.Delete && ep.CanDelete)) {
+            if ((type == SPType.Create && ep.CanCreate) ||
+                (type == SPType.Update && ep.CanUpdate) ||
+                (type == SPType.Delete && ep.CanDelete)) {
                 if (ep.RoleSQLName && ep.RoleSQLName.length > 0) {
                     sOutput += (sOutput === '' ? `GRANT EXECUTE ON [${entity.SchemaName}].[${spName}] TO ` : ', ') + `[${ep.RoleSQLName}]`;
                 }
@@ -1191,7 +1268,7 @@ ${whereClause}GO${permissions}
         //double exclamations used on the firstKey.DefaultValue property otherwise the type of this variable is 'number | ""';
         const primaryKeyAutomatic = firstKey.AutoIncrement; // Only exclude auto-increment fields, allow manual override for all other PKs including UUIDs with defaults
         const efString = this.createEntityFieldsParamString(entity.Fields, false); // Always pass false for isUpdate since this is generateSPCreate
-        const permissions = this.generateSPPermissions(entity, spName, exports.SPType.Create);
+        const permissions = this.generateSPPermissions(entity, spName, SPType.Create);
         let preInsertCode = '';
         let outputCode = '';
         let selectInsertedRecord = '';
@@ -1294,12 +1371,12 @@ GO${permissions}
     `;
     }
     generateUpdatedAtTrigger(entity) {
-        const updatedAtField = entity.Fields.find(f => f.Name.toLowerCase().trim() === core_1.EntityInfo.UpdatedAtFieldName.toLowerCase().trim());
+        const updatedAtField = entity.Fields.find(f => f.Name.toLowerCase().trim() === EntityInfo.UpdatedAtFieldName.toLowerCase().trim());
         if (!updatedAtField)
             return '';
         const triggerStatement = `
 ------------------------------------------------------------
------ TRIGGER FOR ${core_1.EntityInfo.UpdatedAtFieldName} field for the ${entity.BaseTable} table
+----- TRIGGER FOR ${EntityInfo.UpdatedAtFieldName} field for the ${entity.BaseTable} table
 ------------------------------------------------------------
 IF OBJECT_ID('[${entity.SchemaName}].[trgUpdate${entity.ClassName}]', 'TR') IS NOT NULL
     DROP TRIGGER [${entity.SchemaName}].[trgUpdate${entity.ClassName}];
@@ -1313,7 +1390,7 @@ BEGIN
     UPDATE
         [${entity.SchemaName}].[${entity.BaseTable}]
     SET
-        ${core_1.EntityInfo.UpdatedAtFieldName} = GETUTCDATE()
+        ${EntityInfo.UpdatedAtFieldName} = GETUTCDATE()
     FROM
         [${entity.SchemaName}].[${entity.BaseTable}] AS _organicTable
     INNER JOIN
@@ -1326,8 +1403,8 @@ GO`;
     generateSPUpdate(entity) {
         const spName = entity.spUpdate ? entity.spUpdate : `spUpdate${entity.BaseTableCodeName}`;
         const efParamString = this.createEntityFieldsParamString(entity.Fields, true);
-        const permissions = this.generateSPPermissions(entity, spName, exports.SPType.Update);
-        const hasUpdatedAtField = entity.Fields.find(f => f.Name.toLowerCase().trim() === core_1.EntityInfo.UpdatedAtFieldName.trim().toLowerCase()) !== undefined;
+        const permissions = this.generateSPPermissions(entity, spName, SPType.Update);
+        const hasUpdatedAtField = entity.Fields.find(f => f.Name.toLowerCase().trim() === EntityInfo.UpdatedAtFieldName.trim().toLowerCase()) !== undefined;
         const updatedAtTrigger = hasUpdatedAtField ? this.generateUpdatedAtTrigger(entity) : '';
         let selectUpdatedRecord = `SELECT
                                         *
@@ -1521,7 +1598,7 @@ ${updatedAtTrigger}
     generateSPDelete(entity) {
         const spName = entity.spDelete ? entity.spDelete : `spDelete${entity.BaseTableCodeName}`;
         const sCascadeDeletes = this.generateCascadeDeletes(entity);
-        const permissions = this.generateSPPermissions(entity, spName, exports.SPType.Delete);
+        const permissions = this.generateSPPermissions(entity, spName, SPType.Delete);
         let sVariables = '';
         let sSelect = '';
         for (let k of entity.PrimaryKeys) {
@@ -1546,8 +1623,8 @@ ${deleteCode}`;
             deleteCode = `    UPDATE
         [${entity.SchemaName}].[${entity.BaseTable}]
     SET
-        ${core_1.EntityInfo.DeletedAtFieldName} = GETUTCDATE()
-${deleteCode}        AND ${core_1.EntityInfo.DeletedAtFieldName} IS NULL -- don't update the record if it's already been deleted via a soft delete`;
+        ${EntityInfo.DeletedAtFieldName} = GETUTCDATE()
+${deleteCode}        AND ${EntityInfo.DeletedAtFieldName} IS NULL -- don't update the record if it's already been deleted via a soft delete`;
         }
         // Build the NULL select statement for when no rows are affected
         let sNullSelect = '';
@@ -1584,7 +1661,7 @@ GO${permissions}
     generateCascadeDeletes(entity) {
         let sOutput = '';
         if (entity.CascadeDeletes) {
-            const md = new core_1.Metadata();
+            const md = new Metadata();
             // Find all fields in other entities that are foreign keys to this entity
             for (const e of md.Entities) {
                 for (const ef of e.Fields) {
@@ -1614,7 +1691,7 @@ GO${permissions}
             // Nullable FK but no update API - this is a configuration error
             const sqlComment = `WARNING: ${relatedEntity.BaseTable} has nullable FK to ${parentEntity.BaseTable} but doesn't allow update API - cascade operation will fail`;
             const consoleMsg = `WARNING in spDelete${parentEntity.BaseTableCodeName} generation: ${relatedEntity.BaseTable} has nullable FK to ${parentEntity.BaseTable} but doesn't allow update API - cascade operation will fail`;
-            (0, status_logging_1.logWarning)(consoleMsg);
+            logWarning(consoleMsg);
             return `
     -- ${sqlComment}
     -- This will cause the delete operation to fail due to referential integrity`;
@@ -1623,7 +1700,7 @@ GO${permissions}
             // Entity doesn't allow delete API, so we can't cascade delete
             const sqlComment = `WARNING: ${relatedEntity.BaseTable} has non-nullable FK to ${parentEntity.BaseTable} but doesn't allow delete API - cascade operation will fail`;
             const consoleMsg = `WARNING in spDelete${parentEntity.BaseTableCodeName} generation: ${relatedEntity.BaseTable} has non-nullable FK to ${parentEntity.BaseTable} but doesn't allow delete API - cascade operation will fail`;
-            (0, status_logging_1.logWarning)(consoleMsg);
+            logWarning(consoleMsg);
             return `
     -- ${sqlComment}
     -- This will cause a referential integrity violation`;
@@ -1637,7 +1714,7 @@ GO${permissions}
         // Generate unique cursor name using entity code names
         const cursorName = `cascade_${operation}_${relatedEntity.CodeName}_cursor`;
         // Determine which SP to call
-        const spType = operation === 'delete' ? exports.SPType.Delete : exports.SPType.Update;
+        const spType = operation === 'delete' ? SPType.Delete : SPType.Update;
         const spName = this.getSPName(relatedEntity, spType);
         if (operation === 'update') {
             // For update, we need to include all updateable fields
@@ -1731,7 +1808,7 @@ GO${permissions}
         fetchInto = pkComponents.fetchInto;
         allParams = pkComponents.spParams;
         // Then, add all updateable fields with the same prefix
-        const sortedFields = (0, util_1.sortBySequenceAndCreatedAt)(entity.Fields);
+        const sortedFields = sortBySequenceAndCreatedAt(entity.Fields);
         for (const ef of sortedFields) {
             if (!ef.IsPrimaryKey && !ef.IsVirtual && ef.AllowUpdateAPI && !ef.AutoIncrement && !ef.IsSpecialDateField) {
                 if (declarations !== '')
@@ -1757,7 +1834,7 @@ GO${permissions}
      */
     analyzeCascadeDeleteDependencies(entity) {
         if (entity.CascadeDeletes) {
-            const md = new core_1.Metadata();
+            const md = new Metadata();
             // Find all fields in other entities that are foreign keys to this entity
             for (const e of md.Entities) {
                 for (const ef of e.Fields) {
@@ -1799,7 +1876,7 @@ GO${permissions}
     async buildCascadeDeleteDependencies(entities) {
         // Clear existing dependencies
         this.cascadeDeleteDependencies.clear();
-        (0, status_logging_1.logStatus)(`Building cascade delete dependencies...`);
+        logStatus(`Building cascade delete dependencies...`);
         // Analyze cascade deletes for each entity with CascadeDeletes=true
         // This will populate the cascadeDeleteDependencies map WITHOUT generating SQL
         let entitiesWithCascadeDeletes = 0;
@@ -1807,23 +1884,23 @@ GO${permissions}
             if (entity.CascadeDeletes) {
                 entitiesWithCascadeDeletes++;
                 if (entity.spDeleteGenerated) {
-                    (0, status_logging_1.logStatus)(`  Analyzing cascade deletes for ${entity.Name}...`);
+                    logStatus(`  Analyzing cascade deletes for ${entity.Name}...`);
                     this.analyzeCascadeDeleteDependencies(entity);
                 }
                 else {
-                    (0, status_logging_1.logStatus)(`  Skipping ${entity.Name} - has CascadeDeletes but spDeleteGenerated=false`);
+                    logStatus(`  Skipping ${entity.Name} - has CascadeDeletes but spDeleteGenerated=false`);
                 }
             }
         }
-        (0, status_logging_1.logStatus)(`Total entities with CascadeDeletes=true: ${entitiesWithCascadeDeletes}`);
+        logStatus(`Total entities with CascadeDeletes=true: ${entitiesWithCascadeDeletes}`);
         // Log the dependency map
-        (0, status_logging_1.logStatus)(`Cascade delete dependency map built:`);
+        logStatus(`Cascade delete dependency map built:`);
         for (const [dependedOnEntityId, dependentEntityIds] of this.cascadeDeleteDependencies) {
             const dependedOnEntity = entities.find(e => e.ID === dependedOnEntityId);
             const dependentNames = Array.from(dependentEntityIds)
                 .map(id => entities.find(e => e.ID === id)?.Name || id)
                 .join(', ');
-            (0, status_logging_1.logStatus)(`  ${dependedOnEntity?.Name || dependedOnEntityId} is depended on by: ${dependentNames}`);
+            logStatus(`  ${dependedOnEntity?.Name || dependedOnEntityId} is depended on by: ${dependentNames}`);
         }
     }
     /**
@@ -1833,8 +1910,8 @@ GO${permissions}
     async getModifiedEntitiesWithUpdateAPI(entities) {
         const modifiedEntitiesMap = new Map();
         // Get the list of modified entity names from the metadata management phase
-        const modifiedEntityNames = manage_metadata_1.ManageMetadataBase.modifiedEntityList;
-        (0, status_logging_1.logStatus)(`Modified entities from metadata phase: ${modifiedEntityNames.join(', ')}`);
+        const modifiedEntityNames = ManageMetadataBase.modifiedEntityList;
+        logStatus(`Modified entities from metadata phase: ${modifiedEntityNames.join(', ')}`);
         // Convert entity names to IDs and filter for those with update API
         for (const entityName of modifiedEntityNames) {
             const entity = entities.find(e => e.Name === entityName &&
@@ -1842,15 +1919,15 @@ GO${permissions}
                 e.spUpdateGenerated);
             if (entity) {
                 modifiedEntitiesMap.set(entity.Name, entity.ID);
-                (0, status_logging_1.logStatus)(`  - ${entity.Name} (${entity.ID}) has update API and will be tracked`);
+                logStatus(`  - ${entity.Name} (${entity.ID}) has update API and will be tracked`);
             }
             else {
                 const nonUpdateEntity = entities.find(e => e.Name === entityName);
                 if (nonUpdateEntity) {
-                    (0, status_logging_1.logStatus)(`  - ${entityName} found but AllowUpdateAPI=${nonUpdateEntity.AllowUpdateAPI}, spUpdateGenerated=${nonUpdateEntity.spUpdateGenerated}`);
+                    logStatus(`  - ${entityName} found but AllowUpdateAPI=${nonUpdateEntity.AllowUpdateAPI}, spUpdateGenerated=${nonUpdateEntity.spUpdateGenerated}`);
                 }
                 else {
-                    (0, status_logging_1.logStatus)(`  - ${entityName} not found in entities list`);
+                    logStatus(`  - ${entityName} not found in entities list`);
                 }
             }
         }
@@ -1884,38 +1961,38 @@ GO${permissions}
             // Get entities that were modified during metadata management
             const modifiedEntitiesMap = await this.getModifiedEntitiesWithUpdateAPI(entities);
             if (modifiedEntitiesMap.size > 0) {
-                (0, status_logging_1.logStatus)(`Found ${modifiedEntitiesMap.size} entities with schema changes affecting update SPs`);
+                logStatus(`Found ${modifiedEntitiesMap.size} entities with schema changes affecting update SPs`);
                 // Convert map values to set of IDs
                 const changedEntityIds = new Set(modifiedEntitiesMap.values());
                 // Find entities that need delete SP regeneration
                 const entitiesNeedingRegeneration = await this.getEntitiesRequiringCascadeDeleteRegeneration(pool, changedEntityIds);
                 if (entitiesNeedingRegeneration.size > 0) {
-                    (0, status_logging_1.logStatus)(`Identified ${entitiesNeedingRegeneration.size} entities requiring delete SP regeneration due to cascade dependencies`);
+                    logStatus(`Identified ${entitiesNeedingRegeneration.size} entities requiring delete SP regeneration due to cascade dependencies`);
                     // Store the entity IDs that need regeneration (only if spDeleteGenerated=true)
                     for (const entityId of entitiesNeedingRegeneration) {
                         const entity = entities.find(e => e.ID === entityId);
                         if (entity && entity.spDeleteGenerated) {
                             this.entitiesNeedingDeleteSPRegeneration.add(entityId);
-                            (0, status_logging_1.logStatus)(`  - Marked ${entity.Name} for delete SP regeneration (cascade dependency)`);
+                            logStatus(`  - Marked ${entity.Name} for delete SP regeneration (cascade dependency)`);
                         }
                         else if (entity && !entity.spDeleteGenerated) {
-                            (0, status_logging_1.logStatus)(`  - Skipping ${entity.Name} - has cascade dependency but spDeleteGenerated=false (custom SP)`);
+                            logStatus(`  - Skipping ${entity.Name} - has cascade dependency but spDeleteGenerated=false (custom SP)`);
                         }
                     }
                     // Order entities by dependencies for proper regeneration
                     this.orderedEntitiesForDeleteSPRegeneration = this.orderEntitiesByDependencies(entities, this.entitiesNeedingDeleteSPRegeneration);
                     if (this.orderedEntitiesForDeleteSPRegeneration.length > 0) {
-                        (0, status_logging_1.logStatus)(`Ordered entities for delete SP regeneration:`);
+                        logStatus(`Ordered entities for delete SP regeneration:`);
                         this.orderedEntitiesForDeleteSPRegeneration.forEach((entityId, index) => {
                             const entity = entities.find(e => e.ID === entityId);
-                            (0, status_logging_1.logStatus)(`  ${index + 1}. ${entity?.Name || entityId}`);
+                            logStatus(`  ${index + 1}. ${entity?.Name || entityId}`);
                         });
                     }
                 }
             }
         }
         catch (error) {
-            (0, status_logging_1.logError)(`Error in cascade delete dependency analysis: ${error}`);
+            logError(`Error in cascade delete dependency analysis: ${error}`);
             // Continue with normal processing even if dependency analysis fails
         }
     }
@@ -1956,7 +2033,7 @@ GO${permissions}
             if (visiting.has(entityId)) {
                 // Circular dependency detected - mark it but don't fail
                 const entity = entities.find(e => e.ID === entityId);
-                (0, status_logging_1.logStatus)(`Warning: Circular cascade delete dependency detected involving ${entity?.Name || entityId}`);
+                logStatus(`Warning: Circular cascade delete dependency detected involving ${entity?.Name || entityId}`);
                 circularDeps.add(entityId);
                 return false; // Signal circular dependency but continue processing
             }
@@ -1982,17 +2059,16 @@ GO${permissions}
                 if (!success && circularDeps.has(entityId)) {
                     // Entity is part of circular dependency - add it anyway in arbitrary order
                     // The SQL will still be generated, just not in perfect dependency order
-                    (0, status_logging_1.logStatus)(`  - Adding ${entities.find(e => e.ID === entityId)?.Name || entityId} despite circular dependency`);
+                    logStatus(`  - Adding ${entities.find(e => e.ID === entityId)?.Name || entityId} despite circular dependency`);
                     visited.add(entityId);
                     ordered.push(entityId);
                 }
             }
         }
         if (circularDeps.size > 0) {
-            (0, status_logging_1.logStatus)(`Note: ${circularDeps.size} entities have circular cascade delete dependencies and will be regenerated in arbitrary order.`);
+            logStatus(`Note: ${circularDeps.size} entities have circular cascade delete dependencies and will be regenerated in arbitrary order.`);
         }
         return ordered;
     }
 }
-exports.SQLCodeGenBase = SQLCodeGenBase;
 //# sourceMappingURL=sql_codegen.js.map