@memberjunction/codegen-lib 2.48.0 → 2.49.0

package/dist/Database/sql_codegen.js

@@ -49,33 +49,36 @@ exports.SPType = {
  * of that abstract base class and other databases will be sub-classes of the abstract base class as well.
  */
 class SQLCodeGenBase {
-    constructor() {
-        this._sqlUtilityObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(sql_1.SQLUtilityBase);
-        this.__specialUUIDValue = '00000000-0000-0000-0000-000000000000';
-    }
+    _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,
@@ -85,12 +88,13 @@ 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,
@@ -100,41 +104,50 @@ 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();
@@ -145,7 +158,7 @@ class SQLCodeGenBase {
             return false;
         }
     }
-    async runCustomSQLScripts(ds, when) {
+    async runCustomSQLScripts(pool, when) {
         try {
             const scripts = (0, config_1.customSqlScripts)(when);
             let bSuccess = true;
@@ -165,7 +178,7 @@ 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) {
@@ -180,7 +193,7 @@ 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}`);
@@ -231,7 +244,7 @@ class SQLCodeGenBase {
                         return { Success: false, Files: [] };
                     }
                     return this.generateAndExecuteSingleEntitySQLToSeparateFiles({
-                        ds: options.ds,
+                        pool: options.pool,
                         entity: e,
                         directory: options.directory,
                         onlyPermissions: options.onlyPermissions,
@@ -304,7 +317,7 @@ 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
                 };
             }
@@ -317,9 +330,26 @@ 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}`);
@@ -338,7 +368,8 @@ 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));
@@ -349,9 +380,11 @@ 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);
@@ -377,7 +410,9 @@ 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) {
@@ -405,7 +440,9 @@ 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) {
@@ -433,7 +470,9 @@ 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) {
@@ -459,9 +498,9 @@ 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));
@@ -528,11 +567,11 @@ 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';
@@ -562,11 +601,11 @@ 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) {
@@ -586,7 +625,7 @@ 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 *
@@ -653,7 +692,7 @@ class SQLCodeGenBase {
         }
         return { sql, functionName };
     }
-    async getEntityPrimaryKeyIndexName(ds, entity) {
+    async getEntityPrimaryKeyIndexName(pool, entity) {
         const sSQL = `  SELECT
         i.name AS IndexName
     FROM
@@ -668,7 +707,8 @@ 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
@@ -700,10 +740,10 @@ 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) {
@@ -726,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
@@ -776,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);
@@ -808,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++;
             }
@@ -863,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 = '';
@@ -874,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 {
@@ -921,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}]
         (
@@ -930,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
@@ -1007,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) {
@@ -1020,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;