@memberjunction/codegen-lib 6.2.0-edge.0 → 6.2.0-edge.1

package/dist/Database/sql_codegen.js

@@ -1,14 +1,14 @@
 import { EntityInfo, Metadata, ShouldJoinRecordGeoCodes, HasNativeLatLngFields, NativeLatitudeField, NativeLongitudeField, ListEmbeddedGeoSpecs } from '@memberjunction/core';
-import { logError, logStatus, logWarning, startSpinner, updateSpinner, succeedSpinner, failSpinner } from '../Misc/status_logging.js';
+import { logError, logStatus, LogWarning, StartSpinner, UpdateSpinner, SucceedSpinner, FailSpinner } from '../Misc/status_logging.js';
 import * as fs from 'fs';
 import path from 'path';
 import { SQLUtilityBase } from './sql.js';
 import { CodeGenDatabaseProvider } from './codeGenDatabaseProvider.js';
-import { autoIndexForeignKeys, autoIndexSoftPrimaryKeys, configInfo, customSqlScripts, mjCoreSchema } from '../Config/config.js';
-import { entityInCustomBaseViewRefreshScope, shouldEmitCascadeForRelatedEntity } from './schema-filters.js';
+import { AutoIndexForeignKeys, AutoIndexSoftPrimaryKeys, configInfo, CustomSqlScripts, mjCoreSchema } from '../Config/config.js';
+import { EntityInCustomBaseViewRefreshScope, ShouldEmitCascadeForRelatedEntity } from './schema-filters.js';
 import { ManageMetadataBase } from './manage-metadata.js';
 import { UserCache } from '@memberjunction/generic-database-provider';
-import { combineFiles, logIf } from '../Misc/util.js';
+import { CombineFiles, LogIf } from '../Misc/util.js';
 import { MJGlobal, UUIDsEqual } from '@memberjunction/global';
 import { SQLLogging } from '../Misc/sql_logging.js';
 import { TempBatchFile } from '../Misc/temp_batch_file.js';
