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

package/dist/runCodeGen.js

@@ -10,25 +10,25 @@ import { GraphQLServerGeneratorBase } from './Misc/graphql_server_codegen.js';
 import { SQLCodeGenBase } from './Database/sql_codegen.js';
 import { EntitySubClassGeneratorBase } from './Misc/entity_subclasses_codegen.js';
 import { ManageMetadataBase } from './Database/manage-metadata.js';
-import { applyIncludeSchemaScope } from './Database/schema-scope.js';
-import { partitionEntitiesByOutputDirectory } from './Config/schema-output.js';
-import { outputDir, commands, configInfo, getSettingValue, dbPlatform, getExternalEntitySchemas, initializeConfig, applyInProcessAdvancedGenerationPolicy, IN_PROCESS_ADVANCED_GENERATION_ENV } from './Config/config.js';
-import { resolveDirtySchemasForEmit, schemaKey } from './Misc/schema-emit.js';
+import { ApplyIncludeSchemaScope } from './Database/schema-scope.js';
+import { PartitionEntitiesByOutputDirectory } from './Config/schema-output.js';
+import { OutputDir, Commands, configInfo, GetSettingValue, DbPlatform, GetExternalEntitySchemas, InitializeConfig, ApplyInProcessAdvancedGenerationPolicy, IN_PROCESS_ADVANCED_GENERATION_ENV } from './Config/config.js';
+import { ResolveDirtySchemasForEmit, SchemaKey } from './Misc/schema-emit.js';
 import { EmitStats } from './Misc/emit-stats.js';
-import { logError, logStatus, logWarning, startSpinner, updateSpinner, succeedSpinner, failSpinner, warnSpinner } from './Misc/status_logging.js';
+import { logError, logStatus, LogWarning, StartSpinner, UpdateSpinner, SucceedSpinner, FailSpinner, WarnSpinner } from './Misc/status_logging.js';
 import { CodeGenReporter } from './Misc/codegen-reporter.js';
 import * as MJ from '@memberjunction/core';
-import { RunCommandsBase, formatCommandFailureDetail } from './Misc/runCommand.js';
+import { RunCommandsBase, FormatCommandFailureDetail } from './Misc/runCommand.js';
 import { DBSchemaGeneratorBase } from './Database/dbSchema.js';
 import { AngularClientGeneratorBase } from './Angular/angular-codegen.js';
 import { CreateNewUserBase } from './Misc/createNewUser.js';
 import { MJGlobal } from '@memberjunction/global';
 import { ActionSubClassGeneratorBase } from './Misc/action_subclasses_codegen.js';
-import { RemoteOperationGeneratorBase, resolveRemoteOperationSchema } from './Misc/remote_operations_codegen.js';
+import { RemoteOperationGeneratorBase, ResolveRemoteOperationSchema } from './Misc/remote_operations_codegen.js';
 import { SQLLogging } from './Misc/sql_logging.js';
-import { resolveCodeGenDatabaseProvider } from './Database/codeGenDatabaseProvider.js';
+import { ResolveCodeGenDatabaseProvider } from './Database/codeGenDatabaseProvider.js';
 import { SystemIntegrityBase } from './Misc/system_integrity.js';
-import { reconcileFieldLevelSecurity } from './Database/reconcileFieldLevelSecurity.js';
+import { ReconcileFieldLevelSecurity } from './Database/reconcileFieldLevelSecurity.js';
 import { ActionEngineBase } from '@memberjunction/actions-base';
 import { AIEngine } from '@memberjunction/aiengine';
 // Import pre-built MJ class registrations manifest (covers all @memberjunction/* packages)
