easybuild-nox 1.0.0

package/src/commands/db.js

@@ -0,0 +1,423 @@
+const { Command } = require('commander');
+const inquirer = require('inquirer');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+
+const dbCommand = new Command('db')
+  .description('Database operations')
+  .option('-a, --action <action>', 'Action (init, migrate, rollback, seed, studio, generate)')
+  .option('-n, --name <name>', 'Migration/seed name')
+  .action(async (options) => {
+    logger.header('🗄️  Database Manager');
+
+    try {
+      const action = options.action || 'init';
+
+      const actions = {
+        init: dbInit,
+        migrate: dbMigrate,
+        rollback: dbRollback,
+        seed: dbSeed,
+        studio: dbStudio,
+        generate: dbGenerate,
+        reset: dbReset,
+      };
+
+      const actionFn = actions[action];
+      if (!actionFn) {
+        logger.error(`Unknown action: ${action}`);
+        process.exit(1);
+      }
+
+      await actionFn(options);
+    } catch (error) {
+      logger.error(`Database operation failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function dbInit(options) {
+  logger.info('Initializing database configuration...');
+
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'orm',
+      message: 'Select your ORM:',
+      choices: [
+        { name: 'Prisma', value: 'prisma' },
+        { name: 'Drizzle', value: 'drizzle' },
+        { name: 'TypeORM', value: 'typeorm' },
+        { name: 'Mongoose', value: 'mongoose' },
+        { name: 'Sequelize', value: 'sequelize' },
+      ],
+    },
+    {
+      type: 'list',
+      name: 'database',
+      message: 'Select your database:',
+      choices: [
+        { name: 'PostgreSQL', value: 'postgresql' },
+        { name: 'MySQL', value: 'mysql' },
+        { name: 'SQLite', value: 'sqlite' },
+        { name: 'MongoDB', value: 'mongodb' },
+      ],
+    },
+  ]);
+
+  const ormTemplates = {
+    prisma: {
+      'prisma/schema.prisma': `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${answer.database}"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}`,
+      '.env': `DATABASE_URL="${getDefaultDbUrl(answer.database)}"`,
+    },
+    drizzle: {
+      'drizzle.config.ts': `import type { Config } from 'drizzle-kit';
+
+export default {
+  schema: './src/schema/*',
+  out: './drizzle',
+  dialect: '${answer.database}',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+} satisfies Config;`,
+      'src/schema/index.ts': `import { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+
+export const users = pgTable('users', {
+  id: serial('id').primaryKey(),
+  name: text('name'),
+  email: text('email').notNull().unique(),
+  createdAt: timestamp('created_at').defaultNow(),
+});`,
+    },
+    typeorm: {
+      'src/entity/User.ts': `import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+@Entity()
+export class User {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @Column({ unique: true })
+  email: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}`,
+    },
+    mongoose: {
+      'src/models/User.ts': `import mongoose, { Schema, Document } from 'mongoose';
+
+export interface IUser extends Document {
+  name: string;
+  email: string;
+}
+
+const UserSchema = new Schema<IUser>({
+  name: { type: String, required: true },
+  email: { type: String, required: true, unique: true },
+}, {
+  timestamps: true,
+});
+
+export const User = mongoose.model<IUser>('User', UserSchema);`,
+    },
+    sequelize: {
+      'src/models/User.ts': `import { DataTypes, Model } from 'sequelize';
+import { sequelize } from '../config/database';
+
+export class User extends Model {
+  public id!: number;
+  public name!: string;
+  public email!: string;
+}
+
+User.init({
+  id: {
+    type: DataTypes.INTEGER,
+    autoIncrement: true,
+    primaryKey: true,
+  },
+  name: {
+    type: DataTypes.STRING,
+    allowNull: false,
+  },
+  email: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    unique: true,
+  },
+}, {
+  sequelize,
+  tableName: 'users',
+  timestamps: true,
+});`,
+    },
+  };
+
+  const templates = ormTemplates[options.orm || 'prisma'];
+  if (!templates) {
+    logger.error('Unsupported ORM');
+    return;
+  }
+
+  for (const [filePath, content] of Object.entries(templates)) {
+    const fullPath = path.join(process.cwd(), filePath);
+    await fs.ensureDir(path.dirname(fullPath));
+    await fs.writeFile(fullPath, content);
+    logger.success(`Created ${filePath}`);
+  }
+
+  logger.info('Run "easy db migrate" to apply migrations');
+}
+
+async function dbMigrate(options) {
+  logger.info('Running migrations...');
+
+  // Detect ORM and run appropriate command
+  const orm = await detectOrm();
+  if (!orm) {
+    logger.error('No ORM detected. Run "easy db init" first.');
+    return;
+  }
+
+  const commands = {
+    prisma: 'npx prisma migrate dev',
+    drizzle: 'npx drizzle-kit push',
+    typeorm: 'npx typeorm migration:run',
+    sequelize: 'npx sequelize-cli db:migrate',
+  };
+
+  const { spawn } = require('child_process');
+  const cmd = commands[orm];
+  if (!cmd) {
+    logger.error(`Unsupported ORM: ${orm}`);
+    return;
+  }
+
+  const [command, ...args] = cmd.split(' ');
+  const child = spawn(command, args, { stdio: 'inherit', shell: true });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Migrations applied successfully!');
+        resolve();
+      } else {
+        logger.error('Migration failed');
+        reject(new Error('Migration failed'));
+      }
+    });
+  });
+}
+
+async function dbRollback(options) {
+  logger.info('Rolling back migrations...');
+
+  const orm = await detectOrm();
+  if (!orm) {
+    logger.error('No ORM detected');
+    return;
+  }
+
+  const commands = {
+    prisma: 'npx prisma migrate reset',
+    typeorm: 'npx typeorm migration:revert',
+    sequelize: 'npx sequelize-cli db:migrate:undo',
+  };
+
+  const { spawn } = require('child_process');
+  const cmd = commands[orm];
+  if (!cmd) {
+    logger.error(`Rollback not supported for ${orm}`);
+    return;
+  }
+
+  const [command, ...args] = cmd.split(' ');
+  const child = spawn(command, args, { stdio: 'inherit', shell: true });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Rollback completed!');
+        resolve();
+      } else {
+        reject(new Error('Rollback failed'));
+      }
+    });
+  });
+}
+
+async function dbSeed(options) {
+  logger.info('Seeding database...');
+
+  const orm = await detectOrm();
+  if (!orm) {
+    logger.error('No ORM detected');
+    return;
+  }
+
+  const commands = {
+    prisma: 'npx prisma db seed',
+    drizzle: 'npx tsx src/seed.ts',
+    sequelize: 'npx sequelize-cli db:seed:all',
+  };
+
+  const { spawn } = require('child_process');
+  const cmd = commands[orm];
+  if (!cmd) {
+    logger.error(`Seeding not supported for ${orm}`);
+    return;
+  }
+
+  const [command, ...args] = cmd.split(' ');
+  const child = spawn(command, args, { stdio: 'inherit', shell: true });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Database seeded!');
+        resolve();
+      } else {
+        reject(new Error('Seeding failed'));
+      }
+    });
+  });
+}
+
+async function dbStudio(options) {
+  logger.info('Opening database studio...');
+
+  const orm = await detectOrm();
+  if (!orm) {
+    logger.error('No ORM detected');
+    return;
+  }
+
+  const commands = {
+    prisma: 'npx prisma studio',
+  };
+
+  const { spawn } = require('child_process');
+  const cmd = commands[orm];
+  if (!cmd) {
+    logger.error(`Studio not supported for ${orm}`);
+    return;
+  }
+
+  const [command, ...args] = cmd.split(' ');
+  const child = spawn(command, args, { stdio: 'inherit', shell: true });
+
+  return new Promise((resolve) => {
+    child.on('close', () => resolve());
+  });
+}
+
+async function dbGenerate(options) {
+  let name = options.name;
+  if (!name) {
+    const answer = await inquirer.prompt([
+      { type: 'input', name: 'name', message: 'Migration name:' },
+    ]);
+    name = answer.name;
+  }
+
+  logger.info(`Generating migration: ${name}...`);
+
+  const orm = await detectOrm();
+  if (!orm) {
+    logger.error('No ORM detected');
+    return;
+  }
+
+  const timestamp = new Date().toISOString().replace(/[-:]/g, '').split('.')[0];
+  const migrationDir = `migrations/${timestamp}_${name}`;
+
+  await fs.ensureDir(migrationDir);
+  await fs.writeFile(
+    path.join(migrationDir, 'up.sql'),
+    `-- Migration: ${name}\n-- UP\n\n`
+  );
+  await fs.writeFile(
+    path.join(migrationDir, 'down.sql'),
+    `-- Migration: ${name}\n-- DOWN\n\n`
+  );
+
+  logger.success(`Created migration files in ${migrationDir}`);
+}
+
+async function dbReset(options) {
+  const answer = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: 'This will destroy all data. Continue?',
+      default: false,
+    },
+  ]);
+
+  if (!answer.confirm) {
+    logger.info('Cancelled');
+    return;
+  }
+
+  logger.info('Resetting database...');
+  await dbRollback(options);
+  await dbMigrate(options);
+  await dbSeed(options);
+  logger.success('Database reset complete!');
+}
+
+async function detectOrm() {
+  const pkgPath = path.join(process.cwd(), 'package.json');
+  if (await fs.pathExists(pkgPath)) {
+    const pkg = await fs.readJson(pkgPath);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    if (deps.prisma || deps['@prisma/client']) return 'prisma';
+    if (deps['drizzle-orm'] || deps['drizzle-kit']) return 'drizzle';
+    if (deps.typeorm) return 'typeorm';
+    if (deps.mongoose) return 'mongoose';
+    if (deps.sequelize) return 'sequelize';
+  }
+
+  if (await fs.pathExists(path.join(process.cwd(), 'prisma/schema.prisma'))) return 'prisma';
+  if (await fs.pathExists(path.join(process.cwd(), 'drizzle.config.ts'))) return 'drizzle';
+  if (await fs.pathExists(path.join(process.cwd(), 'drizzle.config.js'))) return 'drizzle';
+
+  return null;
+}
+
+function getDefaultDbUrl(database) {
+  const urls = {
+    postgresql: 'postgresql://postgres:password@localhost:5432/mydb',
+    mysql: 'mysql://root:password@localhost:3306/mydb',
+    sqlite: 'file:./dev.db',
+    mongodb: 'mongodb://localhost:27017/mydb',
+  };
+  return urls[database] || urls.postgresql;
+}
+
+module.exports = dbCommand;

