@memberjunction/codegen-lib 1.8.1 → 2.1.0

package/dist/Database/sql_codegen.js

@@ -74,34 +74,39 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             const baselineEntities = entities.filter(e => e.IncludeInAPI);
             const includedEntities = baselineEntities.filter(e => config_1.configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) === undefined); //only include entities that are NOT in the excludeSchemas list
             const excludedEntities = baselineEntities.filter(e => config_1.configInfo.excludeSchemas.find(s => s.toLowerCase() === e.SchemaName.toLowerCase()) !== undefined); //only include entities that ARE in the excludeSchemas list in this array
-            // STEP 2(a) - generate all the SQL files and execute them
+            // STEP 2(a) - clean out all *.generated.sql and *.permissions.generated.sql files from the directory
+            this.deleteGeneratedEntityFiles(directory, baselineEntities);
+            // STEP 2(b) - generate all the SQL files and execute them
             const step2StartTime = new Date();
-            if (!await this.generateAndExecuteEntitySQLToSeparateFiles(ds, includedEntities, directory, false)) {
-                (0, logging_1.logError)('Error generating and executing all entities SQL to separate files');
+            const genResult = await this.generateAndExecuteEntitySQLToSeparateFiles(ds, includedEntities, directory, false, true);
+            if (!genResult.Success) {
+                (0, logging_1.logError)('Error generating all entities SQL to separate files');
                 return false;
             }
-            // STEP 2(b) - for the excludedEntities, while we don't want to generate SQL, we do want to generate the permissions files for them
-            if (!await this.generateAndExecuteEntitySQLToSeparateFiles(ds, excludedEntities, directory, true)) {
-                (0, logging_1.logError)('Error generating and executing permissions SQL for excluded entities to separate files');
+            // STEP 2(c) - for the excludedEntities, while we don't want to generate SQL, we do want to generate the permissions files for them
+            const genResult2 = await this.generateAndExecuteEntitySQLToSeparateFiles(ds, excludedEntities, directory, true, true);
+            if (!genResult2.Success) {
+                (0, logging_1.logError)('Error generating permissions SQL for excluded entities to separate files');
                 return false;
             }
-            (0, logging_1.logStatus)(`   Time to Generate/Execute Entity SQL: ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
-            // now that we've generated the SQL, let's create a combined file in each schema sub-directory for convenience for a DBA
-            this.createCombinedEntitySQLFiles(directory, baselineEntities);
+            (0, logging_1.logStatus)(`   Time to generate entity SQL: ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
+            // STEP 2(d) now that we've generated the SQL, let's create a combined file in each schema sub-directory for convenience for a DBA
+            const allEntityFiles = this.createCombinedEntitySQLFiles(directory, baselineEntities);
+            // STEP 2(e) ---- FINALLY, we now execute all the combined files by schema;
+            const step2eStartTime = new Date();
+            if (!await this.SQLUtilityObject.executeSQLFiles(allEntityFiles, true)) {
+                (0, logging_1.logError)('Error executing combined entity SQL files');
+                return false;
+            }
+            const step2eEndTime = new Date();
+            (0, logging_1.logStatus)(`   Time to Execute Combined Entity SQL: ${(step2eEndTime.getTime() - step2eStartTime.getTime()) / 1000} seconds`);
             const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.ManageMetadataBase);
             // STEP 3 - re-run the process to manage entity fields since the Step 1 and 2 above might have resulted in differences in base view columns compared to what we had at first
-            if (!await manageMD.manageEntityFields(ds, config_1.configInfo.excludeSchemas, true)) {
+            // we CAN skip the entity field values part because that wouldn't change from the first time we ran it
+            if (!await manageMD.manageEntityFields(ds, config_1.configInfo.excludeSchemas, true, true)) {
                 (0, logging_1.logError)('Error managing entity fields');
                 return false;
             }
-            // no logStatus/timer for this because manageEntityFields() has its own internal logging for this including the total, so it is redundant to log it here
-            // STEP 4- Apply permissions, executing all .permissions files
-            const step4StartTime = new Date();
-            if (!await this.applyPermissions(ds, directory, baselineEntities)) {
-                (0, logging_1.logError)('Error applying permissions');
-                return false;
-            }
-            (0, logging_1.logStatus)(`   Time to Apply Permissions: ${(new Date().getTime() - step4StartTime.getTime()) / 1000} seconds`);
             // STEP 5 - execute any custom SQL scripts that should run afterwards
             const step5StartTime = new Date();
             if (!await this.runCustomSQLScripts(ds, 'after-sql'))
@@ -125,7 +130,7 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             if (scripts) {
                 for (let i = 0; i < scripts.length; ++i) {
                     const s = scripts[i];
-                    if (!await this.SQLUtilityObject.executeSQLFile(ds, s.scriptFile, true)) {
+                    if (!await this.SQLUtilityObject.executeSQLFile(s.scriptFile)) {
                         (0, logging_1.logError)(`Error executing custom '${when}' SQL script ${s.scriptFile}`);
                         bSuccess = false; // keep going if we have more scripts, but make sure we return false
                     }
@@ -150,7 +155,7 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                     for (const f of files) {
                         const fullPath = path_1.default.join(directory, f);
                         if (fs.existsSync(fullPath)) {
-                            if (!await this.SQLUtilityObject.executeSQLFile(ds, fullPath, true))
+                            if (!await this.SQLUtilityObject.executeSQLFile(fullPath))
                                 innerSuccess = false; // we keep going, just note that something failed
                         }
                         else {
@@ -181,7 +186,8 @@ let SQLCodeGenBase = class SQLCodeGenBase {
      * @param directory The directory to save the generated SQL files to
      * @param onlyPermissions If true, only the permissions files will be generated and executed, not the actual SQL files. Use this if you are simply setting permission changes but no actual changes to the entities have occured.
      */
-    async generateAndExecuteEntitySQLToSeparateFiles(ds, entities, directory, onlyPermissions, writeFiles = true, batchSize = 5) {
+    async generateAndExecuteEntitySQLToSeparateFiles(ds, entities, directory, onlyPermissions, skipExecution = false, writeFiles = true, batchSize = 5) {
+        const files = [];
         try {
             let bFail = false;
             const totalEntities = entities.length;
@@ -191,46 +197,80 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                     const pkeyField = e.Fields.find(f => f.IsPrimaryKey);
                     if (!pkeyField) {
                         (0, logging_1.logError)(`SKIPPING ENTITY: Entity ${e.Name}, because it does not have a primary key field defined. A table must have a primary key defined to quality to be a MemberJunction entity`);
-                        return false;
+                        return { Success: false, Files: [] };
                     }
-                    return this.generateAndExecuteSingleEntitySQLToSeparateFiles(ds, e, directory, onlyPermissions, writeFiles);
+                    return this.generateAndExecuteSingleEntitySQLToSeparateFiles(ds, e, directory, onlyPermissions, skipExecution, writeFiles);
                 });
                 const results = await Promise.all(promises);
-                if (results.includes(false)) {
-                    bFail = true; // keep going, but will return false at the end
-                }
+                results.forEach(r => {
+                    if (!r.Success)
+                        bFail = true; // keep going, but will return false at the end
+                    files.push(...r.Files); // add the files to the main files array
+                });
             }
-            return !bFail;
+            return { Success: !bFail, Files: files };
         }
         catch (err) {
             (0, logging_1.logError)(err);
-            return false;
+            return { Success: false, Files: files };
         }
     }
-    async createCombinedEntitySQLFiles(directory, entities) {
+    deleteGeneratedEntityFiles(directory, entities) {
+        try {
+            // for the schemas associated with the specified entities, clean out all the generated files
+            const schemaNames = entities.map(e => e.SchemaName).filter((value, index, self) => self.indexOf(value) === index);
+            for (const s of schemaNames) {
+                const fullPath = path_1.default.join(directory, s);
+                // now, within each schema directory, clean out all the generated files
+                // the generated files map this pattern: *.generated.sql or *.permissions.generated.sql
+                if (fs.statSync(fullPath).isDirectory()) {
+                    const files = fs.readdirSync(fullPath).filter(f => f.endsWith('.generated.sql') || f.endsWith('.permissions.generated.sql'));
+                    for (const f of files) {
+                        const filePath = path_1.default.join(fullPath, f);
+                        fs.unlinkSync(filePath);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            (0, logging_1.logError)(e);
+        }
+    }
+    createCombinedEntitySQLFiles(directory, entities) {
         // first, get a disinct list of schemanames from the entities
+        const files = [];
         const schemaNames = entities.map(e => e.SchemaName).filter((value, index, self) => self.indexOf(value) === index);
         for (const s of schemaNames) {
             // generate the all-entities.sql file and all-entities.permissions.sql file in each schema folder
             const fullPath = path_1.default.join(directory, s);
             if (fs.statSync(fullPath).isDirectory()) {
                 (0, util_1.combineFiles)(fullPath, '_all_entities.sql', '*.generated.sql', true);
+                files.push(path_1.default.join(fullPath, '_all_entities.sql'));
                 (0, util_1.combineFiles)(fullPath, '_all_entities.permissions.sql', '*.permissions.generated.sql', true);
+                files.push(path_1.default.join(fullPath, '_all_entities.permissions.sql'));
             }
         }
+        return files;
     }
-    async generateAndExecuteSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions, writeFiles = true) {
+    async generateAndExecuteSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions, skipExecution = false, writeFiles = true) {
         try {
-            const { sql, permissionsSQL } = await this.generateSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions, writeFiles); // this creates the files and returns a single string with all the SQL we can then execute
-            return await this.SQLUtilityObject.executeSQLScript(ds, sql, true) &&
-                await this.SQLUtilityObject.executeSQLScript(ds, permissionsSQL, true);
+            const { sql, permissionsSQL, files } = await this.generateSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions, skipExecution, writeFiles); // this creates the files and returns a single string with all the SQL we can then execute
+            if (!skipExecution) {
+                return {
+                    Success: await this.SQLUtilityObject.executeSQLScript(ds, sql + "\n\nGO\n\n" + permissionsSQL, true), // combine the SQL and permissions and execute it,
+                    Files: files
+                };
+            }
+            else
+                return { Success: true, Files: files };
         }
         catch (err) {
             (0, logging_1.logError)(err);
-            return false;
+            return { Success: false, Files: [] };
         }
     }
-    async generateSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions, writeFiles = true) {
+    async generateSingleEntitySQLToSeparateFiles(ds, entity, directory, onlyPermissions, skipExecution = false, writeFiles = true) {
+        const files = [];
         try {
             // create the directory if it doesn't exist
             if (writeFiles && !fs.existsSync(directory))
@@ -246,16 +286,21 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                 // generate the base view
                 const s = this.generateSingleEntitySQLFileHeader(entity, entity.BaseView) + await this.generateBaseView(ds, entity);
                 const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('view', entity.SchemaName, entity.BaseView, false, true));
-                if (writeFiles)
+                if (writeFiles) {
                     fs.writeFileSync(filePath, s);
+                    files.push(filePath);
+                }
                 sRet += s + '\nGO\n';
             }
             // always generate permissions for the base view
             const s = this.generateSingleEntitySQLFileHeader(entity, 'Permissions for ' + entity.BaseView) + this.generateViewPermissions(entity);
             if (s.length > 0)
                 permissionsSQL += s + '\nGO\n';
-            if (writeFiles)
-                fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('view', entity.SchemaName, entity.BaseView, true, true)), s);
+            if (writeFiles) {
+                const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('view', entity.SchemaName, entity.BaseView, true, true));
+                fs.writeFileSync(filePath, s);
+                files.push(filePath);
+            }
             // now, append the permissions to the return string IF we did NOT generate the base view - because if we generated the base view, that
             // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
             if (!entity.BaseViewGenerated)
@@ -266,15 +311,21 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                 if (!onlyPermissions && entity.spCreateGenerated) {
                     // generate the create SP
                     const s = this.generateSingleEntitySQLFileHeader(entity, spName) + this.generateSPCreate(entity);
-                    if (writeFiles)
-                        fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, false, true)), s);
+                    if (writeFiles) {
+                        const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, false, true));
+                        fs.writeFileSync(filePath, s);
+                        files.push(filePath);
+                    }
                     sRet += s + '\nGO\n';
                 }
                 const s = this.generateSPPermissions(entity, spName, exports.SPType.Create) + '\n\n';
                 if (s.length > 0)
                     permissionsSQL += s + '\nGO\n';
