@memberjunction/codegen-lib 2.111.1 → 2.112.0

package/dist/Database/sql_codegen.js

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLCodeGenBase = exports.SPType = void 0;
-const core_1 = require("@memberjunction/core");
+const global_1 = require("@memberjunction/global");
 const status_logging_1 = require("../Misc/status_logging");
 const fs = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -36,7 +36,7 @@ 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 global_2 = require("@memberjunction/global");
 const sql_logging_1 = require("../Misc/sql_logging");
 const temp_batch_file_1 = require("../Misc/temp_batch_file");
 exports.SPType = {
@@ -50,7 +50,7 @@ exports.SPType = {
  * 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);
+    _sqlUtilityObject = global_2.MJGlobal.Instance.ClassFactory.CreateInstance(sql_1.SQLUtilityBase);
     get SQLUtilityObject() {
         return this._sqlUtilityObject;
     }
@@ -105,7 +105,7 @@ class SQLCodeGenBase {
             //          objects like spCreate for a given entity might reference the vw for that entity
             (0, status_logging_1.startSpinner)('Running custom SQL scripts...');
             const startTime = new Date();
-            if (!await this.runCustomSQLScripts(pool, 'before-sql')) {
+            if (!(await this.runCustomSQLScripts(pool, 'before-sql'))) {
                 (0, status_logging_1.failSpinner)('Failed to run custom SQL scripts');
                 return false;
             }
@@ -113,12 +113,12 @@ class SQLCodeGenBase {
             // ALWAYS use the first filter where we only include entities that have IncludeInAPI = 1
             // Sort entities by name for deterministic processing order (workaround until MJCore fix in issue #1436)
             const sortedEntities = entities.sort((a, b) => a.Name.localeCompare(b.Name));
-            const baselineEntities = sortedEntities.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 baselineEntities = sortedEntities.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
             // 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)));
+            const schemas = Array.from(new Set(baselineEntities.map((e) => e.SchemaName)));
             temp_batch_file_1.TempBatchFile.initialize(directory, schemas);
             // STEP 1.5 - Check for cascade delete dependencies that require regeneration
             (0, status_logging_1.startSpinner)('Analyzing cascade delete dependencies...');
@@ -132,10 +132,10 @@ class SQLCodeGenBase {
             (0, status_logging_1.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));
+            const entitiesWithoutCascadeRegeneration = includedEntities.filter((e) => !this.entitiesNeedingDeleteSPRegeneration.has(e.ID));
             const entitiesForCascadeRegeneration = this.orderedEntitiesForDeleteSPRegeneration
-                .map(id => includedEntities.find(e => e.ID === id))
-                .filter(e => e !== undefined);
+                .map((id) => includedEntities.find((e) => e.ID === id))
+                .filter((e) => e !== undefined);
             // Generate SQL for entities that don't need cascade delete regeneration
             const genResult = await this.generateAndExecuteEntitySQLToSeparateFiles({
                 pool,
@@ -145,7 +145,7 @@ class SQLCodeGenBase {
                 skipExecution: true, // skip execution because we execute it all in a giant batch below
                 writeFiles: true,
                 batchSize: 5,
-                enableSQLLoggingForNewOrModifiedEntities: true
+                enableSQLLoggingForNewOrModifiedEntities: true,
             }); // enable sql logging for NEW entities....
             if (!genResult.Success) {
                 (0, status_logging_1.failSpinner)('Failed to generate entity SQL files');
@@ -162,7 +162,7 @@ class SQLCodeGenBase {
                     skipExecution: true,
                     writeFiles: true,
                     batchSize: 1, // Process sequentially to maintain dependency order
-                    enableSQLLoggingForNewOrModifiedEntities: true
+                    enableSQLLoggingForNewOrModifiedEntities: true,
                 });
                 if (!cascadeGenResult.Success) {
                     (0, status_logging_1.failSpinner)('Failed to regenerate cascade delete SPs');
@@ -180,7 +180,7 @@ class SQLCodeGenBase {
                 skipExecution: true, // skip execution because we execute it all in a giant batch below
                 batchSize: 5,
                 writeFiles: true,
-                enableSQLLoggingForNewOrModifiedEntities: false /*don't log this stuff, it is just permissions for excluded entities*/
+                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');
@@ -216,11 +216,11 @@ class SQLCodeGenBase {
             }
             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);
+            const manageMD = global_2.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.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
             (0, status_logging_1.startSpinner)('Managing entity fields metadata...');
-            if (!await manageMD.manageEntityFields(pool, config_1.configInfo.excludeSchemas, true, true, currentUser)) {
+            if (!(await manageMD.manageEntityFields(pool, config_1.configInfo.excludeSchemas, true, true, currentUser))) {
                 (0, status_logging_1.failSpinner)('Failed to manage entity fields');
                 return false;
             }
@@ -229,7 +229,7 @@ class SQLCodeGenBase {
             // STEP 4- Apply permissions, executing all .permissions files
             (0, status_logging_1.startSpinner)('Applying permissions...');
             const step4StartTime = new Date();
-            if (!await this.applyPermissions(pool, directory, baselineEntities)) {
+            if (!(await this.applyPermissions(pool, directory, baselineEntities))) {
                 (0, status_logging_1.failSpinner)('Failed to apply permissions');
                 return false;
             }
@@ -237,14 +237,14 @@ class SQLCodeGenBase {
             // STEP 5 - execute any custom SQL scripts that should run afterwards
             (0, status_logging_1.startSpinner)('Running post-generation SQL scripts...');
             const step5StartTime = new Date();
-            if (!await this.runCustomSQLScripts(pool, 'after-sql')) {
+            if (!(await this.runCustomSQLScripts(pool, 'after-sql'))) {
                 (0, status_logging_1.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)(`CodeGen completed successfully (${((new Date().getTime() - startTime.getTime()) / 1000)}s total)`);
+            (0, status_logging_1.succeedSpinner)(`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 global_1.Metadata();
             await md.Refresh();
             return true;
         }
@@ -262,7 +262,7 @@ class SQLCodeGenBase {
             if (scripts) {
                 for (let i = 0; i < scripts.length; ++i) {
                     const s = scripts[i];
-                    if (!await this.SQLUtilityObject.executeSQLFile(s.scriptFile)) {
+                    if (!(await this.SQLUtilityObject.executeSQLFile(s.scriptFile))) {
                         (0, status_logging_1.logError)(`Error executing custom '${when}' SQL script ${s.scriptFile}`);
                         bSuccess = false; // keep going if we have more scripts, but make sure we return false
                     }
@@ -335,7 +335,7 @@ class SQLCodeGenBase {
             for (let i = 0; i < totalEntities; i += options.batchSize) {
                 const batch = options.entities.slice(i, i + options.batchSize);
                 const promises = batch.map(async (e) => {
-                    const pkeyField = e.Fields.find(f => f.IsPrimaryKey);
+                    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`);
                         return { Success: false, Files: [] };
@@ -347,11 +347,11 @@ class SQLCodeGenBase {
                         onlyPermissions: options.onlyPermissions,
                         writeFiles: options.writeFiles,
                         skipExecution: options.skipExecution,
-                        enableSQLLoggingForNewOrModifiedEntities: options.enableSQLLoggingForNewOrModifiedEntities
+                        enableSQLLoggingForNewOrModifiedEntities: options.enableSQLLoggingForNewOrModifiedEntities,
                     });
                 });
                 const results = await Promise.all(promises);
-                results.forEach(r => {
+                results.forEach((r) => {
                     if (!r.Success)
                         bFail = true; // keep going, but will return false at the end
                     files.push(...r.Files); // add the files to the main files array
@@ -367,7 +367,7 @@ class SQLCodeGenBase {
     deleteGeneratedEntityFiles(directory, entities) {
         try {
             // 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);
+            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);
                 // now, within each schema directory, clean out all the generated files
@@ -381,7 +381,7 @@ class SQLCodeGenBase {
                     //logMessage(`      Directory '${fullPath}' does not exist so no need to delete previously generated SQL`, 'Info');
                 }
                 if (stats?.isDirectory()) {
-                    const files = fs.readdirSync(fullPath).filter(f => f.endsWith('.generated.sql') || f.endsWith('.permissions.generated.sql'));
+                    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);
                         fs.unlinkSync(filePath);
@@ -396,7 +396,7 @@ class SQLCodeGenBase {
     createCombinedEntitySQLFiles(directory, entities) {
         // first, get a disinct list of schemanames from the entities
         const files = [];
-        const schemaNames = entities.map(e => e.SchemaName).filter((value, index, self) => self.indexOf(value) === index);
+        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);
@@ -414,8 +414,8 @@ class SQLCodeGenBase {
             const { sql, permissionsSQL, files } = await this.generateSingleEntitySQLToSeparateFiles(options); // this creates the files and returns a single string with all the SQL we can then execute
             if (!options.skipExecution) {
                 return {
-                    Success: await this.SQLUtilityObject.executeSQLScript(options.pool, sql + "\n\nGO\n\n" + permissionsSQL, true), // combine the SQL and permissions and execute it,
-                    Files: files
+                    Success: await this.SQLUtilityObject.executeSQLScript(options.pool, sql + '\n\nGO\n\n' + permissionsSQL, true), // combine the SQL and permissions and execute it,
+                    Files: files,
                 };
             }
             else
@@ -431,23 +431,23 @@ 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 = !!manage_metadata_1.ManageMetadataBase.newEntityList.find((e) => e === entity.Name) ||
+                !!manage_metadata_1.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);
+            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 &&
-                    (description.toLowerCase().includes('spcreate') ||
-                        description.toLowerCase().includes('spupdate') ||
-                        description.toLowerCase().includes('spdelete'))));
+            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 &&
+                        (description.toLowerCase().includes('spcreate') ||
+                            description.toLowerCase().includes('spupdate') ||
+                            description.toLowerCase().includes('spdelete'))));
             // Determine if we should log based on entity state and force regeneration settings
             if (isNewOrModified) {
                 // Always log new or modified entities
@@ -458,7 +458,7 @@ class SQLCodeGenBase {
                 shouldLog = true;
             }
             else if (isForceRegeneration) {
-                // For force regeneration, the specific type flags (spCreate, baseViews, etc.) 
+                // For force regeneration, the specific type flags (spCreate, baseViews, etc.)
                 // already filtered this - now we just need to check entity filtering
                 if (this.filterEntitiesQualifiedForRegeneration) {
                     // Only log if entity is in the qualified list
@@ -505,9 +505,7 @@ class SQLCodeGenBase {
             // BASE VIEW AND RELATED TVFs
             // Only generate if BaseViewGenerated is true (respects custom views where it's false)
             // forceRegeneration.baseViews only forces regeneration of views where BaseViewGenerated=true
-            if (!options.onlyPermissions &&
-                options.entity.BaseViewGenerated &&
-                !options.entity.VirtualEntity) {
+            if (!options.onlyPermissions && options.entity.BaseViewGenerated && !options.entity.VirtualEntity) {
                 // ROOT ID FUNCTIONS (TVFs)
                 // Generate inline Table Value Functions for recursive foreign keys
                 // These must be created BEFORE the view that references them
@@ -515,8 +513,7 @@ class SQLCodeGenBase {
                 if (recursiveFKs.length > 0) {
                     for (const field of recursiveFKs) {
                         const functionName = `fn${options.entity.BaseTable}${field.Name}_GetRootID`;
-                        const s = this.generateSingleEntitySQLFileHeader(options.entity, functionName) +
-                            this.generateRootIDFunction(options.entity, field);
+                        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));
                         if (options.writeFiles) {
                             this.logSQLForNewOrModifiedEntity(options.entity, s, `Root ID Function SQL for ${options.entity.Name}.${field.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
@@ -528,7 +525,8 @@ 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 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));
                 if (options.writeFiles) {
                     this.logSQLForNewOrModifiedEntity(options.entity, s, `Base View SQL for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
@@ -538,7 +536,8 @@ class SQLCodeGenBase {
                 sRet += s + '\nGO\n';
             }
             // always generate permissions for the base view
-            const s = this.generateSingleEntitySQLFileHeader(options.entity, 'Permissions for ' + options.entity.BaseView) + this.generateViewPermissions(options.entity);
+            const s = this.generateSingleEntitySQLFileHeader(options.entity, 'Permissions for ' + options.entity.BaseView) +
+                this.generateViewPermissions(options.entity);
             if (s.length > 0)
                 permissionsSQL += s + '\nGO\n';
             if (options.writeFiles) {
@@ -618,8 +617,7 @@ class SQLCodeGenBase {
                 // OR if this entity has cascade delete dependencies that require regeneration
                 // forceRegeneration only forces regeneration of SPs where spDeleteGenerated=true
                 if (!options.onlyPermissions &&
-                    (options.entity.spDeleteGenerated ||
-                        this.entitiesNeedingDeleteSPRegeneration.has(options.entity.ID))) {
+                    (options.entity.spDeleteGenerated || 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`);
@@ -721,37 +719,37 @@ class SQLCodeGenBase {
         let sOutput = '';
         if (entity.BaseViewGenerated && !entity.VirtualEntity)
             // generated the base view (will include permissions)
-            sOutput += await this.generateBaseView(pool, entity) + '\n\n';
+            sOutput += (await this.generateBaseView(pool, entity)) + '\n\n';
+        // still generate the permissions for the view even if a custom view
         else
-            // still generate the permissions for the view even if a custom view
             sOutput += this.generateViewPermissions(entity) + '\n\n';
         if (entity.AllowCreateAPI && !entity.VirtualEntity) {
             if (entity.spCreateGenerated)
                 // generated SP, will include permissions
                 sOutput += this.generateSPCreate(entity) + '\n\n';
+            // custom SP, still generate the permissions
             else
-                // custom SP, still generate the permissions
                 sOutput += this.generateSPPermissions(entity, entity.spCreate, exports.SPType.Create) + '\n\n';
         }
         if (entity.AllowUpdateAPI && !entity.VirtualEntity) {
             if (entity.spUpdateGenerated)
                 // generated SP, will include permissions
                 sOutput += this.generateSPUpdate(entity) + '\n\n';
+            // custom SP, still generate the permissions
             else
-                // custom SP, still generate the permissions
                 sOutput += this.generateSPPermissions(entity, entity.spUpdate, exports.SPType.Update) + '\n\n';
         }
         if (entity.AllowDeleteAPI && !entity.VirtualEntity) {
             if (entity.spDeleteGenerated)
                 // generated SP, will include permissions
                 sOutput += this.generateSPDelete(entity) + '\n\n';
+            // custom SP, still generate the permissions
             else
-                // custom SP, still generate the permissions
                 sOutput += this.generateSPPermissions(entity, entity.spDelete, exports.SPType.Delete) + '\n\n';
         }
         // check to see if the entity supports full text search or not
         if (entity.FullTextSearchEnabled) {
-            sOutput += await this.generateEntityFullTextSearchSQL(pool, entity) + '\n\n';
+            sOutput += (await this.generateEntityFullTextSearchSQL(pool, entity)) + '\n\n';
         }
         return sOutput;
     }
@@ -771,7 +769,9 @@ class SQLCodeGenBase {
     `;
         }
         if (entity.FullTextIndexGenerated) {
-            const fullTextFields = entity.Fields.filter(f => f.FullTextSearchEnabled).map(f => `${f.Name} LANGUAGE 'English'`).join(', ');
+            const fullTextFields = entity.Fields.filter((f) => f.FullTextSearchEnabled)
+                .map((f) => `${f.Name} LANGUAGE 'English'`)
+                .join(', ');
             if (fullTextFields.length === 0)
                 throw new Error(`FullTextIndexGenerated is true for entity ${entity.Name}, but no fields are marked as FullTextSearchEnabled`);
             // drop and recreate the full text index
@@ -803,24 +803,28 @@ class SQLCodeGenBase {
                 GO
     `;
         }
-        const functionName = entity.FullTextSearchFunction && entity.FullTextSearchFunction.length > 0 ? entity.FullTextSearchFunction : `fnSearch${entity.CodeName}`;
+        const functionName = entity.FullTextSearchFunction && entity.FullTextSearchFunction.length > 0
+            ? entity.FullTextSearchFunction
+            : `fnSearch${entity.CodeName}`;
         if (entity.FullTextSearchFunctionGenerated) {
-            const fullTextFieldsSimple = entity.Fields.filter(f => f.FullTextSearchEnabled).map(f => '[' + f.Name + ']').join(', ');
+            const fullTextFieldsSimple = entity.Fields.filter((f) => f.FullTextSearchEnabled)
+                .map((f) => '[' + f.Name + ']')
+                .join(', ');
             if (fullTextFieldsSimple.length === 0)
                 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 md = new global_1.Metadata();
                 const u = sqlserver_dataprovider_1.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);
                 await e.Load(entity.ID);
                 e.FullTextSearchFunction = functionName;
-                if (!await e.Save())
+                if (!(await e.Save()))
                     throw new Error(`Could not update the FullTextSearchFunction for entity ${entity.Name}`);
             }
-            const pkeyList = entity.PrimaryKeys.map(pk => '[' + pk.Name + ']').join(', ');
+            const pkeyList = entity.PrimaryKeys.map((pk) => '[' + pk.Name + ']').join(', ');
             // drop and recreate the full text search function
             sql += `                -- DROP AND RECREATE THE FULL TEXT SEARCH FUNCTION
                 -- Create an inline table-valued function to perform full-text search
@@ -921,8 +925,7 @@ CREATE INDEX ${indexName} ON [${entity.SchemaName}].[${entity.BaseTable}] ([${f.
      * Returns array of field info objects representing recursive relationships
      */
     detectRecursiveForeignKeys(entity) {
-        return entity.Fields.filter(field => field.RelatedEntityID != null &&
-            field.RelatedEntityID === entity.ID);
+        return entity.Fields.filter((field) => field.RelatedEntityID != null && field.RelatedEntityID === entity.ID);
     }
     /**
      * Generates an inline Table Value Function for calculating root ID for a recursive FK field
@@ -1000,20 +1003,20 @@ GO
         if (recursiveFKs.length === 0) {
             return '';
         }
-        return recursiveFKs
-            .map(field => this.generateRootIDFunction(entity, field))
-            .join('\n');
+        return recursiveFKs.map((field) => this.generateRootIDFunction(entity, field)).join('\n');
     }
     /**
      * Generates the SELECT clause additions for root fields from TVFs
      * Example: , root_ParentID.RootID AS [RootParentID]
      */
     generateRootFieldSelects(recursiveFKs, classNameFirstChar) {
-        return recursiveFKs.map(field => {
+        return recursiveFKs
+            .map((field) => {
             const alias = `root_${field.Name}`;
             const columnName = `Root${field.Name}`;
             return `,\n    ${alias}.RootID AS [${columnName}]`;
-        }).join('');
+        })
+            .join('');
     }
     /**
      * Generates OUTER APPLY joins to inline Table Value Functions for root ID calculation
@@ -1026,11 +1029,13 @@ GO
         const primaryKey = entity.FirstPrimaryKey.Name;
         const schemaName = entity.SchemaName;
         const tableName = entity.BaseTable;
-        const joins = recursiveFKs.map(field => {
+        const joins = recursiveFKs
+            .map((field) => {
             const functionName = `fn${tableName}${field.Name}_GetRootID`;
             const alias = `root_${field.Name}`;
             return `OUTER APPLY\n    [${schemaName}].[${functionName}]([${classNameFirstChar}].[${primaryKey}], [${classNameFirstChar}].[${field.Name}]) AS ${alias}`;
-        }).join('\n');
+        })
+            .join('\n');
         return '\n' + joins;
     }
     /**
@@ -1046,9 +1051,11 @@ GO
         const relatedFieldsString = await this.generateBaseViewRelatedFieldsString(pool, entity.Fields);
         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
-` : '';
+        const whereClause = entity.DeleteType === 'Soft'
+            ? `WHERE
+    ${classNameFirstChar}.[${global_1.EntityInfo.DeletedAtFieldName}] IS NULL
+`
+            : '';
         // Detect recursive foreign keys and generate TVF joins and root field selects
         const recursiveFKs = this.detectRecursiveForeignKeys(entity);
         const rootFields = recursiveFKs.length > 0 ? this.generateRootFieldSelects(recursiveFKs, classNameFirstChar) : '';
@@ -1058,7 +1065,7 @@ GO
 ----- BASE VIEW FOR ENTITY:      ${entity.Name}
 -----               SCHEMA:      ${entity.SchemaName}
 -----               BASE TABLE:  ${entity.BaseTable}
------               PRIMARY KEY: ${entity.PrimaryKeys.map(pk => pk.Name).join(', ')}
+-----               PRIMARY KEY: ${entity.PrimaryKeys.map((pk) => pk.Name).join(', ')}
 ------------------------------------------------------------
 IF OBJECT_ID('[${entity.SchemaName}].[${viewName}]', 'V') IS NOT NULL
     DROP VIEW [${entity.SchemaName}].[${viewName}];
@@ -1098,9 +1105,9 @@ ${whereClause}GO${permissions}
     async generateBaseViewRelatedFieldsString(pool, entityFields) {
         let sOutput = '';
         let fieldCount = 0;
-        const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.ManageMetadataBase);
+        const manageMD = global_2.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 qualifyingFields = entityFields.filter((f) => f.RelatedEntityID && f.IncludeRelatedEntityNameFieldInBaseView);
         for (const ef of qualifyingFields) {
             const { nameField, nameFieldIsVirtual } = this.getIsNameFieldForSingleEntity(ef.RelatedEntity);
             if (nameField !== '') {
@@ -1111,7 +1118,8 @@ ${whereClause}GO${permissions}
                 const candidateName = this.stripID(ef.Name);
                 // 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;
+                const bFound = entityFields.find((f) => f.IsVirtual === false && f.Name.trim().toLowerCase() === candidateName.trim().toLowerCase()) !==
+                    undefined;
                 if (bFound)
                     ef._RelatedEntityNameFieldMap = candidateName + '_Virtual';
                 else
@@ -1135,8 +1143,8 @@ ${whereClause}GO${permissions}
         return sOutput;
     }
     getIsNameFieldForSingleEntity(entityName) {
-        const md = new core_1.Metadata(); // use the full metadata entity list, not the filtered version that we receive
-        const e = md.Entities.find(e => e.Name === entityName);
+        const md = new global_1.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;
             if (e.NameField)
@@ -1156,9 +1164,7 @@ ${whereClause}GO${permissions}
         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 == exports.SPType.Create && ep.CanCreate) || (type == exports.SPType.Update && ep.CanUpdate) || (type == exports.SPType.Delete && ep.CanDelete)) {
                 if (ep.RoleSQLName && ep.RoleSQLName.length > 0) {
                     sOutput += (sOutput === '' ? `GRANT EXECUTE ON [${entity.SchemaName}].[${spName}] TO ` : ', ') + `[${ep.RoleSQLName}]`;
                 }
@@ -1270,7 +1276,9 @@ CREATE PROCEDURE [${entity.SchemaName}].[${spName}]
 AS
 BEGIN
     SET NOCOUNT ON;
-    ${preInsertCode}${preInsertCode.includes('INSERT INTO') ? '' : `
+    ${preInsertCode}${preInsertCode.includes('INSERT INTO')
+            ? ''
+            : `
     INSERT INTO
     [${entity.SchemaName}].[${entity.BaseTable}]
         (
@@ -1287,12 +1295,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() === global_1.EntityInfo.UpdatedAtFieldName.toLowerCase().trim());
         if (!updatedAtField)
             return '';
         const triggerStatement = `
 ------------------------------------------------------------
------ TRIGGER FOR ${core_1.EntityInfo.UpdatedAtFieldName} field for the ${entity.BaseTable} table
+----- TRIGGER FOR ${global_1.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}];
@@ -1306,12 +1314,12 @@ BEGIN
     UPDATE
         [${entity.SchemaName}].[${entity.BaseTable}]
     SET
-        ${core_1.EntityInfo.UpdatedAtFieldName} = GETUTCDATE()
+        ${global_1.EntityInfo.UpdatedAtFieldName} = GETUTCDATE()
     FROM
         [${entity.SchemaName}].[${entity.BaseTable}] AS _organicTable
     INNER JOIN
         INSERTED AS I ON
-        ${entity.PrimaryKeys.map(k => `_organicTable.[${k.Name}] = I.[${k.Name}]`).join(' AND ')};
+        ${entity.PrimaryKeys.map((k) => `_organicTable.[${k.Name}] = I.[${k.Name}]`).join(' AND ')};
 END;
 GO`;
         return triggerStatement;
@@ -1320,14 +1328,14 @@ GO`;
         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 hasUpdatedAtField = entity.Fields.find((f) => f.Name.toLowerCase().trim() === global_1.EntityInfo.UpdatedAtFieldName.trim().toLowerCase()) !== undefined;
         const updatedAtTrigger = hasUpdatedAtField ? this.generateUpdatedAtTrigger(entity) : '';
         let selectUpdatedRecord = `SELECT
                                         *
                                     FROM
                                         [${entity.SchemaName}].[${entity.BaseView}]
                                     WHERE
-                                        ${entity.PrimaryKeys.map(k => `[${k.Name}] = @${k.CodeName}`).join(' AND ')}
+                                        ${entity.PrimaryKeys.map((k) => `[${k.Name}] = @${k.CodeName}`).join(' AND ')}
                                     `;
         return `
 ------------------------------------------------------------
@@ -1347,7 +1355,7 @@ BEGIN
     SET
         ${this.createEntityFieldsUpdateString(entity.Fields)}
     WHERE
-        ${entity.PrimaryKeys.map(k => `[${k.Name}] = @${k.CodeName}`).join(' AND ')}
+        ${entity.PrimaryKeys.map((k) => `[${k.Name}] = @${k.CodeName}`).join(' AND ')}
 
     -- Check if the update was successful
     IF @@ROWCOUNT = 0
@@ -1386,7 +1394,7 @@ ${updatedAtTrigger}
             'current_timestamp',
             'user_name()',
             'suser_name()',
-            'system_user'
+            'system_user',
         ];
         // Check if this is a SQL function
         for (const func of sqlFunctions) {
@@ -1446,7 +1454,11 @@ ${updatedAtTrigger}
             const ef = entityFields[i];
             // we only want fields that are (a) not primary keys, or if a pkey, not an auto-increment pkey and (b) not virtual fields and (c) updateable fields and (d) not auto-increment fields if they're not pkeys)
             // ALSO: if excludePrimaryKey is true, skip all primary key fields
-            if ((excludePrimaryKey && ef.IsPrimaryKey) || (ef.IsPrimaryKey && autoGeneratedPrimaryKey) || ef.IsVirtual || !ef.AllowUpdateAPI || ef.AutoIncrement) {
+            if ((excludePrimaryKey && ef.IsPrimaryKey) ||
+                (ef.IsPrimaryKey && autoGeneratedPrimaryKey) ||
+                ef.IsVirtual ||
+                !ef.AllowUpdateAPI ||
+                ef.AutoIncrement) {
                 continue; // skip this field
             }
             if (!isFirst)
@@ -1459,7 +1471,7 @@ ${updatedAtTrigger}
                 else
                     sOutput += `NULL`; // we don't set the deleted at field on an insert, only on a delete
             }
-            else if ((prefix && prefix !== '') && !ef.IsPrimaryKey && ef.IsUniqueIdentifier && ef.HasDefaultValue && !ef.AllowsNull) {
+            else if (prefix && prefix !== '' && !ef.IsPrimaryKey && ef.IsUniqueIdentifier && ef.HasDefaultValue && !ef.AllowsNull) {
                 // this is the VALUE side (prefix not null/blank), is NOT a primary key, and is a uniqueidentifier column with a default value and does NOT allow NULL
                 // We need to handle both NULL and the special value '00000000-0000-0000-0000-000000000000' for backward compatibility
                 // Existing code uses the special value to indicate "use the default", so we preserve that behavior
@@ -1497,11 +1509,7 @@ ${updatedAtTrigger}
         let sOutput = '', isFirst = true;
         for (let i = 0; i < entityFields.length; ++i) {
             const ef = entityFields[i];
-            if (!ef.IsPrimaryKey &&
-                !ef.IsVirtual &&
-                ef.AllowUpdateAPI &&
-                !ef.AutoIncrement &&
-                !ef.IsSpecialDateField) {
+            if (!ef.IsPrimaryKey && !ef.IsVirtual && ef.AllowUpdateAPI && !ef.AutoIncrement && !ef.IsSpecialDateField) {
                 if (!isFirst)
                     sOutput += ',\n        ';
                 else
@@ -1528,7 +1536,7 @@ ${updatedAtTrigger}
         // next up, create the delete code which is based on the type of delete the entity is set to
         // start off by creating the where clause first and then prepend the delete or update statement to it
         let deleteCode = `    WHERE
-        ${entity.PrimaryKeys.map(k => `[${k.Name}] = @${k.CodeName}`).join(' AND ')}
+        ${entity.PrimaryKeys.map((k) => `[${k.Name}] = @${k.CodeName}`).join(' AND ')}
 `;
         if (entity.DeleteType === 'Hard') {
             deleteCode = `    DELETE FROM
@@ -1539,8 +1547,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`;
+        ${global_1.EntityInfo.DeletedAtFieldName} = GETUTCDATE()
+${deleteCode}        AND ${global_1.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 = '';
@@ -1577,7 +1585,7 @@ GO${permissions}
     generateCascadeDeletes(entity) {
         let sOutput = '';
         if (entity.CascadeDeletes) {
-            const md = new core_1.Metadata();
+            const md = new global_1.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) {
@@ -1719,7 +1727,10 @@ GO${permissions}
         const pkComponents = this.buildPrimaryKeyComponents(entity, varPrefix);
         // Add primary key declarations to the declarations string
         // Need to add DECLARE keyword since buildPrimaryKeyComponents doesn't include it
-        declarations = pkComponents.varDeclarations.split(', ').map(decl => `DECLARE ${decl}`).join('\n    ');
+        declarations = pkComponents.varDeclarations
+            .split(', ')
+            .map((decl) => `DECLARE ${decl}`)
+            .join('\n    ');
         selectFields = pkComponents.selectFields;
         fetchInto = pkComponents.fetchInto;
         allParams = pkComponents.spParams;
@@ -1750,7 +1761,7 @@ GO${permissions}
      */
     analyzeCascadeDeleteDependencies(entity) {
         if (entity.CascadeDeletes) {
-            const md = new core_1.Metadata();
+            const md = new global_1.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) {
@@ -1812,9 +1823,9 @@ GO${permissions}
         // Log the dependency map
         (0, status_logging_1.logStatus)(`Cascade delete dependency map built:`);
         for (const [dependedOnEntityId, dependentEntityIds] of this.cascadeDeleteDependencies) {
-            const dependedOnEntity = entities.find(e => e.ID === dependedOnEntityId);
+            const dependedOnEntity = entities.find((e) => e.ID === dependedOnEntityId);
             const dependentNames = Array.from(dependentEntityIds)
-                .map(id => entities.find(e => e.ID === id)?.Name || id)
+                .map((id) => entities.find((e) => e.ID === id)?.Name || id)
                 .join(', ');
             (0, status_logging_1.logStatus)(`  ${dependedOnEntity?.Name || dependedOnEntityId} is depended on by: ${dependentNames}`);
         }
@@ -1830,15 +1841,13 @@ GO${permissions}
         (0, status_logging_1.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 &&
-                e.AllowUpdateAPI &&
-                e.spUpdateGenerated);
+            const entity = entities.find((e) => e.Name === entityName && e.AllowUpdateAPI && 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`);
             }
             else {
-                const nonUpdateEntity = entities.find(e => e.Name === entityName);
+                const nonUpdateEntity = entities.find((e) => e.Name === entityName);
                 if (nonUpdateEntity) {
                     (0, status_logging_1.logStatus)(`  - ${entityName} found but AllowUpdateAPI=${nonUpdateEntity.AllowUpdateAPI}, spUpdateGenerated=${nonUpdateEntity.spUpdateGenerated}`);
                 }
@@ -1886,7 +1895,7 @@ GO${permissions}
                     (0, status_logging_1.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);
+                        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)`);
@@ -1900,7 +1909,7 @@ GO${permissions}
                     if (this.orderedEntitiesForDeleteSPRegeneration.length > 0) {
                         (0, status_logging_1.logStatus)(`Ordered entities for delete SP regeneration:`);
                         this.orderedEntitiesForDeleteSPRegeneration.forEach((entityId, index) => {
-                            const entity = entities.find(e => e.ID === entityId);
+                            const entity = entities.find((e) => e.ID === entityId);
                             (0, status_logging_1.logStatus)(`  ${index + 1}. ${entity?.Name || entityId}`);
                         });
                     }
@@ -1948,7 +1957,7 @@ GO${permissions}
             }
             if (visiting.has(entityId)) {
                 // Circular dependency detected - mark it but don't fail
-                const entity = entities.find(e => e.ID === entityId);
+                const entity = entities.find((e) => e.ID === entityId);
                 (0, status_logging_1.logStatus)(`Warning: Circular cascade delete dependency detected involving ${entity?.Name || entityId}`);
                 circularDeps.add(entityId);
                 return false; // Signal circular dependency but continue processing
@@ -1975,7 +1984,7 @@ 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`);
+                    (0, status_logging_1.logStatus)(`  - Adding ${entities.find((e) => e.ID === entityId)?.Name || entityId} despite circular dependency`);
                     visited.add(entityId);
                     ordered.push(entityId);
                 }