@memberjunction/codegen-lib 2.7.0 → 2.8.0

package/dist/Database/manage-metadata.js

@@ -36,12 +36,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManageMetadataBase = void 0;
 const config_1 = require("../Config/config");
 const core_1 = require("@memberjunction/core");
-const logging_1 = require("../Misc/logging");
+const status_logging_1 = require("../Misc/status_logging");
 const sql_1 = require("./sql");
 const advanced_generation_1 = require("../Misc/advanced_generation");
 const global_1 = require("@memberjunction/global");
 const fs = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
+const sql_logging_1 = require("../Misc/sql_logging");
 /**
  * Base class for managing metadata within the CodeGen system. This class can be sub-classed to extend/override base class functionality. Make sure to use the RegisterClass decorator from the @memberjunction/global package
  * to properly register your subclass with a priority of 1+ to ensure it gets instantiated.
@@ -56,73 +57,6 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
     static get newEntityList() {
         return this._newEntityList;
     }
-    async manageMetaDataLogging(config) {
-        if (!config) {
-            (0, logging_1.logError)("MetadataLoggingConfig is required to enable metadata logging");
-            return;
-        }
-        if (!config.folderPath && !config.filePath) {
-            (0, logging_1.logError)("Either folderPath or filePath is required to enable metadata logging");
-            return;
-        }
-        if (config.folderPath) {
-            const dirExists = fs.existsSync(config.folderPath);
-            if (!dirExists) {
-                fs.mkdirSync(config.folderPath, { recursive: true });
-            }
-            const fileName = this.createFileName();
-            this.FilePath = path_1.default.join(config.folderPath, `${fileName}.sql`);
-            //create an empty file
-            fs.writeFileSync(this.FilePath, '');
-        }
-        else {
-            this.FilePath = config.filePath;
-            if (this.FilePath && config.overwriteFile) {
-                //append to the file
-                fs.writeFileSync(this.FilePath, '');
-            }
-        }
-        this.Config = config;
-        (0, core_1.LogStatus)(`Metadata logging enabled. File path: ${this.FilePath}`);
-    }
-    createFileName() {
-        const date = new Date();
-        const year = date.getUTCFullYear();
-        const month = String(date.getUTCMonth() + 1).padStart(2, '0'); // Month is 0-based
-        const day = String(date.getUTCDate()).padStart(2, '0');
-        const hour = String(date.getUTCHours()).padStart(2, '0');
-        const minute = String(date.getUTCMinutes()).padStart(2, '0');
-        const second = String(date.getUTCSeconds()).padStart(2, '0');
-        const fileName = `CodeGen_Run_${year}-${month}-${day}_${hour}-${minute}-${second}`;
-        return fileName;
-    }
-    async appendToFile(contents, description) {
-        try {
-            if (!contents || !this.FilePath) {
-                return;
-            }
-            if (description) {
-                const comment = `/* ${description} */\n`;
-                contents = `${comment}${contents}`;
-            }
-            contents = `${contents}\n\n`;
-            fs.appendFileSync(this.FilePath, contents);
-        }
-        catch (ex) {
-            (0, logging_1.logError)("Unable to log metadata SQL text to file", ex);
-        }
-    }
-    convertCoreSchemaToFlywaySchema() {
-        if (!this.FilePath) {
-            return;
-        }
-        const coreSchema = (0, config_1.mj_core_schema)();
-        const regex = new RegExp(coreSchema, 'g');
-        const data = fs.readFileSync(`${this.FilePath}`, 'utf-8');
-        const replacedData = data.replace(regex, "${flyway:defaultSchema}");
-        fs.writeFileSync(`${this.FilePath}`, replacedData);
-        (0, logging_1.logStatus)(`Replaced all instances of ${coreSchema} with \${flyway:defaultSchema} in the metadata log file`);
-    }
     /**
      * Primary function to manage metadata within the CodeGen system. This function will call a series of sub-functions to manage the metadata.
      * @param ds - the DataSource object to use for querying and updating the database
@@ -133,62 +67,59 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         const excludeSchemas = config_1.configInfo.excludeSchemas ? config_1.configInfo.excludeSchemas : [];
         let bSuccess = true;
         let start = new Date();
-        (0, logging_1.logStatus)('   Creating new entities...');
+        (0, status_logging_1.logStatus)('   Creating new entities...');
         if (!await this.createNewEntities(ds)) {
-            (0, logging_1.logError)('   Error creating new entities');
+            (0, status_logging_1.logError)('   Error creating new entities');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`    > Created new entities in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`    > Created new entities in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, logging_1.logStatus)('   Updating existing entities...');
+        (0, status_logging_1.logStatus)('   Updating existing entities...');
         if (!await this.updateExistingEntitiesFromSchema(ds, excludeSchemas)) {
-            (0, logging_1.logError)('   Error updating existing entities');
+            (0, status_logging_1.logError)('   Error updating existing entities');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`    > Updated existing entities in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`    > Updated existing entities in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, logging_1.logStatus)('   Scanning for tables that were deleted where entity metadata still exists...');
+        (0, status_logging_1.logStatus)('   Scanning for tables that were deleted where entity metadata still exists...');
         if (!await this.checkAndRemoveMetadataForDeletedTables(ds, excludeSchemas)) {
-            (0, logging_1.logError)('   Error removing metadata for tables that were removed');
+            (0, status_logging_1.logError)('   Error removing metadata for tables that were removed');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`    > Removed metadata for deleted tables in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`    > Removed metadata for deleted tables in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, logging_1.logStatus)('   Recompiling base views...');
+        (0, status_logging_1.logStatus)('   Recompiling base views...');
         const sqlUtility = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(sql_1.SQLUtilityBase);
         if (!await sqlUtility.recompileAllBaseViews(ds, excludeSchemas, true)) {
-            (0, logging_1.logMessage)('   Warning: Non-Fatal error recompiling base views', core_1.SeverityType.Warning, false);
+            (0, status_logging_1.logMessage)('   Warning: Non-Fatal error recompiling base views', core_1.SeverityType.Warning, false);
             // many times the former versions of base views will NOT succesfully recompile, so don't consider that scenario to be a 
             // failure for this entire function
         }
-        (0, logging_1.logStatus)(`    > Recompiled base views in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`    > Recompiled base views in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, logging_1.logStatus)('   Managing entity fields...');
+        (0, status_logging_1.logStatus)('   Managing entity fields...');
         if (!await this.manageEntityFields(ds, excludeSchemas, false, false)) {
-            (0, logging_1.logError)('   Error managing entity fields');
+            (0, status_logging_1.logError)('   Error managing entity fields');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`    > Managed entity fields in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`    > Managed entity fields in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         start = new Date();
-        (0, logging_1.logStatus)('   Managing entity relationships...');
+        (0, status_logging_1.logStatus)('   Managing entity relationships...');
         if (!await this.manageEntityRelationships(ds, excludeSchemas, md)) {
-            (0, logging_1.logError)('   Error managing entity relationships');
+            (0, status_logging_1.logError)('   Error managing entity relationships');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`    > Managed entity relationships in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`    > Managed entity relationships in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
         if (ManageMetadataBase_1.newEntityList.length > 0) {
             await this.generateNewEntityDescriptions(ds, md); // don't pass excludeSchemas becuase by definition this is the NEW entities we created
         }
         const veResult = await this.manageVirtualEntities(ds);
         if (!veResult.success) {
-            (0, logging_1.logError)('   Error managing virtual entities');
+            (0, status_logging_1.logError)('   Error managing virtual entities');
             bSuccess = false;
         }
         // now - we need to tell our metadata object to refresh itself
         await md.Refresh();
-        if (this.Config && this.Config.convertCoreSchemaToFlywaySchema) {
-            this.convertCoreSchemaToFlywaySchema();
-        }
         return bSuccess;
     }
     async manageVirtualEntities(ds) {
@@ -205,7 +136,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 const { success, updatedEntity } = await this.manageSingleVirtualEntity(ds, ve);
                 anyUpdates = anyUpdates || updatedEntity;
                 if (!success) {
-                    (0, logging_1.logError)(`   Error managing virtual entity ${ve.Name}`);
+                    (0, status_logging_1.logError)(`   Error managing virtual entity ${ve.Name}`);
                     bSuccess = false;
                 }
             }
@@ -246,7 +177,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     if (removeList.length > 0) {
                         const sqlRemove = `DELETE FROM [${(0, config_1.mj_core_schema)()}].EntityField WHERE ID IN (${removeList.map(removeId => `'${removeId}'`).join(',')})`;
                         // this removes the fields that shouldn't be there anymore
-                        this.executeAndLogMetadataSQL(ds, sqlRemove, true, `SQL text to remove fields from entity ${virtualEntity.Name}`);
+                        this.LogSQLAndExecute(ds, sqlRemove, `SQL text to remove fields from entity ${virtualEntity.Name}`);
                         bUpdated = true;
                     }
                     // check to see if any of the fields in the virtual entity have Pkey attribute set. If not, we will default to the first field
@@ -258,7 +189,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                         const { success, updatedField } = await this.manageSingleVirtualEntityField(ds, virtualEntity, vef, i + 1, !hasPkey && i === 0);
                         bUpdated = bUpdated || updatedField;
                         if (!success) {
-                            (0, logging_1.logError)(`Error managing virtual entity field ${vef.FieldName} for virtual entity ${virtualEntity.Name}`);
+                            (0, status_logging_1.logError)(`Error managing virtual entity field ${vef.FieldName} for virtual entity ${virtualEntity.Name}`);
                             bSuccess = false;
                         }
                     }
@@ -267,12 +198,12 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             if (bUpdated) {
                 // finally make sure we update the UpdatedAt field for the entity if we made changes to its fields
                 const sqlUpdate = `UPDATE [${(0, config_1.mj_core_schema)()}].Entity SET [${core_1.EntityInfo.UpdatedAtFieldName}]=GETUTCDATE() WHERE ID='${virtualEntity.ID}'`;
-                await ds.query(sqlUpdate);
+                await this.LogSQLAndExecute(ds, sqlUpdate, `SQL text to update virtual entity updated date for ${virtualEntity.Name}`);
             }
             return { success: bSuccess, updatedEntity: bUpdated };
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return { success: false, updatedEntity: bUpdated };
         }
     }
@@ -307,7 +238,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                                     Scale=${veField.Scale}
                                   WHERE 
                                     ID = '${field.ID}'`; // don't need to update the __mj_UpdatedAt field here, that happens automatically via the trigger
