@memberjunction/cli 2.55.0 → 2.57.0

package/README.md

@@ -72,6 +72,40 @@ module.exports = {
 
 ## Commands
 
+### `mj sync`
+
+Manages MemberJunction metadata synchronization between database and local files. This suite of commands enables version control, IDE-based editing, and CI/CD integration for MJ metadata.
+
+```bash
+mj sync [COMMAND] [OPTIONS]
+```
+
+Available sync commands:
+- `validate` - Validate metadata files for correctness
+- `init` - Initialize a directory for metadata sync
+- `pull` - Pull metadata from database to local files
+- `push` - Push local file changes to database
+- `status` - Show status of local vs database metadata
+- `watch` - Watch for changes and auto-sync
+- `file-reset` - Reset file checksums after manual edits
+
+For detailed documentation on metadata sync, see the [MetadataSync README](../MetadataSync/README.md).
+
+#### Quick Examples:
+```bash
+# Validate all metadata files
+mj sync validate
+
+# Pull AI Prompts from database
+mj sync pull --entity="AI Prompts"
+
+# Push changes to database
+mj sync push
+
+# Watch for changes
+mj sync watch
+```
+
 ### `mj install`
 
 Performs a complete installation of MemberJunction, including:

package/dist/commands/sync/file-reset.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class FileReset extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dir: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        sections: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/sync/file-reset.js

@@ -0,0 +1,197 @@
+"use strict";
+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;
+};
+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 ora_classic_1 = __importDefault(require("ora-classic"));
+const chalk_1 = __importDefault(require("chalk"));
+const path = __importStar(require("path"));
+const metadata_sync_1 = require("@memberjunction/metadata-sync");
+class FileReset extends core_1.Command {
+    static description = 'Reset file metadata sections';
+    static examples = [
+        `<%= config.bin %> <%= command.id %>`,
+        `<%= config.bin %> <%= command.id %> --dir="ai-prompts"`,
+        `<%= config.bin %> <%= command.id %> --sections="dependencies,references"`,
+        `<%= config.bin %> <%= command.id %> --all`,
+    ];
+    static flags = {
+        dir: core_1.Flags.string({ description: 'Specific entity directory to reset' }),
+        sections: core_1.Flags.string({ description: 'Comma-separated list of sections to reset (dependencies,references,related,lookup)' }),
+        all: core_1.Flags.boolean({ description: 'Reset all metadata sections' }),
+        'dry-run': core_1.Flags.boolean({ description: 'Show what would be reset without actually resetting' }),
+        force: core_1.Flags.boolean({ description: 'Skip confirmation prompts' }),
+        verbose: core_1.Flags.boolean({ char: 'v', description: 'Show detailed output' }),
+    };
+    async run() {
+        const { flags } = await this.parse(FileReset);
+        const spinner = (0, ora_classic_1.default)();
+        try {
+            // Load configuration
+            spinner.start('Loading configuration');
+            const mjConfig = (0, metadata_sync_1.loadMJConfig)();
+            if (!mjConfig) {
+                this.error('No mj.config.cjs found in current directory or parent directories');
+            }
+            // Stop spinner before provider initialization
+            spinner.stop();
+            // Initialize data provider
+            await (0, metadata_sync_1.initializeProvider)(mjConfig);
+            // Initialize sync engine
+            const syncEngine = await (0, metadata_sync_1.getSyncEngine)((0, metadata_sync_1.getSystemUser)());
+            // Show success after initialization
+            if (flags.verbose) {
+                spinner.succeed('Configuration and metadata loaded');
+            }
+            else {
+                spinner.stop();
+            }
+            // Determine sections to reset
+            let sectionsToReset = [];
+            const availableSections = ['primaryKey', 'sync'];
+            if (flags.all) {
+                sectionsToReset = availableSections;
+            }
+            else if (flags.sections) {
+                sectionsToReset = flags.sections.split(',').map(s => s.trim());
+                // Validate sections
+                const invalidSections = sectionsToReset.filter(s => !availableSections.includes(s));
+                if (invalidSections.length > 0) {
+                    this.error(`Invalid sections: ${invalidSections.join(', ')}. Valid sections are: ${availableSections.join(', ')}`);
+                }
+            }
+            else {
+                // Interactive selection
+                sectionsToReset = await (0, prompts_1.checkbox)({
+                    message: 'Select sections to reset:',
+                    choices: [
+                        { name: 'Primary Key metadata', value: 'primaryKey', checked: false },
+                        { name: 'Sync metadata', value: 'sync', checked: false }
+                    ]
+                });
+                if (sectionsToReset.length === 0) {
+                    this.log(chalk_1.default.yellow('No sections selected. Exiting.'));
+                    return;
+                }
+            }
+            // Determine target directory
+            const targetDir = flags.dir
+                ? path.resolve(metadata_sync_1.configManager.getOriginalCwd(), flags.dir)
+                : metadata_sync_1.configManager.getOriginalCwd();
+            // Show what will be reset
+            this.log(chalk_1.default.bold('\nFile Reset Summary:'));
+            this.log(`Target directory: ${path.relative(process.cwd(), targetDir)}`);
+            this.log(`Sections to reset: ${sectionsToReset.join(', ')}`);
+            this.log(`Mode: ${flags['dry-run'] ? 'Dry run (no changes will be made)' : 'Live (files will be modified)'}`);
+            // Confirm unless forced or dry-run
+            if (!flags.force && !flags['dry-run']) {
+                const shouldContinue = await (0, prompts_1.confirm)({
+                    message: 'This will reset the selected metadata sections. Continue?',
+                    default: false
+                });
+                if (!shouldContinue) {
+                    this.log(chalk_1.default.yellow('\nFile reset cancelled.'));
+                    return;
+                }
+            }
+            // Create file reset service and execute
+            const fileResetService = new metadata_sync_1.FileResetService();
+            spinner.start('Resetting file metadata...');
+            // Map selected sections to service options
+            let serviceSection = 'both';
+            if (sectionsToReset.includes('primaryKey') && sectionsToReset.includes('sync')) {
+                serviceSection = 'both';
+            }
+            else if (sectionsToReset.includes('primaryKey')) {
+                serviceSection = 'primaryKey';
+            }
+            else if (sectionsToReset.includes('sync')) {
+                serviceSection = 'sync';
+            }
+            const result = await fileResetService.resetFiles({
+                sections: serviceSection,
+                dryRun: flags['dry-run'],
+                noBackup: false,
+                verbose: flags.verbose
+            }, {
+                onProgress: (message) => {
+                    spinner.start(message);
+                },
+                onWarn: (message) => {
+                    this.warn(message);
+                },
+                onLog: (message) => {
+                    this.log(message);
+                }
+            });
+            spinner.stop();
+            // Show summary
+            if (result.modifiedFiles > 0) {
+                if (flags['dry-run']) {
+                    this.log(chalk_1.default.blue(`\n🔍 Dry run complete. ${result.modifiedFiles} file(s) would be reset.`));
+                }
+                else {
+                    this.log(chalk_1.default.green(`\n✅ Successfully reset ${result.modifiedFiles} file(s).`));
+                    if (result.backupsCreated > 0) {
+                        this.log(chalk_1.default.gray(`   📁 Created ${result.backupsCreated} backup(s).`));
+                    }
+                }
+            }
+            else {
+                this.log(chalk_1.default.yellow('\n⚠️  No files needed resetting.'));
+            }
+            if (flags.verbose) {
+                this.log(`\n📊 Statistics:`);
+                this.log(`   Files processed: ${result.processedFiles}`);
+                this.log(`   Files with primaryKey: ${result.filesWithPrimaryKey}`);
+                this.log(`   Files with sync: ${result.filesWithSync}`);
+                this.log(`   Total primaryKeys removed: ${result.totalPrimaryKeys}`);
+                this.log(`   Total syncs removed: ${result.totalSyncs}`);
+            }
+        }
+        catch (error) {
+            spinner.fail('File reset failed');
+            // Enhanced error logging
+            this.log('\n=== File Reset Error Details ===');
+            this.log(`Error type: ${error?.constructor?.name || 'Unknown'}`);
+            this.log(`Error message: ${error instanceof Error ? error.message : String(error)}`);
+            if (error instanceof Error && error.stack) {
+                this.log(`\nStack trace:`);
+                this.log(error.stack);
+            }
+            this.error(error);
+        }
+        finally {
+            // Reset singletons
+            (0, metadata_sync_1.resetSyncEngine)();
+            // Exit process
+            process.exit(0);
+        }
+    }
+}
+exports.default = FileReset;