@@ -60,7 +60,7 @@ export class RunCodeGenBase {
             if (!r.success) {
                 const cmd = cmds[i];
                 const cmdText = cmd ? [cmd.command, ...(cmd.args ?? [])].join(' ').trim() : `command #${i + 1}`;
-                const detail = formatCommandFailureDetail(r);
+                const detail = FormatCommandFailureDetail(r);
                 const failure = {
                     context: `${phase} command`,
                     message: detail ? `\`${cmdText}\` failed: ${detail}` : `\`${cmdText}\` failed`,
@@ -85,8 +85,12 @@ export class RunCodeGenBase {
      * `ClassFactory.CreateInstance` returns the abstract base on a missed
      * lookup, so we disambiguate by constructor identity.
      */
+    async SetupDataSource() {
+        return ResolveCodeGenDatabaseProvider(DbPlatform()).SetupDataSource();
+    }
+    /** @deprecated Use {@link SetupDataSource}. */
     async setupDataSource() {
-        return resolveCodeGenDatabaseProvider(dbPlatform()).SetupDataSource();
+        return this.SetupDataSource();
     }
     /**
      * Main entry point for the complete code generation process.
@@ -101,7 +105,7 @@ export class RunCodeGenBase {
             // Re-initialize config from the specified working directory (e.g. repo root)
             // so CodeGen picks up the correct mj.config.cjs with output directories
             if (workingDirectory) {
-                initializeConfig(workingDirectory);
+                InitializeConfig(workingDirectory);
             }
             // Drop the process-static soft-PK/FK cache so this run re-reads additionalSchemaInfo from disk.
             // RSU rewrites that file (WriteAdditionalSchemaInfo) immediately before invoking this in-process
@@ -112,7 +116,7 @@ export class RunCodeGenBase {
             // In-process runs are the runtime schema-update path, where the CLI's full AI profile turns a
             // minutes-class step into an hours-class one and a bad AI answer can drop a table. Off unless the
             // operator opts in; see applyInProcessAdvancedGenerationPolicy for the reasoning.
-            const advancedGeneration = applyInProcessAdvancedGenerationPolicy(configInfo);
+            const advancedGeneration = ApplyInProcessAdvancedGenerationPolicy(configInfo);
             if (advancedGeneration.disabled) {
                 logStatus(`In-process CodeGen: advanced (AI) generation is off for this run; set ${IN_PROCESS_ADVANCED_GENERATION_ENV}=1 to keep it on`);
             }
@@ -144,9 +148,9 @@ export class RunCodeGenBase {
         const startMs = Date.now();
         try {
             const startTime = new Date();
-            const platform = dbPlatform();
-            startSpinner('Starting MemberJunction CodeGen (' + platform + ') @ ' + startTime.toLocaleString());
-            const dataSource = await this.setupDataSource();
+            const platform = DbPlatform();
+            StartSpinner('Starting MemberJunction CodeGen (' + platform + ') @ ' + startTime.toLocaleString());
+            const dataSource = await this.SetupDataSource();
             const success = await this.executeCodeGenPipeline(dataSource, skipDatabaseGeneration, skipFileGeneration);
             let entityCount = 0;
             try {
@@ -168,15 +172,15 @@ export class RunCodeGenBase {
                 durationSeconds: (Date.now() - startMs) / 1000,
                 data: {
                     entityCount,
-                    skippedDb: skipDatabaseGeneration || getSettingValue('skip_database_generation', false),
-                    skippedFiles: skipFileGeneration || getSettingValue('skip_file_generation', false),
+                    skippedDb: skipDatabaseGeneration || GetSettingValue('skip_database_generation', false),
+                    skippedFiles: skipFileGeneration || GetSettingValue('skip_file_generation', false),
                 },
                 errors,
             };
         }
         catch (e) {
             const message = e instanceof Error ? (e.stack ?? e.message) : String(e);
-            failSpinner('CodeGen failed: ' + e);
+            FailSpinner('CodeGen failed: ' + e);
             logError(message);
             return {
                 success: false,
@@ -196,8 +200,8 @@ export class RunCodeGenBase {
         ManageMetadataBase.clearFieldTracking();
         const reporter = CodeGenReporter.Instance;
         reporter.startRun();
-        reporter.mark('platform', dbPlatform());
-        reporter.mark('skipDB', skipDatabaseGeneration || getSettingValue('skip_database_generation', false));
+        reporter.mark('platform', DbPlatform());
+        reporter.mark('skipDB', skipDatabaseGeneration || GetSettingValue('skip_database_generation', false));
         let pipelineSuccess = true;
         this.commandFailures = [];
         try {
@@ -208,9 +212,9 @@ export class RunCodeGenBase {
                 }
                 logStatus('Loaded ' + m.Entities.length + ' entities from metadata');
                 if (configInfo.advancedGeneration?.enableAdvancedGeneration) {
-                    startSpinner('Initializing AI Engine for advanced generation...');
+                    StartSpinner('Initializing AI Engine for advanced generation...');
                     await AIEngine.Instance.Config(false, currentUser);
-                    succeedSpinner('AI Engine initialized');
+                    SucceedSpinner('AI Engine initialized');
                 }
                 return m;
             });
@@ -220,16 +224,16 @@ export class RunCodeGenBase {
             // so the scope still applies on the `--skipdb` path, which skips manageMetadata entirely but
             // still generates files from configInfo.excludeSchemas. applyIncludeSchemaScope is idempotent, so
             // running both is safe and the second pass is a no-op when the first already ran.
-            applyIncludeSchemaScope(Array.from(new Set(md.Entities.map((e) => e.SchemaName))), configInfo);
+            ApplyIncludeSchemaScope(Array.from(new Set(md.Entities.map((e) => e.SchemaName))), configInfo);
             const runCommandsObject = MJGlobal.Instance.ClassFactory.CreateInstance(RunCommandsBase);
             const sqlCodeGenObject = MJGlobal.Instance.ClassFactory.CreateInstance(SQLCodeGenBase);
-            const skipDB = skipDatabaseGeneration || getSettingValue('skip_database_generation', false);
+            const skipDB = skipDatabaseGeneration || GetSettingValue('skip_database_generation', false);
             if (!skipDB) {
-                startSpinner('Handling SQL Script Execution, Metadata Maintenance, and SQL Object Generation...');
+                StartSpinner('Handling SQL Script Execution, Metadata Maintenance, and SQL Object Generation...');
                 SQLLogging.initSQLLogging();
-                const beforeCommands = commands('BEFORE');
+                const beforeCommands = Commands('BEFORE');
                 if (beforeCommands && beforeCommands.length > 0) {
-                    updateSpinner('Executing BEFORE commands...');
+                    UpdateSpinner('Executing BEFORE commands...');
                     const results = await runCommandsObject.runCommands(beforeCommands);
                     if (results.some((r) => !r.success)) {
                         logError('ERROR running one or more BEFORE commands');
@@ -241,12 +245,12 @@ export class RunCodeGenBase {
                         }
                     }
                 }
-                updateSpinner('Executing before-all SQL Scripts...');
+                UpdateSpinner('Executing before-all SQL Scripts...');
                 if (!(await sqlCodeGenObject.runCustomSQLScripts(conn, 'before-all')))
                     logError('ERROR running before-all SQL Scripts');
                 const newUserSetup = configInfo.newUserSetup;
                 if (newUserSetup) {
-                    updateSpinner('Setting up new user...');
+                    UpdateSpinner('Setting up new user...');
                     const newUserObject = MJGlobal.Instance.ClassFactory.CreateInstance(CreateNewUserBase);
                     const result = await newUserObject.createNewUser(newUserSetup);
                     if (!result.Success) {
@@ -255,12 +259,12 @@ export class RunCodeGenBase {
                             logError('   ' + result.Message);
                         }
                         else {
-                            logWarning('Warning: (New User Setup) ' + result.Message);
+                            LogWarning('Warning: (New User Setup) ' + result.Message);
                         }
                     }
                 }
                 const manageMD = MJGlobal.Instance.ClassFactory.CreateInstance(ManageMetadataBase);
-                updateSpinner('Managing Metadata...');
+                UpdateSpinner('Managing Metadata...');
                 const metadataSuccess = await reporter.phase('manageMetadata', () => manageMD.manageMetadata(conn, currentUser));
                 // Refresh in-memory metadata UNCONDITIONALLY after manageMetadata, even when it returned
                 // false. manageMetadata can return false on non-fatal sub-failures (e.g. failed validator
@@ -270,34 +274,34 @@ export class RunCodeGenBase {
                 // 3-bug chain, observed first-run on PG for entities like SystemEvent.
                 await provider.Refresh();
                 if (!metadataSuccess) {
-                    failSpinner('ERROR managing metadata (refresh applied; downstream will use latest available state)');
+                    FailSpinner('ERROR managing metadata (refresh applied; downstream will use latest available state)');
                     pipelineSuccess = false;
                 }
                 else {
-                    succeedSpinner('Metadata management completed');
+                    SucceedSpinner('Metadata management completed');
                 }
                 // Field-level security reconciliation. Runs AFTER the refresh above so it sees the
                 // EntityField rows manageMetadata just created for newly-discovered columns: on an
                 // FLS-enabled entity a field with no permission rows is DENIED, so a column added
                 // without this step would be invisible to every user until something else reconciled.
                 // It also removes rows orphaned by a dropped column or a revoked role.
-                await reporter.phase('reconcileFieldPermissions', () => reconcileFieldLevelSecurity(provider, currentUser));
-                const sqlOutputDir = outputDir('SQL', true);
+                await reporter.phase('reconcileFieldPermissions', () => ReconcileFieldLevelSecurity(provider, currentUser));
+                const sqlOutputDir = OutputDir('SQL', true);
                 let sqlGenerationSucceeded = true;
                 if (sqlOutputDir) {
-                    startSpinner('Managing SQL Scripts and Execution...');
+                    StartSpinner('Managing SQL Scripts and Execution...');
                     const sqlSuccess = await reporter.phase('manageSQLScriptsAndExecution', () => sqlCodeGenObject.manageSQLScriptsAndExecution(conn, md.Entities, sqlOutputDir, currentUser));
                     if (!sqlSuccess) {
-                        failSpinner('Error managing SQL scripts and execution');
+                        FailSpinner('Error managing SQL scripts and execution');
                         sqlGenerationSucceeded = false;
                         pipelineSuccess = false;
                     }
                     else {
-                        succeedSpinner('SQL scripts and execution completed');
+                        SucceedSpinner('SQL scripts and execution completed');
                     }
                 }
                 else {
-                    warnSpinner('SQL output directory NOT found in config file, skipping...');
+                    WarnSpinner('SQL output directory NOT found in config file, skipping...');
                 }
                 // ── Post-run CRUD validator ─────────────────────────────────────────
                 // Runs UNCONDITIONALLY even when the SQL pipeline reported failure so
@@ -314,10 +318,10 @@ export class RunCodeGenBase {
                 // but the default behavior is to fail loudly and exit non-zero.
                 const skipCRUDValidation = process.env.MJ_CODEGEN_SKIP_CRUD_VALIDATION === 'true';
                 if (skipCRUDValidation) {
-                    logWarning('Skipping post-CodeGen CRUD function validation (MJ_CODEGEN_SKIP_CRUD_VALIDATION=true)');
+                    LogWarning('Skipping post-CodeGen CRUD function validation (MJ_CODEGEN_SKIP_CRUD_VALIDATION=true)');
                 }
                 else {
-                    startSpinner('Validating expected CRUD routines exist in database...');
+                    StartSpinner('Validating expected CRUD routines exist in database...');
                     try {
                         // Use the same baseline filter as manageSQLScriptsAndExecution: only
                         // entities flagged IncludeInAPI=true are expected to have routines.
@@ -372,7 +376,7 @@ export class RunCodeGenBase {
                             const list = missing
                                 .map(m => `  - [${m.schema}] ${m.entity} → missing ${m.type} routine: ${m.expectedRoutine}`)
                                 .join('\n');
-                            failSpinner(`Post-CodeGen CRUD validation FAILED: ${missing.length} expected routine(s) missing`);
+                            FailSpinner(`Post-CodeGen CRUD validation FAILED: ${missing.length} expected routine(s) missing`);
                             logError(`Post-CodeGen validation detected ${missing.length} CRUD routine(s) the runtime expects but the database is missing.\n` +
                                 `These entities are configured (AllowCreateAPI/AllowUpdateAPI/AllowDeleteAPI=true) to expose mutations via the API,\n` +
                                 `but the underlying database routine wasn't emitted/applied by CodeGen — runtime saves/deletes on these entities will throw:\n` +
@@ -385,11 +389,11 @@ export class RunCodeGenBase {
                             return false;
                         }
                         else {
-                            succeedSpinner(`Post-CodeGen CRUD validation passed (${md.Entities.length} entities checked)`);
+                            SucceedSpinner(`Post-CodeGen CRUD validation passed (${md.Entities.length} entities checked)`);
                         }
                     }
                     catch (e) {
-                        failSpinner('Post-CodeGen CRUD validation errored');
+                        FailSpinner('Post-CodeGen CRUD validation errored');
                         logError(`CRUD validator threw: ${e instanceof Error ? e.message : String(e)}`);
                         return false;
                     }
@@ -410,7 +414,7 @@ export class RunCodeGenBase {
                 // Set MJ_CODEGEN_STRICT_FIELD_RESOLUTION=true to make it a hard gate; that is the
                 // intended default once fleets are clean.
                 try {
-                    startSpinner('Validating entity fields resolve against their base views...');
+                    StartSpinner('Validating entity fields resolve against their base views...');
                     const baseline = md.Entities.filter(e => e.IncludeInAPI);
                     const gaps = await sqlCodeGenObject.DBProvider.validateEntityFieldsResolve(conn, baseline);
                     if (gaps.length > 0) {
@@ -429,21 +433,21 @@ export class RunCodeGenBase {
                             `Fix: rebuild the affected base view(s). PostgreSQL permits appending columns in place via\n` +
                             `CREATE OR REPLACE VIEW, so no DROP/CASCADE is required.`;
                         if (strict) {
-                            failSpinner(`Field-resolution validation FAILED: ${gaps.length} unreadable field(s)`);
+                            FailSpinner(`Field-resolution validation FAILED: ${gaps.length} unreadable field(s)`);
                             logError(summary);
                             return false;
                         }
-                        warnSpinner(`Field-resolution validation found ${gaps.length} unreadable field(s)`);
-                        logWarning(summary);
+                        WarnSpinner(`Field-resolution validation found ${gaps.length} unreadable field(s)`);
+                        LogWarning(summary);
                     }
                     else {
-                        succeedSpinner('Entity fields all resolve against their base views');
+                        SucceedSpinner('Entity fields all resolve against their base views');
                     }
                 }
                 catch (e) {
                     // Never fail the run on the validator's own error — it is a reporter.
-                    warnSpinner('Field-resolution validation could not run');
-                    logWarning(`Field-resolution validator threw: ${e instanceof Error ? e.message : String(e)}`);
+                    WarnSpinner('Field-resolution validation could not run');
+                    LogWarning(`Field-resolution validator threw: ${e instanceof Error ? e.message : String(e)}`);
                 }
                 // Surface upstream SQL-pipeline failure even if validator passed: a
                 // green validator just means whatever DID get generated is consistent;
@@ -453,7 +457,7 @@ export class RunCodeGenBase {
                 }
             }
             else {
-                warnSpinner('Skipping database generation (skip_database_generation = true)');
+                WarnSpinner('Skipping database generation (skip_database_generation = true)');
             }
             // Persisted validators must reach file generation on EVERY path, not just the skip-DB one.
             //
@@ -474,10 +478,10 @@ export class RunCodeGenBase {
             // deduplicates by `functionName` over a deterministic sort, so a validator both freshly
             // generated and read back from `GeneratedCode` yields one emission, not two.
             const manageMD = MJGlobal.Instance.ClassFactory.CreateInstance(ManageMetadataBase);
-            startSpinner('Checking/Loading AI Generated Code from Metadata...');
+            StartSpinner('Checking/Loading AI Generated Code from Metadata...');
             const metadataSuccess = await reporter.phase('loadGeneratedCode', () => manageMD.loadGeneratedCode(conn, currentUser));
             if (!metadataSuccess) {
-                failSpinner('ERROR checking/loading AI Generated Code from Metadata');
+                FailSpinner('ERROR checking/loading AI Generated Code from Metadata');
                 pipelineSuccess = false;
                 return false;
             }
@@ -488,22 +492,22 @@ export class RunCodeGenBase {
                 // whatever was committed. Both times that regression shipped, the log said exactly this
                 // line and nothing else. A number here makes the next one visible in CI output.
                 const loadedValidators = ManageMetadataBase.generatedValidators.length;
-                succeedSpinner(`AI Generated Code loaded from Metadata (${loadedValidators} validator${loadedValidators === 1 ? '' : 's'})`);
+                SucceedSpinner(`AI Generated Code loaded from Metadata (${loadedValidators} validator${loadedValidators === 1 ? '' : 's'})`);
             }
-            const skipFiles = skipFileGeneration || getSettingValue('skip_file_generation', false);
+            const skipFiles = skipFileGeneration || GetSettingValue('skip_file_generation', false);
             if (skipFiles) {
-                warnSpinner('Skipping file generation (skip_file_generation = true)');
+                WarnSpinner('Skipping file generation (skip_file_generation = true)');
                 SQLLogging.finishSQLLogging();
             }
             else if (!(await this.runFileGenerationPhase(conn, currentUser, md, skipDB))) {
                 pipelineSuccess = false;
                 return false;
             }
-            startSpinner('Running system integrity checks...');
+            StartSpinner('Running system integrity checks...');
             const integrityResults = await SystemIntegrityBase.RunIntegrityChecks(conn, true);
             const integrityFailures = integrityResults.filter((r) => !r.Success);
             if (integrityFailures.length > 0) {
-                failSpinner(`System integrity checks FAILED: ${integrityFailures.length} check(s) failed`);
+                FailSpinner(`System integrity checks FAILED: ${integrityFailures.length} check(s) failed`);
                 pipelineSuccess = false;
                 for (const failure of integrityFailures) {
                     const msg = `Integrity check '${failure.Name}' failed: ${failure.Message}`;
@@ -513,14 +517,14 @@ export class RunCodeGenBase {
                 }
             }
             else {
-                succeedSpinner('System integrity checks completed');
+                SucceedSpinner('System integrity checks completed');
             }
-            const afterCommands = commands('AFTER');
+            const afterCommands = Commands('AFTER');
             if (afterCommands && afterCommands.length > 0) {
-                startSpinner('Executing AFTER commands...');
+                StartSpinner('Executing AFTER commands...');
                 const results = await runCommandsObject.runCommands(afterCommands);
                 if (results.some((r) => !r.success)) {
-                    failSpinner('ERROR running one or more AFTER commands');
+                    FailSpinner('ERROR running one or more AFTER commands');
                     const recorded = this.recordCommandFailures('AFTER', afterCommands, results);
                     pipelineSuccess = false;
                     for (const failure of recorded) {
@@ -529,21 +533,21 @@ export class RunCodeGenBase {
                     }
                 }
                 else
-                    succeedSpinner('AFTER commands completed');
+                    SucceedSpinner('AFTER commands completed');
             }
             if (!skipDB) {
-                startSpinner('Executing after-all SQL Scripts...');
+                StartSpinner('Executing after-all SQL Scripts...');
                 if (!(await sqlCodeGenObject.runCustomSQLScripts(conn, 'after-all')))
-                    failSpinner('ERROR running after-all SQL Scripts');
+                    FailSpinner('ERROR running after-all SQL Scripts');
                 else
-                    succeedSpinner('After-all SQL Scripts completed');
+                    SucceedSpinner('After-all SQL Scripts completed');
             }
             const endTime = new Date();
             const totalSeconds = (endTime.getTime() - startTime.getTime()) / 1000;
             // Visible final summary (succeedSpinner persists a ✔ line in both verbose and
             // non-verbose modes). The detailed/timestamped form stays on logStatus for the
             // verbose log + report.
-            succeedSpinner(`MJ CodeGen complete — ${md.Entities.length} entities in ${totalSeconds.toFixed(2)}s`);
+            SucceedSpinner(`MJ CodeGen complete — ${md.Entities.length} entities in ${totalSeconds.toFixed(2)}s`);
             logStatus('MJ CodeGen Complete! ' + md.Entities.length + ' entities processed in ' + totalSeconds + 's @ ' + endTime.toLocaleString());
             // A BEFORE/AFTER command failure fails the run (success=false, exit 1) so it
             // isn't silently swallowed — details flow into the structured result below.
@@ -584,7 +588,7 @@ export class RunCodeGenBase {
     buildSchemaEmitOptions(entities, skipDB) {
         const fileEmit = configInfo.fileEmit;
         return {
-            dirtySchemas: resolveDirtySchemasForEmit(entities, [...ManageMetadataBase.newEntityList, ...ManageMetadataBase.modifiedEntityList], skipDB, fileEmit?.dirtySchemaOnly !== false, ManageMetadataBase.deletedEntitySchemaList),
+            dirtySchemas: ResolveDirtySchemasForEmit(entities, [...ManageMetadataBase.newEntityList, ...ManageMetadataBase.modifiedEntityList], skipDB, fileEmit?.dirtySchemaOnly !== false, ManageMetadataBase.deletedEntitySchemaList),
         };
     }
     /**
@@ -600,12 +604,12 @@ export class RunCodeGenBase {
         const reporter = CodeGenReporter.Instance;
         EmitStats.Reset();
         const apiEntities = md.Entities.filter((e) => e.IncludeInAPI);
-        const excludedSchemaNames = configInfo.excludeSchemas.map(s => schemaKey(s));
-        const includedEntities = apiEntities.filter((e) => !excludedSchemaNames.includes(schemaKey(e.SchemaName)));
+        const excludedSchemaNames = configInfo.excludeSchemas.map(s => SchemaKey(s));
+        const includedEntities = apiEntities.filter((e) => !excludedSchemaNames.includes(SchemaKey(e.SchemaName)));
         const excludedCount = apiEntities.length - includedEntities.length;
         if (excludedCount > 0) {
             const excludedBySchema = apiEntities
-                .filter((e) => excludedSchemaNames.includes(schemaKey(e.SchemaName)))
+                .filter((e) => excludedSchemaNames.includes(SchemaKey(e.SchemaName)))
                 .reduce((acc, e) => {
                 const schema = (e.SchemaName ?? '').trim() || '(none)';
                 acc[schema] = (acc[schema] || 0) + 1;
@@ -616,42 +620,42 @@ export class RunCodeGenBase {
                 .join(', ');
             logStatus('Excluded ' + excludedCount + ' entities from code generation by schema: ' + schemaDetails);
         }
-        const coreEntities = includedEntities.filter((e) => schemaKey(e.SchemaName) === schemaKey(mjCoreSchema));
-        const nonCoreEntities = includedEntities.filter((e) => schemaKey(e.SchemaName) !== schemaKey(mjCoreSchema));
+        const coreEntities = includedEntities.filter((e) => SchemaKey(e.SchemaName) === SchemaKey(mjCoreSchema));
+        const nonCoreEntities = includedEntities.filter((e) => SchemaKey(e.SchemaName) !== SchemaKey(mjCoreSchema));
         // Entities whose schemas are owned by OTHER packages (see entityPackageName map). They must be
         // excluded from every artifact this package emits — GraphQL ObjectTypes included. If two packages
         // both emit an ObjectType for the same entity, graphql-js rejects the unified schema at boot with
         // "Schema must contain uniquely named types but contains multiple types named ..." and the API
         // crash-loops.
-        const externalSchemas = getExternalEntitySchemas().map(s => s.toLowerCase());
+        const externalSchemas = GetExternalEntitySchemas().map(s => s.toLowerCase());
         const localNonCoreEntities = externalSchemas.length > 0
-            ? nonCoreEntities.filter(e => !externalSchemas.includes(schemaKey(e.SchemaName)))
+            ? nonCoreEntities.filter(e => !externalSchemas.includes(SchemaKey(e.SchemaName)))
             : nonCoreEntities;
         const isVerbose = configInfo?.verboseOutput ?? false;
         if (!isVerbose)
-            startSpinner('Generating TypeScript code...');
-        const graphQLCoreResolversOutputDir = outputDir('GraphQLCoreEntityResolvers', false);
+            StartSpinner('Generating TypeScript code...');
+        const graphQLCoreResolversOutputDir = OutputDir('GraphQLCoreEntityResolvers', false);
         if (graphQLCoreResolversOutputDir) {
             if (isVerbose)
-                startSpinner('Generating CORE Entity GraphQL Resolver Code...');
+                StartSpinner('Generating CORE Entity GraphQL Resolver Code...');
             const graphQLGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(GraphQLServerGeneratorBase);
             const ok = await reporter.phase('generateGraphQLCore', async () => graphQLGenerator.generateGraphQLServerCode(coreEntities, graphQLCoreResolversOutputDir, '@memberjunction/core-entities', true, this.buildSchemaEmitOptions(coreEntities, skipDB)));
             if (!ok) {
-                failSpinner('Error generating GraphQL server code');
+                FailSpinner('Error generating GraphQL server code');
                 return false;
             }
             else if (isVerbose)
-                succeedSpinner('CORE Entity GraphQL Resolver Code generated');
+                SucceedSpinner('CORE Entity GraphQL Resolver Code generated');
         }
-        const graphqlOutputDir = outputDir('GraphQLServer', true);
+        const graphqlOutputDir = OutputDir('GraphQLServer', true);
         if (graphqlOutputDir) {
             if (isVerbose)
-                startSpinner('Generating GraphQL Resolver Code...');
+                StartSpinner('Generating GraphQL Resolver Code...');
             const graphQLGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(GraphQLServerGeneratorBase);
             const entityPackageName = typeof configInfo.entityPackageName === 'string'
                 ? (configInfo.entityPackageName || 'mj_generatedentities')
                 : 'mj_generatedentities';
-            const graphqlGroups = partitionEntitiesByOutputDirectory(localNonCoreEntities, 'GraphQLServer', graphqlOutputDir, configInfo.schemaOutput);
+            const graphqlGroups = PartitionEntitiesByOutputDirectory(localNonCoreEntities, 'GraphQLServer', graphqlOutputDir, configInfo.schemaOutput);
             const ok = await reporter.phase('generateGraphQL', async () => {
                 for (const [dir, group] of graphqlGroups) {
                     const groupOk = graphQLGenerator.generateGraphQLServerCode(group, dir, entityPackageName, false, this.buildSchemaEmitOptions(group, skipDB));
@@ -662,33 +666,33 @@ export class RunCodeGenBase {
                 return true;
             });
             if (!ok) {
-                failSpinner('Error generating GraphQL Resolver code');
+                FailSpinner('Error generating GraphQL Resolver code');
                 return false;
             }
             else if (isVerbose)
-                succeedSpinner('GraphQL Resolver Code generated');
+                SucceedSpinner('GraphQL Resolver Code generated');
         }
         else if (isVerbose)
-            warnSpinner('GraphQL server output directory NOT found in config file, skipping...');
-        const coreEntitySubClassOutputDir = outputDir('CoreEntitySubClasses', false);
+            WarnSpinner('GraphQL server output directory NOT found in config file, skipping...');
+        const coreEntitySubClassOutputDir = OutputDir('CoreEntitySubClasses', false);
         if (coreEntitySubClassOutputDir && coreEntitySubClassOutputDir.length > 0) {
             if (isVerbose)
-                startSpinner('Generating CORE Entity Subclass Code...');
+                StartSpinner('Generating CORE Entity Subclass Code...');
             const entitySubClassGeneratorObject = MJGlobal.Instance.ClassFactory.CreateInstance(EntitySubClassGeneratorBase);
             const ok = await reporter.phase('generateEntitySubclassesCore', () => entitySubClassGeneratorObject.generateAllEntitySubClasses(conn, coreEntities, coreEntitySubClassOutputDir, skipDB, this.buildSchemaEmitOptions(coreEntities, skipDB)));
             if (!ok) {
-                failSpinner('Error generating entity subclass code');
+                FailSpinner('Error generating entity subclass code');
                 return false;
             }
             else if (isVerbose)
-                succeedSpinner('CORE Entity Subclass Code generated');
+                SucceedSpinner('CORE Entity Subclass Code generated');
         }
-        const entitySubClassOutputDir = outputDir('EntitySubClasses', true);
+        const entitySubClassOutputDir = OutputDir('EntitySubClasses', true);
         if (entitySubClassOutputDir) {
             if (isVerbose)
-                startSpinner('Generating Entity Subclass Code...');
+                StartSpinner('Generating Entity Subclass Code...');
             const entitySubClassGeneratorObject = MJGlobal.Instance.ClassFactory.CreateInstance(EntitySubClassGeneratorBase);
-            const entityGroups = partitionEntitiesByOutputDirectory(localNonCoreEntities, 'EntitySubClasses', entitySubClassOutputDir, configInfo.schemaOutput);
+            const entityGroups = PartitionEntitiesByOutputDirectory(localNonCoreEntities, 'EntitySubClasses', entitySubClassOutputDir, configInfo.schemaOutput);
             const ok = await reporter.phase('generateEntitySubclasses', async () => {
                 for (const [dir, group] of entityGroups) {
                     const groupOk = await entitySubClassGeneratorObject.generateAllEntitySubClasses(conn, group, dir, skipDB, this.buildSchemaEmitOptions(group, skipDB));
@@ -699,33 +703,33 @@ export class RunCodeGenBase {
                 return true;
             });
             if (!ok) {
-                failSpinner('Error generating entity subclass code');
+                FailSpinner('Error generating entity subclass code');
                 return false;
             }
             else if (isVerbose)
-                succeedSpinner('Entity Subclass Code generated');
+                SucceedSpinner('Entity Subclass Code generated');
         }
         else if (isVerbose)
-            warnSpinner('Entity subclass output directory NOT found in config file, skipping...');
-        const angularCoreEntitiesOutputDir = outputDir('AngularCoreEntities', false);
+            WarnSpinner('Entity subclass output directory NOT found in config file, skipping...');
+        const angularCoreEntitiesOutputDir = OutputDir('AngularCoreEntities', false);
         if (angularCoreEntitiesOutputDir) {
             if (isVerbose)
-                startSpinner('Generating Angular CORE Entities Code...');
+                StartSpinner('Generating Angular CORE Entities Code...');
             const angularGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(AngularClientGeneratorBase);
             const ok = await reporter.phase('generateAngularCore', () => angularGenerator.generateAngularCode(coreEntities, angularCoreEntitiesOutputDir, 'Core', currentUser, 'AngularCoreEntities'));
             if (!ok) {
-                failSpinner('Error generating Angular CORE Entities code');
+                FailSpinner('Error generating Angular CORE Entities code');
                 return false;
             }
             else if (isVerbose)
-                succeedSpinner('Angular CORE Entities Code generated');
+                SucceedSpinner('Angular CORE Entities Code generated');
         }
-        const angularOutputDir = outputDir('Angular', false);
+        const angularOutputDir = OutputDir('Angular', false);
         if (angularOutputDir) {
             if (isVerbose)
-                startSpinner('Generating Angular Code...');
+                StartSpinner('Generating Angular Code...');
             const angularGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(AngularClientGeneratorBase);
-            const angularGroups = partitionEntitiesByOutputDirectory(localNonCoreEntities, 'Angular', angularOutputDir, configInfo.schemaOutput);
+            const angularGroups = PartitionEntitiesByOutputDirectory(localNonCoreEntities, 'Angular', angularOutputDir, configInfo.schemaOutput);
             const ok = await reporter.phase('generateAngular', async () => {
                 for (const [dir, group] of angularGroups) {
                     const groupOk = angularGenerator.generateAngularCode(group, dir, '', currentUser, 'Angular');
@@ -736,64 +740,64 @@ export class RunCodeGenBase {
                 return true;
             });
             if (!ok) {
-                failSpinner('Error generating Angular code');
+                FailSpinner('Error generating Angular code');
                 return false;
             }
             else if (isVerbose)
-                succeedSpinner('Angular Code generated');
+                SucceedSpinner('Angular Code generated');
         }
         else if (isVerbose)
-            warnSpinner('Angular output directory NOT found in config file, skipping...');
-        const dbSchemaOutputDir = outputDir('DBSchemaJSON', false);
+            WarnSpinner('Angular output directory NOT found in config file, skipping...');
+        const dbSchemaOutputDir = OutputDir('DBSchemaJSON', false);
         if (dbSchemaOutputDir) {
             if (isVerbose)
-                startSpinner('Generating Database Schema JSON Output...');
+                StartSpinner('Generating Database Schema JSON Output...');
             const schemaGeneratorObject = MJGlobal.Instance.ClassFactory.CreateInstance(DBSchemaGeneratorBase);
             await reporter.phase('generateDBSchema', async () => {
                 if (!schemaGeneratorObject.generateDBSchemaJSONOutput(md.Entities, dbSchemaOutputDir)) {
-                    failSpinner('Error generating Database Schema JSON Output, non-fatal, continuing...');
+                    FailSpinner('Error generating Database Schema JSON Output, non-fatal, continuing...');
                 }
                 else if (isVerbose)
-                    succeedSpinner('Database Schema JSON Output generated');
+                    SucceedSpinner('Database Schema JSON Output generated');
             });
         }
         else if (isVerbose)
-            warnSpinner('DB Schema output directory NOT found in config file, skipping...');
-        const coreActionsOutputDir = outputDir('CoreActionSubclasses', false);
+            WarnSpinner('DB Schema output directory NOT found in config file, skipping...');
+        const coreActionsOutputDir = OutputDir('CoreActionSubclasses', false);
         await ActionEngineBase.Instance.Config(false, currentUser);
         if (coreActionsOutputDir) {
             if (isVerbose)
-                startSpinner('Generating CORE Actions Code...');
+                StartSpinner('Generating CORE Actions Code...');
             const actionsGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(ActionSubClassGeneratorBase);
             const ok = await reporter.phase('generateActionsCore', () => actionsGenerator.generateActions(ActionEngineBase.Instance.CoreActions, coreActionsOutputDir));
             if (!ok) {
-                failSpinner('Error generating CORE Actions code');
+                FailSpinner('Error generating CORE Actions code');
                 return false;
             }
             else if (isVerbose)
-                succeedSpinner('CORE Actions Code generated');
+                SucceedSpinner('CORE Actions Code generated');
         }
-        const actionsOutputDir = outputDir('ActionSubclasses', false);
+        const actionsOutputDir = OutputDir('ActionSubclasses', false);
         if (actionsOutputDir) {
             if (isVerbose)
-                startSpinner('Generating Actions Code...');
+                StartSpinner('Generating Actions Code...');
             const actionsGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(ActionSubClassGeneratorBase);
             const ok = await reporter.phase('generateActions', () => actionsGenerator.generateActions(ActionEngineBase.Instance.NonCoreActions, actionsOutputDir));
             if (!ok) {
-                failSpinner('Error generating Actions code');
+                FailSpinner('Error generating Actions code');
                 return false;
             }
             else if (isVerbose)
-                succeedSpinner('Actions Code generated');
+                SucceedSpinner('Actions Code generated');
         }
         else if (isVerbose)
-            warnSpinner('Actions output directory NOT found in config file, skipping...');
+            WarnSpinner('Actions output directory NOT found in config file, skipping...');
         // Remote Operations — emit the typed BaseRemotableOperation subclass for each MJ: Remote Operations row.
         // Two output targets, parallel to the entity-subclass split: `CoreRemoteOperations` (MJ core ops, shipped
         // in @memberjunction/core-entities) and `RemoteOperations` (downstream/user ops, their GeneratedEntities).
         // Remote operations are scoped to includeSchemas / excludeSchemas and partitioned between core and non-core.
-        const coreRemoteOpsDir = outputDir('CoreRemoteOperations', false);
-        const nonCoreRemoteOpsDir = outputDir('RemoteOperations', false);
+        const coreRemoteOpsDir = OutputDir('CoreRemoteOperations', false);
+        const nonCoreRemoteOpsDir = OutputDir('RemoteOperations', false);
         if (coreRemoteOpsDir || nonCoreRemoteOpsDir) {
             const remoteOpsResult = await new MJ.RunView().RunView({ EntityName: 'MJ: Remote Operations', ResultType: 'entity_object' }, currentUser);
             const allRemoteOps = remoteOpsResult.Results ?? [];
@@ -804,17 +808,17 @@ export class RunCodeGenBase {
             ])).filter(Boolean);
             const opsWithSchema = allRemoteOps.map((op) => ({
                 op,
-                schema: resolveRemoteOperationSchema(op, md.Entities, allCandidateSchemas, mjCoreSchema),
+                schema: ResolveRemoteOperationSchema(op, md.Entities, allCandidateSchemas, mjCoreSchema),
             }));
             // Filter operations by excludedSchemaNames (compiled includeSchemas/excludeSchemas scope)
             // and by includeSchemas (if explicitly configured).
             const inScopeOpsWithSchema = opsWithSchema.filter(({ schema }) => {
-                const key = schemaKey(schema);
+                const key = SchemaKey(schema);
                 if (excludedSchemaNames.includes(key)) {
                     return false;
                 }
                 if (configInfo.includeSchemas && configInfo.includeSchemas.length > 0) {
-                    const includeKeys = configInfo.includeSchemas.map((s) => schemaKey(s));
+                    const includeKeys = configInfo.includeSchemas.map((s) => SchemaKey(s));
                     if (!includeKeys.includes(key)) {
                         return false;
                     }
@@ -825,11 +829,11 @@ export class RunCodeGenBase {
             if (excludedOpsCount > 0) {
                 const excludedBySchema = opsWithSchema
                     .filter(({ schema }) => {
-                    const key = schemaKey(schema);
+                    const key = SchemaKey(schema);
                     if (excludedSchemaNames.includes(key))
                         return true;
                     if (configInfo.includeSchemas && configInfo.includeSchemas.length > 0) {
-                        return !configInfo.includeSchemas.map((s) => schemaKey(s)).includes(key);
+                        return !configInfo.includeSchemas.map((s) => SchemaKey(s)).includes(key);
                     }
                     return false;
                 })
@@ -844,10 +848,10 @@ export class RunCodeGenBase {
                 logStatus(`Excluded ${excludedOpsCount} remote operation(s) from code generation by schema: ${details}`);
             }
             const coreRemoteOps = inScopeOpsWithSchema
-                .filter(({ schema }) => schemaKey(schema) === schemaKey(mjCoreSchema))
+                .filter(({ schema }) => SchemaKey(schema) === SchemaKey(mjCoreSchema))
                 .map(({ op }) => op);
             const nonCoreRemoteOps = inScopeOpsWithSchema
-                .filter(({ schema }) => schemaKey(schema) !== schemaKey(mjCoreSchema))
+                .filter(({ schema }) => SchemaKey(schema) !== SchemaKey(mjCoreSchema))
                 .map(({ op }) => op);
             const remoteOpsGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(RemoteOperationGeneratorBase);
             for (const target of [
@@ -857,18 +861,18 @@ export class RunCodeGenBase {
                 if (!target.dir)
                     continue;
                 if (isVerbose)
-                    startSpinner(`Generating ${target.label} typed bases...`);
+                    StartSpinner(`Generating ${target.label} typed bases...`);
                 const ok = await reporter.phase(target.phase, () => remoteOpsGenerator.generateRemoteOperations(target.ops, target.dir));
                 if (!ok) {
-                    failSpinner(`Error generating ${target.label} code`);
+                    FailSpinner(`Error generating ${target.label} code`);
                     return false;
                 }
                 else if (isVerbose)
-                    succeedSpinner(`${target.label} typed bases generated`);
+                    SucceedSpinner(`${target.label} typed bases generated`);
             }
         }
         else if (isVerbose)
-            warnSpinner('Remote Operations output directory NOT found in config file, skipping...');
+            WarnSpinner('Remote Operations output directory NOT found in config file, skipping...');
         const emit = EmitStats.Snapshot();
         reporter.counter('filesWritten', emit.filesWritten);
         reporter.counter('filesSkipped', emit.filesSkipped);
@@ -880,25 +884,33 @@ export class RunCodeGenBase {
             `(assemble ${emit.assembleMs}ms)`);
         SQLLogging.finishSQLLogging();
         if (!isVerbose)
-            succeedSpinner('TypeScript code generation completed');
+            SucceedSpinner('TypeScript code generation completed');
         return true;
     }
 }
 /**
  * Convenience function to run the MemberJunction code generation process.
  */
-export async function runMemberJunctionCodeGeneration(skipDatabaseGeneration = false, skipFileGeneration = false) {
+export async function RunMemberJunctionCodeGeneration(skipDatabaseGeneration = false, skipFileGeneration = false) {
     const runObject = MJGlobal.Instance.ClassFactory.CreateInstance(RunCodeGenBase);
     return await runObject.Run(skipDatabaseGeneration, skipFileGeneration);
 }
+/** @deprecated Use {@link RunMemberJunctionCodeGeneration}. */
+export async function runMemberJunctionCodeGeneration(skipDatabaseGeneration = false, skipFileGeneration = false) {
+    return RunMemberJunctionCodeGeneration(skipDatabaseGeneration, skipFileGeneration);
+}
 /**
  * Like {@link runMemberJunctionCodeGeneration}, but returns a structured
  * {@link MJCLIResult} instead of calling `process.exit()`. The pluggable
  * `mj codegen` plugin uses this so the runtime host can emit the result
  * (e.g. `--format=json`) before the CLI exits.
  */
-export async function runMemberJunctionCodeGenerationWithResult(skipDatabaseGeneration = false, skipFileGeneration = false) {
+export async function RunMemberJunctionCodeGenerationWithResult(skipDatabaseGeneration = false, skipFileGeneration = false) {
     const runObject = MJGlobal.Instance.ClassFactory.CreateInstance(RunCodeGenBase);
     return await runObject.RunWithResult(skipDatabaseGeneration, skipFileGeneration);
 }
+/** @deprecated Use {@link RunMemberJunctionCodeGenerationWithResult}. */
+export async function runMemberJunctionCodeGenerationWithResult(skipDatabaseGeneration = false, skipFileGeneration = false) {
+    return RunMemberJunctionCodeGenerationWithResult(skipDatabaseGeneration, skipFileGeneration);
+}
 //# sourceMappingURL=runCodeGen.js.map