@memberjunction/codegen-lib 2.13.1 → 2.13.3

package/dist/Database/manage-metadata.js

@@ -91,9 +91,13 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         start = new Date();
         (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)) {
+        const adminSchema = (0, config_1.getSettingValue)('mj_core_schema', '__mj');
+        const schemasToExclude = (0, config_1.getSettingValue)('recompile_mj_views', true)
+            ? excludeSchemas.filter((s) => s !== adminSchema)
+            : excludeSchemas;
+        if (!await sqlUtility.recompileAllBaseViews(ds, schemasToExclude, true)) {
             (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 
+            // many times the former versions of base views will NOT succesfully recompile, so don't consider that scenario to be a
             // failure for this entire function
         }
         (0, status_logging_1.logStatus)(`    > Recompiled base views in ${(new Date().getTime() - start.getTime()) / 1000} seconds`);
@@ -148,16 +152,16 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         try {
             // for a given virtual entity, we need to loop through the fields that exist in the current SQL definition for the view
             // and add/update/delete the entity fields to match what's in the view
-            const sql = `  SELECT 
+            const sql = `  SELECT
                            c.name AS FieldName, t.name AS Type, c.max_length AS Length, c.precision Precision, c.scale Scale, c.is_nullable AllowsNull
-                        FROM 
+                        FROM
                            sys.columns c
-                        INNER JOIN 
+                        INNER JOIN
                            sys.types t ON c.user_type_id = t.user_type_id
-                        INNER JOIN 
+                        INNER JOIN
                            sys.views v ON c.object_id = v.object_id
-                        WHERE 
-                           v.name = '${virtualEntity.BaseView}' AND 
+                        WHERE
+                           v.name = '${virtualEntity.BaseView}' AND
                            SCHEMA_NAME(v.schema_id) = '${virtualEntity.SchemaName}'
                         ORDER BY
                            c.column_id`;
@@ -226,17 +230,17 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     field.Precision !== veField.Precision ||
                     field.Sequence !== fieldSequence) {
                     // the field needs to be updated, so update it
-                    const sqlUpdate = `UPDATE 
-                                    [${(0, config_1.mj_core_schema)()}].EntityField 
-                                  SET 
+                    const sqlUpdate = `UPDATE
+                                    [${(0, config_1.mj_core_schema)()}].EntityField
+                                  SET
                                     Sequence=${fieldSequence},
-                                    Type='${veField.Type}', 
+                                    Type='${veField.Type}',
                                     AllowsNull=${veField.AllowsNull ? 1 : 0},
                                     ${makePrimaryKey ? 'IsPrimaryKey=1,IsUnique=1,' : ''}
                                     Length=${veField.Length},
                                     Precision=${veField.Precision},
                                     Scale=${veField.Scale}
-                                  WHERE 
+                                  WHERE
                                     ID = '${field.ID}'`; // don't need to update the __mj_UpdatedAt field here, that happens automatically via the trigger
                     await this.LogSQLAndExecute(ds, sqlUpdate, `SQL text to update virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
                     didUpdate = true;
@@ -246,10 +250,10 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 // 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 (
-                                      ID, EntityID, Name, Type, AllowsNull, 
-                                      Length, Precision, Scale, 
-                                      Sequence, IsPrimaryKey, IsUnique ) 
-                            VALUES (  '${newEntityFieldUUID}', '${entity.ID}', '${veField.FieldName}', '${veField.Type}', ${veField.AllowsNull ? 1 : 0}, 
+                                      ID, EntityID, Name, Type, AllowsNull,
+                                      Length, Precision, Scale,
+                                      Sequence, IsPrimaryKey, IsUnique )
+                            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}
                                     )`;
@@ -280,10 +284,10 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
      * @returns
      */
     async manageOneToManyEntityRelationships(ds, excludeSchemas, md, batchItems = 5) {
-        // the way this works is that we look for entities in our catalog and we look for 
+        // the way this works is that we look for entities in our catalog and we look for
         // foreign keys in those entities. For example, if we saw an entity called Persons and that entity
         // had a foreign key linking to an entity called Organizations via a field called OrganizationID, then we would create a relationship
-        // record in the EntityRelationship table for that relationships. In that example we would create the 
+        // record in the EntityRelationship table for that relationships. In that example we would create the
         // relationship record with the following values:
         //   EntityID = ID of Organizations entity
         //   RelatedEntityID = ID of Persons entity
@@ -294,11 +298,11 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         //   DisplayName = Persons (name of the entity)
         try {
             // STEP 1 - search for all foreign keys in the vwEntityFields view, we use the RelatedEntityID field to determine our FKs
-            const sSQL = `SELECT * 
-                       FROM ${(0, config_1.mj_core_schema)()}.vwEntityFields 
-                       WHERE 
-                             RelatedEntityID IS NOT NULL AND 
-                             IsVirtual = 0 AND 
+            const sSQL = `SELECT *
+                       FROM ${(0, config_1.mj_core_schema)()}.vwEntityFields
+                       WHERE
+                             RelatedEntityID IS NOT NULL AND
+                             IsVirtual = 0 AND
                              EntityID NOT IN (SELECT ID FROM ${(0, config_1.mj_core_schema)()}.Entity WHERE SchemaName IN (${excludeSchemas.map(s => `'${s}'`).join(',')}))
                        ORDER BY RelatedEntityID`;
             const entityFields = await ds.query(sSQL);
@@ -325,7 +329,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                         const relCount = relationshipCountMap.get(f.EntityID) || 0;
                         const sequence = relCount + 1;
                         const newEntityRelationshipUUID = this.createNewUUID();
-                        batchSQL += `INSERT INTO ${(0, config_1.mj_core_schema)()}.EntityRelationship (ID, EntityID, RelatedEntityID, RelatedEntityJoinField, Type, BundleInAPI, DisplayInForm, DisplayName, Sequence) 
+                        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
@@ -360,14 +364,14 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             const entities = await ds.query(sql);
             if (entities && entities.length > 0) {
                 for (const e of entities) {
-                    // for the given entity, wipe out the entity metadata and its core deps. 
+                    // for the given entity, wipe out the entity metadata and its core deps.
                     // the below could fail if there are non-core dependencies on the entity, but that's ok, we will flag that in the console
                     // for the admin to handle manually
                     try {
                         const sqlDelete = `__mj.spDeleteEntityWithCoreDependencies @EntityID='${e.ID}'`;
                         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. 
+                        // 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);
                         await this.checkDropSQLObject(ds, e.spCreateGenerated, 'procedure', e.SchemaName, e.spCreate ? e.spCreate : `spCreate${e.ClassName}`);
@@ -490,22 +494,22 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
      */
     async ensureDeletedAtFieldsExist(ds, excludeSchemas) {
         try {
-            const sqlEntities = `SELECT 
-                                 * 
-                              FROM 
-                                 [${(0, config_1.mj_core_schema)()}].vwEntities 
-                              WHERE 
-                                 VirtualEntity=0 AND 
-                                 DeleteType='Soft' AND 
+            const sqlEntities = `SELECT
+                                 *
+                              FROM
+                                 [${(0, config_1.mj_core_schema)()}].vwEntities
+                              WHERE
+                                 VirtualEntity=0 AND
+                                 DeleteType='Soft' AND
                                  SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})`;
             const entities = await ds.query(sqlEntities);
             let overallResult = true;
             if (entities.length > 0) {
                 // we have 1+ entities that need the special fields, so loop through them and ensure the fields exist
                 // validate that each entity has the __mj_DeletedAt field, and it is a DATETIMEOFFSET fields, NOT NULL and both are fields that have a DEFAULT value of GETUTCDATE().
-                const sql = `SELECT * 
+                const sql = `SELECT *
                          FROM INFORMATION_SCHEMA.COLUMNS
-                         WHERE 
+                         WHERE
                          ${entities.map((e) => `(TABLE_SCHEMA='${e.SchemaName}' AND TABLE_NAME='${e.BaseTable}')`).join(' OR ')}
                          AND COLUMN_NAME='${core_1.EntityInfo.DeletedAtFieldName}'`;
                 const result = await ds.query(sql);
@@ -532,13 +536,13 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
      */
     async ensureCreatedAtUpdatedAtFieldsExist(ds, excludeSchemas) {
         try {
-            const sqlEntities = `SELECT 
-                                 * 
-                              FROM 
-                                 [${(0, config_1.mj_core_schema)()}].vwEntities 
-                              WHERE 
-                                 VirtualEntity = 0 AND 
-                                 TrackRecordChanges = 1 AND 
+            const sqlEntities = `SELECT
+                                 *
+                              FROM
+                                 [${(0, config_1.mj_core_schema)()}].vwEntities
+                              WHERE
+                                 VirtualEntity = 0 AND
+                                 TrackRecordChanges = 1 AND
                                  SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})`;
             const entities = await ds.query(sqlEntities);
             let overallResult = true;
@@ -546,9 +550,9 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 // we have 1+ entities that need the special fields, so loop through them and ensure the fields exist
                 // validate that each entity has two specific fields, the first one is __mj_CreatedAt and the second one is __mj_UpdatedAt
                 // both are DATETIME fields, NOT NULL and both are fields that have a DEFAULT value of GETUTCDATE().
-                const sqlCreatedUpdated = `SELECT * 
+                const sqlCreatedUpdated = `SELECT *
                                        FROM INFORMATION_SCHEMA.COLUMNS
-                                       WHERE 
+                                       WHERE
                                           ${entities.map((e) => `(TABLE_SCHEMA='${e.SchemaName}' AND TABLE_NAME='${e.BaseTable}')`).join(' OR ')}
                                        AND COLUMN_NAME IN ('${core_1.EntityInfo.CreatedAtFieldName}','${core_1.EntityInfo.UpdatedAtFieldName}')`;
                 const result = await ds.query(sqlCreatedUpdated);
@@ -589,7 +593,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 if (currentFieldData.DATA_TYPE.trim().toLowerCase() !== 'datetimeoffset' ||
                     (currentFieldData.IS_NULLABLE.trim().toLowerCase() !== 'no' && !allowNull) ||
                     (currentFieldData.IS_NULLABLE.trim().toLowerCase() === 'no' && allowNull)) {
-                    // the column is the wrong type, or has wrong nullability attribute, so let's update it, first removing the default constraint, then 
+                    // the column is the wrong type, or has wrong nullability attribute, so let's update it, first removing the default constraint, then
                     // 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'}`;
@@ -657,8 +661,8 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
          JOIN sys.schemas s ON t.schema_id = s.schema_id
          JOIN sys.columns c ON t.object_id = c.object_id
          JOIN sys.default_constraints d ON c.default_object_id = d.object_id
-         WHERE s.name = '${entity.SchemaName}' 
-         AND t.name = '${entity.BaseTable}' 
+         WHERE s.name = '${entity.SchemaName}'
+         AND t.name = '${entity.BaseTable}'
          AND c.name = '${fieldName}';
 
          -- Drop the default constraint if it exists
@@ -692,10 +696,10 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
             for (let e of ManageMetadataBase_1.newEntityList) {
                 const data = await ds.query(`SELECT * FROM [${(0, config_1.mj_core_schema)()}].vwEntities WHERE Name = '${e}'`);
                 const fields = await ds.query(`SELECT * FROM [${(0, config_1.mj_core_schema)()}].vwEntityFields WHERE EntityID='${data[0].ID}'`);
-                const entityUserMessage = userMessage + `Entity Name: ${e}, 
-                                                     Base Table: ${data[0].BaseTable}, 
-                                                     Schema: ${data[0].SchemaName}. 
-                                                     Fields: 
+                const entityUserMessage = userMessage + `Entity Name: ${e},
+                                                     Base Table: ${data[0].BaseTable},
+                                                     Schema: ${data[0].SchemaName}.
+                                                     Fields:
                                                      ${fields.map((f) => `   ${f.Name}: ${f.Type}`).join('\n')}`;
                 const result = await llm.ChatCompletion({
                     model: ag.AIModel,
@@ -742,16 +746,16 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
      */
     async updateEntityFieldDisplayNameWhereNull(ds, excludeSchemas) {
         try {
-            const sql = `SELECT 
-                        ef.ID, ef.Name 
-                      FROM 
+            const sql = `SELECT
+                        ef.ID, ef.Name
+                      FROM
                         [${(0, config_1.mj_core_schema)()}].vwEntityFields ef
                       INNER JOIN
                         [${(0, config_1.mj_core_schema)()}].vwEntities e
                       ON
                         ef.EntityID = e.ID
-                      WHERE 
-                        ef.DisplayName IS NULL AND 
+                      WHERE
+                        ef.DisplayName IS NULL AND
                         ef.DisplayName <> ef.Name AND
                         ef.Name <> \'ID\' AND
                         e.SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})
@@ -797,7 +801,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
      */
     getPendingEntityFieldsSELECTSQL() {
         const sSQL = `WITH NumberedRows AS (
-   SELECT 
+   SELECT
       sf.EntityID,
       sf.Sequence,
       sf.FieldName,
@@ -809,31 +813,31 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
       sf.AllowsNull,
       sf.DefaultValue,
       sf.AutoIncrement,
-      IIF(sf.IsVirtual = 1, 0, IIF(sf.FieldName = '${core_1.EntityInfo.CreatedAtFieldName}' OR 
-                                   sf.FieldName = '${core_1.EntityInfo.UpdatedAtFieldName}' OR 
-                                   sf.FieldName = '${core_1.EntityInfo.DeletedAtFieldName}' OR 
+      IIF(sf.IsVirtual = 1, 0, IIF(sf.FieldName = '${core_1.EntityInfo.CreatedAtFieldName}' OR
+                                   sf.FieldName = '${core_1.EntityInfo.UpdatedAtFieldName}' OR
+                                   sf.FieldName = '${core_1.EntityInfo.DeletedAtFieldName}' OR
                                    pk.ColumnName IS NOT NULL, 0, 1)) AllowUpdateAPI,
       sf.IsVirtual,
       e.RelationshipDefaultDisplayType,
       re.ID RelatedEntityID,
       fk.referenced_column RelatedEntityFieldName,
       IIF(sf.FieldName = 'Name', 1, 0) IsNameField,
-      IsPrimaryKey =	CASE 
-            WHEN pk.ColumnName IS NOT NULL THEN 1 
-            ELSE 0 
+      IsPrimaryKey =	CASE
+            WHEN pk.ColumnName IS NOT NULL THEN 1
+            ELSE 0
          END,
-      IsUnique =		CASE 
-            WHEN pk.ColumnName IS NOT NULL THEN 1 
-            ELSE 
-               CASE 
-                  WHEN uk.ColumnName IS NOT NULL THEN 1 
-                  ELSE 0 
-               END 
+      IsUnique =		CASE
+            WHEN pk.ColumnName IS NOT NULL THEN 1
+            ELSE
+               CASE
+                  WHEN uk.ColumnName IS NOT NULL THEN 1
+                  ELSE 0
+               END
          END,
       ROW_NUMBER() OVER (PARTITION BY sf.EntityID, sf.FieldName ORDER BY (SELECT NULL)) AS rn
    FROM
       [${(0, config_1.mj_core_schema)()}].vwSQLColumnsAndEntityFields sf
-   LEFT OUTER JOIN	
+   LEFT OUTER JOIN
       [${(0, config_1.mj_core_schema)()}].Entity e
    ON
       sf.EntityID = e.ID
@@ -843,18 +847,18 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
       sf.FieldName = fk.[column] AND
       e.BaseTable = fk.[table] AND
       e.SchemaName = fk.[schema_name]
-   LEFT OUTER JOIN 
+   LEFT OUTER JOIN
       [${(0, config_1.mj_core_schema)()}].Entity re -- Related Entity
    ON
       re.BaseTable = fk.referenced_table AND
       re.SchemaName = fk.[referenced_schema]
-   LEFT OUTER JOIN 
+   LEFT OUTER JOIN
       [${(0, config_1.mj_core_schema)()}].vwTablePrimaryKeys pk
    ON
       e.BaseTable = pk.TableName AND
       sf.FieldName = pk.ColumnName AND
       e.SchemaName = pk.SchemaName
-   LEFT OUTER JOIN 
+   LEFT OUTER JOIN
       [${(0, config_1.mj_core_schema)()}].vwTableUniqueKeys uk
    ON
       e.BaseTable = uk.TableName AND
@@ -863,10 +867,10 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
    WHERE
       EntityFieldID IS NULL -- only where we have NOT YET CREATED EntityField records\n${this.createExcludeTablesAndSchemasFilter('sf.')}
    )
-   SELECT 
-      * 
-   FROM 
-      NumberedRows -- REMOVED - Need all fkey fields WHERE rn = 1 -- if someone has two foreign keys with same to/from table and field name this makes sure we only get the field info ONCE 
+   SELECT
+      *
+   FROM
+      NumberedRows -- REMOVED - Need all fkey fields WHERE rn = 1 -- if someone has two foreign keys with same to/from table and field name this makes sure we only get the field info ONCE
    ORDER BY EntityID, Sequence`;
         return sSQL;
     }
@@ -984,12 +988,12 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 for (let i = 0; i < newEntityFields.length; ++i) {
                     const n = newEntityFields[i];
                     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 
+                        // 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 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   
+                        // if we get here, we're okay, otherwise we have an exception, which we want as it blows up transaction
                     }
                 }
             });
@@ -1009,7 +1013,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
      */
     async updateEntityFieldRelatedEntityNameFieldMap(ds, entityFieldID, relatedEntityNameFieldMap) {
         try {
-            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spUpdateEntityFieldRelatedEntityNameFieldMap 
+            const sSQL = `EXEC [${(0, config_1.mj_core_schema)()}].spUpdateEntityFieldRelatedEntityNameFieldMap
          @EntityFieldID='${entityFieldID}',
          @RelatedEntityNameFieldMap='${relatedEntityNameFieldMap}'`;
             await this.LogSQLAndExecute(ds, sSQL, `SQL text to update entity field related entity name field map for entity field ID ${entityFieldID}`);
@@ -1055,9 +1059,9 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
     }
     async manageEntityFieldValues(ds, excludeSchemas) {
         try {
-            // here we want to get all of the entity fields that have check constraints attached to them. For each field that has a check constraint, we want to 
+            // here we want to get all of the entity fields that have check constraints attached to them. For each field that has a check constraint, we want to
             // evaluate it to see if it is a simple series of OR statements or not, if it is a simple series of OR statements, we can parse the possible values
-            // for the field and sync that up with the EntityFieldValue table. If it is not a simple series of OR statements, we will not be able to parse it and we'll 
+            // for the field and sync that up with the EntityFieldValue table. If it is not a simple series of OR statements, we will not be able to parse it and we'll
             // just ignore it.
             const filter = excludeSchemas && excludeSchemas.length > 0 ? ` WHERE SchemaName NOT IN (${excludeSchemas.map(s => `'${s}'`).join(',')})` : '';
             const sSQL = `SELECT * FROM [${(0, config_1.mj_core_schema)()}].vwEntityFieldsWithCheckConstraints${filter}`;
@@ -1112,9 +1116,9 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 for (const v of possibleValues) {
                     if (!existingValues.find((ev) => ev.Value === v)) {
                         // add the value to the database
-                        const sSQLInsert = `INSERT INTO [${(0, config_1.mj_core_schema)()}].EntityFieldValue 
-                                       (EntityFieldID, Sequence, Value, Code) 
-                                    VALUES 
+                        const sSQLInsert = `INSERT INTO [${(0, config_1.mj_core_schema)()}].EntityFieldValue
+                                       (EntityFieldID, Sequence, Value, Code)
+                                    VALUES
                                        ('${entityFieldID}', ${1 + possibleValues.indexOf(v)}, '${v}', '${v}')`;
                         await this.LogSQLAndExecute(ds, sSQLInsert, `SQL text to insert entity field values`);
                         numAdded++;
@@ -1207,7 +1211,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 if (ManageMetadataBase_1.newEntityList.length > 0) {
                     // only do this if we actually created new entities
                     (0, core_1.LogStatus)(`   Done creating entities, refreshing metadata to reflect new entities...`);
-                    await md.Refresh(); // refresh now since we've added some new entities   
+                    await md.Refresh(); // refresh now since we've added some new entities
                 }
             }
             return true; // if we get here, we succeeded
@@ -1293,7 +1297,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
         try {
             const { shouldCreate, validationMessage } = await this.shouldCreateNewEntity(ds, newEntity);
             if (shouldCreate) {
-                // process a single new entity 
+                // process a single new entity
                 let newEntityName = await this.createNewEntityName(newEntity);
                 let suffix = '';
                 const existingEntity = md.Entities.find(e => e.Name === newEntityName);
@@ -1312,7 +1316,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 // 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 
+                // 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) {
@@ -1323,7 +1327,7 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                         // 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 
+                        await md.Refresh(); // refresh now since we've added a new application, not super efficient to do this for each new application but that won't happen super
                         // often so not a huge deal, would be more efficient do this in batch after all new apps are created but that would be an over optimization IMO
                     }
                 }
@@ -1334,8 +1338,8 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                 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 
+                        const sSQLInsertApplicationEntity = `INSERT INTO ${(0, config_1.mj_core_schema)()}.ApplicationEntity
+                                    (ApplicationID, EntityID, Sequence) VALUES
                                     ('${appUUID}', '${newEntityID}', (SELECT ISNULL(MAX(Sequence),0)+1 FROM ${(0, config_1.mj_core_schema)()}.ApplicationEntity WHERE ApplicationID = '${appUUID}'))`;
                         await this.LogSQLAndExecute(ds, sSQLInsertApplicationEntity, `SQL generated to add new entity ${newEntityName} to application ID: '${appUUID}'`);
                     }
@@ -1354,8 +1358,8 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
                     for (const p of permissions) {
                         const RoleID = md.Roles.find(r => r.Name.trim().toLowerCase() === p.RoleName.trim().toLowerCase())?.ID;
                         if (RoleID) {
-                            const sSQLInsertPermission = `INSERT INTO ${(0, config_1.mj_core_schema)()}.EntityPermission 
-                                                   (EntityID, RoleID, CanRead, CanCreate, CanUpdate, CanDelete) VALUES 
+                            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.LogSQLAndExecute(ds, sSQLInsertPermission, `SQL generated to add new permission for entity ${newEntityName} for role ${p.RoleName}`);
                         }
@@ -1398,16 +1402,16 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
     createNewEntityInsertSQL(newEntityUUID, newEntityName, newEntity, newEntitySuffix) {
         const newEntityDefaults = config_1.configInfo.newEntityDefaults;
         const newEntityDescriptionEscaped = newEntity.Description ? `'${newEntity.Description.replace(/'/g, "''")}` : null;
-        const sSQLInsert = `    
+        const sSQLInsert = `
       INSERT INTO [${(0, config_1.mj_core_schema)()}].Entity (
          ID,
-         Name, 
+         Name,
          Description,
          NameSuffix,
-         BaseTable, 
-         BaseView, 
-         SchemaName, 
-         IncludeInAPI, 
+         BaseTable,
+         BaseView,
+         SchemaName,
+         IncludeInAPI,
          AllowUserSearchAPI
          ${newEntityDefaults.TrackRecordChanges === undefined ? '' : ', TrackRecordChanges'}
          ${newEntityDefaults.AuditRecordAccess === undefined ? '' : ', AuditRecordAccess'}
@@ -1417,16 +1421,16 @@ let ManageMetadataBase = ManageMetadataBase_1 = class ManageMetadataBase {
          ${newEntityDefaults.AllowUpdateAPI === undefined ? '' : ', AllowUpdateAPI'}
          ${newEntityDefaults.AllowDeleteAPI === undefined ? '' : ', AllowDeleteAPI'}
          ${newEntityDefaults.UserViewMaxRows === undefined ? '' : ', UserViewMaxRows'}
-      ) 
+      )
       VALUES (
          '${newEntityUUID}',
-         '${newEntityName}', 
+         '${newEntityName}',
          ${newEntityDescriptionEscaped ? newEntityDescriptionEscaped : 'NULL' /*if no description, then null*/},
          ${newEntitySuffix && newEntitySuffix.length > 0 ? `'${newEntitySuffix}'` : 'NULL'},
-         '${newEntity.TableName}', 
-         'vw${this.generatePluralName(newEntity.TableName) + (newEntitySuffix && newEntitySuffix.length > 0 ? newEntitySuffix : '')}', 
+         '${newEntity.TableName}',
+         'vw${this.generatePluralName(newEntity.TableName) + (newEntitySuffix && newEntitySuffix.length > 0 ? newEntitySuffix : '')}',
          '${newEntity.SchemaName}',
-         1, 
+         1,
          ${newEntityDefaults.AllowUserSearchAPI === undefined ? 1 : newEntityDefaults.AllowUserSearchAPI ? 1 : 0}
          ${newEntityDefaults.TrackRecordChanges === undefined ? '' : ', ' + (newEntityDefaults.TrackRecordChanges ? '1' : '0')}
          ${newEntityDefaults.AuditRecordAccess === undefined ? '' : ', ' + (newEntityDefaults.AuditRecordAccess ? '1' : '0')}