package/dist/commands/sync/init.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/sync/init.js

@@ -0,0 +1,101 @@
+"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 ora_classic_1 = __importDefault(require("ora-classic"));
+const metadata_sync_1 = require("@memberjunction/metadata-sync");
+class Init extends core_1.Command {
+    static description = 'Initialize a directory for metadata synchronization';
+    static examples = [
+        `<%= config.bin %> <%= command.id %>`,
+    ];
+    async run() {
+        const spinner = (0, ora_classic_1.default)();
+        try {
+            // Check if already initialized
+            const initService = new metadata_sync_1.InitService();
+            // Build options from user input
+            const options = {};
+            // Check for existing configuration
+            try {
+                // If .mj-sync.json exists, ask about overwrite
+                const overwrite = await (0, prompts_1.select)({
+                    message: 'Directory already initialized. Overwrite configuration?',
+                    choices: [
+                        { name: 'Yes', value: true },
+                        { name: 'No', value: false }
+                    ]
+                });
+                if (!overwrite) {
+                    this.log('Initialization cancelled');
+                    return;
+                }
+                options.overwrite = true;
+            }
+            catch {
+                // File doesn't exist, proceed normally
+            }
+            // Ask if they want to set up an entity directory
+            const setupEntity = await (0, prompts_1.select)({
+                message: 'Would you like to set up an entity directory now?',
+                choices: [
+                    { name: 'Yes - AI Prompts', value: 'ai-prompts' },
+                    { name: 'Yes - Other entity', value: 'other' },
+                    { name: 'No - I\'ll set up later', value: 'no' }
+                ]
+            });
+            options.setupEntity = setupEntity;
+            if (setupEntity === 'other') {
+                options.entityName = await (0, prompts_1.input)({
+                    message: 'Enter the entity name (e.g., "Templates", "AI Models"):'
+                });
+                options.dirName = await (0, prompts_1.input)({
+                    message: 'Enter the directory name:',
+                    default: options.entityName.toLowerCase().replace(/\s+/g, '-')
+                });
+            }
+            // Initialize with callbacks
+            await initService.initialize(options, {
+                onProgress: (message) => {
+                    spinner.start(message);
+                },
+                onSuccess: (message) => {
+                    spinner.succeed(message);
+                },
+                onError: (message) => {
+                    spinner.fail(message);
+                }
+            });
+            this.log('\n✅ Initialization complete!');
+            // Show next steps
+            const nextSteps = initService.getNextSteps();
+            this.log('\nNext steps:');
+            nextSteps.forEach((step, index) => {
+                this.log(`${index + 1}. ${step.replace('mj-sync', 'mj sync')}`);
+            });
+        }
+        catch (error) {
+            spinner.fail('Initialization failed');
+            // Enhanced error logging
+            this.log('\n=== Initialization Error Details ===');
+            this.log(`Error type: ${error?.constructor?.name || 'Unknown'}`);
+            this.log(`Error message: ${error instanceof Error ? error.message : String(error)}`);
+            if (error instanceof Error && error.stack) {
+                this.log(`\nStack trace:`);
+                this.log(error.stack);
+            }
+            // Check for error hints
+            if (error instanceof Error) {
+                const hint = new metadata_sync_1.InitService().getErrorHint(error);
+                if (hint) {
+                    this.log(`\nHint: ${hint}`);
+                }
+            }
+            this.error(error);
+        }
+    }
+}
+exports.default = Init;

