@memberjunction/cli 2.133.0 → 3.0.0

package/bin/dev.cmd

@@ -1,3 +1,3 @@
-@echo off
-
+@echo off
+
 node "%~dp0\dev" %*

package/bin/run.cmd

@@ -1,3 +1,3 @@
-@echo off
-
-node "%~dp0\run" %*
+@echo off
+
+node "%~dp0\run" %*

package/dist/commands/dbdoc/review.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Review extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        schema: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'unapproved-only': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/dbdoc/review.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const prompts_1 = require("@inquirer/prompts");
+const chalk_1 = __importDefault(require("chalk"));
+const db_auto_doc_1 = require("@memberjunction/db-auto-doc");
+class Review extends core_1.Command {
+    static description = 'Review and approve AI-generated documentation';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --schema dbo',
+        '<%= config.bin %> <%= command.id %> --unapproved-only',
+    ];
+    static flags = {
+        schema: core_1.Flags.string({
+            description: 'Review specific schema',
+        }),
+        'unapproved-only': core_1.Flags.boolean({
+            description: 'Only show unapproved items',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Review);
+        this.log(chalk_1.default.blue.bold('\n📝 Review Documentation\n'));
+        try {
+            const stateManager = new db_auto_doc_1.StateManager();
+            const state = await stateManager.load();
+            const unapproved = stateManager.getUnapprovedTables(flags.schema);
+            if (unapproved.length === 0) {
+                this.log(chalk_1.default.green('✅ All tables approved!'));
+                return;
+            }
+            this.log(`Found ${unapproved.length} unapproved tables\n`);
+            for (const { schema, table } of unapproved) {
+                const schemaState = state.schemas[schema];
+                const tableState = schemaState.tables[table];
+                this.log(chalk_1.default.cyan.bold(`\n${schema}.${table}`));
+                this.log('─'.repeat(50));
+                if (tableState.aiGenerated) {
+                    this.log(chalk_1.default.white('Description:'));
+                    this.log(tableState.aiGenerated.description);
+                    this.log('');
+                    this.log(chalk_1.default.gray(`Confidence: ${(tableState.aiGenerated.confidence * 100).toFixed(0)}%`));
+                }
+                const action = await (0, prompts_1.select)({
+                    message: 'Action:',
+                    choices: [
+                        { name: 'Approve', value: 'approve' },
+                        { name: 'Add notes', value: 'notes' },
+                        { name: 'Skip', value: 'skip' },
+                        { name: 'Exit review', value: 'exit' },
+                    ],
+                });
+                if (action === 'exit') {
+                    break;
+                }
+                if (action === 'approve') {
+                    stateManager.approveTable(schema, table);
+                    this.log(chalk_1.default.green('✓ Approved'));
+                }
+                if (action === 'notes') {
+                    const notes = await (0, prompts_1.input)({
+                        message: 'Enter notes:',
+                    });
+                    stateManager.addTableNotes(schema, table, notes);
+                    this.log(chalk_1.default.green('✓ Notes added'));
+                }
+            }
+            await stateManager.save();
+            this.log(chalk_1.default.green('\n✅ Review complete!'));
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+    }
+}
+exports.default = Review;

package/dist/commands/migrate/index.d.ts

@@ -7,4 +7,5 @@ export default class Migrate extends Command {
         tag: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    private analyzeFlywayError;
 }

package/dist/commands/migrate/index.js

@@ -24,7 +24,9 @@ class Migrate extends core_1.Command {
         const flyway = new node_flyway_1.Flyway(flywayConfig);
         if (flags.verbose) {
             this.log(`Connecting to ${flywayConfig.url}`);
+            this.log(`Database Connection: ${config.dbHost}, ${config.dbDatabase}, User: ${flywayConfig.user}`);
             this.log(`Migrating ${config.coreSchema} schema using migrations from:\n\t- ${flywayConfig.migrationLocations.join('\n\t- ')}\n`);
+            this.log(`Flyway config settings: baselineVersion: ${config.baselineVersion}, baselineMigrate: ${config.baselineOnMigrate}\n`);
         }
         if (flags.tag) {
             this.log(`Migrating to ${flags.tag}`);
@@ -32,6 +34,7 @@ class Migrate extends core_1.Command {
         const spinner = (0, ora_classic_1.default)('Running migrations...');
         spinner.start();
         const result = await flyway.migrate();
+        const isParseError = result.error?.errorCode === 'UNABLE_TO_PARSE_RESPONSE';
         if (result.success) {
             spinner.succeed();
             this.log(`Migrations complete in ${result.additionalDetails.executionTime / 1000}s`);
@@ -39,6 +42,73 @@ class Migrate extends core_1.Command {
                 this.log(`\tUpdated to ${result.flywayResponse?.targetSchemaVersion}`);
             }
         }
+        else if (isParseError) {
+            // Parse error - could be SQL error or connection issue
+            // Run Flyway CLI directly to get the actual error
+            spinner.fail();
+            this.logToStderr('\n❌ Migration failed - unable to parse Flyway response.');
+            this.logToStderr(`Execution time: ${result.additionalDetails.executionTime / 1000}s\n`);
+            this.logToStderr('🔍 Running diagnostic to identify the actual error...');
+            const dbInfo = `${config.dbHost}:${config.dbPort}/${config.dbDatabase}`;
+            this.logToStderr(`   Database: ${dbInfo}`);
+            this.logToStderr(`   User: ${config.codeGenLogin}\n`);
+            try {
+                const { spawnSync } = require('child_process');
+                const path = require('path');
+                const os = require('os');
+                // Construct Flyway executable path
+                const flywayDir = result.additionalDetails.flywayCli.location;
+                const flywayExeName = os.platform() === 'win32' ? 'flyway.cmd' : 'flyway';
+                const flywayExePath = path.join(flywayDir, flywayExeName);
+                // Use spawnSync to avoid shell interpretation of special characters in password
+                const jdbcUrl = `jdbc:sqlserver://${config.dbHost}:${config.dbPort};databaseName=${config.dbDatabase};trustServerCertificate=${config.dbTrustServerCertificate}`;
+                // Build common args
+                const baseArgs = [
+                    `-url=${jdbcUrl}`,
+                    `-user=${config.codeGenLogin}`,
+                    `-password=${config.codeGenPassword}`,
+                    `-schemas=${config.coreSchema}`
+                ];
+                // Convert relative migration paths to absolute paths
+                const absoluteMigrationPaths = flywayConfig.migrationLocations.map((loc) => {
+                    // Remove 'filesystem:' prefix if present
+                    const cleanLoc = loc.replace(/^filesystem:/, '');
+                    // Convert to absolute path if relative
+                    return path.isAbsolute(cleanLoc) ? loc : `filesystem:${path.resolve(cleanLoc)}`;
+                });
+                // First try migrate to see the actual SQL error
+                const migrateArgs = [
+                    ...baseArgs,
+                    `-baselineVersion=${config.baselineVersion}`,
+                    `-baselineOnMigrate=${config.baselineOnMigrate}`,
+                    `-locations=${absoluteMigrationPaths.join(',')}`,
+                    'migrate'
+                ];
+                const migrateResult = spawnSync(flywayExePath, migrateArgs, { encoding: 'utf8' });
+                const migrateOutput = migrateResult.stderr || migrateResult.stdout || '';
+                // Check if output contains error messages even if exit code is 0
+                const hasErrorsInOutput = migrateOutput.toLowerCase().includes('error') ||
+                    migrateOutput.toLowerCase().includes('incorrect syntax') ||
+                    migrateOutput.toLowerCase().includes('must be the only statement');
+                if (migrateResult.status === 0 && !hasErrorsInOutput) {
+                    this.logToStderr('✓ Migration executed successfully (Flyway CLI reports success)');
+                    this.logToStderr('   The issue was with node-flyway response parsing only\n');
+                }
+                else if (migrateResult.status === 0 && hasErrorsInOutput) {
+                    // Exit code was 0 but output contains errors - SQL script likely has error handling
+                    this.logToStderr('⚠️  Migration completed but errors were detected in output:\n');
+                    this.analyzeFlywayError(migrateOutput, config);
+                }
+                else {
+                    // Migration failed with non-zero exit code
+                    this.analyzeFlywayError(migrateOutput, config);
+                }
+            }
+            catch (err) {
+                this.logToStderr(`❌ Error running diagnostic: ${err.message || err}\n`);
+            }
+            this.error('Migration failed - see diagnostic information above');
+        }
         else {
             spinner.fail();
             if (result.error) {
@@ -51,5 +121,95 @@ class Migrate extends core_1.Command {
             this.error('Migrations failed');
         }
     }
+    analyzeFlywayError(errorOutput, config) {
+        const errorLines = errorOutput.split('\n');
+        const fullError = errorOutput.toLowerCase();
+        // Find error details
+        const errorCodeLine = errorLines.find(line => line.includes('Error Code')) || '';
+        const messageLine = errorLines.find(line => line.includes('Message')) || '';
+        const errorLine = errorLines.find(line => line.includes('ERROR:') && !line.includes('Skipping filesystem location')) || '';
+        // Determine error type
+        const isSqlError = fullError.includes('incorrect syntax') ||
+            fullError.includes('must be the only statement in the batch') ||
+            fullError.includes('invalid object name') ||
+            fullError.includes('permission denied') ||
+            (fullError.includes('error') && fullError.includes('line'));
+        const isConnectionError = fullError.includes('login failed') ||
+            fullError.includes('unable to obtain connection') ||
+            fullError.includes('connection') && !fullError.includes('clientconnectionid');
+        // Display error header
+        if (isSqlError) {
+            this.logToStderr('❌ SQL Migration Error Detected\n');
+        }
+        else if (isConnectionError) {
+            this.logToStderr('❌ Database Connection Failed\n');
+        }
+        else {
+            this.logToStderr('❌ Migration Failed\n');
+        }
+        // Display error details
+        if (errorCodeLine && messageLine) {
+            this.logToStderr(`   ${errorCodeLine.trim()}`);
+            this.logToStderr(`   ${messageLine.trim()}\n`);
+        }
+        else if (errorLine) {
+            const cleanError = errorLine.replace(/^ERROR:\s*/, '').trim();
+            this.logToStderr(`   Error: ${cleanError}\n`);
+        }
+        else if (errorOutput) {
+            // Show lines containing error-related keywords
+            const errorKeywords = ['error', 'incorrect', 'syntax', 'invalid', 'failed', 'must be', 'cannot', 'line'];
+            const relevantLines = errorOutput.split('\n')
+                .filter(line => {
+                const lower = line.toLowerCase();
+                return line.trim() &&
+                    !lower.includes('flyway community') &&
+                    !lower.includes('skipping filesystem location') &&
+                    errorKeywords.some(keyword => lower.includes(keyword));
+            })
+                .slice(0, 15);
+            if (relevantLines.length > 0) {
+                this.logToStderr('   Error details from Flyway output:');
+                relevantLines.forEach(line => this.logToStderr(`   ${line.trim()}`));
+                this.logToStderr('');
+            }
+            else {
+                // If no error keywords found, show last 20 lines of output
+                const allLines = errorOutput.split('\n').filter(l => l.trim());
+                const lastLines = allLines.slice(-20);
+                this.logToStderr('   Last 20 lines of Flyway output:');
+                lastLines.forEach(line => this.logToStderr(`   ${line.trim()}`));
+                this.logToStderr('');
+            }
+        }
+        // Provide guidance
+        if (isSqlError) {
+            this.logToStderr('💡 This is a SQL script error:');
+            this.logToStderr('   - Check the migration SQL file for syntax errors');
+            this.logToStderr('   - Look for missing GO statements before CREATE TRIGGER/PROCEDURE/FUNCTION');
+            this.logToStderr('   - Verify all object names and references are correct');
+            this.logToStderr('   - Check database permissions for the migration user');
+        }
+        else if (fullError.includes('login failed') || fullError.includes('password')) {
+            this.logToStderr('💡 This is a credential issue:');
+            this.logToStderr('   - Check CODEGEN_DB_USERNAME and CODEGEN_DB_PASSWORD in .env file');
+            this.logToStderr('   - Verify the user has permission to access the database');
+            this.logToStderr('   - Check for shell environment variables overriding .env settings');
+        }
+        else if (fullError.includes('database') && fullError.includes('does not exist')) {
+            this.logToStderr('💡 The database does not exist:');
+            this.logToStderr(`   - Create the database: CREATE DATABASE ${config.dbDatabase}`);
+            this.logToStderr('   - Or verify DB_DATABASE is set correctly in .env file');
+        }
+        else if (fullError.includes('connection') || fullError.includes('timeout') || fullError.includes('refused')) {
+            this.logToStderr('💡 Cannot connect to SQL Server:');
+            this.logToStderr('   - Verify SQL Server is running');
+            this.logToStderr(`   - Check host and port: ${config.dbHost}:${config.dbPort}`);
+            this.logToStderr('   - Check firewall settings');
+        }
+        else {
+            this.logToStderr('💡 Check the error details above to diagnose the issue');
+        }
+    }
 }
 exports.default = Migrate;

package/dist/config.d.ts

@@ -12,8 +12,9 @@ declare const mjConfigSchema: z.ZodObject<{
     coreSchema: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     cleanDisabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     mjRepoUrl: z.ZodCatch<z.ZodString>;
+    baselineVersion: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    baselineOnMigrate: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
-    cleanDisabled: boolean;
     dbHost: string;
     dbDatabase: string;
     dbPort: number;
@@ -22,21 +23,25 @@ declare const mjConfigSchema: z.ZodObject<{
     migrationsLocation: string;
     dbTrustServerCertificate: boolean;
     coreSchema: string;
+    cleanDisabled: boolean;
     mjRepoUrl: string;
+    baselineVersion: string;
+    baselineOnMigrate: boolean;
 }, {
     dbDatabase: string;
     codeGenLogin: string;
     codeGenPassword: string;
-    cleanDisabled?: boolean | undefined;
     dbHost?: string | undefined;
     dbPort?: number | undefined;
     migrationsLocation?: string | undefined;
     dbTrustServerCertificate?: boolean | undefined;
     coreSchema?: string | undefined;
+    cleanDisabled?: boolean | undefined;
     mjRepoUrl?: unknown;
+    baselineVersion?: string | undefined;
+    baselineOnMigrate?: boolean | undefined;
 }>;
 export declare const config: {
-    cleanDisabled: boolean;
     dbHost: string;
     dbDatabase: string;
     dbPort: number;
@@ -45,7 +50,10 @@ export declare const config: {
     migrationsLocation: string;
     dbTrustServerCertificate: boolean;
     coreSchema: string;
+    cleanDisabled: boolean;
     mjRepoUrl: string;
+    baselineVersion: string;
+    baselineOnMigrate: boolean;
 } | undefined;
 /**
  * Get validated config for commands that require database connection.

package/dist/config.js

@@ -6,9 +6,37 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const simple_git_1 = require("simple-git");
 const zod_1 = require("zod");
+const config_1 = require("@memberjunction/config");
 const MJ_REPO_URL = 'https://github.com/MemberJunction/MJ.git';
+/**
+ * Default database configuration for MJCLI.
+ * Database settings come from environment variables with sensible defaults.
+ */
+const DEFAULT_CLI_CONFIG = {
+    dbHost: process.env.DB_HOST ?? 'localhost',
+    dbPort: process.env.DB_PORT ? parseInt(process.env.DB_PORT) : 1433,
+    dbDatabase: process.env.DB_DATABASE ?? '',
+    dbTrustServerCertificate: process.env.DB_TRUST_SERVER_CERTIFICATE === 'true',
+    codeGenLogin: process.env.CODEGEN_DB_USERNAME ?? '',
+    codeGenPassword: process.env.CODEGEN_DB_PASSWORD ?? '',
+    coreSchema: '__mj',
+    cleanDisabled: true,
+    baselineVersion: '202601122300',
+    baselineOnMigrate: true,
+    mjRepoUrl: MJ_REPO_URL,
+    migrationsLocation: 'filesystem:./migrations',
+};
 const explorer = (0, cosmiconfig_1.cosmiconfigSync)('mj', { searchStrategy: 'global' });
-const result = explorer.search(process.cwd());
+const searchResult = explorer.search(process.cwd());
+// Merge user config with DEFAULT_CLI_CONFIG to support minimal config
+// This allows database fields to come from environment variables
+const mergedConfig = searchResult?.config
+    ? (0, config_1.mergeConfigs)(DEFAULT_CLI_CONFIG, searchResult.config)
+    : DEFAULT_CLI_CONFIG;
+// Create a result object with merged config for backward compatibility
+const result = searchResult
+    ? { ...searchResult, config: mergedConfig }
+    : { config: mergedConfig, filepath: '', isEmpty: false };
 // Schema for database-dependent config (required fields)
 const mjConfigSchema = zod_1.z.object({
     dbHost: zod_1.z.string().default('localhost'),
@@ -21,6 +49,8 @@ const mjConfigSchema = zod_1.z.object({
     coreSchema: zod_1.z.string().optional().default('__mj'),
     cleanDisabled: zod_1.z.boolean().optional().default(true),
     mjRepoUrl: zod_1.z.string().url().catch(MJ_REPO_URL),
+    baselineVersion: zod_1.z.string().optional().default('202601122300'),
+    baselineOnMigrate: zod_1.z.boolean().optional().default(true),
 });
 // Schema for non-database commands (all fields optional)
 const mjConfigSchemaOptional = zod_1.z.object({
@@ -34,6 +64,8 @@ const mjConfigSchemaOptional = zod_1.z.object({
     coreSchema: zod_1.z.string().optional().default('__mj'),
     cleanDisabled: zod_1.z.boolean().optional().default(true),
     mjRepoUrl: zod_1.z.string().url().catch(MJ_REPO_URL),
+    baselineVersion: zod_1.z.string().optional().default('202601122300'),
+    baselineOnMigrate: zod_1.z.boolean().optional().default(true),
 });
 // Don't validate at module load - let commands decide when they need validated config
 exports.config = result?.config;
@@ -65,7 +97,12 @@ exports.getOptionalConfig = getOptionalConfig;
  * Returns undefined silently if config is invalid (command will handle the error).
  */
 const updatedConfig = () => {
-    const maybeConfig = mjConfigSchema.safeParse(explorer.search(process.cwd())?.config);
+    const freshSearchResult = explorer.search(process.cwd());
+    // Merge fresh config with DEFAULT_CLI_CONFIG
+    const freshMergedConfig = freshSearchResult?.config
+        ? (0, config_1.mergeConfigs)(DEFAULT_CLI_CONFIG, freshSearchResult.config)
+        : DEFAULT_CLI_CONFIG;
+    const maybeConfig = mjConfigSchema.safeParse(freshMergedConfig);
     // Don't log errors here - let the calling command handle validation
     return maybeConfig.success ? maybeConfig.data : undefined;
 };
@@ -91,7 +128,12 @@ const getFlywayConfig = async (mjConfig, tag) => {
         user: mjConfig.codeGenLogin,
         password: mjConfig.codeGenPassword,
         migrationLocations: [location],
-        advanced: { schemas: [mjConfig.coreSchema], cleanDisabled: mjConfig.cleanDisabled === false ? false : undefined },
+        advanced: {
+            schemas: [mjConfig.coreSchema],
+            cleanDisabled: mjConfig.cleanDisabled === false ? false : undefined,
+            baselineVersion: mjConfig.baselineVersion,
+            baselineOnMigrate: mjConfig.baselineOnMigrate,
+        },
     };
 };
 exports.getFlywayConfig = getFlywayConfig;