@@ -23,10 +23,14 @@ export const SPType = {
  * This is the CodeGen run's in-scope set: SQL objects and GRANTs are
  * generated and executed only for these. excludeSchemas means "not this run".
  */
-export function entitiesNotInExcludedSchemas(entities, excludeSchemas) {
+export function EntitiesNotInExcludedSchemas(entities, excludeSchemas) {
     const exclude = new Set(excludeSchemas.map((s) => s.toLowerCase()));
     return entities.filter((e) => !exclude.has(e.SchemaName.toLowerCase()));
 }
+/** @deprecated Use {@link EntitiesNotInExcludedSchemas}. */
+export function entitiesNotInExcludedSchemas(entities, excludeSchemas) {
+    return EntitiesNotInExcludedSchemas(entities, excludeSchemas);
+}
 /**
  * This class is responsible for generating database level objects like views, stored procedures, permissions, etc. You can sub-class this class to create your own SQL generation logic or implement support for other
  * 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
@@ -85,7 +89,7 @@ export class SQLCodeGenBase {
     set DBProvider(value) {
         this._dbProvider = value;
     }
-    async manageSQLScriptsAndExecution(pool, entities, directory, currentUser) {
+    async ManageSQLScriptsAndExecution(pool, entities, directory, currentUser) {
         try {
             this.existingRoutines = null;
             // Build list of entities qualified for forced regeneration if entityWhereClause is provided
@@ -116,31 +120,31 @@ export class SQLCodeGenBase {
             //          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
-            startSpinner('Running custom SQL scripts...');
+            StartSpinner('Running custom SQL scripts...');
             const startTime = new Date();
-            if (!await this.runCustomSQLScripts(pool, 'before-sql')) {
-                failSpinner('Failed to run custom SQL scripts');
+            if (!await this.RunCustomSQLScripts(pool, 'before-sql')) {
+                FailSpinner('Failed to run custom SQL scripts');
                 return false;
             }
-            succeedSpinner(`Custom SQL scripts completed (${(new Date().getTime() - startTime.getTime()) / 1000}s)`);
+            SucceedSpinner(`Custom SQL scripts completed (${(new Date().getTime() - startTime.getTime()) / 1000}s)`);
             await this.loadExistingRoutines(pool, entities);
             // ALWAYS use the first filter where we only include entities that have IncludeInAPI = 1
             // Entities are already sorted by name in PostProcessEntityMetadata (see providerBase.ts)
             const baselineEntities = entities.filter(e => e.IncludeInAPI);
             // OPTIMIZATION: Use a Set for O(1) lookups instead of O(n) array finds to improve performance
-            const includedEntities = entitiesNotInExcludedSchemas(baselineEntities, configInfo.excludeSchemas);
+            const includedEntities = EntitiesNotInExcludedSchemas(baselineEntities, configInfo.excludeSchemas);
             // Initialize temp batch files for each schema
             // These will be populated as SQL is generated and will be used for actual execution
             const schemas = Array.from(new Set(baselineEntities.map(e => e.SchemaName))).sort();
             TempBatchFile.initialize(directory, schemas);
             // STEP 1.5 - Check for cascade delete dependencies that require regeneration
-            startSpinner('Analyzing cascade delete dependencies...');
+            StartSpinner('Analyzing cascade delete dependencies...');
             await this.markEntitiesForCascadeDeleteRegeneration(pool, includedEntities);
-            succeedSpinner('Cascade delete dependency analysis completed');
+            SucceedSpinner('Cascade delete dependency analysis completed');
             // STEP 2(a) - clean out all *.generated.sql and *.permissions.generated.sql files from the directory
-            startSpinner('Cleaning generated files...');
-            this.deleteGeneratedEntityFiles(directory, baselineEntities);
-            succeedSpinner('Cleaned generated files');
+            StartSpinner('Cleaning generated files...');
+            this.DeleteGeneratedEntityFiles(directory, baselineEntities);
+            SucceedSpinner('Cleaned generated files');
             // STEP 2(a.5) - field-level security / permission-reconciliation run context.
             // One async pass over the live catalog (permission state + service-login role
             // memberships) so the synchronous permission emitters can (1) REVOKE-and-reassert
@@ -149,7 +153,7 @@ export class SQLCodeGenBase {
             // only: PostgreSQL has no DENY primitive, so per decision D2 it emits nothing.
             await this.prepareFieldSecurityRunContext(pool);
             // STEP 2(b) - generate all the SQL files and execute them
-            startSpinner(`Generating SQL for ${includedEntities.length} entities...`);
+            StartSpinner(`Generating SQL for ${includedEntities.length} entities...`);
             const step2StartTime = new Date();
             // When the provider offers a phased executor (PG today), run per-entity
             // execution DURING file generation. This gives us view → CRUD fns →
@@ -207,7 +211,7 @@ export class SQLCodeGenBase {
             const configuredBatch = configInfo.fileEmit?.sqlEntityBatchSize ?? 8;
             const perEntityBatchSize = configInfo.dbPlatform === 'postgresql' ? 1 : configuredBatch;
             // Generate SQL for entities that don't need cascade delete regeneration
-            const genResult = await this.generateAndExecuteEntitySQLToSeparateFiles({
+            const genResult = await this.GenerateAndExecuteEntitySQLToSeparateFiles({
                 pool,
                 entities: entitiesWithoutCascadeRegeneration,
                 directory,
@@ -226,8 +230,8 @@ export class SQLCodeGenBase {
             }
             // Generate SQL for cascade delete regenerations in dependency order (sequentially)
             if (entitiesForCascadeRegeneration.length > 0) {
-                updateSpinner(`Regenerating ${entitiesForCascadeRegeneration.length} delete SPs in dependency order...`);
-                const cascadeGenResult = await this.generateAndExecuteEntitySQLToSeparateFiles({
+                UpdateSpinner(`Regenerating ${entitiesForCascadeRegeneration.length} delete SPs in dependency order...`);
+                const cascadeGenResult = await this.GenerateAndExecuteEntitySQLToSeparateFiles({
                     pool,
                     entities: entitiesForCascadeRegeneration,
                     directory,
@@ -258,18 +262,18 @@ export class SQLCodeGenBase {
             //
             // Permissions are applied in STEP 4 for includedEntities only.
             if (entityGenSuccess) {
-                succeedSpinner(`Entity generation completed (${(new Date().getTime() - step2StartTime.getTime()) / 1000}s)`);
+                SucceedSpinner(`Entity generation completed (${(new Date().getTime() - step2StartTime.getTime()) / 1000}s)`);
             }
             else {
-                failSpinner(`Entity generation completed with batch failures (${(new Date().getTime() - step2StartTime.getTime()) / 1000}s) — see post-run CRUD validator for the authoritative gap report`);
+                FailSpinner(`Entity generation completed with batch failures (${(new Date().getTime() - step2StartTime.getTime()) / 1000}s) — see post-run CRUD validator for the authoritative gap report`);
             }
             // 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
-            startSpinner('Creating combined SQL files...');
-            const allEntityFiles = this.createCombinedEntitySQLFiles(directory, includedEntities);
-            succeedSpinner(`Created combined SQL files for ${allEntityFiles.length} file(s)`);
+            StartSpinner('Creating combined SQL files...');
+            const allEntityFiles = this.CreateCombinedEntitySQLFiles(directory, includedEntities);
+            SucceedSpinner(`Created combined SQL files for ${allEntityFiles.length} file(s)`);
             // STEP 2(e) ---- FINALLY, we execute SQL in proper dependency order
             // Use temp batch files (which maintain CodeGen log order) if available, otherwise fall back to combined files
-            startSpinner('Executing entity SQL files...');
+            StartSpinner('Executing entity SQL files...');
             const step2eStartTime = new Date();
             let executionSuccess = false;
             if (useProviderPhasedExecution) {
@@ -279,26 +283,26 @@ export class SQLCodeGenBase {
                 // undo the work the phased executor just did.
                 TempBatchFile.cleanup();
                 executionSuccess = true;
-                logIf(configInfo?.verboseOutput ?? false, 'Skipping bulk SQL file execution — per-entity phased execution already ran');
+                LogIf(configInfo?.verboseOutput ?? false, 'Skipping bulk SQL file execution — per-entity phased execution already ran');
             }
             else if (TempBatchFile.hasContent()) {
                 // Execute temp batch files in dependency order (matches CodeGen run log)
                 const tempFiles = TempBatchFile.getTempFilePaths();
-                logIf(configInfo?.verboseOutput ?? false, `Executing ${tempFiles.length} temp batch file(s) in dependency order`);
+                LogIf(configInfo?.verboseOutput ?? false, `Executing ${tempFiles.length} temp batch file(s) in dependency order`);
                 executionSuccess = await this.SQLUtilityObject.executeSQLFiles(tempFiles, configInfo?.verboseOutput ?? false);
                 // Clean up temp files after execution
                 TempBatchFile.cleanup();
             }
             else {
                 // Fall back to combined files (for backward compatibility or if temp files weren't created)
-                logIf(configInfo?.verboseOutput ?? false, `Executing ${allEntityFiles.length} combined file(s)`);
+                LogIf(configInfo?.verboseOutput ?? false, `Executing ${allEntityFiles.length} combined file(s)`);
                 executionSuccess = await this.SQLUtilityObject.executeSQLFiles(allEntityFiles, configInfo?.verboseOutput ?? false);
             }
             // Initialize from entityGenSuccess so any per-batch failures from
             // STEP 2(b)/(c) carry forward instead of being lost. Bug 2 fix.
             let overallSuccess = entityGenSuccess;
             if (!executionSuccess) {
-                failSpinner('Failed to execute entity SQL files');
+                FailSpinner('Failed to execute entity SQL files');
                 TempBatchFile.cleanup(); // Cleanup on error
                 overallSuccess = false;
                 // Continue to manage entity fields metadata even after SQL execution failure.
@@ -307,7 +311,7 @@ export class SQLCodeGenBase {
             }
             else {
                 const step2eEndTime = new Date();
-                succeedSpinner(`SQL execution completed (${(step2eEndTime.getTime() - step2eStartTime.getTime()) / 1000}s)`);
+                SucceedSpinner(`SQL execution completed (${(step2eEndTime.getTime() - step2eStartTime.getTime()) / 1000}s)`);
             }
             const manageMD = MJGlobal.Instance.ClassFactory.CreateInstance(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
@@ -324,13 +328,13 @@ export class SQLCodeGenBase {
                         ...ManageMetadataBase.newEntityList,
                         ...ManageMetadataBase.modifiedEntityList,
                     ])];
-            startSpinner('Managing entity fields metadata...');
+            StartSpinner('Managing entity fields metadata...');
             if (!await manageMD.manageEntityFields(pool, configInfo.excludeSchemas, true, true, currentUser, false, false, pass2EntityFilter)) {
-                failSpinner('Failed to manage entity fields');
+                FailSpinner('Failed to manage entity fields');
                 overallSuccess = false;
             }
             else {
-                succeedSpinner('Entity fields metadata updated');
+                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 3.5 - Late-phase view regeneration
@@ -340,7 +344,7 @@ export class SQLCodeGenBase {
             const regenList = ManageMetadataBase.EntitiesRequiringViewRegen;
             if (regenList.length > 0) {
                 const uniqueEntityNames = [...new Set(regenList.map(e => e.EntityName))];
-                startSpinner(`Regenerating ${uniqueEntityNames.length} entities with late-phase view changes...`);
+                StartSpinner(`Regenerating ${uniqueEntityNames.length} entities with late-phase view changes...`);
                 // Refresh metadata to pick up DB changes from Step 3 (e.g., SupportsGeoCoding = 1)
                 const regenMd = new Metadata(); // global-provider-ok: codegen runs offline against a single provider
                 await regenMd.Refresh();
@@ -355,7 +359,7 @@ export class SQLCodeGenBase {
                     .filter((e) => e !== null);
                 if (entitiesToRegen.length > 0) {
                     // Regenerate views + SPs for affected entities only
-                    const regenResult = await this.generateAndExecuteEntitySQLToSeparateFiles({
+                    const regenResult = await this.GenerateAndExecuteEntitySQLToSeparateFiles({
                         pool,
                         entities: entitiesToRegen,
                         directory,
@@ -373,45 +377,45 @@ export class SQLCodeGenBase {
                         await manageMD.manageEntityFields(pool, configInfo.excludeSchemas, true, true, currentUser, true, false, lateRegenFilter);
                         // Apply reason-specific fixups
                         await this.applyLatePhaseFixups(pool, regenList, entitiesToRegen);
-                        succeedSpinner(`Regenerated ${entitiesToRegen.length} late-phase entities`);
+                        SucceedSpinner(`Regenerated ${entitiesToRegen.length} late-phase entities`);
                     }
                     else {
-                        failSpinner('Late-phase view regeneration failed');
+                        FailSpinner('Late-phase view regeneration failed');
                         overallSuccess = false;
                     }
                 }
                 else {
-                    succeedSpinner('No valid entities to regenerate');
+                    SucceedSpinner('No valid entities to regenerate');
                 }
             }
             // STEP 4- Apply permissions for THIS run's schemas only. Excluded-schema
             // GRANT files are not generated (see STEP 2(c) note) and must not be
             // executed: a missing sibling object would fail CodeGen with
             // "Cannot find the object 'vw…'" even though this app's work succeeded.
-            startSpinner('Applying permissions...');
+            StartSpinner('Applying permissions...');
             const step4StartTime = new Date();
-            if (!await this.applyPermissions(pool, directory, includedEntities)) {
-                failSpinner('Failed to apply permissions');
+            if (!await this.ApplyPermissions(pool, directory, includedEntities)) {
+                FailSpinner('Failed to apply permissions');
                 overallSuccess = false;
             }
             else {
-                succeedSpinner(`Permissions applied (${(new Date().getTime() - step4StartTime.getTime()) / 1000}s)`);
+                SucceedSpinner(`Permissions applied (${(new Date().getTime() - step4StartTime.getTime()) / 1000}s)`);
             }
             // STEP 4.5 - Emit sp_refreshview for modified custom base view entities into the
             // migration log file so other environments pick up schema changes automatically.
             this.emitCustomBaseViewRefreshes();
             // STEP 5 - execute any custom SQL scripts that should run afterwards
-            startSpinner('Running post-generation SQL scripts...');
+            StartSpinner('Running post-generation SQL scripts...');
             const step5StartTime = new Date();
-            if (!await this.runCustomSQLScripts(pool, 'after-sql')) {
-                failSpinner('Failed to run post-generation SQL scripts');
+            if (!await this.RunCustomSQLScripts(pool, 'after-sql')) {
+                FailSpinner('Failed to run post-generation SQL scripts');
                 overallSuccess = false;
             }
             else {
-                succeedSpinner(`Post-generation scripts completed (${(new Date().getTime() - step5StartTime.getTime()) / 1000}s)`);
+                SucceedSpinner(`Post-generation scripts completed (${(new Date().getTime() - step5StartTime.getTime()) / 1000}s)`);
             }
             if (overallSuccess) {
-                succeedSpinner(`SQL CodeGen completed successfully (${((new Date().getTime() - startTime.getTime()) / 1000)}s total)`);
+                SucceedSpinner(`SQL 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 Metadata(); // global-provider-ok: codegen runs offline against a single provider
@@ -425,6 +429,10 @@ export class SQLCodeGenBase {
             return false;
         }
     }
+    /** @deprecated Use {@link ManageSQLScriptsAndExecution}. */
+    async manageSQLScriptsAndExecution(pool, entities, directory, currentUser) {
+        return this.ManageSQLScriptsAndExecution(pool, entities, directory, currentUser);
+    }
     /**
      * Apply reason-specific fixups after late-phase view regeneration.
      * Each regen reason may require additional SQL to be executed and logged
@@ -446,9 +454,9 @@ export class SQLCodeGenBase {
             await pool.query(lngSQL);
         }
     }
-    async runCustomSQLScripts(pool, when) {
+    async RunCustomSQLScripts(pool, when) {
         try {
-            const scripts = customSqlScripts(when);
+            const scripts = CustomSqlScripts(when);
             let bSuccess = true;
             if (scripts) {
                 for (let i = 0; i < scripts.length; ++i) {
@@ -466,6 +474,10 @@ export class SQLCodeGenBase {
             return false;
         }
     }
+    /** @deprecated Use {@link RunCustomSQLScripts}. */
+    async runCustomSQLScripts(pool, when) {
+        return this.RunCustomSQLScripts(pool, when);
+    }
     /**
      * Builds the once-per-run {@link FieldSecurityRunContext} and hands it to the dialect
      * provider (whose permission emitters are synchronous string builders and cannot query).
@@ -553,19 +565,19 @@ export class SQLCodeGenBase {
             logStatus(`   Field-security run context ready: ${roleSQLNameByID.size} custom role(s), ${serviceProtected.size} service-protected role(s), ${catalog.size} object(s) with managed permissions`);
         }
         catch (e) {
-            logWarning(`   ⚠️  Could not build the field-security run context (${e instanceof Error ? e.message : String(e)}). ` +
+            LogWarning(`   ⚠️  Could not build the field-security run context (${e instanceof Error ? e.message : String(e)}). ` +
                 `Permission emission degrades to grants-only for this run: no field-security DENYs and no reconciliation REVOKEs.`);
             this._dbProvider.SetFieldSecurityRunContext(null);
         }
     }
-    async applyPermissions(pool, directory, entities, batchSize = 5) {
+    async ApplyPermissions(pool, directory, entities, batchSize = 5) {
         try {
             let bSuccess = true;
             for (let i = 0; i < entities.length; i += batchSize) {
                 const batch = entities.slice(i, i + batchSize);
                 const promises = batch.map(async (e) => {
                     // generate the file names for the entity
-                    const files = this.getEntityPermissionFileNames(e);
+                    const files = this.GetEntityPermissionFileNames(e);
                     let innerSuccess = true;
                     for (const f of files) {
                         const fullPath = path.join(directory, f);
@@ -608,6 +620,10 @@ export class SQLCodeGenBase {
             return false;
         }
     }
+    /** @deprecated Use {@link ApplyPermissions}. */
+    async applyPermissions(pool, directory, entities, batchSize = 5) {
+        return this.ApplyPermissions(pool, directory, entities, batchSize);
+    }
     /**
      * This function will handle the process of creating all of the generated objects like base view, stored procedures, etc. for all entities in the entities array. It will generate the SQL for each entity and then execute it.
      * @param ds The DataSource object to use to execute the SQL
@@ -615,7 +631,7 @@ export 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(options) {
+    async GenerateAndExecuteEntitySQLToSeparateFiles(options) {
         if (!options.batchSize)
             options.batchSize = 5; // default to 5 if not specified
         const files = [];
@@ -637,7 +653,7 @@ export class SQLCodeGenBase {
                         logError(`SKIPPING SQL GENERATION: Entity ${e.Name} has no primary key field in metadata. If using soft primary keys, ensure metadata was refreshed after applySoftPKFKConfig().`);
                         return { entity: e, result: { Success: false, Files: [] } };
                     }
-                    const result = await this.generateAndExecuteSingleEntitySQLToSeparateFiles({
+                    const result = await this.GenerateAndExecuteSingleEntitySQLToSeparateFiles({
                         pool: options.pool,
                         entity: e,
                         directory: options.directory,
@@ -673,7 +689,11 @@ export class SQLCodeGenBase {
             return { Success: false, Files: files };
         }
     }
-    deleteGeneratedEntityFiles(directory, entities) {
+    /** @deprecated Use {@link GenerateAndExecuteEntitySQLToSeparateFiles}. */
+    async generateAndExecuteEntitySQLToSeparateFiles(options) {
+        return this.GenerateAndExecuteEntitySQLToSeparateFiles(options);
+    }
+    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).sort();
@@ -702,7 +722,11 @@ export class SQLCodeGenBase {
             logError(e);
         }
     }