package/src/commands/deploy.js

@@ -0,0 +1,203 @@
+const { Command } = require('commander');
+const inquirer = require('inquirer');
+const { spawn } = require('child_process');
+const logger = require('../utils/logger');
+const ProjectDetector = require('../utils/detector');
+const ConfigLoader = require('../utils/config');
+
+const deployCommand = new Command('deploy')
+  .description('Deploy your application')
+  .option('-p, --provider <provider>', 'Cloud provider (aws, gcp, azure, vercel, netlify, railway, render, fly)')
+  .option('-e, --environment <env>', 'Deployment environment', 'production')
+  .action(async (options) => {
+    logger.header('🚀 Deploying Application');
+
+    const detector = new ProjectDetector();
+    const config = new ConfigLoader();
+
+    try {
+      const projectInfo = await detector.detect();
+      const configData = await config.load();
+
+      let provider = options.provider;
+
+      // Get provider if not provided
+      if (!provider) {
+        const providerAnswer = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'provider',
+            message: 'Select deployment provider:',
+            choices: [
+              { name: 'Vercel - Best for frontend/fullstack', value: 'vercel' },
+              { name: 'Netlify - Best for static sites', value: 'netlify' },
+              { name: 'Railway - Easy fullstack deployment', value: 'railway' },
+              { name: 'Render - Simple cloud hosting', value: 'render' },
+              { name: 'Fly.io - Global edge deployment', value: 'fly' },
+              { name: 'AWS - Amazon Web Services', value: 'aws' },
+              { name: 'Google Cloud Platform', value: 'gcp' },
+              { name: 'Microsoft Azure', value: 'azure' },
+            ],
+          },
+        ]);
+        provider = providerAnswer.provider;
+      }
+
+      await deploy(projectInfo, configData, provider, options);
+    } catch (error) {
+      logger.error(`Deployment failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function deploy(projectInfo, config, provider, options) {
+  logger.info(`Provider: ${provider}`);
+  logger.info(`Environment: ${options.environment}`);
+  logger.info('');
+
+  const deployers = {
+    vercel: deployVercel,
+    netlify: deployNetlify,
+    railway: deployRailway,
+    render: deployRender,
+    fly: deployFly,
+    aws: deployAWS,
+    gcp: deployGCP,
+    azure: deployAzure,
+  };
+
+  const deployer = deployers[provider];
+  if (!deployer) {
+    throw new Error(`Unsupported provider: ${provider}`);
+  }
+
+  await deployer(projectInfo, config, options);
+}
+
+async function deployVercel(projectInfo, config, options) {
+  logger.info('Deploying to Vercel...');
+
+  // Check if vercel is installed
+  const child = spawn('npx', ['vercel', options.environment === 'production' ? '--prod' : ''], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Deployed to Vercel successfully!');
+        resolve();
+      } else {
+        reject(new Error('Vercel deployment failed'));
+      }
+    });
+  });
+}
+
+async function deployNetlify(projectInfo, config, options) {
+  logger.info('Deploying to Netlify...');
+
+  const child = spawn('npx', ['netlify-cli', 'deploy', options.environment === 'production' ? '--prod' : ''], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Deployed to Netlify successfully!');
+        resolve();
+      } else {
+        reject(new Error('Netlify deployment failed'));
+      }
+    });
+  });
+}
+
+async function deployRailway(projectInfo, config, options) {
+  logger.info('Deploying to Railway...');
+
+  const child = spawn('npx', ['railway', 'up'], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Deployed to Railway successfully!');
+        resolve();
+      } else {
+        reject(new Error('Railway deployment failed'));
+      }
+    });
+  });
+}
+
+async function deployRender(projectInfo, config, options) {
+  logger.info('Deploying to Render...');
+  logger.info('Please connect your repository to Render dashboard');
+  logger.info('https://dashboard.render.com');
+}
+
+async function deployFly(projectInfo, config, options) {
+  logger.info('Deploying to Fly.io...');
+
+  const child = spawn('flyctl', ['deploy'], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) {
+        logger.success('Deployed to Fly.io successfully!');
+        resolve();
+      } else {
+        reject(new Error('Fly.io deployment failed'));
+      }
+    });
+  });
+}
+
+async function deployAWS(projectInfo, config, options) {
+  logger.info('Deploying to AWS...');
+  logger.info('Supported AWS services:');
+  logger.list([
+    'AWS Lambda (serverless)',
+    'AWS Elastic Beanstalk',
+    'AWS ECS/Fargate',
+    'AWS App Runner',
+  ]);
+  logger.info('');
+  logger.info('Please configure your AWS credentials and select a service');
+}
+
+async function deployGCP(projectInfo, config, options) {
+  logger.info('Deploying to Google Cloud...');
+  logger.info('Supported GCP services:');
+  logger.list([
+    'Cloud Run',
+    'Cloud Functions',
+    'App Engine',
+    'Cloud Run Jobs',
+  ]);
+  logger.info('');
+  logger.info('Please configure gcloud CLI and select a service');
+}
+
+async function deployAzure(projectInfo, config, options) {
+  logger.info('Deploying to Microsoft Azure...');
+  logger.info('Supported Azure services:');
+  logger.list([
+    'Azure App Service',
+    'Azure Functions',
+    'Azure Container Apps',
+    'Azure Static Web Apps',
+  ]);
+  logger.info('');
+  logger.info('Please configure Azure CLI and select a service');
+}
+
+module.exports = deployCommand;