@memberjunction/codegen-lib 3.3.0 → 4.0.0

package/dist/Config/config.js

@@ -1,123 +1,117 @@
-"use strict";
 /**
  * Configuration management module for MemberJunction CodeGen.
  * Handles loading, parsing, and validation of configuration files using Zod schemas.
  * Supports various configuration sources through cosmiconfig (package.json, .mjrc, etc.).
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mj_core_schema = exports.MAX_INDEX_NAME_LENGTH = exports.autoIndexForeignKeys = exports.getSettingValue = exports.getSetting = exports.customSqlScripts = exports.commands = exports.outputOptionValue = exports.outputOptions = exports.outputDir = exports.initializeConfig = exports.dbDatabase = exports.mjCoreSchema = exports.configInfo = exports.currentWorkingDirectory = exports.DEFAULT_CODEGEN_CONFIG = void 0;
-const zod_1 = require("zod");
-const cosmiconfig_1 = require("cosmiconfig");
-const path_1 = __importDefault(require("path"));
-const status_logging_1 = require("../Misc/status_logging");
-const config_1 = require("@memberjunction/config");
+import { z } from 'zod';
+import { cosmiconfigSync } from 'cosmiconfig';
+import path from 'path';
+import { logStatus } from '../Misc/status_logging.js';
+import { mergeConfigs, parseBooleanEnv } from '@memberjunction/config';
 /** Global configuration explorer for finding MJ config files */
-const explorer = (0, cosmiconfig_1.cosmiconfigSync)('mj', { searchStrategy: 'global' });
+const explorer = cosmiconfigSync('mj', { searchStrategy: 'global' });
 /** Initial config search result from current working directory */
 const configSearchResult = explorer.search(process.cwd());