-                if (writeFiles)
-                    fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, true, true)), s);
+                if (writeFiles) {
+                    const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, true, true));
+                    fs.writeFileSync(filePath, s);
+                    files.push(filePath);
+                }
                 // now, append the permissions to the return string IF we did NOT generate the proc - because if we generated the proc, that
                 // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
                 if (!entity.spCreateGenerated)
@@ -286,15 +337,21 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                 if (!onlyPermissions && entity.spUpdateGenerated) {
                     // generate the update SP
                     const s = this.generateSingleEntitySQLFileHeader(entity, spName) + this.generateSPUpdate(entity);
-                    if (writeFiles)
-                        fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, false, true)), s);
+                    if (writeFiles) {
+                        const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, false, true));
+                        fs.writeFileSync(filePath, s);
+                        files.push(filePath);
+                    }
                     sRet += s + '\nGO\n';
                 }
                 const s = this.generateSPPermissions(entity, spName, exports.SPType.Update) + '\n\n';
                 if (s.length > 0)
                     permissionsSQL += s + '\nGO\n';
-                if (writeFiles)
-                    fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, true, true)), s);
+                if (writeFiles) {
+                    const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, true, true));
+                    fs.writeFileSync(filePath, s);
+                    files.push(filePath);
+                }
                 // now, append the permissions to the return string IF we did NOT generate the proc - because if we generated the proc, that
                 // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
                 if (!entity.spUpdateGenerated)