-    createCombinedEntitySQLFiles(directory, entities) {
+    /** @deprecated Use {@link DeleteGeneratedEntityFiles}. */
+    deleteGeneratedEntityFiles(directory, entities) {
+        return this.DeleteGeneratedEntityFiles(directory, entities);
+    }
+    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).sort();
@@ -710,17 +734,21 @@ export class SQLCodeGenBase {
             // generate the all-entities.sql file and all-entities.permissions.sql file in each schema folder
             const fullPath = path.join(directory, s);
             if (fs.statSync(fullPath).isDirectory()) {
-                combineFiles(fullPath, '_all_entities.sql', '*.generated.sql', true);
+                CombineFiles(fullPath, '_all_entities.sql', '*.generated.sql', true);
                 files.push(path.join(fullPath, '_all_entities.sql'));
-                combineFiles(fullPath, '_all_entities.permissions.sql', '*.permissions.generated.sql', true);
+                CombineFiles(fullPath, '_all_entities.permissions.sql', '*.permissions.generated.sql', true);
                 files.push(path.join(fullPath, '_all_entities.permissions.sql'));
             }
         }
         return files;
     }
-    async generateAndExecuteSingleEntitySQLToSeparateFiles(options) {
+    /** @deprecated Use {@link CreateCombinedEntitySQLFiles}. */
+    createCombinedEntitySQLFiles(directory, entities) {
+        return this.CreateCombinedEntitySQLFiles(directory, entities);
+    }
+    async GenerateAndExecuteSingleEntitySQLToSeparateFiles(options) {
         try {
-            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
+            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: true, Files: files };
             }
@@ -731,7 +759,7 @@ export class SQLCodeGenBase {
             // is explicitly gated on phase 1 success so we never create fn_*
             // against a missing or stale view rowtype.
             if (!options.onlyPermissions && this._dbProvider.executeEntityPhased) {
-                const phaseResult = await this.executeEntityInPhases(options.pool, options.entity, options.willRegenerate);
+                const phaseResult = await this.ExecuteEntityInPhases(options.pool, options.entity, options.willRegenerate);
                 if (!phaseResult.success) {
                     const where = phaseResult.phase ?? 'unknown';
                     logError(`Phased execution for ${options.entity.SchemaName}.${options.entity.Name} failed in phase "${where}": ${phaseResult.error?.message ?? '(no message)'}`);
@@ -751,13 +779,17 @@ export class SQLCodeGenBase {
             return { Success: false, Files: [] };
         }
     }
+    /** @deprecated Use {@link GenerateAndExecuteSingleEntitySQLToSeparateFiles}. */
+    async generateAndExecuteSingleEntitySQLToSeparateFiles(options) {
+        return this.GenerateAndExecuteSingleEntitySQLToSeparateFiles(options);
+    }
     /**
      * Generates the entity's per-phase SQL pieces (view, CRUD functions, view
      * permissions) and dispatches them to the provider's phased executor. Lives
      * here because it needs access to the internal generators; the provider
      * doesn't own context building for the view.
      */
-    async executeEntityInPhases(pool, entity, willRegenerate) {
+    async ExecuteEntityInPhases(pool, entity, willRegenerate) {
         // External-data-source entities have no physical MJ table/view/sproc — their data is
         // proxied live. Skip all DDL generation/execution (mirrors the early-return in
         // generateSingleEntitySQLToSeparateFiles). Without this, the view phase would
@@ -784,7 +816,7 @@ export class SQLCodeGenBase {
         const generatesView = (entity.BaseViewGenerated || entity.HasLayeredBaseView) && !entity.VirtualEntity;
         const tvfSQL = generatesView ? this.generateRecursiveFKTVFs(entity) : '';
         const viewPieces = generatesView
-            ? await this.generateBaseViewPieces(pool, entity)
+            ? await this.GenerateBaseViewPieces(pool, entity)
             : { viewSQL: '', viewPermSQL: '' };
         const crudCreateSQL = entity.AllowCreateAPI && entity.spCreateGenerated && !entity.VirtualEntity
             ? this.generateSPCreate(entity)
@@ -806,6 +838,10 @@ export class SQLCodeGenBase {
             willRegenerate,
         });
     }
+    /** @deprecated Use {@link ExecuteEntityInPhases}. */
+    async executeEntityInPhases(pool, entity, willRegenerate) {
+        return this.ExecuteEntityInPhases(pool, entity, willRegenerate);
+    }
     /**
      * Concatenates the hierarchy TVF SQL for every recursive ParentID-style FK
      * on this entity. Mirrors the inline TVF generation in
@@ -885,7 +921,7 @@ export class SQLCodeGenBase {
         }
         catch (e) {
             // Non-fatal — if we can't compare, the existing logic still runs
-            logIf(configInfo.verboseOutput, `Could not compare base view for ${entity.Name}: ${e}`);
+            LogIf(configInfo.verboseOutput, `Could not compare base view for ${entity.Name}: ${e}`);
             return false;
         }
     }
@@ -1004,7 +1040,7 @@ export class SQLCodeGenBase {
             SQLLogging.appendToSQLLogFile(sql, description);
             TempBatchFile.appendToTempBatchFile(sql, entity.SchemaName);
         }
-        logIf(configInfo.verboseOutput, `SQL Generated for ${entity.Name}: ${description}`);
+        LogIf(configInfo.verboseOutput, `SQL Generated for ${entity.Name}: ${description}`);
     }
     /**
      * Emits sp_refreshview statements into the migration log file for modified custom base view
@@ -1037,7 +1073,7 @@ export class SQLCodeGenBase {
             !e.BaseViewGenerated &&
             e.IncludeInAPI &&
             !e.VirtualEntity &&
-            entityInCustomBaseViewRefreshScope(e.SchemaName, configInfo.excludeSchemas ?? [], configInfo.includeSchemas));
+            EntityInCustomBaseViewRefreshScope(e.SchemaName, configInfo.excludeSchemas ?? [], configInfo.includeSchemas));
     }
     /**
      * Builds a combined SQL string of sp_refreshview statements for the given entities.
@@ -1074,7 +1110,7 @@ export class SQLCodeGenBase {
         })
             .join('\n');
     }
-    async generateSingleEntitySQLToSeparateFiles(options) {
+    async GenerateSingleEntitySQLToSeparateFiles(options) {
         const files = [];
         try {
             // External-data-source entities are backed by a remote system (Snowflake/MongoDB/
@@ -1101,18 +1137,18 @@ export class SQLCodeGenBase {
             // Indexes for Fkeys for the table (skip for virtual entities — views can't have indexes)
             if (!options.onlyPermissions && !options.entity.VirtualEntity) {
                 const forceIndexes = !!(configInfo.forceRegeneration?.enabled && configInfo.forceRegeneration?.indexes);
-                const shouldGenerateIndexes = autoIndexForeignKeys() || forceIndexes;
-                const indexSQL = shouldGenerateIndexes ? this.generateIndexesForForeignKeys(options.pool, options.entity) : ''; // generate indexes if auto-indexing is on OR force regeneration is enabled
+                const shouldGenerateIndexes = AutoIndexForeignKeys() || forceIndexes;
+                const indexSQL = shouldGenerateIndexes ? this.GenerateIndexesForForeignKeys(options.pool, options.entity) : ''; // generate indexes if auto-indexing is on OR force regeneration is enabled
                 // The soft-PK index rides in the same generated file (and therefore the same
                 // migration log), but on its own setting — see generateIndexForSoftPrimaryKey.
                 // Appended rather than prepended so the file's existing content stays
                 // byte-identical for every entity that has no soft PK, which is nearly all of
                 // them: writeFileIfChanged compares content, and reordering would rewrite the
                 // whole tree for no functional gain.
-                const softPKSQL = (autoIndexSoftPrimaryKeys() || forceIndexes)
-                    ? this.generateIndexForSoftPrimaryKey(options.entity)
+                const softPKSQL = (AutoIndexSoftPrimaryKeys() || forceIndexes)
+                    ? this.GenerateIndexForSoftPrimaryKey(options.entity)
                     : '';
-                const s = this.generateSingleEntitySQLFileHeader(options.entity, 'Index for Foreign Keys')
+                const s = this.GenerateSingleEntitySQLFileHeader(options.entity, 'Index for Foreign Keys')
                     + indexSQL
                     + (softPKSQL ? (indexSQL ? '\n\n' : '') + softPKSQL : '');
                 if (options.writeFiles) {
@@ -1153,7 +1189,7 @@ export class SQLCodeGenBase {
                     }
                 }
                 // Generate the base view (which may reference the TVFs created above)
-                const s = this.generateSingleEntitySQLFileHeader(options.entity, options.entity.GeneratedViewName) + await this.generateBaseView(options.pool, options.entity);
+                const s = this.GenerateSingleEntitySQLFileHeader(options.entity, options.entity.GeneratedViewName) + await this.GenerateBaseView(options.pool, options.entity);
                 // Compare generated view SQL against what's currently in the database.
                 // If the SELECT body differs, force-log just this base view via the forceLog flag
                 // so logging stays centralized in logSQLForNewOrModifiedEntity.
@@ -1176,7 +1212,7 @@ export class SQLCodeGenBase {
                 sRet += s + '\n' + this._dbProvider.BatchSeparator + '\n';
             }
             // always generate permissions for the base view
-            const permHeader = this.generateSingleEntitySQLFileHeader(options.entity, 'Permissions for ' + options.entity.BaseView);
+            const permHeader = this.GenerateSingleEntitySQLFileHeader(options.entity, 'Permissions for ' + options.entity.BaseView);
             const rawPermBody = this.generateViewPermissions(options.entity);
             // Guarded for the same reason as in generateBaseViewPieces: these GRANTs target the
             // application-owned BaseView, which does not exist during a layered entity's bootstrap
@@ -1202,12 +1238,12 @@ export class SQLCodeGenBase {
             }
             // CREATE SP
             if (options.entity.AllowCreateAPI && !options.entity.VirtualEntity) {
-                const spName = this.getSPName(options.entity, SPType.Create);
+                const spName = this.GetSPName(options.entity, SPType.Create);
                 // Only generate if spCreateGenerated is true (respects custom SPs where it's false)
                 // forceRegeneration only forces regeneration of SPs where spCreateGenerated=true
                 if (!options.onlyPermissions && options.entity.spCreateGenerated) {
                     // generate the create SP
-                    const s = this.generateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPCreate(options.entity);
+                    const s = this.GenerateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPCreate(options.entity);
                     if (options.writeFiles) {
                         const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, false, true));
                         this.writeFileIfChanged(filePath, s);
@@ -1232,12 +1268,12 @@ export class SQLCodeGenBase {
             }
             // UPDATE SP
             if (options.entity.AllowUpdateAPI && !options.entity.VirtualEntity) {
-                const spName = this.getSPName(options.entity, SPType.Update);
+                const spName = this.GetSPName(options.entity, SPType.Update);
                 // Only generate if spUpdateGenerated is true (respects custom SPs where it's false)
                 // forceRegeneration only forces regeneration of SPs where spUpdateGenerated=true
                 if (!options.onlyPermissions && options.entity.spUpdateGenerated) {
                     // generate the update SP
-                    const s = this.generateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPUpdate(options.entity);
+                    const s = this.GenerateSingleEntitySQLFileHeader(options.entity, spName) + this.generateSPUpdate(options.entity);
                     if (options.writeFiles) {
                         const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, false, true));
                         this.writeFileIfChanged(filePath, s);
@@ -1262,7 +1298,7 @@ export class SQLCodeGenBase {
             }
             // DELETE SP
             if (options.entity.AllowDeleteAPI && !options.entity.VirtualEntity) {
-                const spName = this.getSPName(options.entity, SPType.Delete);
+                const spName = this.GetSPName(options.entity, SPType.Delete);
                 // Only generate if spDeleteGenerated is true (respects custom SPs where it's false)
                 // OR if this entity has cascade delete dependencies that require regeneration
                 // forceRegeneration only forces regeneration of SPs where spDeleteGenerated=true
@@ -1273,7 +1309,7 @@ export class SQLCodeGenBase {
                     if (this.entitiesNeedingDeleteSPRegeneration.has(options.entity.ID)) {
                         logStatus(`  Regenerating ${spName} due to cascade dependency changes`);
                     }
-                    const s = this.generateSingleEntitySQLFileHeader(options.entity, spName) + await this.generateSPDelete(options.entity, options.pool);
+                    const s = this.GenerateSingleEntitySQLFileHeader(options.entity, spName) + await this.generateSPDelete(options.entity, options.pool);
                     if (options.writeFiles) {
                         const filePath = path.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('sp', options.entity.SchemaName, spName, false, true));
                         this.writeFileIfChanged(filePath, s);
@@ -1299,7 +1335,7 @@ export class SQLCodeGenBase {
             // check to see if the options.entity supports full text search or not
             if (options.entity.FullTextSearchEnabled || (configInfo.forceRegeneration?.enabled && 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.pool, 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.join(options.directory, this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', options.entity.SchemaName, options.entity.BaseTable, false, true));
@@ -1331,9 +1367,17 @@ export class SQLCodeGenBase {
             return null;
         }
     }
-    getSPName(entity, type) {
+    /** @deprecated Use {@link GenerateSingleEntitySQLToSeparateFiles}. */
+    async generateSingleEntitySQLToSeparateFiles(options) {
+        return this.GenerateSingleEntitySQLToSeparateFiles(options);
+    }
+    GetSPName(entity, type) {
         return this._dbProvider.getCRUDRoutineName(entity, type);
     }
+    /** @deprecated Use {@link GetSPName}. */
+    getSPName(entity, type) {
+        return this.GetSPName(entity, type);
+    }
     /**
      * Snapshot every CRUD routine currently in the database (one query) so
      * generate-and-log can force-emit CREATE PROC for objects that vanished
@@ -1357,7 +1401,7 @@ export class SQLCodeGenBase {
             }
         }
         catch (e) {
-            logWarning(`Could not load existing CRUD routines (missing-proc self-heal disabled this run): ${e instanceof Error ? e.message : String(e)}`);
+            LogWarning(`Could not load existing CRUD routines (missing-proc self-heal disabled this run): ${e instanceof Error ? e.message : String(e)}`);
             this.existingRoutines = null;
         }
     }
@@ -1370,7 +1414,7 @@ export class SQLCodeGenBase {
     forceLogForRoutine(entity, routineName, baseViewChanged) {
         return baseViewChanged || this.isRoutineMissing(entity.SchemaName, routineName);
     }
-    getEntityPermissionFileNames(entity) {
+    GetEntityPermissionFileNames(entity) {
         const files = [];
         // all entities have a base view - and we always generate permissions for the base view even if not generated base view
         files.push(this.SQLUtilityObject.getDBObjectFileName('view', entity.SchemaName, entity.BaseView, true, true));
@@ -1378,16 +1422,20 @@ export class SQLCodeGenBase {
         if (!entity.VirtualEntity) {
             // only add each SP file if the Allow flags are set to true, doesn't matter if the SPs are generated or not, we always generate permissions
             if (entity.AllowCreateAPI)
-                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, SPType.Create), true, true));
+                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.GetSPName(entity, SPType.Create), true, true));
             if (entity.AllowUpdateAPI)
-                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, SPType.Update), true, true));
+                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.GetSPName(entity, SPType.Update), true, true));
             if (entity.AllowDeleteAPI)
-                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.getSPName(entity, SPType.Delete), true, true));
+                files.push(this.SQLUtilityObject.getDBObjectFileName('sp', entity.SchemaName, this.GetSPName(entity, SPType.Delete), true, true));
         }
         if (entity.FullTextSearchEnabled)
             files.push(this.SQLUtilityObject.getDBObjectFileName('full_text_search_function', entity.SchemaName, entity.BaseTable, true, true));
         return files;
     }
+    /** @deprecated Use {@link GetEntityPermissionFileNames}. */
+    getEntityPermissionFileNames(entity) {
+        return this.GetEntityPermissionFileNames(entity);
+    }
     /**
      * Deprecated - do not use
      * @deprecated
@@ -1399,7 +1447,7 @@ export class SQLCodeGenBase {
         let sOutput = '';
         if (entity.BaseViewGenerated && !entity.VirtualEntity)
             // generated the base view (will include permissions)
-            sOutput += await this.generateBaseView(pool, 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';
@@ -1429,11 +1477,11 @@ export class SQLCodeGenBase {
         }
         // check to see if the entity supports full text search or not
         if (entity.FullTextSearchEnabled) {
-            sOutput += await this.generateEntityFullTextSearchSQL(pool, entity) + '\n\n';
+            sOutput += await this.GenerateEntityFullTextSearchSQL(pool, entity) + '\n\n';
         }
         return sOutput;
     }
-    async generateEntityFullTextSearchSQL(pool, entity) {
+    async GenerateEntityFullTextSearchSQL(pool, entity) {
         const searchFields = entity.Fields.filter(f => f.FullTextSearchEnabled);
         // Validate search fields exist when needed
         if (entity.FullTextIndexGenerated && searchFields.length === 0)
@@ -1443,7 +1491,7 @@ export class SQLCodeGenBase {
         // Get the primary key index name (needed for full text index)
         let primaryKeyIndexName = '';
         if (entity.FullTextIndexGenerated) {
-            primaryKeyIndexName = await this.getEntityPrimaryKeyIndexName(pool, entity);
+            primaryKeyIndexName = await this.GetEntityPrimaryKeyIndexName(pool, entity);
         }
         // If the function name is not set, save it to the DB
         const functionName = entity.FullTextSearchFunction && entity.FullTextSearchFunction.length > 0
@@ -1468,7 +1516,11 @@ export class SQLCodeGenBase {
         }
         return result;
     }
-    async getEntityPrimaryKeyIndexName(pool, entity) {
+    /** @deprecated Use {@link GenerateEntityFullTextSearchSQL}. */
+    async generateEntityFullTextSearchSQL(pool, entity) {
+        return this.GenerateEntityFullTextSearchSQL(pool, entity);
+    }
+    async GetEntityPrimaryKeyIndexName(pool, entity) {
         const sSQL = this._dbProvider.getPrimaryKeyIndexNameSQL(entity.SchemaName, entity.BaseTable);
         const resultResult = await pool.query(sSQL);
         const result = resultResult.recordset;
@@ -1477,20 +1529,36 @@ export class SQLCodeGenBase {
         else
             throw new Error(`Could not find primary key index for entity ${entity.Name}`);
     }
-    generateAllEntitiesSQLFileHeader() {
+    /** @deprecated Use {@link GetEntityPrimaryKeyIndexName}. */
+    async getEntityPrimaryKeyIndexName(pool, entity) {
+        return this.GetEntityPrimaryKeyIndexName(pool, entity);
+    }
+    GenerateAllEntitiesSQLFileHeader() {
         return this._dbProvider.generateAllEntitiesSQLFileHeader();
     }
-    generateSingleEntitySQLFileHeader(entity, itemName) {
+    /** @deprecated Use {@link GenerateAllEntitiesSQLFileHeader}. */
+    generateAllEntitiesSQLFileHeader() {
+        return this.GenerateAllEntitiesSQLFileHeader();
+    }
+    GenerateSingleEntitySQLFileHeader(entity, itemName) {
         return this._dbProvider.generateSQLFileHeader(entity, itemName);
     }
+    /** @deprecated Use {@link GenerateSingleEntitySQLFileHeader}. */
+    generateSingleEntitySQLFileHeader(entity, itemName) {
+        return this.GenerateSingleEntitySQLFileHeader(entity, itemName);
+    }
     /**
      * Generates the SQL for creating indexes for the foreign keys in the entity.
      * Delegates to the database provider for platform-specific index DDL.
      */
-    generateIndexesForForeignKeys(pool, entity) {
+    GenerateIndexesForForeignKeys(pool, entity) {
         const indexStatements = this._dbProvider.generateForeignKeyIndexes(entity);
         return indexStatements.join('\n\n');
     }
+    /** @deprecated Use {@link GenerateIndexesForForeignKeys}. */
+    generateIndexesForForeignKeys(pool, entity) {
+        return this.GenerateIndexesForForeignKeys(pool, entity);
+    }
     /**
      * Generates the composite index covering the entity's SOFT primary key. Empty for every
      * entity with a real `PRIMARY KEY` constraint, which is nearly all of them.
@@ -1500,10 +1568,14 @@ export class SQLCodeGenBase {
      * different concern from indexing foreign keys for joins and filters, and an operator's
      * opinion about one is not an opinion about the other.
      */
-    generateIndexForSoftPrimaryKey(entity) {
+    GenerateIndexForSoftPrimaryKey(entity) {
         const indexStatements = this._dbProvider.generateSoftPrimaryKeyIndex(entity);
         return indexStatements.join('\n\n');
     }
+    /** @deprecated Use {@link GenerateIndexForSoftPrimaryKey}. */
+    generateIndexForSoftPrimaryKey(entity) {
+        return this.GenerateIndexForSoftPrimaryKey(entity);
+    }
     /**
      * Detects self-referential foreign keys in an entity (e.g., ParentTaskID pointing back to Task table)
      * Returns array of field info objects representing recursive relationships
@@ -1517,7 +1589,7 @@ export class SQLCodeGenBase {
             return [];
         }
         if (entity.PrimaryKeys.length !== 1) {
-            logWarning(`[Hierarchy] Entity '${entity.Name}' has ${hierarchyFKs.length} hierarchy foreign key(s) ` +
+            LogWarning(`[Hierarchy] Entity '${entity.Name}' has ${hierarchyFKs.length} hierarchy foreign key(s) ` +
                 `(${hierarchyFKs.map(f => f.Name).join(', ')}), but has ${entity.PrimaryKeys.length} primary key fields. ` +
                 `MemberJunction hierarchy TVF generation and traversal require a single-column primary key. Skipping hierarchy generation for this entity.`);
             return [];
@@ -1535,25 +1607,25 @@ export class SQLCodeGenBase {
         return [
             {
                 functionName: metaFnName,
-                sql: this.generateSingleEntitySQLFileHeader(entity, metaFnName) + this._dbProvider.generateHierarchyMetaFunction(entity, field),
+                sql: this.GenerateSingleEntitySQLFileHeader(entity, metaFnName) + this._dbProvider.generateHierarchyMetaFunction(entity, field),
                 description: `Hierarchy Metadata Function SQL for ${entity.Name}.${field.Name}`,
                 fieldName: field.Name
             },
             {
                 functionName: descFnName,
-                sql: this.generateSingleEntitySQLFileHeader(entity, descFnName) + this._dbProvider.generateDescendantsFunction(entity, field),
+                sql: this.GenerateSingleEntitySQLFileHeader(entity, descFnName) + this._dbProvider.generateDescendantsFunction(entity, field),
                 description: `Descendants Traversal Function SQL for ${entity.Name}.${field.Name}`,
                 fieldName: field.Name
             },
             {
                 functionName: ancFnName,
-                sql: this.generateSingleEntitySQLFileHeader(entity, ancFnName) + this._dbProvider.generateAncestorsFunction(entity, field),
+                sql: this.GenerateSingleEntitySQLFileHeader(entity, ancFnName) + this._dbProvider.generateAncestorsFunction(entity, field),
                 description: `Ancestors Traversal Function SQL for ${entity.Name}.${field.Name}`,
                 fieldName: field.Name
             },
             {
                 functionName: rootFnName,
-                sql: this.generateSingleEntitySQLFileHeader(entity, rootFnName) + this._dbProvider.generateRootIDFunction(entity, field),
+                sql: this.GenerateSingleEntitySQLFileHeader(entity, rootFnName) + this._dbProvider.generateRootIDFunction(entity, field),
                 description: `Root ID Function SQL for ${entity.Name}.${field.Name}`,
                 fieldName: field.Name
             }
@@ -1681,10 +1753,14 @@ export class SQLCodeGenBase {
         }
         return joins.join('\n');
     }
-    async generateBaseView(pool, entity) {
-        const { viewSQL, viewPermSQL } = await this.generateBaseViewPieces(pool, entity);
+    async GenerateBaseView(pool, entity) {
+        const { viewSQL, viewPermSQL } = await this.GenerateBaseViewPieces(pool, entity);
         return viewSQL + viewPermSQL;
     }
+    /** @deprecated Use {@link GenerateBaseView}. */
+    async generateBaseView(pool, entity) {
+        return this.GenerateBaseView(pool, entity);
+    }
     /**
      * Same as `generateBaseView`, but returns the view DDL and the GRANT/permissions
      * DDL as separate strings rather than concatenating. Used by phased per-entity
@@ -1693,9 +1769,9 @@ export class SQLCodeGenBase {
      * phase — concatenating them would prevent the executor from detecting where
      * a failure actually occurred.
      */
-    async generateBaseViewPieces(pool, entity) {
+    async GenerateBaseViewPieces(pool, entity) {
         const classNameFirstChar = entity.BaseTableCodeName.charAt(0).toLowerCase();
-        let relatedFieldsString = await this.generateBaseViewRelatedFieldsString(pool, entity.Fields);
+        let relatedFieldsString = await this.GenerateBaseViewRelatedFieldsString(pool, entity.Fields);
         const relatedFieldsJoinString = this.generateBaseViewJoins(entity, entity.Fields);
         // Geo WRITE source: native lat/lng aliases, or RecordGeoCode JOIN when the entity
         // has writable Geo* fields and no native coords. Display-only entities (Person/Org
@@ -1750,6 +1826,10 @@ export class SQLCodeGenBase {
             viewPermSQL: permissions,
         };
     }
+    /** @deprecated Use {@link GenerateBaseViewPieces}. */
+    async generateBaseViewPieces(pool, entity) {
+        return this.GenerateBaseViewPieces(pool, entity);
+    }
     generateViewPermissions(entity) {
         return this._dbProvider.generateViewPermissions(entity);
     }
@@ -1922,7 +2002,7 @@ export class SQLCodeGenBase {
     generateRecordGeoCodeFields(qi) {
         return `    __mj_rgc.${qi('Latitude')} AS ${qi('__mj_Latitude')},\n    __mj_rgc.${qi('Longitude')} AS ${qi('__mj_Longitude')}`;
     }
-    async generateBaseViewRelatedFieldsString(pool, entityFields) {
+    async GenerateBaseViewRelatedFieldsString(pool, entityFields) {
         let sOutput = '';
         let fieldCount = 0;
         const manageMD = MJGlobal.Instance.ClassFactory.CreateInstance(ManageMetadataBase);
@@ -2084,6 +2164,10 @@ export class SQLCodeGenBase {
         }
         return sOutput;
     }
+    /** @deprecated Use {@link GenerateBaseViewRelatedFieldsString}. */
+    async generateBaseViewRelatedFieldsString(pool, entityFields) {
+        return this.GenerateBaseViewRelatedFieldsString(pool, entityFields);
+    }
     getIsNameFieldForSingleEntity(entityName) {
         const md = new Metadata(); // use the full metadata entity list, not the filtered version that we receive // global-provider-ok: codegen runs offline against a single provider
         const e = md.EntityByName(entityName);
@@ -2172,7 +2256,7 @@ export class SQLCodeGenBase {
             const md = new Metadata(); // global-provider-ok: codegen runs offline against a single provider
             // Find all fields in other entities that are foreign keys to this entity
             for (const e of md.Entities) {
-                if (!shouldEmitCascadeForRelatedEntity(entity.SchemaName, e.SchemaName, configInfo.allowCrossSchemaCascadeDeletes === true)) {
+                if (!ShouldEmitCascadeForRelatedEntity(entity.SchemaName, e.SchemaName, configInfo.allowCrossSchemaCascadeDeletes === true)) {
                     continue;
                 }
                 for (const ef of e.Fields) {
@@ -2203,7 +2287,7 @@ export class SQLCodeGenBase {
                 else {
                     // Can't delete and can't safely update - warn
                     const msg = `${relatedEntity.Name}.${fkField.Name} is part of composite unique constraint but entity doesn't allow delete API`;
-                    logWarning(`WARNING in spDelete${parentEntity.BaseTableCodeName}: ${msg}`);
+                    LogWarning(`WARNING in spDelete${parentEntity.BaseTableCodeName}: ${msg}`);
                     return `
     -- WARNING: ${msg} - cascade operation may fail due to unique constraint violation`;
                 }
@@ -2221,7 +2305,7 @@ export class SQLCodeGenBase {
             // Nullable FK but no update API - this is a configuration error
             const sqlComment = `WARNING: ${relatedEntity.BaseTable} has nullable FK to ${parentEntity.BaseTable} but doesn't allow update API - cascade operation will fail`;
             const consoleMsg = `WARNING in spDelete${parentEntity.BaseTableCodeName} generation: ${relatedEntity.BaseTable} has nullable FK to ${parentEntity.BaseTable} but doesn't allow update API - cascade operation will fail`;
-            logWarning(consoleMsg);
+            LogWarning(consoleMsg);
             return `
     -- ${sqlComment}
     -- This will cause the delete operation to fail due to referential integrity`;
@@ -2230,7 +2314,7 @@ export class SQLCodeGenBase {
             // Entity doesn't allow delete API, so we can't cascade delete
             const sqlComment = `WARNING: ${relatedEntity.BaseTable} has non-nullable FK to ${parentEntity.BaseTable} but doesn't allow delete API - cascade operation will fail`;
             const consoleMsg = `WARNING in spDelete${parentEntity.BaseTableCodeName} generation: ${relatedEntity.BaseTable} has non-nullable FK to ${parentEntity.BaseTable} but doesn't allow delete API - cascade operation will fail`;
-            logWarning(consoleMsg);
+            LogWarning(consoleMsg);
             return `
     -- ${sqlComment}
     -- This will cause a referential integrity violation`;
@@ -2272,7 +2356,7 @@ export class SQLCodeGenBase {
             return result.recordset.length > 0;
         }
         catch (error) {
-            logWarning(`Failed to check composite unique constraint for ${schemaName}.${tableName}.${columnName}: ${error}`);
+            LogWarning(`Failed to check composite unique constraint for ${schemaName}.${tableName}.${columnName}: ${error}`);
             return false; // Fallback to existing UPDATE behavior
         }
     }
@@ -2285,7 +2369,7 @@ export class SQLCodeGenBase {
             const md = new Metadata(); // global-provider-ok: codegen runs offline against a single provider
             // Find all fields in other entities that are foreign keys to this entity
             for (const e of md.Entities) {
-                if (!shouldEmitCascadeForRelatedEntity(entity.SchemaName, e.SchemaName, configInfo.allowCrossSchemaCascadeDeletes === true)) {
+                if (!ShouldEmitCascadeForRelatedEntity(entity.SchemaName, e.SchemaName, configInfo.allowCrossSchemaCascadeDeletes === true)) {
                     continue;
                 }
                 for (const ef of e.Fields) {