@memberjunction/codegen-lib 2.7.1 → 2.9.0

package/dist/Database/manage-metadata.js

@@ -36,12 +36,14 @@ 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 uuid_1 = require("uuid");
 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 +58,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 +68,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 +137,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 +178,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 +190,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 +199,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 };
         }
     }
@@ -282,6 +214,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         // first, get the entity definition
         const md = new core_1.Metadata();
         const entity = md.EntityByName(virtualEntity.Name);
+        let newEntityFieldUUID = null;
         let didUpdate = false;
         if (entity) {
             const field = entity.Fields.find(f => f.Name.trim().toLowerCase() === veField.FieldName.trim().toLowerCase());
@@ -307,25 +240,26 @@ 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;
                 }
             }
             else {
                 // this means that we do NOT have a match so the field does not exist in the entity definition, so we need to add it
+                newEntityFieldUUID = this.createNewUUID();
                 const sqlAdd = `INSERT INTO [${(0, config_1.mj_core_schema)()}].EntityField (
-                                      EntityID, Name, Type, AllowsNull, 
+                                      ID, EntityID, Name, Type, AllowsNull, 
                                       Length, Precision, Scale, 
                                       Sequence, IsPrimaryKey, IsUnique ) 
-                            VALUES (  '${entity.ID}', '${veField.FieldName}', '${veField.Type}', ${veField.AllowsNull ? 1 : 0}, 
+                            VALUES (  '${newEntityFieldUUID}', '${entity.ID}', '${veField.FieldName}', '${veField.Type}', ${veField.AllowsNull ? 1 : 0}, 
                                        ${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;
             }
         }
-        return { success: true, updatedField: didUpdate };
+        return { success: true, updatedField: didUpdate, newFieldID: newEntityFieldUUID };
     }
     /**
      * This method creates and updates relationships in the metadata based on foreign key relationships in the database.
@@ -392,15 +326,16 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                         // calculate the sequence by getting the count of existing relationships for the entity and adding 1 and then increment the count for future inserts in this loop
                         const relCount = relationshipCountMap.get(f.EntityID) || 0;
                         const sequence = relCount + 1;
-                        batchSQL += `INSERT INTO ${(0, config_1.mj_core_schema)()}.EntityRelationship (EntityID, RelatedEntityID, RelatedEntityJoinField, Type, BundleInAPI, DisplayInForm, DisplayName, Sequence) 
-                                          VALUES ('${f.RelatedEntityID}', '${f.EntityID}', '${f.Name}', 'One To Many', 1, 1, '${e.Name}', ${sequence});
+                        const newEntityRelationshipUUID = this.createNewUUID();
+                        batchSQL += `INSERT INTO ${(0, config_1.mj_core_schema)()}.EntityRelationship (ID, EntityID, RelatedEntityID, RelatedEntityJoinField, Type, BundleInAPI, DisplayInForm, DisplayName, Sequence) 
+                                          VALUES ('${newEntityRelationshipUUID}', '${f.RelatedEntityID}', '${f.EntityID}', '${f.Name}', 'One To Many', 1, 1, '${e.Name}', ${sequence});
                               `;
                         // now update the map for the relationship count
                         relationshipCountMap.set(f.EntityID, sequence);
                     }
                 });
                 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 +346,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 +367,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 +378,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 +388,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 +396,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 +410,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 +440,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 +522,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 +568,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 +584,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 +595,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 +615,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 +625,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 +669,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 +717,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 +764,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 +784,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;
         }
     }
@@ -941,7 +877,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
      * @param n - the new field
      * @returns
      */
-    getPendingEntityFieldINSERTSQL(n) {
+    getPendingEntityFieldINSERTSQL(newEntityFieldUUID, n) {
         const bDefaultInView = (n.FieldName?.trim().toLowerCase() === 'id' ||
             n.FieldName?.trim().toLowerCase() === 'name' ||
             n.Sequence <= config_1.configInfo.newEntityDefaults?.IncludeFirstNFieldsAsDefaultInView ||
@@ -965,6 +901,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         return `
       INSERT INTO [${(0, config_1.mj_core_schema)()}].EntityField
       (
+         ID,
          EntityID,
          Sequence,
          Name,
@@ -991,6 +928,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
       )
       VALUES
       (
+         '${newEntityFieldUUID}',
          '${n.EntityID}',
          ${n.Sequence},
          '${n.FieldName}',
@@ -1050,8 +988,9 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     if (n.EntityID !== null && n.EntityID !== undefined && n.EntityID.length > 0) {
                         // 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`);
+                        const newEntityFieldUUID = this.createNewUUID();
+                        const sSQLInsert = this.getPendingEntityFieldINSERTSQL(newEntityFieldUUID, n);
+                        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 +998,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 +1014,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;
         }
     }
