mongoose-database-schema/index.js

MongoDB database documentation generator with table schemas and relationships

#!/usr/bin/env node

const yargs = require('yargs');
const DatabaseConnection = require('./src/database');
const SchemaAnalyzer = require('./src/schemaAnalyzer');
const RelationshipDetector = require('./src/relationshipDetector');
const DocumentationGenerator = require('./src/documentationGenerator');

async function main() {
  const argv = yargs
    .option('connection', {
      alias: 'c',
      description: 'MongoDB connection string',
      type: 'string',
      demandOption: true
    })
    .option('database', {
      alias: 'd',
      description: 'Database name',
      type: 'string',
      demandOption: true
    })
    .option('output', {
      alias: 'o',
      description: 'Output format (markdown, json, html)',
      type: 'string',
      default: 'markdown',
      choices: ['markdown', 'json', 'html']
    })
    .option('sample-size', {
      alias: 's',
      description: 'Sample size for schema analysis',
      type: 'number',
      default: 100
    })
    .option('collections', {
      description: 'Specific collections to analyze (comma-separated)',
      type: 'string'
    })
    .option('skip-relationships', {
      description: 'Skip relationship detection for faster processing',
      type: 'boolean',
      default: false
    })
    .help()
    .alias('help', 'h')
    .example('$0 -c "mongodb://localhost:27017" -d mydb', 'Generate documentation for mydb')
    .example('$0 -c "mongodb://localhost:27017" -d mydb -o json', 'Generate JSON documentation')
    .argv;

  const dbConnection = new DatabaseConnection(argv.connection, argv.database);
  
  try {
    console.log('Connecting to MongoDB...');
    const db = await dbConnection.connect();
    
    console.log('Discovering collections...');
    let collections = await dbConnection.getCollections();
    
    if (argv.collections) {
      const specifiedCollections = argv.collections.split(',').map(c => c.trim());
      collections = collections.filter(c => specifiedCollections.includes(c));
      console.log(`Analyzing specified collections: ${collections.join(', ')}`);
    } else {
      console.log(`Found ${collections.length} collections: ${collections.join(', ')}`);
    }
    
    if (collections.length === 0) {
      console.log('No collections found or specified collections do not exist.');
      return;
    }
    
    console.log('Analyzing schemas...');
    const analyzer = new SchemaAnalyzer(db);
    const schemas = [];
    
    for (const collectionName of collections) {
      console.log(`  Analyzing ${collectionName}...`);
      const schema = await analyzer.analyzeCollection(collectionName, argv.sampleSize);
      schemas.push(schema);
    }
    
    let relationships = [];
    let embeddedRelationships = [];
    
    if (!argv.skipRelationships) {
      console.log('Detecting relationships...');
      const relationshipDetector = new RelationshipDetector(db);
      relationships = await relationshipDetector.detectRelationships(schemas);
      
      console.log(`Found ${relationships.length} reference relationships`);
    } else {
      console.log('Skipping relationship detection...');
    }
    
    console.log('Generating documentation...');
    const generator = new DocumentationGenerator();
    await generator.generateDocumentation(schemas, relationships, embeddedRelationships, argv.output);
    
    console.log('Documentation generation completed successfully!');
    
  } catch (error) {
    console.error('Error:', error.message);
    process.exit(1);
  } finally {
    await dbConnection.disconnect();
  }
}

if (require.main === module) {
  main().catch(console.error);
}

module.exports = {
  main,
  DatabaseConnection: require('./src/database'),
  SchemaAnalyzer: require('./src/schemaAnalyzer'),
  RelationshipDetector: require('./src/relationshipDetector'),
  DocumentationGenerator: require('./src/documentationGenerator')
};