easybuild-nox 1.0.0

package/src/targets/node.js

@@ -0,0 +1,146 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+
+class NodeBuilder {
+  constructor(projectInfo, config) {
+    this.projectInfo = projectInfo;
+    this.config = config;
+    this.outDir = config.outDir || 'dist';
+  }
+
+  async build(options) {
+    logger.section('Building Node.js Application');
+
+    // Determine bundler
+    const bundler = this.projectInfo.bundler || 'esbuild';
+
+    switch (bundler) {
+      case 'esbuild':
+        await this.buildWithEsbuild(options);
+        break;
+      case 'webpack':
+        await this.buildWithWebpack(options);
+        break;
+      case 'rollup':
+        await this.buildWithRollup(options);
+        break;
+      case 'vite':
+        await this.buildWithVite(options);
+        break;
+      default:
+        await this.buildWithEsbuild(options);
+    }
+  }
+
+  async buildWithEsbuild(options) {
+    logger.info('Building with esbuild...');
+
+    const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+    const entryPoint = this.config.entry || pkg.main || 'src/index.js';
+
+    const args = [
+      'esbuild',
+      entryPoint,
+      '--bundle',
+      '--platform=node',
+      '--target=node20',
+      `--outdir=${options.outDir || this.outDir}`,
+    ];
+
+    if (options.minify) args.push('--minify');
+    if (options.sourcemap) args.push('--sourcemap');
+    if (this.config.format === 'esm') args.push('--format=esm');
+
+    // External dependencies
+    const externals = Object.keys(pkg.dependencies || {});
+    if (externals.length > 0) {
+      args.push(`--external:${externals.join(',')}`);
+    }
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with esbuild');
+          resolve();
+        } else {
+          reject(new Error('esbuild build failed'));
+        }
+      });
+    });
+  }
+
+  async buildWithWebpack(options) {
+    logger.info('Building with webpack...');
+
+    const args = ['webpack', '--mode', 'production'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with webpack');
+          resolve();
+        } else {
+          reject(new Error('webpack build failed'));
+        }
+      });
+    });
+  }
+
+  async buildWithRollup(options) {
+    logger.info('Building with Rollup...');
+
+    const args = ['rollup', '-c'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Rollup');
+          resolve();
+        } else {
+          reject(new Error('Rollup build failed'));
+        }
+      });
+    });
+  }
+
+  async buildWithVite(options) {
+    logger.info('Building with Vite...');
+
+    const args = ['vite', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Vite');
+          resolve();
+        } else {
+          reject(new Error('Vite build failed'));
+        }
+      });
+    });
+  }
+}
+
+module.exports = NodeBuilder;

package/src/utils/config.js

@@ -0,0 +1,191 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const CONFIG_FILE_NAMES = [
+  'easy.config.js',
+  'easy.config.mjs',
+  'easy.config.ts',
+  'easy.config.json',
+  '.easyrc',
+  '.easyrc.json',
+  '.easyrc.js',
+];
+
+const DEFAULT_CONFIG = {
+  // Project settings
+  name: 'my-app',
+  version: '1.0.0',
+  description: '',
+
+  // Build settings
+  entry: 'src/index.js',
+  outDir: 'dist',
+  target: 'node',
+  format: 'cjs',
+  platform: 'current',
+
+  // TypeScript
+  typescript: {
+    enabled: false,
+    tsconfig: 'tsconfig.json',
+    declaration: true,
+    sourceMap: true,
+  },
+
+  // Development
+  dev: {
+    port: 3000,
+    host: 'localhost',
+    open: true,
+    watch: true,
+  },
+
+  // Production build
+  build: {
+    minify: true,
+    sourcemap: false,
+    analyze: false,
+    clean: true,
+  },
+
+  // Electron
+  electron: {
+    enabled: false,
+    main: 'electron/main.js',
+    preload: 'electron/preload.js',
+    renderer: 'electron/renderer',
+    output: 'release',
+    platforms: ['win', 'mac', 'linux'],
+    arch: ['x64', 'arm64'],
+    icon: null,
+    asar: true,
+  },
+
+  // Docker
+  docker: {
+    enabled: false,
+    baseImage: 'node:20-alpine',
+    workdir: '/app',
+    port: 3000,
+    output: 'Dockerfile',
+  },
+
+  // Cloud deployment
+  deploy: {
+    provider: null,
+    region: 'us-east-1',
+    runtime: 'nodejs20.x',
+  },
+
+  // Monorepo
+  monorepo: {
+    enabled: false,
+    packages: ['packages/*'],
+  },
+
+  // Testing
+  test: {
+    framework: 'node',
+    coverage: false,
+  },
+
+  // Linting
+  lint: {
+    enabled: false,
+    eslint: true,
+    prettier: true,
+  },
+};
+
+class ConfigLoader {
+  constructor(rootDir = process.cwd()) {
+    this.rootDir = rootDir;
+    this.config = null;
+    this.userConfig = null;
+  }
+
+  async load() {
+    // Load user config
+    this.userConfig = await this.loadUserConfig();
+
+    // Merge with defaults
+    this.config = this.mergeConfig(DEFAULT_CONFIG, this.userConfig || {});
+
+    // Apply environment-specific overrides
+    await this.applyEnvironmentOverrides();
+
+    return this.config;
+  }
+
+  async loadUserConfig() {
+    for (const configName of CONFIG_FILE_NAMES) {
+      const configPath = path.join(this.rootDir, configName);
+      if (await fs.pathExists(configPath)) {
+        try {
+          if (configName.endsWith('.json')) {
+            return await fs.readJson(configPath);
+          } else {
+            // For JS/MJS files, require them
+            delete require.cache[require.resolve(configPath)];
+            return require(configPath);
+          }
+        } catch (error) {
+          console.error(`Error loading config from ${configName}:`, error.message);
+        }
+      }
+    }
+    return null;
+  }
+
+  mergeConfig(defaults, user) {
+    const merged = { ...defaults };
+
+    for (const key of Object.keys(user)) {
+      if (typeof user[key] === 'object' && !Array.isArray(user[key]) && user[key] !== null) {
+        merged[key] = this.mergeConfig(defaults[key] || {}, user[key]);
+      } else {
+        merged[key] = user[key];
+      }
+    }
+
+    return merged;
+  }
+
+  async applyEnvironmentOverrides() {
+    const env = process.env.NODE_ENV || 'development';
+
+    if (env === 'production') {
+      this.config.build.minify = true;
+      this.config.build.sourcemap = false;
+      this.config.dev.watch = false;
+    } else if (env === 'development') {
+      this.config.build.minify = false;
+      this.config.build.sourcemap = true;
+      this.config.dev.watch = true;
+    }
+  }
+
+  get(key) {
+    return key.split('.').reduce((obj, k) => obj?.[k], this.config);
+  }
+
+  set(key, value) {
+    const keys = key.split('.');
+    let obj = this.config;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!obj[keys[i]]) obj[keys[i]] = {};
+      obj = obj[keys[i]];
+    }
+
+    obj[keys[keys.length - 1]] = value;
+  }
+
+  async save() {
+    const configPath = path.join(this.rootDir, 'easy.config.js');
+    const content = `module.exports = ${JSON.stringify(this.config, null, 2)};`;
+    await fs.writeFile(configPath, content);
+  }
+}
+
+module.exports = ConfigLoader;