package/dist/commands/sync/pull.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Pull extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        entity: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        filter: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'multi-file': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-validate': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private findEntityDirectories;
+}

package/dist/commands/sync/pull.js

@@ -0,0 +1,185 @@
+"use strict";
+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;
+};
+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 ora_classic_1 = __importDefault(require("ora-classic"));
+const chalk_1 = __importDefault(require("chalk"));
+const metadata_sync_1 = require("@memberjunction/metadata-sync");
+class Pull extends core_1.Command {
+    static description = 'Pull metadata from database to local files';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> --entity="AI Prompts"`,
+        `<%= config.bin %> <%= command.id %> --entity="AI Prompts" --filter="CategoryID='customer-service-id'"`,
+    ];
+    static flags = {
+        entity: core_1.Flags.string({ description: 'Entity name to pull', required: true }),
+        filter: core_1.Flags.string({ description: 'Additional filter for pulling specific records' }),
+        'dry-run': core_1.Flags.boolean({ description: 'Show what would be pulled without actually pulling' }),
+        'multi-file': core_1.Flags.string({ description: 'Create a single file with multiple records (provide filename)' }),
+        verbose: core_1.Flags.boolean({ char: 'v', description: 'Show detailed output' }),
+        'no-validate': core_1.Flags.boolean({ description: 'Skip validation before pull' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Pull);
+        const spinner = (0, ora_classic_1.default)();
+        try {
+            // Load MJ config first
+            spinner.start('Loading configuration');
+            const mjConfig = (0, metadata_sync_1.loadMJConfig)();
+            if (!mjConfig) {
+                this.error('No mj.config.cjs found in current directory or parent directories');
+            }
+            // Stop spinner before provider initialization
+            spinner.stop();
+            // Initialize data provider
+            await (0, metadata_sync_1.initializeProvider)(mjConfig);
+            // Get singleton sync engine
+            const syncEngine = await (0, metadata_sync_1.getSyncEngine)((0, metadata_sync_1.getSystemUser)());
+            // Show success after initialization
+            if (flags.verbose) {
+                spinner.succeed('Configuration and metadata loaded');
+            }
+            else {
+                spinner.stop();
+            }
+            // Run validation unless disabled
+            if (!flags['no-validate']) {
+                spinner.start('Validating metadata...');
+                const validator = new metadata_sync_1.ValidationService({ verbose: flags.verbose });
+                const formatter = new metadata_sync_1.FormattingService();
+                const validationResult = await validator.validateDirectory(metadata_sync_1.configManager.getOriginalCwd());
+                spinner.stop();
+                if (!validationResult.isValid || validationResult.warnings.length > 0) {
+                    // Show validation results
+                    this.log('\n' + formatter.formatValidationResult(validationResult, flags.verbose));
+                    if (!validationResult.isValid) {
+                        // Ask for confirmation
+                        const shouldContinue = await (0, prompts_1.select)({
+                            message: 'Validation failed with errors. Do you want to continue anyway?',
+                            choices: [
+                                { name: 'No, fix the errors first', value: false },
+                                { name: 'Yes, continue anyway', value: true }
+                            ],
+                            default: false
+                        });
+                        if (!shouldContinue) {
+                            this.error('Pull cancelled due to validation errors.');
+                        }
+                    }
+                }
+                else {
+                    this.log(chalk_1.default.green('✓ Validation passed'));
+                }
+            }
+            // Set target directory if specified via environment
+            const envTargetDir = process.env.METADATA_SYNC_TARGET_DIR;
+            // Create pull service and execute
+            const pullService = new metadata_sync_1.PullService(syncEngine, (0, metadata_sync_1.getSystemUser)());
+            try {
+                const result = await pullService.pull({
+                    entity: flags.entity,
+                    filter: flags.filter,
+                    dryRun: flags['dry-run'],
+                    multiFile: flags['multi-file'],
+                    verbose: flags.verbose,
+                    noValidate: flags['no-validate'],
+                    targetDir: envTargetDir
+                }, {
+                    onProgress: (message) => {
+                        spinner.start(message);
+                    },
+                    onSuccess: (message) => {
+                        spinner.succeed(message);
+                    },
+                    onError: (message) => {
+                        spinner.fail(message);
+                    },
+                    onWarn: (message) => {
+                        this.warn(message);
+                    },
+                    onLog: (message) => {
+                        this.log(message);
+                    }
+                });
+                if (!flags['dry-run']) {
+                    this.log(`\n✅ Pull completed successfully`);
+                }
+            }
+            catch (pullError) {
+                // If it's a "multiple directories found" error, handle it specially
+                if (pullError instanceof Error && pullError.message.includes('Multiple directories found')) {
+                    // Re-throw to be caught by outer handler
+                    throw pullError;
+                }
+                throw pullError;
+            }
+        }
+        catch (error) {
+            spinner.fail('Pull failed');
+            // Handle multiple directories error
+            if (error instanceof Error && error.message.includes('Multiple directories found')) {
+                const entityDirs = await this.findEntityDirectories(flags.entity);
+                const targetDir = await (0, prompts_1.select)({
+                    message: `Multiple directories found for entity "${flags.entity}". Which one to use?`,
+                    choices: entityDirs.map(dir => ({ name: dir, value: dir }))
+                });
+                // Re-run with specific target directory
+                process.env.METADATA_SYNC_TARGET_DIR = targetDir;
+                await this.run();
+                return;
+            }
+            // Enhanced error logging
+            this.log('\n=== Pull Error Details ===');
+            this.log(`Error type: ${error?.constructor?.name || 'Unknown'}`);
+            this.log(`Error message: ${error instanceof Error ? error.message : String(error)}`);
+            if (error instanceof Error && error.stack) {
+                this.log(`\nStack trace:`);
+                this.log(error.stack);
+            }
+            // Context information
+            this.log(`\nContext:`);
+            this.log(`- Working directory: ${metadata_sync_1.configManager.getOriginalCwd()}`);
+            this.log(`- Entity: ${flags.entity || 'not specified'}`);
+            this.log(`- Filter: ${flags.filter || 'none'}`);
+            this.error(error);
+        }
+        finally {
+            // Reset singletons
+            (0, metadata_sync_1.resetSyncEngine)();
+            // Exit process to prevent background MJ tasks from throwing errors
+            process.exit(0);
+        }
+    }
+    async findEntityDirectories(entityName) {
+        // This is a simplified version - would need full implementation
+        const { findEntityDirectories } = await Promise.resolve().then(() => __importStar(require('@memberjunction/metadata-sync')));
+        return findEntityDirectories(metadata_sync_1.configManager.getOriginalCwd());
+    }
+}
+exports.default = Pull;

package/dist/commands/sync/push.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Push extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dir: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        ci: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-validate': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}