@@ -1134,15 +1076,20 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                         // we have parsed values from the check constraint, so sync them with the entity field values
                         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}`);
+                        // check to see if the ValueListType is already set to "List", if not, update it
+                        const sSQLCheck = `SELECT ValueListType FROM [${(0, config_1.mj_core_schema)()}].EntityField WHERE ID='${r.EntityFieldID}'`;
+                        const checkResult = await ds.query(sSQLCheck);
+                        if (checkResult && checkResult.length > 0 && checkResult[0].ValueListType.trim().toLowerCase() !== 'list') {
+                            const sSQL = `UPDATE [${(0, config_1.mj_core_schema)()}].EntityField SET ValueListType='List' WHERE ID='${r.EntityFieldID}'`;
+                            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 +1105,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 +1118,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 +1129,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 +1137,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 +1148,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
@@ -1341,6 +1288,9 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
     simpleNewEntityName(tableName) {
         return this.convertCamelCaseToHaveSpaces(this.generatePluralName(tableName));
     }
+    createNewUUID() {
+        return (0, uuid_1.v4)();
+    }
     async createNewEntity(ds, newEntity, md) {
         try {
             const { shouldCreate, validationMessage } = await this.shouldCreateNewEntity(ds, newEntity);
@@ -1358,41 +1308,46 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     (0, core_1.LogError)(`   >>>> WARNING: Entity name already exists, so using ${newEntityName} instead. If you did not intend for this, please rename the ${newEntity.SchemaName}.${newEntity.TableName} table in the database.`);
                 }
                 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 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}`);
-                }
+                const newEntityID = this.createNewUUID();
+                const sSQLInsert = this.createNewEntityInsertSQL(newEntityID, newEntityName, newEntity, suffix);
+                await this.LogSQLAndExecute(ds, sSQLInsert, `SQL generated to create new entity ${newEntityName}`);
                 // if we get here we created a new entity safely, otherwise we get exception
                 // add it to the new entity list
                 ManageMetadataBase_1.newEntityList.push(newEntityName);
                 // next, check if this entity is in a schema that is new (e.g. no other entities have been added to this schema yet), if so and if 
                 // our config option is set to create new applications from new schemas, then create a new application for this schema
