@memberjunction/codegen-lib 3.4.0 → 4.0.0

package/dist/runCodeGen.js

@@ -1,59 +1,33 @@
-"use strict";
 /**
  * Main orchestrator for the MemberJunction code generation process.
  * Coordinates all aspects of code generation including database schema analysis,
  * metadata management, SQL generation, TypeScript entities, Angular components,
  * GraphQL resolvers, and more.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runMemberJunctionCodeGeneration = exports.RunCodeGenBase = void 0;
-const graphql_server_codegen_1 = require("./Misc/graphql_server_codegen");
-const sql_codegen_1 = require("./Database/sql_codegen");
-const entity_subclasses_codegen_1 = require("./Misc/entity_subclasses_codegen");
-const sqlserver_dataprovider_1 = require("@memberjunction/sqlserver-dataprovider");
-const db_connection_1 = require("./Config/db-connection");
-const manage_metadata_1 = require("./Database/manage-metadata");
-const config_1 = require("./Config/config");
-const status_logging_1 = require("./Misc/status_logging");
-const MJ = __importStar(require("@memberjunction/core"));
-const runCommand_1 = require("./Misc/runCommand");
-const dbSchema_1 = require("./Database/dbSchema");
-const angular_codegen_1 = require("./Angular/angular-codegen");
-const sqlserver_dataprovider_2 = require("@memberjunction/sqlserver-dataprovider");
-const createNewUser_1 = require("./Misc/createNewUser");
-const global_1 = require("@memberjunction/global");
-const action_subclasses_codegen_1 = require("./Misc/action_subclasses_codegen");
-const sql_logging_1 = require("./Misc/sql_logging");
-const system_integrity_1 = require("./Misc/system_integrity");
-const actions_base_1 = require("@memberjunction/actions-base");
-const core_entities_server_1 = require("@memberjunction/core-entities-server");
-const aiengine_1 = require("@memberjunction/aiengine");
-(0, core_entities_server_1.LoadCoreEntitiesServerSubClasses)(); // Load the core entities server subclasses to ensure they are registered and not tree shaken
+import { GraphQLServerGeneratorBase } from './Misc/graphql_server_codegen.js';
+import { SQLCodeGenBase } from './Database/sql_codegen.js';
+import { EntitySubClassGeneratorBase } from './Misc/entity_subclasses_codegen.js';
+import { UserCache, setupSQLServerClient } from '@memberjunction/sqlserver-dataprovider';
+import { MSSQLConnection, sqlConfig } from './Config/db-connection.js';
+import { ManageMetadataBase } from './Database/manage-metadata.js';
+import { outputDir, commands, mj_core_schema, configInfo, getSettingValue } from './Config/config.js';
+import { logError, logWarning, startSpinner, updateSpinner, succeedSpinner, failSpinner, warnSpinner } from './Misc/status_logging.js';
+import * as MJ from '@memberjunction/core';
+import { RunCommandsBase } from './Misc/runCommand.js';
+import { DBSchemaGeneratorBase } from './Database/dbSchema.js';
+import { AngularClientGeneratorBase } from './Angular/angular-codegen.js';
+import { SQLServerProviderConfigData } from '@memberjunction/sqlserver-dataprovider';
+import { CreateNewUserBase } from './Misc/createNewUser.js';
+import { MJGlobal } from '@memberjunction/global';
+import { ActionSubClassGeneratorBase } from './Misc/action_subclasses_codegen.js';
+import { SQLLogging } from './Misc/sql_logging.js';
+import { SystemIntegrityBase } from './Misc/system_integrity.js';
+import { ActionEngineBase } from '@memberjunction/actions-base';
+import { AIEngine } from '@memberjunction/aiengine';
+// Import pre-built MJ class registrations manifest (covers all @memberjunction/* packages)
+import '@memberjunction/server-bootstrap-lite/mj-class-registrations';
 /** Extract core schema name from configuration */
-const { mjCoreSchema } = config_1.configInfo;
+const { mjCoreSchema } = configInfo;
 /**
  * Main orchestrator class for the MemberJunction code generation process.
  *
@@ -82,7 +56,7 @@ const { mjCoreSchema } = config_1.configInfo;
  * await codeGen.Run(true); // Skip database operations
  * ```
  */
