js-mvc-app/dist/templates/database.js

A CLI tool to scaffold complete Node.js MVC projects with TypeScript, just like Laravel

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getDatabaseConfig = getDatabaseConfig;
function getDatabaseConfig(config) {
    const { database } = config;
    switch (database) {
        case 'mongodb':
            return {
                dependencies: ['mongoose'],
                devDependencies: ['@types/mongoose'],
                connectionFile: getMongoConnection(),
                modelExample: ''
            };
        case 'mysql':
            return {
                dependencies: ['sequelize', 'mysql2'],
                devDependencies: [],
                connectionFile: getSequelizeConnection(database),
                modelExample: getSequelizeSetup()
            };
        case 'postgresql':
            return {
                dependencies: ['sequelize', 'pg'],
                devDependencies: ['@types/pg'],
                connectionFile: getSequelizeConnection(database),
                modelExample: getSequelizeSetup()
            };
        case 'sqlite':
            return {
                dependencies: ['sequelize', 'sqlite3'],
                devDependencies: [],
                connectionFile: getSequelizeConnection(database),
                modelExample: getSequelizeSetup()
            };
        default:
            throw new Error(`Unsupported database: ${database}`);
    }
}
function getMongoConnection() {
    return `import mongoose from 'mongoose';
import { logger } from '../utils/logger';

const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/nodeapp';

export async function connectDatabase(): Promise<void> {
  try {
    await mongoose.connect(MONGODB_URI);
    logger.info('Connected to MongoDB');
    console.log('📦 Connected to MongoDB');
  } catch (error) {
    logger.error('MongoDB connection error:', error);
    console.error('❌ MongoDB connection error:', error);
    process.exit(1);
  }
}

export async function disconnectDatabase(): Promise<void> {
  try {
    await mongoose.disconnect();
    logger.info('Disconnected from MongoDB');
  } catch (error) {
    logger.error('MongoDB disconnection error:', error);
  }
}

// Handle connection events
mongoose.connection.on('connected', () => {
  logger.info('Mongoose connected to MongoDB');
});

mongoose.connection.on('error', (err) => {
  logger.error('Mongoose connection error:', err);
});

mongoose.connection.on('disconnected', () => {
  logger.info('Mongoose disconnected from MongoDB');
});

// Graceful shutdown
process.on('SIGINT', async () => {
  await disconnectDatabase();
  process.exit(0);
});
`;
}
function getSequelizeConnection(database) {
    const dialectMap = {
        mysql: 'mysql',
        postgresql: 'postgres',
        sqlite: 'sqlite'
    };
    const dialect = dialectMap[database];
    const defaultPort = database === 'postgresql' ? '5432' : '3306';
    const storageConfig = database === 'sqlite' ? 'storage: process.env.DB_STORAGE || \'./database.sqlite\',' : '';
    const dbUpperCase = database.toUpperCase();
    return `import { Sequelize } from 'sequelize';
import { logger } from '../utils/logger';

const DATABASE_URL = process.env.DATABASE_URL;
const DB_NAME = process.env.DB_NAME || 'nodeapp';
const DB_USER = process.env.DB_USER || 'root';
const DB_PASSWORD = process.env.DB_PASSWORD || '';
const DB_HOST = process.env.DB_HOST || 'localhost';
const DB_PORT = parseInt(process.env.DB_PORT || '${defaultPort}');

let sequelize: Sequelize;

if (DATABASE_URL) {
  // Use connection string (common in production)
  sequelize = new Sequelize(DATABASE_URL, {
    dialect: '${dialect}',
    logging: (msg) => logger.debug(msg),
    pool: {
      max: 5,
      min: 0,
      acquire: 30000,
      idle: 10000
    }
  });
} else {
  // Use individual connection parameters
  sequelize = new Sequelize(DB_NAME, DB_USER, DB_PASSWORD, {
    host: DB_HOST,
    port: DB_PORT,
    dialect: '${dialect}',
    ${storageConfig}
    logging: (msg) => logger.debug(msg),
    pool: {
      max: 5,
      min: 0,
      acquire: 30000,
      idle: 10000
    }
  });
}

export async function connectDatabase(): Promise<void> {
  try {
    await sequelize.authenticate();
    logger.info('Connected to ${dbUpperCase} database');
    console.log('📦 Connected to ${dbUpperCase} database');
    
    // Sync database (be careful in production)
    if (process.env.NODE_ENV !== 'production') {
      await sequelize.sync({ alter: true });
      logger.info('Database synchronized');
    }
  } catch (error) {
    logger.error('Database connection error:', error);
    console.error('❌ Database connection error:', error);
    process.exit(1);
  }
}

export async function disconnectDatabase(): Promise<void> {
  try {
    await sequelize.close();
    logger.info('Disconnected from database');
  } catch (error) {
    logger.error('Database disconnection error:', error);
  }
}

export { sequelize };

// Graceful shutdown
process.on('SIGINT', async () => {
  await disconnectDatabase();
  process.exit(0);
});
`;
}
function getSequelizeSetup() {
    return `import { sequelize } from './database';

// Import models here
import '../models/User';

// Add model associations here if needed
export function setupAssociations(): void {
  // Example:
  // User.hasMany(Post);
  // Post.belongsTo(User);
}

// Initialize associations
setupAssociations();

export { sequelize };
`;
}
//# sourceMappingURL=database.js.map