@@ -306,15 +363,21 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                 if (!onlyPermissions && entity.spDeleteGenerated) {
                     // generate the delete SP
                     const s = this.generateSingleEntitySQLFileHeader(entity, spName) + this.generateSPDelete(entity);
-                    if (writeFiles)
-                        fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, false, true)), s);
+                    if (writeFiles) {
+                        const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, false, true));
+                        fs.writeFileSync(filePath, s);
+                        files.push(filePath);
+                    }
                     sRet += s + '\nGO\n';
                 }
                 const s = this.generateSPPermissions(entity, spName, exports.SPType.Delete) + '\n\n';
                 if (s.length > 0)
                     permissionsSQL += s + '\nGO\n';
-                if (writeFiles)
-                    fs.writeFileSync(path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, true, true)), s);
+                if (writeFiles) {
+                    const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, spName, true, true));
+                    fs.writeFileSync(filePath, s);
+                    files.push(filePath);
+                }
                 // now, append the permissions to the return string IF we did NOT generate the proc - because if we generated the proc, that
                 // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
                 if (!entity.spDeleteGenerated)
@@ -327,22 +390,26 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                 if (!onlyPermissions) {
                     // only write the actual sql out if we're not only generating permissions
                     const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', entity.SchemaName, entity.BaseTable, false, true));
-                    if (writeFiles)
+                    if (writeFiles) {
                         fs.writeFileSync(filePath, ft.sql);
+                        files.push(filePath);
+                    }
                     sRet += ft.sql + '\nGO\n';
                 }
                 const sP = this.generateFullTextSearchFunctionPermissions(entity, ft.functionName) + '\n\n';
                 if (sP.length > 0)
                     permissionsSQL += sP + '\nGO\n';
                 const filePath = path_1.default.join(directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', entity.SchemaName, entity.BaseTable, true, true));
-                if (writeFiles)
+                if (writeFiles) {
                     fs.writeFileSync(filePath, sP);
+                    files.push(filePath);
+                }
                 // now, append the permissions to the return string IF we did NOT generate the function - because if we generated the function, that
                 // means we already generated the permissions for it above and it is part of sRet already, but we always save it to a file, (per above line)
                 if (!entity.FullTextSearchFunctionGenerated)
                     sRet += sP + '\nGO\n';
             }