-class RunCodeGenBase {
+export class RunCodeGenBase {
     /**
      * Sets up the SQL Server data source and initializes the MemberJunction core metadata.
      * This method establishes the database connection pool and configures the data provider
@@ -98,20 +72,20 @@ class RunCodeGenBase {
         /****************************************************************************************
             // First, setup the data source and make sure the metadata and related stuff for MJCore is initialized
             ****************************************************************************************/
-        (0, status_logging_1.startSpinner)('Initializing database connection...');
-        const pool = await (0, db_connection_1.MSSQLConnection)(); // get the MSSQL connection pool
-        const config = new sqlserver_dataprovider_2.SQLServerProviderConfigData(pool, (0, config_1.mj_core_schema)());
-        const sqlServerProvider = await (0, sqlserver_dataprovider_1.setupSQLServerClient)(config);
+        startSpinner('Initializing database connection...');
+        const pool = await MSSQLConnection(); // get the MSSQL connection pool
+        const config = new SQLServerProviderConfigData(pool, mj_core_schema());
+        const sqlServerProvider = await setupSQLServerClient(config);
         // Get connection details from the sqlConfig
-        let connectionInfo = db_connection_1.sqlConfig.server;
-        if (db_connection_1.sqlConfig.port) {
-            connectionInfo += `:${db_connection_1.sqlConfig.port}`;
+        let connectionInfo = sqlConfig.server;
+        if (sqlConfig.port) {
+            connectionInfo += `:${sqlConfig.port}`;
         }
-        if (db_connection_1.sqlConfig.options?.instanceName) {
-            connectionInfo += `\\${db_connection_1.sqlConfig.options.instanceName}`;
+        if (sqlConfig.options?.instanceName) {
+            connectionInfo += `\\${sqlConfig.options.instanceName}`;
         }
-        connectionInfo += `/${db_connection_1.sqlConfig.database}`;
-        (0, status_logging_1.succeedSpinner)(`Database connection initialized: ${connectionInfo}`);
+        connectionInfo += `/${sqlConfig.database}`;
+        succeedSpinner(`Database connection initialized: ${connectionInfo}`);
         return sqlServerProvider;
     }
     /**
@@ -142,329 +116,328 @@ class RunCodeGenBase {
     async Run(skipDatabaseGeneration = false) {
         try {
             const startTime = new Date();
-            (0, status_logging_1.startSpinner)(`Starting MemberJunction CodeGen @ ${startTime.toLocaleString()}`);
+            startSpinner(`Starting MemberJunction CodeGen @ ${startTime.toLocaleString()}`);
             const provider = await this.setupDataSource();
-            (0, status_logging_1.updateSpinner)('Loading user cache and metadata...');
-            const pool = await (0, db_connection_1.MSSQLConnection)();
-            await sqlserver_dataprovider_1.UserCache.Instance.Refresh(pool);
-            const userMatch = sqlserver_dataprovider_1.UserCache.Users.find((u) => u?.Type?.trim().toLowerCase() === 'owner');
-            const currentUser = userMatch ? userMatch : sqlserver_dataprovider_1.UserCache.Users[0]; // if we don't find an Owner, use the first user in the cache
+            updateSpinner('Loading user cache and metadata...');
+            const pool = await MSSQLConnection();
+            await UserCache.Instance.Refresh(pool);
+            const userMatch = UserCache.Users.find((u) => u?.Type?.trim().toLowerCase() === 'owner');
+            const currentUser = userMatch ? userMatch : UserCache.Users[0]; // if we don't find an Owner, use the first user in the cache
             // get the entity metadata
             const md = new MJ.Metadata();
             if (md.Entities.length === 0) {
-                (0, status_logging_1.failSpinner)('No entities found in metadata');
+                failSpinner('No entities found in metadata');
                 process.exit(1);
             }
-            (0, status_logging_1.succeedSpinner)(`Loaded ${md.Entities.length} entities from metadata`);
+            succeedSpinner(`Loaded ${md.Entities.length} entities from metadata`);
             // Initialize AIEngine for advanced generation features (needed for prompt metadata access)
-            if (config_1.configInfo.advancedGeneration?.enableAdvancedGeneration) {
-                (0, status_logging_1.startSpinner)('Initializing AI Engine for advanced generation...');
-                await aiengine_1.AIEngine.Instance.Config(false, currentUser);
-                (0, status_logging_1.succeedSpinner)('AI Engine initialized');
+            if (configInfo.advancedGeneration?.enableAdvancedGeneration) {
+                startSpinner('Initializing AI Engine for advanced generation...');
+                await AIEngine.Instance.Config(false, currentUser);
+                succeedSpinner('AI Engine initialized');
             }
-            const runCommandsObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(runCommand_1.RunCommandsBase);
-            const sqlCodeGenObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(sql_codegen_1.SQLCodeGenBase);
+            const runCommandsObject = MJGlobal.Instance.ClassFactory.CreateInstance(RunCommandsBase);
+            const sqlCodeGenObject = MJGlobal.Instance.ClassFactory.CreateInstance(SQLCodeGenBase);
             // check to see if the user wants to skip database generation via the config settings
-            const skipDB = skipDatabaseGeneration || (0, config_1.getSettingValue)('skip_database_generation', false);
+            const skipDB = skipDatabaseGeneration || getSettingValue('skip_database_generation', false);
             if (!skipDB) {
-                (0, status_logging_1.startSpinner)('Handling SQL Script Execution, Metadata Maintenance, and SQL Object Generation...');
-                sql_logging_1.SQLLogging.initSQLLogging(); // initialize the SQL Logging functionality
+                startSpinner('Handling SQL Script Execution, Metadata Maintenance, and SQL Object Generation...');
+                SQLLogging.initSQLLogging(); // initialize the SQL Logging functionality
                 /****************************************************************************************
                         // STEP 0 --- Precursor Step execute any commands specified in the config file
                         ****************************************************************************************/
-                const beforeCommands = (0, config_1.commands)('BEFORE');
+                const beforeCommands = commands('BEFORE');
                 if (beforeCommands && beforeCommands.length > 0) {
-                    (0, status_logging_1.updateSpinner)('Executing BEFORE commands...');
+                    updateSpinner('Executing BEFORE commands...');
                     const results = await runCommandsObject.runCommands(beforeCommands);
                     if (results.some((r) => !r.success))
-                        (0, status_logging_1.logError)('ERROR running one or more BEFORE commands');
+                        logError('ERROR running one or more BEFORE commands');
                 }
                 /****************************************************************************************
                         // STEP 0.1 --- Execute any before SQL Scripts specified in the config file
                         ****************************************************************************************/
-                (0, status_logging_1.updateSpinner)('Executing before-all SQL Scripts...');
+                updateSpinner('Executing before-all SQL Scripts...');
                 if (!(await sqlCodeGenObject.runCustomSQLScripts(pool, 'before-all')))
-                    (0, status_logging_1.logError)('ERROR running before-all SQL Scripts');
+                    logError('ERROR running before-all SQL Scripts');
                 /****************************************************************************************
                         // STEP 0.2 --- Create a new user if there is newUserSetup info in the config file
                         ****************************************************************************************/
-                const newUserSetup = config_1.configInfo.newUserSetup;
+                const newUserSetup = configInfo.newUserSetup;
                 if (newUserSetup) {
-                    (0, status_logging_1.updateSpinner)('Setting up new user...');
-                    const newUserObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(createNewUser_1.CreateNewUserBase);
+                    updateSpinner('Setting up new user...');
+                    const newUserObject = MJGlobal.Instance.ClassFactory.CreateInstance(CreateNewUserBase);
                     const result = await newUserObject.createNewUser(newUserSetup);
                     if (!result.Success) {
                         if (result.Severity === 'error') {
-                            (0, status_logging_1.logError)('ERROR creating new user');
-                            (0, status_logging_1.logError)('   ' + result.Message);
+                            logError('ERROR creating new user');
+                            logError('   ' + result.Message);
                         }
                         else {
-                            (0, status_logging_1.logWarning)('Warning: (New User Setup) ' + result.Message);
+                            logWarning('Warning: (New User Setup) ' + result.Message);
                         }
                     }
                 }
                 /****************************************************************************************
                         // STEP 1 - Manage Metadata - including generating new metadata as required
                         ****************************************************************************************/
-                const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.ManageMetadataBase);
-                (0, status_logging_1.updateSpinner)('Managing Metadata...');
+                const manageMD = MJGlobal.Instance.ClassFactory.CreateInstance(ManageMetadataBase);
+                updateSpinner('Managing Metadata...');
                 const metadataSuccess = await manageMD.manageMetadata(pool, currentUser);
                 if (!metadataSuccess) {
-                    (0, status_logging_1.failSpinner)('ERROR managing metadata');
+                    failSpinner('ERROR managing metadata');
                 }
                 else {
                     // now - we need to tell our metadata object to refresh itself
                     await provider.Refresh();
-                    (0, status_logging_1.succeedSpinner)('Metadata management completed');
+                    succeedSpinner('Metadata management completed');
                 }
                 /****************************************************************************************
                         // STEP 2 - SQL Script Generation
                         ****************************************************************************************/
-                const sqlOutputDir = (0, config_1.outputDir)('SQL', true);
+                const sqlOutputDir = outputDir('SQL', true);
                 if (sqlOutputDir) {
-                    (0, status_logging_1.startSpinner)('Managing SQL Scripts and Execution...');
+                    startSpinner('Managing SQL Scripts and Execution...');
                     const sqlSuccess = await sqlCodeGenObject.manageSQLScriptsAndExecution(pool, md.Entities, sqlOutputDir, currentUser);
                     if (!sqlSuccess) {
-                        (0, status_logging_1.failSpinner)('Error managing SQL scripts and execution');
+                        failSpinner('Error managing SQL scripts and execution');
                     }
                     else {
-                        (0, status_logging_1.succeedSpinner)('SQL scripts and execution completed');
+                        succeedSpinner('SQL scripts and execution completed');
                     }
                 }
                 else {
-                    (0, status_logging_1.warnSpinner)('SQL output directory NOT found in config file, skipping...');
+                    warnSpinner('SQL output directory NOT found in config file, skipping...');
                 }
             }
             else {
-                (0, status_logging_1.warnSpinner)('Skipping database generation (skip_database_generation = true)');
+                warnSpinner('Skipping database generation (skip_database_generation = true)');
                 // we skipped the database generation but we need to load generated code for validators from the database to ensure that we have them
                 // ready for later use.
-                const manageMD = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(manage_metadata_1.ManageMetadataBase);
-                (0, status_logging_1.startSpinner)('Checking/Loading AI Generated Code from Metadata...');
+                const manageMD = MJGlobal.Instance.ClassFactory.CreateInstance(ManageMetadataBase);
+                startSpinner('Checking/Loading AI Generated Code from Metadata...');
                 const metadataSuccess = await manageMD.loadGeneratedCode(pool, currentUser);
                 if (!metadataSuccess) {
-                    (0, status_logging_1.failSpinner)('ERROR checking/loading AI Generated Code from Metadata');
+                    failSpinner('ERROR checking/loading AI Generated Code from Metadata');
                     return; // FATAL ERROR - we can't continue
                 }
                 else {
-                    (0, status_logging_1.succeedSpinner)('AI Generated Code loaded from Metadata');
+                    succeedSpinner('AI Generated Code loaded from Metadata');
                 }
             }
             const coreEntities = md.Entities.filter((e) => e.IncludeInAPI).filter((e) => e.SchemaName.trim().toLowerCase() === mjCoreSchema.trim().toLowerCase());
             const nonCoreEntities = md.Entities.filter((e) => e.IncludeInAPI).filter((e) => e.SchemaName.trim().toLowerCase() !== mjCoreSchema.trim().toLowerCase());
             // Check if we're in verbose mode to determine spinner behavior
-            const isVerbose = config_1.configInfo?.verboseOutput ?? false;
+            const isVerbose = configInfo?.verboseOutput ?? false;
             if (!isVerbose) {
                 // In non-verbose mode, start a single spinner for all TypeScript generation
-                (0, status_logging_1.startSpinner)('Generating TypeScript code...');
+                startSpinner('Generating TypeScript code...');
             }
             /****************************************************************************************
                   // STEP 3(a) - GraphQL Server Code Gen
                   ****************************************************************************************/
-            const graphQLCoreResolversOutputDir = (0, config_1.outputDir)('GraphQLCoreEntityResolvers', false);
+            const graphQLCoreResolversOutputDir = outputDir('GraphQLCoreEntityResolvers', false);
             if (graphQLCoreResolversOutputDir) {
                 // generate the GraphQL server code
                 if (isVerbose)
-                    (0, status_logging_1.startSpinner)('Generating CORE Entity GraphQL Resolver Code...');
-                const graphQLGenerator = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(graphql_server_codegen_1.GraphQLServerGeneratorBase);
+                    startSpinner('Generating CORE Entity GraphQL Resolver Code...');
+                const graphQLGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(GraphQLServerGeneratorBase);
                 if (!graphQLGenerator.generateGraphQLServerCode(coreEntities, graphQLCoreResolversOutputDir, '@memberjunction/core-entities', true)) {
-                    (0, status_logging_1.failSpinner)('Error generating GraphQL server code');
+                    failSpinner('Error generating GraphQL server code');
                     return;
                 }
                 else if (isVerbose) {
-                    (0, status_logging_1.succeedSpinner)('CORE Entity GraphQL Resolver Code generated');
+                    succeedSpinner('CORE Entity GraphQL Resolver Code generated');
                 }
             }
-            const graphqlOutputDir = (0, config_1.outputDir)('GraphQLServer', true);
+            const graphqlOutputDir = outputDir('GraphQLServer', true);
             if (graphqlOutputDir) {
                 // generate the GraphQL server code
                 if (isVerbose)
-                    (0, status_logging_1.startSpinner)('Generating GraphQL Resolver Code...');
-                const graphQLGenerator = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(graphql_server_codegen_1.GraphQLServerGeneratorBase);
-                const entityPackageName = config_1.configInfo.entityPackageName || 'mj_generatedentities';
+                    startSpinner('Generating GraphQL Resolver Code...');
+                const graphQLGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(GraphQLServerGeneratorBase);
+                const entityPackageName = configInfo.entityPackageName || 'mj_generatedentities';
                 if (!graphQLGenerator.generateGraphQLServerCode(nonCoreEntities, graphqlOutputDir, entityPackageName, false)) {
-                    (0, status_logging_1.failSpinner)('Error generating GraphQL Resolver code');
+                    failSpinner('Error generating GraphQL Resolver code');
                     return;
                 }
                 else if (isVerbose) {
-                    (0, status_logging_1.succeedSpinner)('GraphQL Resolver Code generated');
+                    succeedSpinner('GraphQL Resolver Code generated');
                 }
             }
             else if (isVerbose) {
-                (0, status_logging_1.warnSpinner)('GraphQL server output directory NOT found in config file, skipping...');
+                warnSpinner('GraphQL server output directory NOT found in config file, skipping...');
             }
             /****************************************************************************************
                   // STEP 4 - Core Entity Subclass Code Gen
                   ****************************************************************************************/
-            const coreEntitySubClassOutputDir = (0, config_1.outputDir)('CoreEntitySubClasses', false);
+            const coreEntitySubClassOutputDir = outputDir('CoreEntitySubClasses', false);
             if (coreEntitySubClassOutputDir && coreEntitySubClassOutputDir.length > 0) {
                 // generate the entity subclass code
                 if (isVerbose)
-                    (0, status_logging_1.startSpinner)('Generating CORE Entity Subclass Code...');
-                const entitySubClassGeneratorObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(entity_subclasses_codegen_1.EntitySubClassGeneratorBase);
+                    startSpinner('Generating CORE Entity Subclass Code...');
+                const entitySubClassGeneratorObject = MJGlobal.Instance.ClassFactory.CreateInstance(EntitySubClassGeneratorBase);
                 if (!await entitySubClassGeneratorObject.generateAllEntitySubClasses(pool, coreEntities, coreEntitySubClassOutputDir, skipDB)) {
-                    (0, status_logging_1.failSpinner)('Error generating entity subclass code');
+                    failSpinner('Error generating entity subclass code');
                     return;
                 }
                 else if (isVerbose) {
-                    (0, status_logging_1.succeedSpinner)('CORE Entity Subclass Code generated');
+                    succeedSpinner('CORE Entity Subclass Code generated');
                 }
             }
             /****************************************************************************************
                   // STEP 4.1 - Entity Subclass Code Gen
                   ****************************************************************************************/
-            const entitySubClassOutputDir = (0, config_1.outputDir)('EntitySubClasses', true);
+            const entitySubClassOutputDir = outputDir('EntitySubClasses', true);
             if (entitySubClassOutputDir) {
                 // generate the entity subclass code
                 if (isVerbose)
-                    (0, status_logging_1.startSpinner)('Generating Entity Subclass Code...');
-                const entitySubClassGeneratorObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(entity_subclasses_codegen_1.EntitySubClassGeneratorBase);
+                    startSpinner('Generating Entity Subclass Code...');
+                const entitySubClassGeneratorObject = MJGlobal.Instance.ClassFactory.CreateInstance(EntitySubClassGeneratorBase);
                 if (!await entitySubClassGeneratorObject.generateAllEntitySubClasses(pool, nonCoreEntities, entitySubClassOutputDir, skipDB)) {
-                    (0, status_logging_1.failSpinner)('Error generating entity subclass code');
+                    failSpinner('Error generating entity subclass code');
                     return;
                 }
                 else if (isVerbose) {
-                    (0, status_logging_1.succeedSpinner)('Entity Subclass Code generated');
+                    succeedSpinner('Entity Subclass Code generated');
                 }
             }
             else if (isVerbose) {
-                (0, status_logging_1.warnSpinner)('Entity subclass output directory NOT found in config file, skipping...');
+                warnSpinner('Entity subclass output directory NOT found in config file, skipping...');
             }
             /****************************************************************************************
                   // STEP 5 - Angular Code Gen
                   ****************************************************************************************/
-            const angularCoreEntitiesOutputDir = (0, config_1.outputDir)('AngularCoreEntities', false);
+            const angularCoreEntitiesOutputDir = outputDir('AngularCoreEntities', false);
             if (angularCoreEntitiesOutputDir) {
                 // generate the Angular client code
                 if (isVerbose)
-                    (0, status_logging_1.startSpinner)('Generating Angular CORE Entities Code...');
-                const angularGenerator = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(angular_codegen_1.AngularClientGeneratorBase);
+                    startSpinner('Generating Angular CORE Entities Code...');
+                const angularGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(AngularClientGeneratorBase);
                 if (!(await angularGenerator.generateAngularCode(coreEntities, angularCoreEntitiesOutputDir, 'Core', currentUser))) {
-                    (0, status_logging_1.failSpinner)('Error generating Angular CORE Entities code');
+                    failSpinner('Error generating Angular CORE Entities code');
                     return;
                 }
                 else if (isVerbose) {
-                    (0, status_logging_1.succeedSpinner)('Angular CORE Entities Code generated');
+                    succeedSpinner('Angular CORE Entities Code generated');
                 }
             }
-            const angularOutputDir = (0, config_1.outputDir)('Angular', false);
+            const angularOutputDir = outputDir('Angular', false);
             if (angularOutputDir) {
                 // generate the Angular client code
                 if (isVerbose)
-                    (0, status_logging_1.startSpinner)('Generating Angular Code...');
-                const angularGenerator = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(angular_codegen_1.AngularClientGeneratorBase);
+                    startSpinner('Generating Angular Code...');
+                const angularGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(AngularClientGeneratorBase);
                 if (!(await angularGenerator.generateAngularCode(nonCoreEntities, angularOutputDir, '', currentUser))) {
-                    (0, status_logging_1.failSpinner)('Error generating Angular code');
+                    failSpinner('Error generating Angular code');
                     return;
                 }
                 else if (isVerbose) {
-                    (0, status_logging_1.succeedSpinner)('Angular Code generated');
+                    succeedSpinner('Angular Code generated');
                 }
             }
             else if (isVerbose) {
-                (0, status_logging_1.warnSpinner)('Angular output directory NOT found in config file, skipping...');
+                warnSpinner('Angular output directory NOT found in config file, skipping...');
             }
             /****************************************************************************************
                   // STEP 6 - Database Schema Output in JSON - for documentation and can be used by AI/etc.
                   ****************************************************************************************/
-            const dbSchemaOutputDir = (0, config_1.outputDir)('DBSchemaJSON', false);
+            const dbSchemaOutputDir = outputDir('DBSchemaJSON', false);
             if (dbSchemaOutputDir) {
                 // generate the GraphQL client code
                 if (isVerbose)
-                    (0, status_logging_1.startSpinner)('Generating Database Schema JSON Output...');
-                const schemaGeneratorObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(dbSchema_1.DBSchemaGeneratorBase);
+                    startSpinner('Generating Database Schema JSON Output...');
+                const schemaGeneratorObject = MJGlobal.Instance.ClassFactory.CreateInstance(DBSchemaGeneratorBase);
                 if (!schemaGeneratorObject.generateDBSchemaJSONOutput(md.Entities, dbSchemaOutputDir)) {
-                    (0, status_logging_1.failSpinner)('Error generating Database Schema JSON Output, non-fatal, continuing...');
+                    failSpinner('Error generating Database Schema JSON Output, non-fatal, continuing...');
                 }
                 else if (isVerbose) {
-                    (0, status_logging_1.succeedSpinner)('Database Schema JSON Output generated');
+                    succeedSpinner('Database Schema JSON Output generated');
                 }
             }
             else if (isVerbose) {
-                (0, status_logging_1.warnSpinner)('DB Schema output directory NOT found in config file, skipping...');
+                warnSpinner('DB Schema output directory NOT found in config file, skipping...');
             }
             /****************************************************************************************
                   // STEP 7 - Actions Code Gen
                   ****************************************************************************************/
-            const coreActionsOutputDir = (0, config_1.outputDir)('CoreActionSubclasses', false);
-            await actions_base_1.ActionEngineBase.Instance.Config(false, currentUser); // this is inefficient as we have the server 
+            const coreActionsOutputDir = outputDir('CoreActionSubclasses', false);
+            await ActionEngineBase.Instance.Config(false, currentUser); // this is inefficient as we have the server 
             if (coreActionsOutputDir) {
                 if (isVerbose)
-                    (0, status_logging_1.startSpinner)('Generating CORE Actions Code...');
-                const actionsGenerator = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(action_subclasses_codegen_1.ActionSubClassGeneratorBase);
-                if (!(await actionsGenerator.generateActions(actions_base_1.ActionEngineBase.Instance.CoreActions, coreActionsOutputDir))) {
-                    (0, status_logging_1.failSpinner)('Error generating CORE Actions code');
+                    startSpinner('Generating CORE Actions Code...');
+                const actionsGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(ActionSubClassGeneratorBase);
+                if (!(await actionsGenerator.generateActions(ActionEngineBase.Instance.CoreActions, coreActionsOutputDir))) {
+                    failSpinner('Error generating CORE Actions code');
                     return;
                 }
                 else if (isVerbose) {
-                    (0, status_logging_1.succeedSpinner)('CORE Actions Code generated');
+                    succeedSpinner('CORE Actions Code generated');
                 }
             }
-            const actionsOutputDir = (0, config_1.outputDir)('ActionSubclasses', false);
+            const actionsOutputDir = outputDir('ActionSubclasses', false);
             if (actionsOutputDir) {
                 if (isVerbose)
-                    (0, status_logging_1.startSpinner)('Generating Actions Code...');
-                const actionsGenerator = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(action_subclasses_codegen_1.ActionSubClassGeneratorBase);
-                if (!(await actionsGenerator.generateActions(actions_base_1.ActionEngineBase.Instance.NonCoreActions, actionsOutputDir))) {
-                    (0, status_logging_1.failSpinner)('Error generating Actions code');
+                    startSpinner('Generating Actions Code...');
+                const actionsGenerator = MJGlobal.Instance.ClassFactory.CreateInstance(ActionSubClassGeneratorBase);
+                if (!(await actionsGenerator.generateActions(ActionEngineBase.Instance.NonCoreActions, actionsOutputDir))) {
+                    failSpinner('Error generating Actions code');
                     return;
                 }
                 else if (isVerbose) {
-                    (0, status_logging_1.succeedSpinner)('Actions Code generated');
+                    succeedSpinner('Actions Code generated');
                 }
             }
             else if (isVerbose) {
-                (0, status_logging_1.warnSpinner)('Actions output directory NOT found in config file, skipping...');
+                warnSpinner('Actions output directory NOT found in config file, skipping...');
             }
             // WRAP UP SQL LOGGING HERE
-            sql_logging_1.SQLLogging.finishSQLLogging(); // finish up the SQL Logging
+            SQLLogging.finishSQLLogging(); // finish up the SQL Logging
             // Complete the TypeScript generation spinner in non-verbose mode
             if (!isVerbose) {
-                (0, status_logging_1.succeedSpinner)('TypeScript code generation completed');
+                succeedSpinner('TypeScript code generation completed');
             }
             // now run integrity checks
-            (0, status_logging_1.startSpinner)('Running system integrity checks...');
-            await system_integrity_1.SystemIntegrityBase.RunIntegrityChecks(pool, true);
-            (0, status_logging_1.succeedSpinner)('System integrity checks completed');
+            startSpinner('Running system integrity checks...');
+            await SystemIntegrityBase.RunIntegrityChecks(pool, true);
+            succeedSpinner('System integrity checks completed');
             /****************************************************************************************
             // STEP 8 --- Finalization Step - execute any AFTER commands specified in the config file
             ****************************************************************************************/
-            const afterCommands = (0, config_1.commands)('AFTER');
+            const afterCommands = commands('AFTER');
             if (afterCommands && afterCommands.length > 0) {
-                (0, status_logging_1.startSpinner)('Executing AFTER commands...');
+                startSpinner('Executing AFTER commands...');
                 const results = await runCommandsObject.runCommands(afterCommands);
                 if (results.some((r) => !r.success)) {
-                    (0, status_logging_1.failSpinner)('ERROR running one or more AFTER commands');
+                    failSpinner('ERROR running one or more AFTER commands');
                 }
                 else {
-                    (0, status_logging_1.succeedSpinner)('AFTER commands completed');
+                    succeedSpinner('AFTER commands completed');
                 }
             }
             /****************************************************************************************
             // STEP 9 --- Execute any AFTER SQL Scripts specified in the config file
             ****************************************************************************************/
             if (!skipDB) {
-                (0, status_logging_1.startSpinner)('Executing after-all SQL Scripts...');
+                startSpinner('Executing after-all SQL Scripts...');
                 if (!(await sqlCodeGenObject.runCustomSQLScripts(pool, 'after-all'))) {
-                    (0, status_logging_1.failSpinner)('ERROR running after-all SQL Scripts');
+                    failSpinner('ERROR running after-all SQL Scripts');
                 }
                 else {
-                    (0, status_logging_1.succeedSpinner)('After-all SQL Scripts completed');
+                    succeedSpinner('After-all SQL Scripts completed');
                 }
             }
             const endTime = new Date();
             const totalSeconds = (endTime.getTime() - startTime.getTime()) / 1000;
-            (0, status_logging_1.succeedSpinner)(`MJ CodeGen Complete! ${md.Entities.length} entities processed in ${totalSeconds}s @ ${endTime.toLocaleString()}`);
+            succeedSpinner(`MJ CodeGen Complete! ${md.Entities.length} entities processed in ${totalSeconds}s @ ${endTime.toLocaleString()}`);
             process.exit(0); // wrap it up, 0 means success
         }
         catch (e) {
-            (0, status_logging_1.failSpinner)(`CodeGen failed: ${e}`);
-            (0, status_logging_1.logError)(e);
+            failSpinner(`CodeGen failed: ${e}`);
+            logError(e);
             process.exit(1); // error code
         }
     }
 }
-exports.RunCodeGenBase = RunCodeGenBase;
 /**
  * Convenience function to run the MemberJunction code generation process.
  * Creates a new instance of RunCodeGenBase and executes the full generation pipeline.
@@ -485,9 +458,8 @@ exports.RunCodeGenBase = RunCodeGenBase;
  * await runMemberJunctionCodeGeneration(true);
  * ```
  */
-async function runMemberJunctionCodeGeneration(skipDatabaseGeneration = false) {
-    const runObject = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(RunCodeGenBase);
+export async function runMemberJunctionCodeGeneration(skipDatabaseGeneration = false) {
+    const runObject = MJGlobal.Instance.ClassFactory.CreateInstance(RunCodeGenBase);
     return await runObject.Run(skipDatabaseGeneration);
 }
-exports.runMemberJunctionCodeGeneration = runMemberJunctionCodeGeneration;
 //# sourceMappingURL=runCodeGen.js.map