@memberjunction/codegen-lib 2.47.0 → 2.49.0

package/dist/Database/sql_codegen.js

@@ -15,12 +15,6 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -54,34 +48,37 @@ exports.SPType = {
  * databases. The base class implements support for SQL Server. In future versions of MJ, we will break out an abstract base class that has the skeleton of the logic and then the SQL Server version will be a sub-class
  * of that abstract base class and other databases will be sub-classes of the abstract base class as well.
  */
-let SQLCodeGenBase = class SQLCodeGenBase {
-    constructor() {
-        this._sqlUtilityObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(sql_1.SQLUtilityBase);
-        this.__specialUUIDValue = '00000000-0000-0000-0000-000000000000';
-    }
+class SQLCodeGenBase {
+    _sqlUtilityObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(sql_1.SQLUtilityBase);
     get SQLUtilityObject() {
         return this._sqlUtilityObject;
     }
-    async manageSQLScriptsAndExecution(ds, entities, directory, currentUser) {
+    async manageSQLScriptsAndExecution(pool, entities, directory, currentUser) {
         try {
             // STEP 1 - execute any custom SQL scripts for object creation that need to happen first - for example, if
             //          we have custom base views, need to have them defined before we do
             //          the rest as the generated stuff might use custom base views in compiled
             //          objects like spCreate for a given entity might reference the vw for that entity
+            (0, status_logging_1.startSpinner)('Running custom SQL scripts...');
             const startTime = new Date();
-            if (!await this.runCustomSQLScripts(ds, 'before-sql'))
+            if (!await this.runCustomSQLScripts(pool, 'before-sql')) {
+                (0, status_logging_1.failSpinner)('Failed to run custom SQL scripts');
                 return false;
-            (0, status_logging_1.logStatus)(`   Time to run custom SQL scripts: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
+            }
+            (0, status_logging_1.succeedSpinner)(`Custom SQL scripts completed (${(new Date().getTime() - startTime.getTime()) / 1000}s)`);
             // ALWAYS use the first filter where we only include entities that have IncludeInAPI = 1
             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) - clean out all *.generated.sql and *.permissions.generated.sql files from the directory
+            (0, status_logging_1.startSpinner)('Cleaning generated files...');
             this.deleteGeneratedEntityFiles(directory, baselineEntities);
+            (0, status_logging_1.succeedSpinner)('Cleaned generated files');
             // STEP 2(b) - generate all the SQL files and execute them
+            (0, status_logging_1.startSpinner)(`Generating SQL for ${includedEntities.length} entities...`);
             const step2StartTime = new Date();
             const genResult = await this.generateAndExecuteEntitySQLToSeparateFiles({
-                ds,
+                pool,
                 entities: includedEntities,
                 directory,
                 onlyPermissions: false,
@@ -91,12 +88,13 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                 enableSQLLoggingForNewOrModifiedEntities: true
             }); // enable sql logging for NEW entities....
             if (!genResult.Success) {
-                (0, status_logging_1.logError)('Error generating all entities SQL to separate files');
+                (0, status_logging_1.failSpinner)('Failed to generate entity SQL files');
                 return false;
             }
             // STEP 2(c) - for the excludedEntities, while we don't want to generate SQL, we do want to generate the permissions files for them
+            (0, status_logging_1.updateSpinner)(`Generating permissions for ${excludedEntities.length} excluded entities...`);
             const genResult2 = await this.generateAndExecuteEntitySQLToSeparateFiles({
-                ds,
+                pool,
                 entities: excludedEntities,
                 directory,
                 onlyPermissions: true,
@@ -106,41 +104,50 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                 enableSQLLoggingForNewOrModifiedEntities: false /*don't log this stuff, it is just permissions for excluded entities*/
             });
             if (!genResult2.Success) {
-                (0, status_logging_1.logError)('Error generating permissions SQL for excluded entities to separate files');
+                (0, status_logging_1.failSpinner)('Failed to generate permissions for excluded entities');
                 return false;
             }
-            (0, status_logging_1.logStatus)(`   Time to generate entity SQL: ${(new Date().getTime() - step2StartTime.getTime()) / 1000} seconds`);
+            (0, status_logging_1.succeedSpinner)(`Entity generation completed (${(new Date().getTime() - step2StartTime.getTime()) / 1000}s)`);
             // 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
+            (0, status_logging_1.startSpinner)('Creating combined SQL files...');
             const allEntityFiles = this.createCombinedEntitySQLFiles(directory, baselineEntities);
+            (0, status_logging_1.succeedSpinner)(`Created combined SQL files for ${allEntityFiles.length} schemas`);
             // STEP 2(e) ---- FINALLY, we now execute all the combined files by schema;
+            (0, status_logging_1.startSpinner)('Executing combined entity SQL files...');
             const step2eStartTime = new Date();
-            if (!await this.SQLUtilityObject.executeSQLFiles(allEntityFiles, true)) {
-                (0, status_logging_1.logError)('Error executing combined entity SQL files');
+            if (!await this.SQLUtilityObject.executeSQLFiles(allEntityFiles, config_1.configInfo?.verboseOutput ?? false)) {
+                (0, status_logging_1.failSpinner)('Failed to execute combined entity SQL files');
                 return false;
             }
             const step2eEndTime = new Date();
-            (0, status_logging_1.logStatus)(`   Time to Execute Combined Entity SQL: ${(step2eEndTime.getTime() - step2eStartTime.getTime()) / 1000} seconds`);
+            (0, status_logging_1.succeedSpinner)(`SQL execution completed (${(step2eEndTime.getTime() - step2eStartTime.getTime()) / 1000}s)`);
             const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.ManageMetadataBase);
             // STEP 3 - re-run the process to manage entity fields since the Step 1 and 2 above might have resulted in differences in base view columns compared to what we had at first
             // we CAN skip the entity field values part because that wouldn't change from the first time we ran it
-            if (!await manageMD.manageEntityFields(ds, config_1.configInfo.excludeSchemas, true, true, currentUser)) {
-                (0, status_logging_1.logError)('Error managing entity fields');
+            (0, status_logging_1.startSpinner)('Managing entity fields metadata...');
+            if (!await manageMD.manageEntityFields(pool, config_1.configInfo.excludeSchemas, true, true, currentUser)) {
+                (0, status_logging_1.failSpinner)('Failed to manage entity fields');
                 return false;
             }
+            (0, status_logging_1.succeedSpinner)('Entity fields metadata updated');
             // 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
+            (0, status_logging_1.startSpinner)('Applying permissions...');
             const step4StartTime = new Date();
-            if (!await this.applyPermissions(ds, directory, baselineEntities)) {
-                (0, status_logging_1.logError)('Error applying permissions');
+            if (!await this.applyPermissions(pool, directory, baselineEntities)) {
+                (0, status_logging_1.failSpinner)('Failed to apply permissions');
                 return false;
             }
-            (0, status_logging_1.logStatus)(`   Time to Apply Permissions: ${(new Date().getTime() - step4StartTime.getTime()) / 1000} seconds`);
+            (0, status_logging_1.succeedSpinner)(`Permissions applied (${(new Date().getTime() - step4StartTime.getTime()) / 1000}s)`);
             // STEP 5 - execute any custom SQL scripts that should run afterwards
+            (0, status_logging_1.startSpinner)('Running post-generation SQL scripts...');
             const step5StartTime = new Date();
-            if (!await this.runCustomSQLScripts(ds, 'after-sql'))
+            if (!await this.runCustomSQLScripts(pool, 'after-sql')) {
+                (0, status_logging_1.failSpinner)('Failed to run post-generation SQL scripts');
                 return false;
-            (0, status_logging_1.logStatus)(`   Time to run custom SQL scripts: ${(new Date().getTime() - step5StartTime.getTime()) / 1000} seconds`);
-            (0, status_logging_1.logStatus)('   Total time to run generate and execute SQL scripts: ' + ((new Date().getTime() - startTime.getTime()) / 1000) + ' seconds');
+            }
+            (0, status_logging_1.succeedSpinner)(`Post-generation scripts completed (${(new Date().getTime() - step5StartTime.getTime()) / 1000}s)`);
+            (0, status_logging_1.succeedSpinner)(`CodeGen completed successfully (${((new Date().getTime() - startTime.getTime()) / 1000)}s total)`);
             // now - we need to tell our metadata object to refresh itself
             const md = new core_1.Metadata();
             await md.Refresh();
@@ -151,7 +158,7 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             return false;
         }
     }
-    async runCustomSQLScripts(ds, when) {
+    async runCustomSQLScripts(pool, when) {
         try {
             const scripts = (0, config_1.customSqlScripts)(when);
             let bSuccess = true;
@@ -171,7 +178,7 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             return false;
         }
     }
-    async applyPermissions(ds, directory, entities, batchSize = 5) {
+    async applyPermissions(pool, directory, entities, batchSize = 5) {
         try {
             let bSuccess = true;
             for (let i = 0; i < entities.length; i += batchSize) {
@@ -186,7 +193,7 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                             const fileBuffer = fs.readFileSync(fullPath);
                             const fileContents = fileBuffer.toString();
                             try {
-                                await ds.query(fileContents);
+                                await pool.request().query(fileContents);
                             }
                             catch (e) {
                                 (0, status_logging_1.logError)(`Error executing permissions file ${fullPath} for entity ${e.Name}: ${e}`);
@@ -237,7 +244,7 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                         return { Success: false, Files: [] };
                     }
                     return this.generateAndExecuteSingleEntitySQLToSeparateFiles({
-                        ds: options.ds,
+                        pool: options.pool,
                         entity: e,
                         directory: options.directory,
                         onlyPermissions: options.onlyPermissions,
@@ -310,7 +317,7 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             const { sql, permissionsSQL, files } = await this.generateSingleEntitySQLToSeparateFiles(options); // this creates the files and returns a single string with all the SQL we can then execute
             if (!options.skipExecution) {
                 return {
-                    Success: await this.SQLUtilityObject.executeSQLScript(options.ds, sql + "\n\nGO\n\n" + permissionsSQL, true), // combine the SQL and permissions and execute it,
+                    Success: await this.SQLUtilityObject.executeSQLScript(options.pool, sql + "\n\nGO\n\n" + permissionsSQL, true), // combine the SQL and permissions and execute it,
                     Files: files
                 };
             }
@@ -323,9 +330,26 @@ let SQLCodeGenBase = class SQLCodeGenBase {
         }
     }
     logSQLForNewOrModifiedEntity(entity, sql, description, logSql = false) {
-        if (logSql &&
-            (manage_metadata_1.ManageMetadataBase.newEntityList.find(e => e === entity.Name) || manage_metadata_1.ManageMetadataBase.modifiedEntityList.find(e => e === entity.Name))) {
-            // per above only do this if (a) logSql is true and (b) the entity is in the newEntityList OR modifiedEntityList
+        // Check if we should log this SQL
+        let shouldLog = false;
+        if (logSql) {
+            // Check if entity is in new or modified lists
+            const isNewOrModified = !!manage_metadata_1.ManageMetadataBase.newEntityList.find(e => e === entity.Name) ||
+                !!manage_metadata_1.ManageMetadataBase.modifiedEntityList.find(e => e === entity.Name);
+            // Check if force regeneration is enabled for relevant SQL types
+            const isForceRegeneration = config_1.configInfo.forceRegeneration?.enabled && ((description.toLowerCase().includes('base view') && config_1.configInfo.forceRegeneration.baseViews) ||
+                (description.toLowerCase().includes('spcreate') && config_1.configInfo.forceRegeneration.spCreate) ||
+                (description.toLowerCase().includes('spupdate') && config_1.configInfo.forceRegeneration.spUpdate) ||
+                (description.toLowerCase().includes('spdelete') && config_1.configInfo.forceRegeneration.spDelete) ||
+                (description.toLowerCase().includes('index') && config_1.configInfo.forceRegeneration.indexes) ||
+                (description.toLowerCase().includes('full text search') && config_1.configInfo.forceRegeneration.fullTextSearch) ||
+                (config_1.configInfo.forceRegeneration.allStoredProcedures &&
+                    (description.toLowerCase().includes('spcreate') ||
+                        description.toLowerCase().includes('spupdate') ||
+                        description.toLowerCase().includes('spdelete'))));
+            shouldLog = isNewOrModified || isForceRegeneration;
+        }
+        if (shouldLog) {
             sql_logging_1.SQLLogging.appendToSQLLogFile(sql, description);
         }
         (0, util_1.logIf)(config_1.configInfo.verboseOutput, `SQL Generated for ${entity.Name}: ${description}`);
@@ -344,7 +368,8 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             let permissionsSQL = '';
             // Indexes for Fkeys for the table
             if (!options.onlyPermissions) {
-                const indexSQL = (0, config_1.autoIndexForeignKeys)() ? this.generateIndexesForForeignKeys(options.ds, options.entity) : ''; // if autoIndexForeignKeys is true, generate the indexes, otherwise, just add a blank string to the header
+                const shouldGenerateIndexes = (0, config_1.autoIndexForeignKeys)() || (config_1.configInfo.forceRegeneration?.enabled && config_1.configInfo.forceRegeneration?.indexes);
+                const indexSQL = shouldGenerateIndexes ? this.generateIndexesForForeignKeys(options.pool, options.entity) : ''; // generate indexes if auto-indexing is on OR force regeneration is enabled
                 const s = this.generateSingleEntitySQLFileHeader(options.entity, 'Index for Foreign Keys') + indexSQL;
                 if (options.writeFiles) {
                     const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('index', options.entity.SchemaName, options.entity.BaseTable, false, true));
@@ -355,9 +380,11 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                 sRet += s + '\nGO\n';
             }
             // BASE VIEW
-            if (!options.onlyPermissions && options.entity.BaseViewGenerated && !options.entity.VirtualEntity) {
+            if (!options.onlyPermissions &&
+                (options.entity.BaseViewGenerated || (config_1.configInfo.forceRegeneration?.enabled && config_1.configInfo.forceRegeneration?.baseViews)) &&
+                !options.entity.VirtualEntity) {
                 // generate the base view
-                const s = this.generateSingleEntitySQLFileHeader(options.entity, options.entity.BaseView) + await this.generateBaseView(options.ds, options.entity);
+                const s = this.generateSingleEntitySQLFileHeader(options.entity, options.entity.BaseView) + await this.generateBaseView(options.pool, options.entity);
                 const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('view', options.entity.SchemaName, options.entity.BaseView, false, true));
                 if (options.writeFiles) {
                     this.logSQLForNewOrModifiedEntity(options.entity, s, `Base View SQL for ${options.entity.Name}`, options.enableSQLLoggingForNewOrModifiedEntities);
@@ -383,7 +410,9 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             // CREATE SP
             if (options.entity.AllowCreateAPI && !options.entity.VirtualEntity) {
                 const spName = this.getSPName(options.entity, exports.SPType.Create);
-                if (!options.onlyPermissions && options.entity.spCreateGenerated) {
+                if (!options.onlyPermissions &&
+                    (options.entity.spCreateGenerated ||
+                        (config_1.configInfo.forceRegeneration?.enabled && (config_1.configInfo.forceRegeneration?.spCreate || config_1.configInfo.forceRegeneration?.allStoredProcedures)))) {
                     // generate the create SP
                     const s = this.generateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPCreate(options.entity);
                     if (options.writeFiles) {
@@ -411,7 +440,9 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             // UPDATE SP
             if (options.entity.AllowUpdateAPI && !options.entity.VirtualEntity) {
                 const spName = this.getSPName(options.entity, exports.SPType.Update);
-                if (!options.onlyPermissions && options.entity.spUpdateGenerated) {
+                if (!options.onlyPermissions &&
+                    (options.entity.spUpdateGenerated ||
+                        (config_1.configInfo.forceRegeneration?.enabled && (config_1.configInfo.forceRegeneration?.spUpdate || config_1.configInfo.forceRegeneration?.allStoredProcedures)))) {
                     // generate the update SP
                     const s = this.generateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPUpdate(options.entity);
                     if (options.writeFiles) {
@@ -439,7 +470,9 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             // DELETE SP
             if (options.entity.AllowDeleteAPI && !options.entity.VirtualEntity) {
                 const spName = this.getSPName(options.entity, exports.SPType.Delete);
-                if (!options.onlyPermissions && options.entity.spDeleteGenerated) {
+                if (!options.onlyPermissions &&
+                    (options.entity.spDeleteGenerated ||
+                        (config_1.configInfo.forceRegeneration?.enabled && (config_1.configInfo.forceRegeneration?.spDelete || config_1.configInfo.forceRegeneration?.allStoredProcedures)))) {
                     // generate the delete SP
                     const s = this.generateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPDelete(options.entity);
                     if (options.writeFiles) {
@@ -465,9 +498,9 @@ let SQLCodeGenBase = class SQLCodeGenBase {
                     sRet += s + '\nGO\n';
             }
             // check to see if the options.entity supports full text search or not
-            if (options.entity.FullTextSearchEnabled) {
+            if (options.entity.FullTextSearchEnabled || (config_1.configInfo.forceRegeneration?.enabled && config_1.configInfo.forceRegeneration?.fullTextSearch)) {
                 // always generate the code so we can get the function name from the below function call
-                const ft = await this.generateEntityFullTextSearchSQL(options.ds, options.entity);
+                const ft = await this.generateEntityFullTextSearchSQL(options.pool, options.entity);
                 if (!options.onlyPermissions) {
                     // only write the actual sql out if we're not only generating permissions
                     const filePath = path_1.default.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', options.entity.SchemaName, options.entity.BaseTable, false, true));
@@ -534,11 +567,11 @@ let SQLCodeGenBase = class SQLCodeGenBase {
      * @param entity
      * @returns
      */
-    async generateEntitySQL(ds, entity) {
+    async generateEntitySQL(pool, entity) {
         let sOutput = '';
         if (entity.BaseViewGenerated && !entity.VirtualEntity)
             // generated the base view (will include permissions)
-            sOutput += await this.generateBaseView(ds, entity) + '\n\n';
+            sOutput += await this.generateBaseView(pool, entity) + '\n\n';
         else
             // still generate the permissions for the view even if a custom view
             sOutput += this.generateViewPermissions(entity) + '\n\n';
@@ -568,11 +601,11 @@ let SQLCodeGenBase = class SQLCodeGenBase {
         }
         // check to see if the entity supports full text search or not
         if (entity.FullTextSearchEnabled) {
-            sOutput += await this.generateEntityFullTextSearchSQL(ds, entity) + '\n\n';
+            sOutput += await this.generateEntityFullTextSearchSQL(pool, entity) + '\n\n';
         }
         return sOutput;
     }
-    async generateEntityFullTextSearchSQL(ds, entity) {
+    async generateEntityFullTextSearchSQL(pool, entity) {
         let sql = '';
         const catalogName = entity.FullTextCatalog && entity.FullTextCatalog.length > 0 ? entity.FullTextCatalog : config_1.dbDatabase + '_FullTextCatalog';
         if (entity.FullTextCatalogGenerated) {
@@ -592,7 +625,7 @@ let SQLCodeGenBase = class SQLCodeGenBase {
             if (fullTextFields.length === 0)
                 throw new Error(`FullTextIndexGenerated is true for entity ${entity.Name}, but no fields are marked as FullTextSearchEnabled`);
             // drop and recreate the full text index
-            const entity_pk_name = await this.getEntityPrimaryKeyIndexName(ds, entity);
+            const entity_pk_name = await this.getEntityPrimaryKeyIndexName(pool, entity);
             sql += `                -- DROP AND RECREATE THE FULL TEXT INDEX
                 IF EXISTS (
                     SELECT *
@@ -659,7 +692,7 @@ let SQLCodeGenBase = class SQLCodeGenBase {
         }
         return { sql, functionName };
     }
-    async getEntityPrimaryKeyIndexName(ds, entity) {
+    async getEntityPrimaryKeyIndexName(pool, entity) {
         const sSQL = `  SELECT
         i.name AS IndexName
     FROM
@@ -674,7 +707,8 @@ let SQLCodeGenBase = class SQLCodeGenBase {
         o.schema_id = SCHEMA_ID('${entity.SchemaName}') AND
         kc.type = 'PK';
         `;
-        const result = await ds.query(sSQL);
+        const resultResult = await pool.request().query(sSQL);
+        const result = resultResult.recordset;
         if (result && result.length > 0)
             return result[0].IndexName;
         else
@@ -706,10 +740,10 @@ let SQLCodeGenBase = class SQLCodeGenBase {
     }
     /**
      * Generates the SQL for creating indexes for the foreign keys in the entity
-     * @param ds
+     * @param pool
      * @param entity
      */
-    generateIndexesForForeignKeys(ds, entity) {
+    generateIndexesForForeignKeys(pool, entity) {
         // iterate through all of the fields in the entity that are foreign keys and generate an index for each one
         let sOutput = '';
         for (const f of entity.Fields) {
@@ -732,10 +766,10 @@ CREATE INDEX ${indexName} ON [${entity.SchemaName}].[${entity.BaseTable}] ([${f.
         }
         return sOutput;
     }
-    async generateBaseView(ds, entity) {
+    async generateBaseView(pool, entity) {
         const viewName = entity.BaseView ? entity.BaseView : `vw${entity.CodeName}`;
         const classNameFirstChar = entity.ClassName.charAt(0).toLowerCase();
-        const relatedFieldsString = await this.generateBaseViewRelatedFieldsString(ds, entity.Fields);
+        const relatedFieldsString = await this.generateBaseViewRelatedFieldsString(pool, entity.Fields);
         const relatedFieldsJoinString = this.generateBaseViewJoins(entity, entity.Fields);
         const permissions = this.generateViewPermissions(entity);
         const whereClause = entity.DeleteType === 'Soft' ? `WHERE
@@ -782,7 +816,7 @@ ${whereClause}GO${permissions}
         }
         return sOutput;
     }
-    async generateBaseViewRelatedFieldsString(ds, entityFields) {
+    async generateBaseViewRelatedFieldsString(pool, entityFields) {
         let sOutput = '';
         let fieldCount = 0;
         const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.ManageMetadataBase);
@@ -814,7 +848,7 @@ ${whereClause}GO${permissions}
                     // 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);
+                    await manageMD.updateEntityFieldRelatedEntityNameFieldMap(pool, ef.ID, ef.RelatedEntityNameFieldMap);
                 }
                 fieldCount++;
             }
@@ -869,8 +903,8 @@ ${whereClause}GO${permissions}
         const spName = entity.spCreate ? entity.spCreate : `spCreate${entity.ClassName}`;
         const firstKey = entity.FirstPrimaryKey;
         //double exclamations used on the firstKey.DefaultValue property otherwise the type of this variable is 'number | ""';
-        const primaryKeyAutomatic = firstKey.AutoIncrement || (firstKey.Type.toLowerCase().trim() === 'uniqueidentifier') && (!!firstKey.DefaultValue && firstKey.DefaultValue.trim().length > 0);
-        const efString = this.createEntityFieldsParamString(entity.Fields, !primaryKeyAutomatic);
+        const primaryKeyAutomatic = firstKey.AutoIncrement; // Only exclude auto-increment fields, allow manual override for all other PKs including UUIDs with defaults
+        const efString = this.createEntityFieldsParamString(entity.Fields, false); // Always pass false for isUpdate since this is generateSPCreate
         const permissions = this.generateSPPermissions(entity, spName, exports.SPType.Create);
         let preInsertCode = '';
         let outputCode = '';
@@ -880,29 +914,58 @@ ${whereClause}GO${permissions}
         if (entity.FirstPrimaryKey.AutoIncrement) {
             selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.FirstPrimaryKey.Name}] = SCOPE_IDENTITY()`;
         }
-        else if (entity.FirstPrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier') {
-            // 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
+        else if (entity.FirstPrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier' && entity.PrimaryKeys.length === 1) {
+            // our primary key is a uniqueidentifier. Now we support optional override:
+            // - If PKEY is provided (not NULL), use it
+            // - If PKEY is NULL and there's a default value, let the database use it
+            // - If PKEY is NULL and no default value, generate NEWID()
             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
-    `;
+                // Has default value - use conditional logic to either include the field or let DB use default
+                preInsertCode = `DECLARE @InsertedRow TABLE ([${entity.FirstPrimaryKey.Name}] UNIQUEIDENTIFIER)
+    
+    IF @${entity.FirstPrimaryKey.Name} IS NOT NULL
+    BEGIN
+        -- User provided a value, use it
+        INSERT INTO [${entity.SchemaName}].[${entity.BaseTable}]
+            (
+                [${entity.FirstPrimaryKey.Name}],
+                ${this.createEntityFieldsInsertString(entity, entity.Fields, '', true)}
+            )
+        OUTPUT INSERTED.[${entity.FirstPrimaryKey.Name}] INTO @InsertedRow
+        VALUES
+            (
+                @${entity.FirstPrimaryKey.Name},
+                ${this.createEntityFieldsInsertString(entity, entity.Fields, '@', true)}
+            )
+    END
+    ELSE
+    BEGIN
+        -- No value provided, let database use its default (e.g., NEWSEQUENTIALID())
+        INSERT INTO [${entity.SchemaName}].[${entity.BaseTable}]
+            (
+                ${this.createEntityFieldsInsertString(entity, entity.Fields, '', true)}
+            )
+        OUTPUT INSERTED.[${entity.FirstPrimaryKey.Name}] INTO @InsertedRow
+        VALUES
+            (
+                ${this.createEntityFieldsInsertString(entity, entity.Fields, '@', true)}
+            )
+    END`;
+                // Clear these as we're handling the INSERT in preInsertCode
+                additionalFieldList = '';
+                additionalValueList = '';
+                outputCode = '';
                 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`;
+                // No default value - we calculate the ID upfront, so no need for OUTPUT clause
+                preInsertCode = `DECLARE @ActualID UNIQUEIDENTIFIER = ISNULL(@${entity.FirstPrimaryKey.Name}, NEWID())`;
+                additionalFieldList = ',\n                [' + entity.FirstPrimaryKey.Name + ']';
+                additionalValueList = ',\n                @ActualID';
+                outputCode = ''; // No OUTPUT clause needed
+                // We already know the ID, so just select using it directly
+                selectInsertedRecord = `SELECT * FROM [${entity.SchemaName}].[${entity.BaseView}] WHERE [${entity.FirstPrimaryKey.Name}] = @ActualID`;
             }
         }
         else {
@@ -927,7 +990,7 @@ CREATE PROCEDURE [${entity.SchemaName}].[${spName}]
 AS
 BEGIN
     SET NOCOUNT ON;
-    ${preInsertCode}
+    ${preInsertCode}${preInsertCode.includes('INSERT INTO') ? '' : `
     INSERT INTO
     [${entity.SchemaName}].[${entity.BaseTable}]
         (
@@ -936,7 +999,7 @@ BEGIN
     ${outputCode}VALUES
         (
             ${this.createEntityFieldsInsertString(entity, entity.Fields, '@')}${additionalValueList}
-        )
+        )`}
     -- return the new record from the base view, which might have some calculated fields
     ${selectInsertedRecord}
 END
@@ -1013,12 +1076,13 @@ GO
 ${updatedAtTrigger}
         `;
     }
+    __specialUUIDValue = '00000000-0000-0000-0000-000000000000';
     createEntityFieldsParamString(entityFields, isUpdate) {
         let sOutput = '', isFirst = true;
         for (let i = 0; i < entityFields.length; ++i) {
             const ef = entityFields[i];
-            const autoGeneratedPrimaryKey = ef.AutoIncrement || ef.Type.toLowerCase().trim() === 'uniqueidentifier';
-            if ((ef.AllowUpdateAPI || (ef.IsPrimaryKey && isUpdate)) &&
+            const autoGeneratedPrimaryKey = ef.AutoIncrement; // Only exclude auto-increment fields from params
+            if ((ef.AllowUpdateAPI || (ef.IsPrimaryKey && isUpdate) || (ef.IsPrimaryKey && !autoGeneratedPrimaryKey && !isUpdate)) &&
                 !ef.IsVirtual &&
                 (!ef.IsPrimaryKey || !autoGeneratedPrimaryKey || isUpdate) &&
                 !ef.IsSpecialDateField) {
@@ -1026,58 +1090,60 @@ ${updatedAtTrigger}
                     sOutput += ',\n    ';
                 else
                     isFirst = false;
-                // for unique identifiers, only for spCreate procs, IF there is a default value specified then we append a default parameter value
-                // to the sproc param with '00000000-0000-0000-0000-000000000000' so that the sproc can be called without passing in a value
-                // within the sproc body for spCreate, we will look for this special value and substitute it with the actual default value for the column (typically newid() or newsequentialid())
+                // Check if we need a default value
                 let defaultParamValue = '';
-                if (!isUpdate && ef.IsUniqueIdentifier && ef.HasDefaultValue) {
-                    defaultParamValue = ` = '${this.__specialUUIDValue}'`;
+                if (!isUpdate && ef.IsPrimaryKey && !ef.AutoIncrement) {
+                    // For primary keys (non-auto-increment), make them optional with NULL default
+                    // This allows callers to omit the PK and let the DB/sproc handle it
+                    defaultParamValue = ' = NULL';
                 }
                 sOutput += `@${ef.CodeName} ${ef.SQLFullType}${defaultParamValue}`;
             }
         }
         return sOutput;
     }
-    createEntityFieldsInsertString(entity, entityFields, prefix) {
-        const autoGeneratedPrimaryKey = entity.FirstPrimaryKey.AutoIncrement || entity.FirstPrimaryKey.Type.toLowerCase().trim() === 'uniqueidentifier';
+    createEntityFieldsInsertString(entity, entityFields, prefix, excludePrimaryKey = false) {
+        const autoGeneratedPrimaryKey = entity.FirstPrimaryKey.AutoIncrement; // Only exclude auto-increment PKs from insert
         let sOutput = '', isFirst = true;
         const filteredFields = entityFields.filter(f => f.AllowUpdateAPI);
         for (let i = 0; i < entityFields.length; ++i) {
             const ef = entityFields[i];
             const quotes = ef.NeedsQuotes ? "'" : "";
             // we only want fields that are (a) not primary keys, or if a pkey, not an auto-increment pkey and (b) not virtual fields and (c) updateable fields and (d) not auto-increment fields if they're not pkeys)
-            if ((!ef.IsPrimaryKey || !autoGeneratedPrimaryKey) && !ef.IsVirtual && ef.AllowUpdateAPI && !ef.AutoIncrement) {
-                if (!isFirst)
-                    sOutput += ',\n            ';
+            // ALSO: if excludePrimaryKey is true, skip all primary key fields
+            if ((excludePrimaryKey && ef.IsPrimaryKey) || (ef.IsPrimaryKey && autoGeneratedPrimaryKey) || ef.IsVirtual || !ef.AllowUpdateAPI || ef.AutoIncrement) {
+                continue; // skip this field
+            }
+            if (!isFirst)
+                sOutput += ',\n                ';
+            else
+                isFirst = false;
+            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
-                    isFirst = false;
-                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 if ((prefix && prefix !== '') && !ef.IsPrimaryKey && ef.IsUniqueIdentifier && ef.HasDefaultValue) {
-                    // this is the VALUE side (prefix not null/blank), is NOT a primary key, and is a uniqueidentifier column, and has a default value specified
-                    // in this situation we need to check if the value being passed in is the special value '00000000-0000-0000-0000-000000000000' (which is in __specialUUIDValue) if it is, we substitute it with the actual default value
-                    // otherwise we use the value passed in
-                    // next check to make sure ef.DefaultValue does not contain quotes around the value if it is a string type, if it does, we need to remove them
-                    let defValue = ef.DefaultValue;
-                    if (ef.TSType === core_1.EntityFieldTSType.String) {
-                        if (defValue.startsWith("'") && defValue.endsWith("'")) {
-                            defValue = defValue.substring(1, defValue.length - 1).trim(); // remove the quotes
-                        }
+                    sOutput += `NULL`; // we don't set the deleted at field on an insert, only on a delete
+            }
+            else if ((prefix && prefix !== '') && !ef.IsPrimaryKey && ef.IsUniqueIdentifier && ef.HasDefaultValue) {
+                // this is the VALUE side (prefix not null/blank), is NOT a primary key, and is a uniqueidentifier column, and has a default value specified
+                // in this situation we need to check if the value being passed in is the special value '00000000-0000-0000-0000-000000000000' (which is in __specialUUIDValue) if it is, we substitute it with the actual default value
+                // otherwise we use the value passed in
+                // next check to make sure ef.DefaultValue does not contain quotes around the value if it is a string type, if it does, we need to remove them
+                let defValue = ef.DefaultValue;
+                if (ef.TSType === core_1.EntityFieldTSType.String) {
+                    if (defValue.startsWith("'") && defValue.endsWith("'")) {
+                        defValue = defValue.substring(1, defValue.length - 1).trim(); // remove the quotes
                     }
-                    sOutput += `CASE @${ef.CodeName} WHEN '${this.__specialUUIDValue}' THEN ${quotes}${defValue}${quotes} ELSE @${ef.CodeName} END`;
-                }
-                else {
-                    let sVal = '';
-                    if (!prefix || prefix.length === 0)
-                        sVal = '[' + ef.Name + ']'; // always put field names in brackets so that if reserved words are being used for field names in a table like "USER" and so on, they still work
-                    else
-                        sVal = prefix + ef.CodeName;
-                    sOutput += sVal;
                 }
+                sOutput += `CASE @${ef.CodeName} WHEN '${this.__specialUUIDValue}' THEN ${quotes}${defValue}${quotes} ELSE @${ef.CodeName} END`;
+            }
+            else {
+                let sVal = '';
+                if (!prefix || prefix.length === 0)
+                    sVal = '[' + ef.Name + ']'; // always put field names in brackets so that if reserved words are being used for field names in a table like "USER" and so on, they still work
+                else
+                    sVal = prefix + ef.CodeName;
+                sOutput += sVal;
             }
         }
         return sOutput;
@@ -1196,9 +1262,6 @@ GO${permissions}
         }
         return sOutput === '' ? '' : `${sOutput}\n    `;
     }
-};
+}
 exports.SQLCodeGenBase = SQLCodeGenBase;
-exports.SQLCodeGenBase = SQLCodeGenBase = __decorate([
-    (0, global_1.RegisterClass)(SQLCodeGenBase)
-], SQLCodeGenBase);
 //# sourceMappingURL=sql_codegen.js.map