+                let appUUID = '';
                 if (isNewSchema && config_1.configInfo.newSchemaDefaults.CreateNewApplicationWithSchemaName) {
                     // new schema and config option is to create a new application from the schema name so do that
-                    if (!await this.applicationExists(ds, newEntity.SchemaName)) {
-                        await this.createNewApplication(ds, newEntity.SchemaName);
+                    // check to see if the app already exists
+                    appUUID = await this.getApplicationIDForSchema(ds, newEntity.SchemaName);
+                    if (!appUUID || appUUID.length === 0 || appUUID.trim().length === 0) {
+                        // doesn't already exist, so create it
+                        appUUID = this.createNewUUID();
+                        await this.createNewApplication(ds, appUUID, newEntity.SchemaName);
                         await md.Refresh(); // refresh now since we've added a new application, not super efficient to do this for each new application but that won't happen super 
-                        // often so not a huge deal, would be more efficient do this in batch after all new apps are created but taht would be an over optimization IMO
+                        // often so not a huge deal, would be more efficient do this in batch after all new apps are created but that would be an over optimization IMO
                     }
                 }
                 else {
                     // not a new schema, attempt to look up the application for this schema
-                    await this.getApplicationIDForSchema(ds, newEntity.SchemaName);
+                    appUUID = await this.getApplicationIDForSchema(ds, newEntity.SchemaName);
                 }
-                if (config_1.configInfo.newEntityDefaults.AddToApplicationWithSchemaName) {
-                    // we should add this entity to the application
-                    const appName = newEntity.SchemaName === (0, config_1.mj_core_schema)() ? 'Admin' : newEntity.SchemaName; // for the __mj schema or whatever it is installed as for mj_core - we want to drop stuff into the admin app
-                    const app = md.Applications.find(a => a.Name.trim().toLowerCase() === appName.trim().toLowerCase());
-                    if (app) {
+                if (appUUID && appUUID.length > 0) {
+                    if (config_1.configInfo.newEntityDefaults.AddToApplicationWithSchemaName) {
+                        // only do this if the configuration setting is set to add new entities to applications for schema names
                         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}`);
+                                    (ApplicationID, EntityID, Sequence) VALUES 
+                                    ('${appUUID}', '${newEntityID}', (SELECT ISNULL(MAX(Sequence),0)+1 FROM ${(0, config_1.mj_core_schema)()}.ApplicationEntity WHERE ApplicationID = '${appUUID}'))`;
+                        this.LogSQLAndExecute(ds, sSQLInsertApplicationEntity, `SQL generated to add new entity ${newEntityName} to application ID: '${appUUID}'`);
+                    }
+                    else {
+                        // this is NOT an error condition, we do have an application UUID, but the configuration setting is to NOT add new entities to applications for schema names
                     }
-                    else
-                        (0, core_1.LogError)(`   >>>> ERROR: Unable to find Application ID for application ${appName} to add new entity ${newEntityName} to it`);
+                }
+                else {
+                    // this is an error condition, we should have an application for this schema, if we don't, log an error, non fatal, but should be logged
+                    (0, core_1.LogError)(`   >>>> ERROR: Unable to add new entity ${newEntityName} to an application because an Application record for schema ${newEntity.SchemaName} does not exist.`);
                 }
                 // next up, we need to check if we're configured to add permissions for new entities, and if so, add them
                 if (config_1.configInfo.newEntityDefaults.PermissionDefaults && config_1.configInfo.newEntityDefaults.PermissionDefaults.AutoAddPermissionsForNewEntities) {
@@ -1404,7 +1359,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}`);
@@ -1427,9 +1382,9 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         const result = await ds.query(sSQL);
         return result && result.length > 0 ? result[0].Count === 0 : true;
     }
-    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}`);
+    async createNewApplication(ds, appID, appName) {
+        const sSQL = "INSERT INTO [" + (0, config_1.mj_core_schema)() + "].Application (ID, Name, Description) VALUES ('" + appID + "', '" + appName + "', 'Generated for schema')";
+        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) {
@@ -1442,12 +1397,12 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         const result = await ds.query(sSQL);
         return result && result.length > 0 ? result[0].ID : null;
     }
-    createNewEntityInsertSQL(newEntityName, newEntity, newEntitySuffix) {
+    createNewEntityInsertSQL(newEntityUUID, newEntityName, newEntity, newEntitySuffix) {
         const newEntityDefaults = config_1.configInfo.newEntityDefaults;
         const newEntityDescriptionEscaped = newEntity.Description ? `'${newEntity.Description.replace(/'/g, "''")}` : null;
         const sSQLInsert = `    
-      DECLARE @InsertedRow TABLE ([ID] UNIQUEIDENTIFIER)
       INSERT INTO [${(0, config_1.mj_core_schema)()}].Entity (
+         ID,
          Name, 
          Description,
          NameSuffix,
@@ -1465,8 +1420,8 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
          ${newEntityDefaults.AllowDeleteAPI === undefined ? '' : ', AllowDeleteAPI'}
          ${newEntityDefaults.UserViewMaxRows === undefined ? '' : ', UserViewMaxRows'}
       ) 
-      OUTPUT INSERTED.[ID] INTO @InsertedRow
       VALUES (
+         '${newEntityUUID}',
          '${newEntityName}', 
          ${newEntityDescriptionEscaped ? newEntityDescriptionEscaped : 'NULL' /*if no description, then null*/},
          ${newEntitySuffix && newEntitySuffix.length > 0 ? `'${newEntitySuffix}'` : 'NULL'},
@@ -1484,7 +1439,6 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
          ${newEntityDefaults.AllowDeleteAPI === undefined ? '' : ', ' + (newEntityDefaults.AllowDeleteAPI ? '1' : '0')}
          ${newEntityDefaults.UserViewMaxRows === undefined ? '' : ', ' + (newEntityDefaults.UserViewMaxRows)}
       )
-      SELECT * FROM [__mj].vwEntities WHERE [ID] = (SELECT [ID] FROM @InsertedRow)
    `;
         return sSQLInsert;
     }
@@ -1551,15 +1505,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;