-            return { sql: sRet, permissionsSQL: permissionsSQL };
+            return { sql: sRet, permissionsSQL: permissionsSQL, files: files };
         }
         catch (err) {
             (0, logging_1.logError)(err);
@@ -555,6 +622,9 @@ let SQLCodeGenBase = class SQLCodeGenBase {
         const relatedFieldsString = await this.generateBaseViewRelatedFieldsString(ds, entity.Fields);
         const relatedFieldsJoinString = this.generateBaseViewJoins(entity.Fields);
         const permissions = this.generateViewPermissions(entity);
+        const whereClause = entity.DeleteType === 'Soft' ? `WHERE 
+    ${baseTableFirstChar}.[${core_1.EntityInfo.DeletedAtFieldName}] IS NULL
+` : '';
         return `
 ------------------------------------------------------------
 ----- BASE VIEW FOR ENTITY:      ${entity.Name}
@@ -571,7 +641,7 @@ SELECT
     ${baseTableFirstChar}.*${relatedFieldsString.length > 0 ? ',' : ''}${relatedFieldsString}
 FROM
     [${entity.SchemaName}].[${entity.BaseTable}] AS ${baseTableFirstChar}${relatedFieldsJoinString ? '\n' + relatedFieldsJoinString : ''}
-GO${permissions}
+${whereClause}GO${permissions}
     `;
     }
     generateViewPermissions(entity) {
@@ -597,38 +667,37 @@ GO${permissions}
         let sOutput = '';
         let fieldCount = 0;
         const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.ManageMetadataBase);
-        for (let i = 0; i < entityFields.length; i++) {
-            const ef = entityFields[i];
-            if (ef.RelatedEntityID && ef.IncludeRelatedEntityNameFieldInBaseView) {
-                const { nameField, nameFieldIsVirtual } = this.getIsNameFieldForSingleEntity(ef.RelatedEntity);
-                if (nameField !== '') {
-                    // only add to the output, if we found a name field for the related entity.
-                    ef._RelatedEntityTableAlias = ef.RelatedEntityClassName + '_' + ef.Name;
-                    ef._RelatedEntityNameFieldIsVirtual = nameFieldIsVirtual;
-                    // This next section generates a field name for the new virtual field and makes sure it doesn't collide with a field in the base table
-                    const candidateName = this.stripID(ef.Name);
-                    // check to make sure candidateName is not already a field name in the base table (other than a virtual field of course, as that is what we're creating) 
-                    // because if it is, we need to change it to something else
-                    const bFound = entityFields.find(f => f.IsVirtual === false && f.Name.trim().toLowerCase() === candidateName.trim().toLowerCase()) !== undefined;
-                    if (bFound)
-                        ef._RelatedEntityNameFieldMap = candidateName + '_Virtual';
-                    else
-                        ef._RelatedEntityNameFieldMap = candidateName;
-                    // now we have a safe field name alias for the new virtual field in the _RelatedEntityNameFieldMap property, so use it...
-                    sOutput += `${fieldCount == 0 ? '' : ','}\n    ${ef._RelatedEntityTableAlias}.[${nameField}] AS [${ef._RelatedEntityNameFieldMap}]`;
-                    // check to see if the database already knows about the RelatedEntityNameFieldMap or not
-                    if (ef.RelatedEntityNameFieldMap === null ||
-                        ef.RelatedEntityNameFieldMap === undefined ||
-                        ef.RelatedEntityNameFieldMap.trim().length === 0) {
-                        // the database doesn't yet know about this RelatedEntityNameFieldMap, so we need to update it
-                        // first update the actul field in the metadata object so it can be used from this point forward
-                        // and it also reflects what the DB will hold
-                        ef.RelatedEntityNameFieldMap = ef._RelatedEntityNameFieldMap;
-                        // then update the database itself
-                        await manageMD.updateEntityFieldRelatedEntityNameFieldMap(ds, ef.ID, ef.RelatedEntityNameFieldMap);
-                    }
-                    fieldCount++;
+        // next get the fields that are related entities and have the IncludeRelatedEntityNameFieldInBaseView flag set to true
+        const qualifyingFields = entityFields.filter(f => f.RelatedEntityID && f.IncludeRelatedEntityNameFieldInBaseView);
+        for (const ef of qualifyingFields) {
+            const { nameField, nameFieldIsVirtual } = this.getIsNameFieldForSingleEntity(ef.RelatedEntity);
+            if (nameField !== '') {
+                // only add to the output, if we found a name field for the related entity.
+                ef._RelatedEntityTableAlias = ef.RelatedEntityClassName + '_' + ef.Name;
+                ef._RelatedEntityNameFieldIsVirtual = nameFieldIsVirtual;
+                // This next section generates a field name for the new virtual field and makes sure it doesn't collide with a field in the base table
+                const candidateName = this.stripID(ef.Name);
+                // check to make sure candidateName is not already a field name in the base table (other than a virtual field of course, as that is what we're creating) 
+                // because if it is, we need to change it to something else
+                const bFound = entityFields.find(f => f.IsVirtual === false && f.Name.trim().toLowerCase() === candidateName.trim().toLowerCase()) !== undefined;
+                if (bFound)
+                    ef._RelatedEntityNameFieldMap = candidateName + '_Virtual';
+                else
+                    ef._RelatedEntityNameFieldMap = candidateName;
+                // now we have a safe field name alias for the new virtual field in the _RelatedEntityNameFieldMap property, so use it...
+                sOutput += `${fieldCount === 0 ? '' : ','}\n    ${ef._RelatedEntityTableAlias}.[${nameField}] AS [${ef._RelatedEntityNameFieldMap}]`;
+                // check to see if the database already knows about the RelatedEntityNameFieldMap or not
+                if (ef.RelatedEntityNameFieldMap === null ||
+                    ef.RelatedEntityNameFieldMap === undefined ||
+                    ef.RelatedEntityNameFieldMap.trim().length === 0) {
+                    // the database doesn't yet know about this RelatedEntityNameFieldMap, so we need to update it
+                    // first update the actul field in the metadata object so it can be used from this point forward
+                    // and it also reflects what the DB will hold
+                    ef.RelatedEntityNameFieldMap = ef._RelatedEntityNameFieldMap;
+                    // then update the database itself
+                    await manageMD.updateEntityFieldRelatedEntityNameFieldMap(ds, ef.ID, ef.RelatedEntityNameFieldMap);
                 }
+                fieldCount++;
             }
         }
         return sOutput;
@@ -673,9 +742,12 @@ GO${permissions}
     }
     generateSPCreate(entity) {
         const spName = entity.spCreate ? entity.spCreate : `spCreate${entity.ClassName}`;
-        const efString = this.createEntityFieldsParamString(entity.Fields, !entity.FirstPrimaryKey.AutoIncrement);
+        const firstKey = entity.FirstPrimaryKey;
+        const primaryKeyAutomatic = firstKey.AutoIncrement || (firstKey.Type.toLowerCase().trim() === 'uniqueidentifier' && firstKey.DefaultValue && firstKey.DefaultValue.trim().length > 0);
+        const efString = this.createEntityFieldsParamString(entity.Fields, !primaryKeyAutomatic);
         const permissions = this.generateSPPermissions(entity, spName, exports.SPType.Create);
-        let primaryKeyInsertValue = '';
+        let preInsertCode = '';
+        let outputCode = '';
         let selectInsertedRecord = '';
         let additionalFieldList = '';
         let additionalValueList = '';
@@ -683,10 +755,29 @@ GO${permissions}
             selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.FirstPrimaryKey.Name}] = SCOPE_IDENTITY()`;
         }
         else if (entity.FirstPrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier') {
-            primaryKeyInsertValue = `DECLARE @newId UNIQUEIDENTIFIER = NEWID();\n    SET @${entity.FirstPrimaryKey.Name} = @newId;\n`;
-            additionalFieldList = ',\n            [' + entity.FirstPrimaryKey.CodeName + ']';
-            additionalValueList = ',\n            @newId';
-            selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.FirstPrimaryKey.Name}] = @newId`;
+            // our primary key is a uniqueidentifier. Two scenarios exist for this:
+            // 1) The default value is specified in the database (usually either NEWID() or NEWSEQUENTIALID()). 
+            // 2) No default value is specified, so we need to generate a new GUID in the stored procedure using NEWID() --- NewSequentialID() is not allowed in a stored procedure, only usable as a default value.
+            // so, first check to see if there is a default value for the field or not
+            const hasDefaultValue = entity.FirstPrimaryKey.DefaultValue && entity.FirstPrimaryKey.DefaultValue.trim().length > 0;
+            // if we have a default value, then we do NOT want to insert a new value, let the database use the default
+            if (hasDefaultValue) {
+                // in this situation, we DO have a default value, so we do NOT insert a new value, we let the database use the default
+                // however, we need to do some extra preprocessing to use the OUTPUT from the INSERT statement and return the record that was
+                // just created, that is how we get the newly created GUID that was the default value
+                preInsertCode = `DECLARE @InsertedRow TABLE ([${entity.FirstPrimaryKey.Name}] UNIQUEIDENTIFIER)`;
+                outputCode = `OUTPUT INSERTED.[${entity.FirstPrimaryKey.Name}] INTO @InsertedRow
+    `;
+                selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.FirstPrimaryKey.Name}] = (SELECT [${entity.FirstPrimaryKey.Name}] FROM @InsertedRow)`;
+            }
+            else {
+                // we have no default value, so we use NEWID() to generate a new GUID and we manually insert it into the table
+                // as part of the sproc
+                preInsertCode = `DECLARE @newId UNIQUEIDENTIFIER = NEWID();\n    SET @${entity.FirstPrimaryKey.Name} = @newId;\n`;
+                additionalFieldList = ',\n            [' + entity.FirstPrimaryKey.Name + ']';
+                additionalValueList = ',\n            @newId';
+                selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.FirstPrimaryKey.Name}] = @newId`;
+            }
         }
         else {
             selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE `;
@@ -710,13 +801,13 @@ CREATE PROCEDURE [${entity.SchemaName}].[${spName}]
 AS
 BEGIN
     SET NOCOUNT ON;
-    ${primaryKeyInsertValue}
+    ${preInsertCode}
     INSERT INTO 
     [${entity.SchemaName}].[${entity.BaseTable}]
         (
             ${this.createEntityFieldsInsertString(entity, entity.Fields, '')}${additionalFieldList}
         )
-    VALUES
+    ${outputCode}VALUES
         (
             ${this.createEntityFieldsInsertString(entity, entity.Fields, '@')}${additionalValueList}
         )
@@ -822,14 +913,17 @@ ${updatedAtTrigger}
             if ((!ef.IsPrimaryKey || !autoGeneratedPrimaryKey) &&
                 ef.IsVirtual === false &&
                 ef.AllowUpdateAPI &&
-                ef.AutoIncrement === false &&
-                ef.Type.trim().toLowerCase() !== 'uniqueidentifier') {
+                ef.AutoIncrement === false) {
                 if (!isFirst)
                     sOutput += ',\n            ';
                 else
                     isFirst = false;
-                if (prefix !== '' && ef.IsSpecialDateField)
-                    sOutput += `GETUTCDATE()`;
+                if (prefix !== '' && ef.IsSpecialDateField) {
+                    if (ef.IsCreatedAtField || ef.IsUpdatedAtField)
+                        sOutput += `GETUTCDATE()`; // we set the inserted row value to the current date for created and updated at fields
+                    else
+                        sOutput += `NULL`; // we don't set the deleted at field on an insert, only on a delete
+                }
                 else {
                     let sVal = prefix + (prefix !== '' ? ef.CodeName : ef.Name); // if we have a prefix, then we need to use the CodeName, otherwise we use the actual field name
                     if (!prefix || prefix.length === 0)
@@ -848,8 +942,7 @@ ${updatedAtTrigger}
                 !ef.IsVirtual &&
                 ef.AllowUpdateAPI &&
                 !ef.AutoIncrement &&
-                !ef.IsSpecialDateField &&
-                ef.Type.toLowerCase().trim() !== 'uniqueidentifier') {
+                !ef.IsSpecialDateField) {
                 if (!isFirst)
                     sOutput += ',\n        ';
                 else
@@ -873,6 +966,23 @@ ${updatedAtTrigger}
                 sSelect += ', ';
             sSelect += `@${k.CodeName} AS [${k.Name}]`;
         }
+        // next up, create the delete code which is based on the type of delete the entity is set to
+        // start off by creating the where clause first and then prepend the delete or update statement to it
+        let deleteCode = `    WHERE 
+        ${entity.PrimaryKeys.map(k => `[${k.Name}] = @${k.CodeName}`).join(' AND ')}
+`;
+        if (entity.DeleteType === 'Hard') {
+            deleteCode = `    DELETE FROM 
+        [${entity.SchemaName}].[${entity.BaseTable}]
+${deleteCode}`;
+        }
+        else {
+            deleteCode = `    UPDATE
+        [${entity.SchemaName}].[${entity.BaseTable}]
+    SET
+        ${core_1.EntityInfo.DeletedAtFieldName} = GETUTCDATE()
+${deleteCode}        AND ${core_1.EntityInfo.DeletedAtFieldName} IS NULL -- don't update the record if it's already been deleted via a soft delete`;
+        }
         return `
 ------------------------------------------------------------
 ----- DELETE PROCEDURE FOR ${entity.BaseTable}
@@ -886,10 +996,7 @@ AS
 BEGIN
     SET NOCOUNT ON;${sCascadeDeletes}
 
-    DELETE FROM 
-        [${entity.SchemaName}].[${entity.BaseTable}]
-    WHERE 
-        ${entity.PrimaryKeys.map(k => `[${k.Name}] = @${k.CodeName}`).join(' AND ')}
+${deleteCode}
 
     SELECT ${sSelect} -- Return the primary key to indicate we successfully deleted the record
 END