-                    await this.executeAndLogMetadataSQL(ds, sqlUpdate, true, `SQL text to update virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
+                    await this.LogSQLAndExecute(ds, sqlUpdate, `SQL text to update virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
                     didUpdate = true;
                 }
             }
@@ -321,7 +252,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                                        ${veField.Length}, ${veField.Precision}, ${veField.Scale},
                                        ${fieldSequence}, ${makePrimaryKey ? 1 : 0}, ${makePrimaryKey ? 1 : 0}
                                     )`;
-                await this.executeAndLogMetadataSQL(ds, sqlAdd, true, `SQL text to add virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
+                await this.LogSQLAndExecute(ds, sqlAdd, `SQL text to add virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
                 didUpdate = true;
             }
         }
@@ -400,7 +331,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     }
                 });
                 if (batchSQL.length > 0) {
-                    await this.executeAndLogMetadataSQL(ds, batchSQL, true, `SQL text to create Entitiy Relationships`);
+                    await this.LogSQLAndExecute(ds, batchSQL, `SQL text to create Entitiy Relationships`);
                 }
             };
             // Split entityFields into batches and process each batch
@@ -411,7 +342,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -432,8 +363,8 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     // for the admin to handle manually
                     try {
                         const sqlDelete = `__mj.spDeleteEntityWithCoreDependencies @EntityID='${e.ID}'`;
-                        await ds.query(sqlDelete);
-                        (0, logging_1.logStatus)(`      > Removed metadata for table ${e.SchemaName}.${e.BaseTable}`);
+                        await this.LogSQLAndExecute(ds, sqlDelete, `SQL text to remove entity ${e.Name}`);
+                        (0, status_logging_1.logStatus)(`      > Removed metadata for table ${e.SchemaName}.${e.BaseTable}`);
                         // next up we need to remove the spCreate, spDelete, spUpdate, BaseView, and FullTextSearchFunction, if provided. 
                         // We only remoe these artifcacts when they are generated which is info we have in the BaseViewGenerated, spCreateGenerated, etc. fields
                         await this.checkDropSQLObject(ds, e.BaseViewGenerated, 'view', e.SchemaName, e.BaseView);
@@ -443,7 +374,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                         await this.checkDropSQLObject(ds, e.FullTextSearchFunctionGenerated, 'function', e.SchemaName, e.FullTextSearchFunction);
                     }
                     catch (ex) {
-                        (0, logging_1.logError)(`Error removing metadata for entity ${ex.Name}, error: ${ex}`);
+                        (0, status_logging_1.logError)(`Error removing metadata for entity ${ex.Name}, error: ${ex}`);
                     }
                 }
                 // if we get here we now need to refresh our metadata object
@@ -453,7 +384,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -461,7 +392,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         try {
             if (proceed && schemaName && name && schemaName.trim().length > 0 && name.trim().length > 0) {
                 const sqlDelete = `DROP ${type} IF EXISTS [${schemaName}].[${name}]`;
-                await ds.query(sqlDelete);
+                await this.LogSQLAndExecute(ds, sqlDelete, `SQL text to remove ${type} ${schemaName}.${name}`);
                 // next up, we need to clean up the cache of saved DB objects that may exist for this entity in the appropriate sub-directory.
                 const sqlOutputDir = (0, config_1.outputDir)('SQL', true);
                 if (sqlOutputDir) {
@@ -475,11 +406,11 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     if (fs.existsSync(filePathPermissions))
                         fs.unlinkSync(filePathPermissions);
                 }
-                (0, logging_1.logStatus)(`         > Removed ${type} ${schemaName}.${name}`);
+                (0, status_logging_1.logStatus)(`         > Removed ${type} ${schemaName}.${name}`);
             }
         }
         catch (e) {
-            (0, logging_1.logError)(`         > Error removing ${type} ${schemaName}.${name}, error: ${e}`);
+            (0, status_logging_1.logError)(`         > Error removing ${type} ${schemaName}.${name}, error: ${e}`);
         }
     }
     /**
@@ -505,51 +436,51 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         if (!skipCreatedAtUpdatedAtDeletedAtFieldValidation) {
             if (!await this.ensureCreatedAtUpdatedAtFieldsExist(ds, excludeSchemas) ||
                 !await this.ensureDeletedAtFieldsExist(ds, excludeSchemas)) {
-                (0, logging_1.logError)(`Error ensuring ${core_1.EntityInfo.CreatedAtFieldName}, ${core_1.EntityInfo.UpdatedAtFieldName} and ${core_1.EntityInfo.DeletedAtFieldName} fields exist`);
+                (0, status_logging_1.logError)(`Error ensuring ${core_1.EntityInfo.CreatedAtFieldName}, ${core_1.EntityInfo.UpdatedAtFieldName} and ${core_1.EntityInfo.DeletedAtFieldName} fields exist`);
                 bSuccess = false;
             }
-            (0, logging_1.logStatus)(`      Ensured ${core_1.EntityInfo.CreatedAtFieldName}/${core_1.EntityInfo.UpdatedAtFieldName}/${core_1.EntityInfo.DeletedAtFieldName} fields exist in ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
+            (0, status_logging_1.logStatus)(`      Ensured ${core_1.EntityInfo.CreatedAtFieldName}/${core_1.EntityInfo.UpdatedAtFieldName}/${core_1.EntityInfo.DeletedAtFieldName} fields exist in ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
         }
         const step1StartTime = new Date();
         if (!await this.deleteUnneededEntityFields(ds, excludeSchemas)) {
-            (0, logging_1.logError)('Error deleting unneeded entity fields');
+            (0, status_logging_1.logError)('Error deleting unneeded entity fields');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`      Deleted unneeded entity fields in ${(new Date().getTime() - step1StartTime.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`      Deleted unneeded entity fields in ${(new Date().getTime() - step1StartTime.getTime()) / 1000} seconds`);
         const step2StartTime = new Date();
         if (!await this.updateExistingEntityFieldsFromSchema(ds, excludeSchemas)) {
-            (0, logging_1.logError)('Error updating existing entity fields from schema');
+            (0, status_logging_1.logError)('Error updating existing entity fields from schema');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`      Updated existing entity fields from schema in ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`      Updated existing entity fields from schema in ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
         const step3StartTime = new Date();
         if (!await this.createNewEntityFieldsFromSchema(ds)) { // has its own internal filtering for exclude schema/table so don't pass in
-            (0, logging_1.logError)('Error creating new entity fields from schema');
+            (0, status_logging_1.logError)('Error creating new entity fields from schema');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`      Created new entity fields from schema in ${(new Date().getTime() - step3StartTime.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`      Created new entity fields from schema in ${(new Date().getTime() - step3StartTime.getTime()) / 1000} seconds`);
         const step4StartTime = new Date();
         if (!await this.setDefaultColumnWidthWhereNeeded(ds, excludeSchemas)) {
-            (0, logging_1.logError)('Error setting default column width where needed');
+            (0, status_logging_1.logError)('Error setting default column width where needed');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`      Set default column width where needed in ${(new Date().getTime() - step4StartTime.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`      Set default column width where needed in ${(new Date().getTime() - step4StartTime.getTime()) / 1000} seconds`);
         const step5StartTime = new Date();
         if (!await this.updateEntityFieldDisplayNameWhereNull(ds, excludeSchemas)) {
-            (0, logging_1.logError)('Error updating entity field display name where null');
+            (0, status_logging_1.logError)('Error updating entity field display name where null');
             bSuccess = false;
         }
-        (0, logging_1.logStatus)(`      Updated entity field display name where null in ${(new Date().getTime() - step5StartTime.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`      Updated entity field display name where null in ${(new Date().getTime() - step5StartTime.getTime()) / 1000} seconds`);
         if (!skipEntityFieldValues) {
             const step6StartTime = new Date();
-            (0, logging_1.logStatus)(`      Starting to manage entity field values...`);
+            (0, status_logging_1.logStatus)(`      Starting to manage entity field values...`);
             if (!await this.manageEntityFieldValues(ds, excludeSchemas)) {
-                (0, logging_1.logError)('Error managing entity field values');
+                (0, status_logging_1.logError)('Error managing entity field values');
                 bSuccess = false;
             }
-            (0, logging_1.logStatus)(`      Managed entity field values in ${(new Date().getTime() - step6StartTime.getTime()) / 1000} seconds`);
+            (0, status_logging_1.logStatus)(`      Managed entity field values in ${(new Date().getTime() - step6StartTime.getTime()) / 1000} seconds`);
         }
-        (0, logging_1.logStatus)(`      Total time to manage entity fields: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
+        (0, status_logging_1.logStatus)(`      Total time to manage entity fields: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
         return bSuccess;
     }
     /**
@@ -587,7 +518,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             return overallResult;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -633,7 +564,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             return overallResult;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -649,7 +580,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             if (!currentFieldData) {
                 // field doesn't exist, let's create it
                 const sql = `ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] ADD ${fieldName} DATETIMEOFFSET ${allowNull ? 'NULL' : 'NOT NULL DEFAULT GETUTCDATE()'}`;
-                await this.executeAndLogMetadataSQL(ds, sql, true, `SQL text to add special date field ${fieldName} to entity ${entity.SchemaName}.${entity.BaseTable}`);
+                await this.LogSQLAndExecute(ds, sql, `SQL text to add special date field ${fieldName} to entity ${entity.SchemaName}.${entity.BaseTable}`);
             }
             else {
                 // field does exist, let's first check the data type/nullability
@@ -660,7 +591,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     // modifying the column, and finally adding the default constraint back in.
                     await this.dropExistingDefaultConstraint(ds, entity, fieldName);
                     const sql = `ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] ALTER COLUMN ${fieldName} DATETIMEOFFSET ${allowNull ? 'NULL' : 'NOT NULL'}`;
-                    await this.executeAndLogMetadataSQL(ds, sql, true, `SQL text to update special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
+                    await this.LogSQLAndExecute(ds, sql, `SQL text to update special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
                     if (!allowNull)
                         await this.createDefaultConstraintForSpecialDateField(ds, entity, fieldName);
                 }
@@ -680,7 +611,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -690,10 +621,10 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
     async createDefaultConstraintForSpecialDateField(ds, entity, fieldName) {
         try {
             const sqlAddDefaultConstraint = `ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] ADD CONSTRAINT DF_${entity.SchemaName}_${(0, core_1.CodeNameFromString)(entity.BaseTable)}_${fieldName} DEFAULT GETUTCDATE() FOR [${fieldName}]`;
-            await this.executeAndLogMetadataSQL(ds, sqlAddDefaultConstraint, true, `SQL text to add default constraint for special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
+            await this.LogSQLAndExecute(ds, sqlAddDefaultConstraint, `SQL text to add default constraint for special date field ${fieldName} in entity ${entity.SchemaName}.${entity.BaseTable}`);
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
         }
     }
     /**
@@ -734,10 +665,10 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             EXEC('ALTER TABLE [${entity.SchemaName}].[${entity.BaseTable}] DROP CONSTRAINT ' + @constraintName);
          END
          `;
-            this.executeAndLogMetadataSQL(ds, sqlDropDefaultConstraint, true, `SQL text to drop default existing default constraints in entity ${entity.SchemaName}.${entity.BaseTable}`);
+            this.LogSQLAndExecute(ds, sqlDropDefaultConstraint, `SQL text to drop default existing default constraints in entity ${entity.SchemaName}.${entity.BaseTable}`);
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
         }
     }
     /**
@@ -782,8 +713,8 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     try {
                         const structuredResult = JSON.parse(resultText);
                         if (structuredResult?.entityDescription && structuredResult.entityDescription.length > 0) {
-                            const ssql = `UPDATE [${(0, config_1.mj_core_schema)()}].Entity SET Description = '${structuredResult.entityDescription}' WHERE Name = '${e}'`;
-                            await this.executeAndLogMetadataSQL(ds, ssql, true, `SQL text to update entity description for entity ${e}`);
+                            const sSQL = `UPDATE [${(0, config_1.mj_core_schema)()}].Entity SET Description = '${structuredResult.entityDescription}' WHERE Name = '${e}'`;
+                            await this.LogSQLAndExecute(ds, sSQL, `SQL text to update entity description for entity ${e}`);
                         }
                         else {
                             console.warn('   >>> Advanced Generation Error: LLM returned a blank entity description, skipping entity description for entity ' + e);
@@ -829,13 +760,13 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     const sDisplayName = this.stripTrailingChars(this.convertCamelCaseToHaveSpaces(field.Name), 'ID', true).trim();
                     if (sDisplayName.length > 0 && sDisplayName.toLowerCase().trim() !== field.Name.toLowerCase().trim()) {
                         const sSQL = `UPDATE [${(0, config_1.mj_core_schema)()}].EntityField SET ${core_1.EntityInfo.UpdatedAtFieldName}=GETUTCDATE(), DisplayName = '${sDisplayName}' WHERE ID = '${field.ID}'`;
-                        await this.executeAndLogMetadataSQL(ds, sSQL, true, `SQL text to update display name for field ${field.Name}`);
+                        await this.LogSQLAndExecute(ds, sSQL, `SQL text to update display name for field ${field.Name}`);
                     }
                 }
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -849,11 +780,12 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
      */
     async setDefaultColumnWidthWhereNeeded(ds, excludeSchemas) {
         try {
-            await ds.query(`EXEC ${(0, config_1.mj_core_schema)()}.spSetDefaultColumnWidthWhereNeeded @ExcludedSchemaNames='${excludeSchemas.join(',')}'`);
+            const sSQL = `EXEC ${(0, config_1.mj_core_schema)()}.spSetDefaultColumnWidthWhereNeeded @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            await this.LogSQLAndExecute(ds, sSQL, `SQL text to set default column width where needed`);
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -1051,7 +983,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                         // need to check for null entity id = that is because the above query can return candidate Entity Fields but the entities may not have been created if the entities 
                         // that would have been created violate rules - such as not having an ID column, etc.
                         const sSQLInsert = this.getPendingEntityFieldINSERTSQL(n);
-                        await this.executeAndLogMetadataSQL(ds, sSQLInsert, true, `SQL text to insert new entity field`);
+                        await this.LogSQLAndExecute(ds, sSQLInsert, `SQL text to insert new entity field`);
                         // if we get here, we're okay, otherwise we have an exception, which we want as it blows up transaction   
                     }
                 }
@@ -1059,7 +991,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -1075,41 +1007,44 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spUpdateEntityFieldRelatedEntityNameFieldMap 
          @EntityFieldID='${entityFieldID}',
          @RelatedEntityNameFieldMap='${relatedEntityNameFieldMap}'`;
-            await ds.query(sSQL);
+            await this.LogSQLAndExecute(ds, sSQL, `SQL text to update entity field related entity name field map for entity field ID ${entityFieldID}`);
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
     async updateExistingEntitiesFromSchema(ds, excludeSchemas) {
         try {
-            await ds.query(`EXEC [${(0, config_1.mj_core_schema)()}].spUpdateExistingEntitiesFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`);
+            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spUpdateExistingEntitiesFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            await this.LogSQLAndExecute(ds, sSQL, `SQL text to update existing entities from schema`);
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
     async updateExistingEntityFieldsFromSchema(ds, excludeSchemas) {
         try {
-            await ds.query(`EXEC [${(0, config_1.mj_core_schema)()}].spUpdateExistingEntityFieldsFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`);
+            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spUpdateExistingEntityFieldsFromSchema @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            await this.LogSQLAndExecute(ds, sSQL, `SQL text to update existingg entity fields from schema`);
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
     async deleteUnneededEntityFields(ds, excludeSchemas) {
         try {
-            await ds.query(`EXEC [${(0, config_1.mj_core_schema)()}].spDeleteUnneededEntityFields @ExcludedSchemaNames='${excludeSchemas.join(',')}'`);
+            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spDeleteUnneededEntityFields @ExcludedSchemaNames='${excludeSchemas.join(',')}'`;
+            await this.LogSQLAndExecute(ds, sSQL, `SQL text to delete unneeded entity fields`);
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -1135,14 +1070,14 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                         await this.syncEntityFieldValues(ds, r.EntityFieldID, parsedValues, allEntityFieldValues);
                         // finally, make sure the ValueListType column within the EntityField table is set to "List" because for check constraints we only allow the values specified in the list.
                         const sSQL = `UPDATE [${(0, config_1.mj_core_schema)()}].EntityField SET ValueListType='List' WHERE ID='${r.EntityFieldID}'`;
-                        await this.executeAndLogMetadataSQL(ds, sSQL, true, `SQL text to update ValueListType for entity field ID ${r.EntityFieldID}`);
+                        await this.LogSQLAndExecute(ds, sSQL, `SQL text to update ValueListType for entity field ID ${r.EntityFieldID}`);
                     }
                 }
             }
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -1158,7 +1093,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     if (!possibleValues.find(v => v === ev.Value)) {
                         // delete the value from the database
                         const sSQLDelete = `DELETE FROM [${(0, config_1.mj_core_schema)()}].EntityFieldValue WHERE ID='${ev.ID}'`;
-                        await this.executeAndLogMetadataSQL(ds, sSQLDelete, true, `SQL text to delete entity field value ID ${ev.ID}`);
+                        await this.LogSQLAndExecute(ds, sSQLDelete, `SQL text to delete entity field value ID ${ev.ID}`);
                         numRemoved++;
                     }
                 }
@@ -1171,7 +1106,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                                        (EntityFieldID, Sequence, Value, Code) 
                                     VALUES 
                                        ('${entityFieldID}', ${1 + possibleValues.indexOf(v)}, '${v}', '${v}')`;
-                        await this.executeAndLogMetadataSQL(ds, sSQLInsert, true, `SQL text to insert entity field values`);
+                        await this.LogSQLAndExecute(ds, sSQLInsert, `SQL text to insert entity field values`);
                         numAdded++;
                     }
                 }
@@ -1182,7 +1117,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     if (ev && ev.Sequence !== 1 + possibleValues.indexOf(v)) {
                         // update the sequence to match the order in the possible values list, if it doesn't already match
                         const sSQLUpdate = `UPDATE [${(0, config_1.mj_core_schema)()}].EntityFieldValue SET Sequence=${1 + possibleValues.indexOf(v)} WHERE ID='${ev.ID}'`;
-                        await this.executeAndLogMetadataSQL(ds, sSQLUpdate, true, `SQL text to update entity field value sequence`);
+                        await this.LogSQLAndExecute(ds, sSQLUpdate, `SQL text to update entity field value sequence`);
                         numUpdated++;
                     }
                 }
@@ -1190,7 +1125,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             return true;
         }
         catch (e) {
-            (0, logging_1.logError)(e);
+            (0, status_logging_1.logError)(e);
             return false;
         }
     }
@@ -1201,7 +1136,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         // Note: Assuming fieldName does not contain regex special characters; otherwise, it needs to be escaped as well.
         const structureRegex = new RegExp(`^\\(\\[${fieldName}\\]='[^']+'(?: OR \\[${fieldName}\\]='[^']+?')+\\)$`);
         if (!structureRegex.test(constraintDefinition)) {
-            (0, logging_1.logWarning)(`         Can't extract value list from [${entityName}].[${fieldName}]. The check constraint does not match the simple OR condition pattern or field name does not match:   ${constraintDefinition}`);
+            (0, status_logging_1.logWarning)(`         Can't extract value list from [${entityName}].[${fieldName}]. The check constraint does not match the simple OR condition pattern or field name does not match:   ${constraintDefinition}`);
             return null;
         }
         // Regular expression to match the values within the single quotes specifically for the field
@@ -1359,7 +1294,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 }
                 const isNewSchema = await this.isSchemaNew(ds, newEntity.SchemaName);
                 const sSQLInsert = this.createNewEntityInsertSQL(newEntityName, newEntity, suffix);
-                const newEntityResult = await this.executeAndLogMetadataSQL(ds, sSQLInsert, true, `SQL generated to create new entity ${newEntityName}`);
+                const newEntityResult = await this.LogSQLAndExecute(ds, sSQLInsert, `SQL generated to create new entity ${newEntityName}`);
                 const newEntityID = newEntityResult && newEntityResult.length > 0 ? newEntityResult[0].ID : null;
                 if (!newEntityID) {
                     throw new Error(`Failed to create new entity ${newEntityName} for table ${newEntity.SchemaName}.${newEntity.TableName}`);
@@ -1389,7 +1324,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                         const sSQLInsertApplicationEntity = `INSERT INTO ${(0, config_1.mj_core_schema)()}.ApplicationEntity 
                                                             (ApplicationID, EntityID, Sequence) VALUES 
                                                             ('${app.ID}', '${newEntityID}', (SELECT ISNULL(MAX(Sequence),0)+1 FROM ${(0, config_1.mj_core_schema)()}.ApplicationEntity WHERE ApplicationID = '${app.ID}'))`;
-                        this.executeAndLogMetadataSQL(ds, sSQLInsertApplicationEntity, true, `SQL generated to add new entity ${newEntityName} to application ${appName}`);
+                        this.LogSQLAndExecute(ds, sSQLInsertApplicationEntity, `SQL generated to add new entity ${newEntityName} to application ${appName}`);
                     }
                     else
                         (0, core_1.LogError)(`   >>>> ERROR: Unable to find Application ID for application ${appName} to add new entity ${newEntityName} to it`);
@@ -1404,7 +1339,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                             const sSQLInsertPermission = `INSERT INTO ${(0, config_1.mj_core_schema)()}.EntityPermission 
                                                    (EntityID, RoleID, CanRead, CanCreate, CanUpdate, CanDelete) VALUES 
                                                    ('${newEntityID}', '${RoleID}', ${p.CanRead ? 1 : 0}, ${p.CanCreate ? 1 : 0}, ${p.CanUpdate ? 1 : 0}, ${p.CanDelete ? 1 : 0})`;
-                            await this.executeAndLogMetadataSQL(ds, sSQLInsertPermission, true, `SQL generated to add new permission for entity ${newEntityName} for role ${p.RoleName}`);
+                            await this.LogSQLAndExecute(ds, sSQLInsertPermission, `SQL generated to add new permission for entity ${newEntityName} for role ${p.RoleName}`);
                         }
                         else
                             (0, core_1.LogError)(`   >>>> ERROR: Unable to find Role ID for role ${p.RoleName} to add permissions for new entity ${newEntityName}`);
@@ -1429,7 +1364,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
     }
     async createNewApplication(ds, appName) {
         const sSQL = "INSERT INTO [" + (0, config_1.mj_core_schema)() + "].Application (Name, Description) VALUES ('" + appName + "', 'Generated for Schema'); SELECT @@IDENTITY AS ID";
-        const result = await this.executeAndLogMetadataSQL(ds, sSQL, true, `SQL generated to create new application ${appName}`);
+        const result = await this.LogSQLAndExecute(ds, sSQL, `SQL generated to create new application ${appName}`);
         return result && result.length > 0 ? result[0].ID : null;
     }
     async applicationExists(ds, applicationName) {
@@ -1551,15 +1486,11 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
      * Note that in order to append to the log file, ManageMetadataBase.manageMetaDataLogging must be called first.
      * @param ds - The DataSource object to use to execute the query.
      * @param query - The SQL query to execute.
-     * @param appendToLogFile - If true, the query will be appended to the log file.
      * @param description - A description of the query to append to the log file.
      * @returns - The result of the query execution.
      */
-    async executeAndLogMetadataSQL(ds, query, appendToLogFile, description) {
-        if (appendToLogFile) {
-            this.appendToFile(query, description);
-        }
-        return ds.query(query);
+    async LogSQLAndExecute(ds, query, description) {
+        sql_logging_1.SQLLogging.LogSQLAndExecute(ds, query, description);
     }
 };
 exports.ManageMetadataBase = ManageMetadataBase;