-const settingInfoSchema = zod_1.z.object({
+const settingInfoSchema = z.object({
     /** The name/key of the setting */
-    name: zod_1.z.string(),
+    name: z.string(),
     /** The value of the setting (can be any type) */
-    value: zod_1.z.any(),
+    value: z.any(),
 });
-const logInfoSchema = zod_1.z.object({
+const logInfoSchema = z.object({
     /** Whether logging is enabled */
-    log: zod_1.z.boolean().default(true),
+    log: z.boolean().default(true),
     /** File path for log output */
-    logFile: zod_1.z.string().default('codegen.output.log'),
+    logFile: z.string().default('codegen.output.log'),
     /** Whether to also log to console */
-    console: zod_1.z.boolean().default(true),
+    console: z.boolean().default(true),
 });
-const customSQLScriptSchema = zod_1.z.object({
+const customSQLScriptSchema = z.object({
     /** When to run the script (e.g., 'before-all', 'after-all') */
-    when: zod_1.z.string(),
+    when: z.string(),
     /** Path to the SQL script file */
-    scriptFile: zod_1.z.string(),
+    scriptFile: z.string(),
 });
-const commandInfoSchema = zod_1.z.object({
+const commandInfoSchema = z.object({
     /** Working directory to run the command from */
-    workingDirectory: zod_1.z.string(),
+    workingDirectory: z.string(),
     /** The command to execute */
-    command: zod_1.z.string(),
+    command: z.string(),
     /** Command line arguments */
-    args: zod_1.z.string().array(),
+    args: z.string().array(),
     /** Optional timeout in milliseconds */
-    timeout: zod_1.z.number().nullish(),
+    timeout: z.number().nullish(),
     /** When to run the command (e.g., 'before', 'after') */
-    when: zod_1.z.string(),
+    when: z.string(),
 });
-const outputOptionInfoSchema = zod_1.z.object({
+const outputOptionInfoSchema = z.object({
     /** Name of the output option */
-    name: zod_1.z.string(),
+    name: z.string(),
     /** Value of the output option */
-    value: zod_1.z.any(),
+    value: z.any(),
 });
-const outputInfoSchema = zod_1.z.object({
+const outputInfoSchema = z.object({
     /** Type of output (e.g., 'SQL', 'Angular', 'GraphQLServer') */
-    type: zod_1.z.string(),
+    type: z.string(),
     /** Directory path for output files */
-    directory: zod_1.z.string(),
+    directory: z.string(),
     /** Whether to append additional output code subdirectory */
-    appendOutputCode: zod_1.z.boolean().optional(),
+    appendOutputCode: z.boolean().optional(),
     /** Additional options for this output type */
     options: outputOptionInfoSchema.array().optional(),
 });
-const tableInfoSchema = zod_1.z.object({
+const tableInfoSchema = z.object({
     /** Schema name (supports wildcards like '%') */
-    schema: zod_1.z.string(),
+    schema: z.string(),
     /** Table name (supports wildcards like 'sys%') */
-    table: zod_1.z.string(),
+    table: z.string(),
 });
-const dbSchemaJSONOutputBundleSchema = zod_1.z.object({
+const dbSchemaJSONOutputBundleSchema = z.object({
     /** Name of the bundle */
-    name: zod_1.z.string(),
+    name: z.string(),
     /** Schemas to include in this bundle */
-    schemas: zod_1.z.string().array().default([]),
+    schemas: z.string().array().default([]),
     /** Schemas to exclude from this bundle */
-    excludeSchemas: zod_1.z.string().array().default(['sys', 'staging']),
+    excludeSchemas: z.string().array().default(['sys', 'staging']),
     /** Entities to exclude from this bundle */
-    excludeEntities: zod_1.z.string().array().default([]),
+    excludeEntities: z.string().array().default([]),
 });
-const dbSchemaJSONOutputSchema = zod_1.z.object({
-    excludeEntities: zod_1.z.string().array(),
-    excludeSchemas: zod_1.z.string().array().default(['sys', 'staging', 'dbo']),
+const dbSchemaJSONOutputSchema = z.object({
+    excludeEntities: z.string().array(),
+    excludeSchemas: z.string().array().default(['sys', 'staging', 'dbo']),
     bundles: dbSchemaJSONOutputBundleSchema.array().default([{ name: '_Core_Apps', excludeSchemas: ['__mj'] }]),
 });
-const newUserSetupSchema = zod_1.z.object({
-    UserName: zod_1.z.string(),
-    FirstName: zod_1.z.string(),
-    LastName: zod_1.z.string(),
-    Email: zod_1.z.string(),
-    Roles: zod_1.z.string().array().default(['Developer', 'Integration', 'UI']),
-    CreateUserApplicationRecords: zod_1.z.boolean().optional().default(false),
-    UserApplications: zod_1.z.array(zod_1.z.string()).optional().default([]),
+const newUserSetupSchema = z.object({
+    UserName: z.string(),
+    FirstName: z.string(),
+    LastName: z.string(),
+    Email: z.string(),
+    Roles: z.string().array().default(['Developer', 'Integration', 'UI']),
+    CreateUserApplicationRecords: z.boolean().optional().default(false),
+    UserApplications: z.array(z.string()).optional().default([]),
 });
-const advancedGenerationFeatureOptionSchema = zod_1.z.object({
+const advancedGenerationFeatureOptionSchema = z.object({
     /** Name of the option */
-    name: zod_1.z.string(),
+    name: z.string(),
     /** Value of the option (can be any type) */
-    value: zod_1.z.unknown(),
+    value: z.unknown(),
 });
-const advancedGenerationFeatureSchema = zod_1.z.object({
+const advancedGenerationFeatureSchema = z.object({
     /** Name of the feature */
-    name: zod_1.z.string(),
+    name: z.string(),
     /** Whether the feature is enabled */
-    enabled: zod_1.z.boolean(),
+    enabled: z.boolean(),
     /** Description for documentation (not used by code) */
-    description: zod_1.z.string().nullish(),
+    description: z.string().nullish(),
     /** System prompt for AI interaction */
-    systemPrompt: zod_1.z.string().nullish(),
+    systemPrompt: z.string().nullish(),
     /** User message template for AI interaction */
-    userMessage: zod_1.z.string().nullish(),
+    userMessage: z.string().nullish(),
     /** Additional options for the feature */
     options: advancedGenerationFeatureOptionSchema.array().nullish(),
 });
-const advancedGenerationSchema = zod_1.z.object({
-    enableAdvancedGeneration: zod_1.z.boolean().default(true),
+const advancedGenerationSchema = z.object({
+    enableAdvancedGeneration: z.boolean().default(true),
     // NOTE: AIVendor and AIModel have been removed. Model configuration is now per-prompt
     // in the AI Prompts table via the MJ: AI Prompt Models relationship.
     features: advancedGenerationFeatureSchema.array().default([
@@ -158,128 +152,143 @@ const advancedGenerationSchema = zod_1.z.object({
         },
     ]),
 });
-const integrityCheckConfigSchema = zod_1.z.object({
-    enabled: zod_1.z.boolean(),
-    entityFieldsSequenceCheck: zod_1.z.boolean(),
+const integrityCheckConfigSchema = z.object({
+    enabled: z.boolean(),
+    entityFieldsSequenceCheck: z.boolean(),
 });
-const forceRegenerationConfigSchema = zod_1.z.object({
+const forceRegenerationConfigSchema = z.object({
     /**
      * Force regeneration of all SQL objects even if no schema changes are detected
      */
-    enabled: zod_1.z.boolean().default(false),
+    enabled: z.boolean().default(false),
     /**
      * Optional SQL WHERE clause to filter entities for forced regeneration
      * Example: "SchemaName = 'dbo' AND Name LIKE 'User%'"
      */
-    entityWhereClause: zod_1.z.string().optional(),
+    entityWhereClause: z.string().optional(),
     /**
      * Force regeneration of base views
      */
-    baseViews: zod_1.z.boolean().default(false),
+    baseViews: z.boolean().default(false),
     /**
      * Force regeneration of spCreate procedures
      */
-    spCreate: zod_1.z.boolean().default(false),
+    spCreate: z.boolean().default(false),
     /**
      * Force regeneration of spUpdate procedures
      */
-    spUpdate: zod_1.z.boolean().default(false),
+    spUpdate: z.boolean().default(false),
     /**
      * Force regeneration of spDelete procedures
      */
-    spDelete: zod_1.z.boolean().default(false),
+    spDelete: z.boolean().default(false),
     /**
      * Force regeneration of all stored procedures
      */
-    allStoredProcedures: zod_1.z.boolean().default(false),
+    allStoredProcedures: z.boolean().default(false),
     /**
      * Force regeneration of indexes for foreign keys
      */
-    indexes: zod_1.z.boolean().default(false),
+    indexes: z.boolean().default(false),
     /**
      * Force regeneration of full text search components
      */
-    fullTextSearch: zod_1.z.boolean().default(false),
+    fullTextSearch: z.boolean().default(false),
 });
-const sqlOutputConfigSchema = zod_1.z.object({
+const sqlOutputConfigSchema = z.object({
     /**
      * Whether or not sql statements generated while managing metadata should be written to a file
      */
-    enabled: zod_1.z.boolean().default(true),
+    enabled: z.boolean().default(true),
     /**
      * The path of the folder to use when logging is enabled.
      * If provided, a file will be created with the format "CodeGen_Run_yyyy-mm-dd_hh-mm-ss.sql"
      */
-    folderPath: zod_1.z.string().default('../../migrations/v3/'),
+    folderPath: z.string().default('../../migrations/v3/'),
     /**
      * Optional, the file name that will be written WITHIN the folderPath specified.
      */
-    fileName: zod_1.z.string().optional(),
+    fileName: z.string().optional(),
     /**
      * If set to true, then we append to the existing file, if one exists, otherwise we create a new file.
      */
-    appendToFile: zod_1.z.boolean().default(true),
+    appendToFile: z.boolean().default(true),
     /**
      * If true, all mention of the core schema within the log file will be replaced with the flyway schema,
      * ${flyway:defaultSchema}
      */
-    convertCoreSchemaToFlywayMigrationFile: zod_1.z.boolean().default(true),
+    convertCoreSchemaToFlywayMigrationFile: z.boolean().default(true),
     /**
      * If true, scripts that are being emitted via SQL logging that are marked by CodeGen as recurring will be SKIPPED. Defaults to false
      */
-    omitRecurringScriptsFromLog: zod_1.z.boolean().default(false),
+    omitRecurringScriptsFromLog: z.boolean().default(false),
+    /**
+     * Optional array of schema-to-placeholder mappings for Flyway migrations.
+     * Each mapping specifies a database schema name and its corresponding Flyway placeholder.
+     * If not provided, defaults to replacing the MJ core schema with ${flyway:defaultSchema}.
+     *
+     * Example:
+     * [
+     *   { schema: '__mj', placeholder: '${mjSchema}' },
+     *   { schema: '__BCSaaS', placeholder: '${flyway:defaultSchema}' }
+     * ]
+     */
+    schemaPlaceholders: z.array(z.object({
+        schema: z.string(),
+        placeholder: z.string()
+    })).optional(),
 });
-const newSchemaDefaultsSchema = zod_1.z.object({
-    CreateNewApplicationWithSchemaName: zod_1.z.boolean().default(true),
+const newSchemaDefaultsSchema = z.object({
+    CreateNewApplicationWithSchemaName: z.boolean().default(true),
 });
-const entityPermissionSchema = zod_1.z.object({
-    RoleName: zod_1.z.string(),
-    CanRead: zod_1.z.boolean(),
-    CanCreate: zod_1.z.boolean(),
-    CanUpdate: zod_1.z.boolean(),
-    CanDelete: zod_1.z.boolean(),
+const entityPermissionSchema = z.object({
+    RoleName: z.string(),
+    CanRead: z.boolean(),
+    CanCreate: z.boolean(),
+    CanUpdate: z.boolean(),
+    CanDelete: z.boolean(),
 });
-const newEntityPermissionDefaultsSchema = zod_1.z.object({
-    AutoAddPermissionsForNewEntities: zod_1.z.boolean().default(true),
+const newEntityPermissionDefaultsSchema = z.object({
+    AutoAddPermissionsForNewEntities: z.boolean().default(true),
     Permissions: entityPermissionSchema.array().default([
         { RoleName: 'UI', CanRead: true, CanCreate: false, CanUpdate: false, CanDelete: false },
         { RoleName: 'Developer', CanRead: true, CanCreate: true, CanUpdate: true, CanDelete: false },
         { RoleName: 'Integration', CanRead: true, CanCreate: true, CanUpdate: true, CanDelete: true },
     ]),
 });
-const newEntityNameRulesBySchema = zod_1.z.object({
-    SchemaName: zod_1.z.string(),
-    EntityNamePrefix: zod_1.z.string().default(''),
-    EntityNameSuffix: zod_1.z.string().default(''),
+const newEntityNameRulesBySchema = z.object({
+    SchemaName: z.string(),
+    EntityNamePrefix: z.string().default(''),
+    EntityNameSuffix: z.string().default(''),
 });
-const newEntityDefaultsSchema = zod_1.z.object({
-    TrackRecordChanges: zod_1.z.boolean().default(true),
-    AuditRecordAccess: zod_1.z.boolean().default(false),
-    AuditViewRuns: zod_1.z.boolean().default(false),
-    AllowAllRowsAPI: zod_1.z.boolean().default(false),
-    AllowCreateAPI: zod_1.z.boolean().default(true),
-    AllowUpdateAPI: zod_1.z.boolean().default(true),
-    AllowDeleteAPI: zod_1.z.boolean().default(true),
-    AllowUserSearchAPI: zod_1.z.boolean().default(true),
-    CascadeDeletes: zod_1.z.boolean().default(false),
-    UserViewMaxRows: zod_1.z.number().default(1000),
-    AddToApplicationWithSchemaName: zod_1.z.boolean().default(true),
-    IncludeFirstNFieldsAsDefaultInView: zod_1.z.number().default(5),
+const newEntityDefaultsSchema = z.object({
+    TrackRecordChanges: z.boolean().default(true),
+    AuditRecordAccess: z.boolean().default(false),
+    AuditViewRuns: z.boolean().default(false),
+    AllowAllRowsAPI: z.boolean().default(false),
+    AllowCreateAPI: z.boolean().default(true),
+    AllowUpdateAPI: z.boolean().default(true),
+    AllowDeleteAPI: z.boolean().default(true),
+    AllowUserSearchAPI: z.boolean().default(true),
+    CascadeDeletes: z.boolean().default(false),
+    UserViewMaxRows: z.number().default(1000),
+    AddToApplicationWithSchemaName: z.boolean().default(true),
+    IncludeFirstNFieldsAsDefaultInView: z.number().default(5),
     PermissionDefaults: newEntityPermissionDefaultsSchema,
     NameRulesBySchema: newEntityNameRulesBySchema.array().default([]),
 });
-const newEntityRelationshipDefaultsSchema = zod_1.z.object({
-    AutomaticallyCreateRelationships: zod_1.z.boolean().default(true),
-    CreateOneToManyRelationships: zod_1.z.boolean().default(true),
+const newEntityRelationshipDefaultsSchema = z.object({
+    AutomaticallyCreateRelationships: z.boolean().default(true),
+    CreateOneToManyRelationships: z.boolean().default(true),
 });
-const configInfoSchema = zod_1.z.object({
+const configInfoSchema = z.object({
     newUserSetup: newUserSetupSchema.nullish(),
     settings: settingInfoSchema.array().default([
         { name: 'mj_core_schema', value: '__mj' },
         { name: 'skip_database_generation', value: false },
         { name: 'auto_index_foreign_keys', value: true },
     ]),
-    excludeSchemas: zod_1.z.string().array().default(['sys', 'staging']),
+    excludeSchemas: z.string().array().default(['sys', 'staging']),
     excludeTables: tableInfoSchema.array().default([
         { schema: '%', table: 'sys%' },
         { schema: '%', table: 'flyway_schema_history' }
@@ -320,6 +329,8 @@ const configInfoSchema = zod_1.z.object({
         { workingDirectory: '../MJServer', command: 'npm', args: ['run', 'build'], when: 'after' },
         { workingDirectory: '../MJAPI', command: 'npm', args: ['start'], timeout: 30000, when: 'after' },
     ]),
+    /** Path to JSON file containing soft PK/FK definitions for tables without database constraints */
+    additionalSchemaInfo: z.string().optional(),
     logging: logInfoSchema,
     newEntityDefaults: newEntityDefaultsSchema,
     newSchemaDefaults: newSchemaDefaultsSchema,
@@ -327,20 +338,21 @@ const configInfoSchema = zod_1.z.object({
     newEntityRelationshipDefaults: newEntityRelationshipDefaultsSchema,
     SQLOutput: sqlOutputConfigSchema,
     forceRegeneration: forceRegenerationConfigSchema,
-    dbHost: zod_1.z.string(),
-    dbPort: zod_1.z.coerce.number().int().positive().default(1433),
-    codeGenLogin: zod_1.z.string(),
-    codeGenPassword: zod_1.z.string(),
-    dbDatabase: zod_1.z.string(),
-    dbInstanceName: zod_1.z.string().nullish(),
-    dbTrustServerCertificate: zod_1.z.coerce
+    dbHost: z.string(),
+    dbPort: z.coerce.number().int().positive().default(1433),
+    codeGenLogin: z.string(),
+    codeGenPassword: z.string(),
+    dbDatabase: z.string(),
+    dbInstanceName: z.string().nullish(),
+    dbTrustServerCertificate: z.coerce
         .boolean()
         .default(false)
         .transform((v) => (v ? 'Y' : 'N')),
-    outputCode: zod_1.z.string().nullish(),
-    mjCoreSchema: zod_1.z.string().default('__mj'),
-    graphqlPort: zod_1.z.coerce.number().int().positive().default(4000),
-    verboseOutput: zod_1.z.boolean().optional().default(false),
+    outputCode: z.string().nullish(),
+    mjCoreSchema: z.string().default('__mj'),
+    graphqlPort: z.coerce.number().int().positive().default(4000),
+    entityPackageName: z.string().default('mj_generatedentities'),
+    verboseOutput: z.boolean().optional().default(false),
 });
 /**
  * Default CodeGen configuration - provides sensible defaults for all CodeGen settings.
@@ -348,7 +360,7 @@ const configInfoSchema = zod_1.z.object({
  *
  * Database connection settings come from environment variables.
  */
-exports.DEFAULT_CODEGEN_CONFIG = {
+export const DEFAULT_CODEGEN_CONFIG = {
     // Database connection settings (from environment variables)
     dbHost: process.env.DB_HOST ?? 'localhost',
     dbPort: 1433,
@@ -356,7 +368,7 @@ exports.DEFAULT_CODEGEN_CONFIG = {
     codeGenLogin: process.env.CODEGEN_DB_USERNAME ?? '',
     codeGenPassword: process.env.CODEGEN_DB_PASSWORD ?? '',
     dbInstanceName: process.env.DB_INSTANCE_NAME,
-    dbTrustServerCertificate: ['true', '1', 'Y', 'y'].includes(process.env.DB_TRUST_SERVER_CERTIFICATE ?? '') ? 'Y' : 'N',
+    dbTrustServerCertificate: parseBooleanEnv(process.env.DB_TRUST_SERVER_CERTIFICATE) ? 'Y' : 'N',
     mjCoreSchema: '__mj',
     graphqlPort: 4000,
     verboseOutput: false,
@@ -483,14 +495,14 @@ exports.DEFAULT_CODEGEN_CONFIG = {
 /**
  * Current working directory for the code generation process
  */
-exports.currentWorkingDirectory = process.cwd();
+export let currentWorkingDirectory = process.cwd();
 /**
  * Merge user config with DEFAULT_CODEGEN_CONFIG.
  * Database settings come from user config or environment variables.
  */
 const mergedConfig = configSearchResult?.config
-    ? (0, config_1.mergeConfigs)(exports.DEFAULT_CODEGEN_CONFIG, configSearchResult.config)
-    : exports.DEFAULT_CODEGEN_CONFIG;
+    ? mergeConfigs(DEFAULT_CODEGEN_CONFIG, configSearchResult.config)
+    : DEFAULT_CODEGEN_CONFIG;
 /** Parse and validate the merged configuration */
 const configParsing = configInfoSchema.safeParse(mergedConfig);
 // Don't log errors at module load - commands that need config will validate explicitly
@@ -500,67 +512,65 @@ const configParsing = configInfoSchema.safeParse(mergedConfig);
 /**
  * Parsed configuration object with fallback to empty object if parsing fails
  */
-exports.configInfo = configParsing.data ?? {};
+export const configInfo = configParsing.data ?? {};
 /**
  * Destructured commonly used configuration values
  */
-exports.mjCoreSchema = exports.configInfo.mjCoreSchema, exports.dbDatabase = exports.configInfo.dbDatabase;
+export const { mjCoreSchema, dbDatabase } = configInfo;
 /**
  * Initializes configuration from the specified working directory
  * @param cwd The current working directory to search for config files
  * @returns Parsed configuration object
  * @throws Error if no configuration is found
  */
-function initializeConfig(cwd) {
-    exports.currentWorkingDirectory = cwd;
+export function initializeConfig(cwd) {
+    currentWorkingDirectory = cwd;
     // Merge user config with DEFAULT_CODEGEN_CONFIG
-    const userConfigResult = explorer.search(exports.currentWorkingDirectory);
+    const userConfigResult = explorer.search(currentWorkingDirectory);
     const mergedConfig = userConfigResult?.config
-        ? (0, config_1.mergeConfigs)(exports.DEFAULT_CODEGEN_CONFIG, userConfigResult.config)
-        : exports.DEFAULT_CODEGEN_CONFIG;
+        ? mergeConfigs(DEFAULT_CODEGEN_CONFIG, userConfigResult.config)
+        : DEFAULT_CODEGEN_CONFIG;
     const maybeConfig = configInfoSchema.safeParse(mergedConfig);
     // Don't log errors - let the calling code handle validation failures
     // if (!maybeConfig.success) {
     //   LogError('Error parsing config file', null, JSON.stringify(maybeConfig.error.issues, null, 2));
     // }
-    const config = maybeConfig.success ? maybeConfig.data : exports.configInfo;
+    const config = maybeConfig.success ? maybeConfig.data : configInfo;
     if (config === undefined) {
         throw new Error('No configuration found');
     }
     return config;
 }
-exports.initializeConfig = initializeConfig;
 /**
  * Gets the output directory for a specific generation type
  * @param type The type of output (e.g., 'SQL', 'Angular')
  * @param useLocalDirectoryIfMissing Whether to use a local directory if config is missing
  * @returns The output directory path or null if not found
  */
-function outputDir(type, useLocalDirectoryIfMissing) {
-    const outputInfo = exports.configInfo.output.find((o) => o.type.trim().toUpperCase() === type.trim().toUpperCase());
+export function outputDir(type, useLocalDirectoryIfMissing) {
+    const outputInfo = configInfo.output.find((o) => o.type.trim().toUpperCase() === type.trim().toUpperCase());
     if (outputInfo) {
-        if (outputInfo.appendOutputCode && outputInfo.appendOutputCode === true && exports.configInfo.outputCode)
-            return path_1.default.join(exports.currentWorkingDirectory, outputInfo.directory, exports.configInfo.outputCode);
+        if (outputInfo.appendOutputCode && outputInfo.appendOutputCode === true && configInfo.outputCode)
+            return path.join(currentWorkingDirectory, outputInfo.directory, configInfo.outputCode);
         else
-            return path_1.default.join(exports.currentWorkingDirectory, outputInfo.directory);
+            return path.join(currentWorkingDirectory, outputInfo.directory);
     }
     else {
         if (useLocalDirectoryIfMissing) {
-            (0, status_logging_1.logStatus)('>>> No output directory found for type: ' + type + ' within config file, using local directory instead');
-            return path_1.default.join(exports.currentWorkingDirectory, 'output', type);
+            logStatus('>>> No output directory found for type: ' + type + ' within config file, using local directory instead');
+            return path.join(currentWorkingDirectory, 'output', type);
         }
         else
             return null;
     }
 }
-exports.outputDir = outputDir;
 /**
  * Gets the output options for a specific generation type
  * @param type The type of output
  * @returns Array of output options or null if not found
  */
-function outputOptions(type) {
-    const outputInfo = exports.configInfo.output.find((o) => o.type.trim().toUpperCase() === type.trim().toUpperCase());
+export function outputOptions(type) {
+    const outputInfo = configInfo.output.find((o) => o.type.trim().toUpperCase() === type.trim().toUpperCase());
     if (outputInfo) {
         return outputInfo.options;
     }
@@ -568,7 +578,6 @@ function outputOptions(type) {
         return null;
     }
 }
-exports.outputOptions = outputOptions;
 /**
  * Gets a specific output option value for a generation type
  * @param type The type of output
@@ -576,8 +585,8 @@ exports.outputOptions = outputOptions;
  * @param defaultValue Default value if option is not found
  * @returns The option value or default value
  */
-function outputOptionValue(type, optionName, defaultValue) {
-    const outputInfo = exports.configInfo.output?.find((o) => o.type.trim().toUpperCase() === type.trim().toUpperCase());
+export function outputOptionValue(type, optionName, defaultValue) {
+    const outputInfo = configInfo.output?.find((o) => o.type.trim().toUpperCase() === type.trim().toUpperCase());
     if (outputInfo && outputInfo.options) {
         const theOption = outputInfo.options.find((o) => o.name.trim().toUpperCase() === optionName.trim().toUpperCase());
         if (theOption)
@@ -589,53 +598,48 @@ function outputOptionValue(type, optionName, defaultValue) {
         return defaultValue;
     }
 }
-exports.outputOptionValue = outputOptionValue;
 /**
  * Gets commands configured to run at a specific time
  * @param when When the commands should run (e.g., 'before', 'after')
  * @returns Array of commands to execute
  */
-function commands(when) {
-    return exports.configInfo.commands.filter((c) => c.when.trim().toUpperCase() === when.trim().toUpperCase());
+export function commands(when) {
+    return configInfo.commands.filter((c) => c.when.trim().toUpperCase() === when.trim().toUpperCase());
 }
-exports.commands = commands;
 /**
  * Gets custom SQL scripts configured to run at a specific time
  * @param when When the scripts should run
  * @returns Array of SQL scripts to execute
  */
-function customSqlScripts(when) {
-    return exports.configInfo.customSQLScripts.filter((c) => c.when.trim().toUpperCase() === when.trim().toUpperCase());
+export function customSqlScripts(when) {
+    return configInfo.customSQLScripts.filter((c) => c.when.trim().toUpperCase() === when.trim().toUpperCase());
 }
-exports.customSqlScripts = customSqlScripts;
 /**
  * Gets a specific setting by name
  * @param settingName The name of the setting to retrieve
  * @returns The setting object
  */
-function getSetting(settingName) {
-    return exports.configInfo.settings.find((s) => s.name.trim().toUpperCase() === settingName.trim().toUpperCase());
+export function getSetting(settingName) {
+    return configInfo.settings.find((s) => s.name.trim().toUpperCase() === settingName.trim().toUpperCase());
 }
-exports.getSetting = getSetting;
 /**
  * Gets the value of a specific setting
  * @param settingName The name of the setting
  * @param defaultValue Default value if setting is not found
  * @returns The setting value or default value
  */
-function getSettingValue(settingName, defaultValue) {
+export function getSettingValue(settingName, defaultValue) {
     const setting = getSetting(settingName);
     if (setting)
         return setting.value;
     else
         return defaultValue;
 }
-exports.getSettingValue = getSettingValue;
 /**
  * Checks if automatic indexing of foreign keys is enabled
  * @returns True if auto-indexing is enabled, false otherwise
  */
-function autoIndexForeignKeys() {
+export function autoIndexForeignKeys() {
     const keyName = 'auto_index_foreign_keys';
     const setting = getSetting(keyName);
     if (setting)
@@ -643,17 +647,15 @@ function autoIndexForeignKeys() {
     else
         return false;
 }
-exports.autoIndexForeignKeys = autoIndexForeignKeys;
 /**
  * Maximum length allowed for database index names
  */
-exports.MAX_INDEX_NAME_LENGTH = 128;
+export const MAX_INDEX_NAME_LENGTH = 128;
 /**
  * Gets the MemberJunction core schema name from configuration
  * @returns The core schema name (typically '__mj')
  */
-function mj_core_schema() {
+export function mj_core_schema() {
     return getSetting('mj_core_schema').value;
 }
-exports.mj_core_schema = mj_core_schema;
 //# sourceMappingURL=config.js.map