@engjts/nexus 0.1.8 → 0.1.10

package/src/cli/cli.ts

@@ -1,158 +0,0 @@
-import { CreateCommand } from './commands/create';
-import { InitCommand } from './commands/init';
-import { GenerateCommand } from './commands/generate';
-import { AddCommand } from './commands/add';
-import { DevCommand } from './commands/dev';
-import { BuildCommand } from './commands/build';
-import { HelpCommand } from './commands/help';
-import { VersionCommand } from './commands/version';
-import { Logger } from './utils/logger';
-
-export interface Command {
-  name: string;
-  description: string;
-  usage: string;
-  options?: CommandOption[];
-  execute(args: string[], options: Record<string, string | boolean>): Promise<void>;
-}
-
-export interface CommandOption {
-  name: string;
-  alias?: string;
-  description: string;
-  required?: boolean;
-  defaultValue?: string | boolean;
-}
-
-export class CLI {
-  private commands: Map<string, Command> = new Map();
-  private logger = new Logger();
-
-  constructor() {
-    this.registerCommands();
-  }
-
-  private registerCommands(): void {
-    const commands: Command[] = [
-      new CreateCommand(),
-      new InitCommand(),
-      new GenerateCommand(),
-      new AddCommand(),
-      new DevCommand(),
-      new BuildCommand(),
-      new HelpCommand(() => this.commands),
-      new VersionCommand(),
-    ];
-
-    for (const command of commands) {
-      this.commands.set(command.name, command);
-    }
-  }
-
-  async run(args: string[]): Promise<void> {
-    if (args.length === 0) {
-      this.showWelcome();
-      return;
-    }
-
-    const [commandName, ...rest] = args;
-
-    // Handle global flags
-    if (commandName === '--help' || commandName === '-h') {
-      const helpCommand = this.commands.get('help');
-      await helpCommand?.execute([], {});
-      return;
-    }
-
-    if (commandName === '--version' || commandName === '-v') {
-      const versionCommand = this.commands.get('version');
-      await versionCommand?.execute([], {});
-      return;
-    }
-
-    const command = this.commands.get(commandName);
-    if (!command) {
-      this.logger.error(`Unknown command: ${commandName}`);
-      this.logger.info('Run "nexus --help" for available commands');
-      process.exit(1);
-    }
-
-    const { positionalArgs, options } = this.parseArgs(rest);
-
-    try {
-      await command.execute(positionalArgs, options);
-    } catch (error) {
-      if (error instanceof Error) {
-        this.logger.error(error.message);
-      }
-      process.exit(1);
-    }
-  }
-
-  private parseArgs(args: string[]): {
-    positionalArgs: string[];
-    options: Record<string, string | boolean>;
-  } {
-    const positionalArgs: string[] = [];
-    const options: Record<string, string | boolean> = {};
-
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-
-      if (arg.startsWith('--')) {
-        const [key, value] = arg.slice(2).split('=');
-        if (value !== undefined) {
-          options[key] = value;
-        } else if (args[i + 1] && !args[i + 1].startsWith('-')) {
-          options[key] = args[++i];
-        } else {
-          options[key] = true;
-        }
-      } else if (arg.startsWith('-')) {
-        const key = arg.slice(1);
-        if (args[i + 1] && !args[i + 1].startsWith('-')) {
-          options[key] = args[++i];
-        } else {
-          options[key] = true;
-        }
-      } else {
-        positionalArgs.push(arg);
-      }
-    }
-
-    return { positionalArgs, options };
-  }
-
-  private showWelcome(): void {
-    console.log(`
-╔═══════════════════════════════════════════════════════════╗
-║                                                           ║
-║   ███╗   ██╗███████╗██╗  ██╗██╗   ██╗███████╗             ║
-║   ████╗  ██║██╔════╝╚██╗██╔╝██║   ██║██╔════╝             ║
-║   ██╔██╗ ██║█████╗   ╚███╔╝ ██║   ██║███████╗             ║
-║   ██║╚██╗██║██╔══╝   ██╔██╗ ██║   ██║╚════██║             ║
-║   ██║ ╚████║███████╗██╔╝ ██╗╚██████╔╝███████║             ║
-║   ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝             ║
-║                                                           ║
-║   Async-First Web Framework with Type-Safety              ║
-║                                                           ║
-╚═══════════════════════════════════════════════════════════╝
-
-  ${this.logger.colors.cyan}Usage:${this.logger.colors.reset} nexus <command> [options]
-
-  ${this.logger.colors.cyan}Commands:${this.logger.colors.reset}
-    create <name>     Create a new Nexus project
-    init              Initialize Nexus in current directory
-    generate <type>   Generate components (route, middleware, etc.)
-    add <plugin>      Add plugins (swagger, playground, postman)
-    dev               Start development server
-    build             Build for production
-
-  ${this.logger.colors.cyan}Options:${this.logger.colors.reset}
-    --help, -h        Show help
-    --version, -v     Show version
-
-  Run ${this.logger.colors.green}nexus <command> --help${this.logger.colors.reset} for more information on a command.
-`);
-  }
-}

package/src/cli/commands/add.ts

@@ -1,178 +0,0 @@
-import { Command, CommandOption } from '../cli';
-import { Logger } from '../utils/logger';
-import { FileSystem } from '../utils/file-system';
-
-type PluginType = 'playground' | 'postman' | 'swagger';
-
-interface PluginConfig {
-  name: string;
-  import: string;
-  feature: string;
-  description: string;
-}
-
-export class AddCommand implements Command {
-  name = 'add';
-  description = 'Add plugins to your Nexus project';
-  usage = 'nexus add <plugin> [options]';
-  options: CommandOption[] = [
-    {
-      name: 'path',
-      alias: 'p',
-      description: 'Path to the entry file (default: src/index.ts)',
-      defaultValue: 'src/index.ts',
-    },
-  ];
-
-  private logger = new Logger();
-  private validPlugins: PluginType[] = ['playground', 'postman', 'swagger'];
-
-  private pluginConfigs: Record<PluginType, PluginConfig> = {
-    playground: {
-      name: 'playground',
-      import: 'playground',
-      feature: 'playground()',
-      description: 'Interactive API playground at /playground',
-    },
-    postman: {
-      name: 'postman',
-      import: 'postman',
-      feature: 'postman()',
-      description: 'Postman collection export at /postman',
-    },
-    swagger: {
-      name: 'swagger',
-      import: 'swagger',
-      feature: 'swagger()',
-      description: 'Swagger/OpenAPI documentation at /docs',
-    },
-  };
-
-  async execute(
-    args: string[],
-    options: Record<string, string | boolean>
-  ): Promise<void> {
-    if (args.length < 1) {
-      this.showUsage();
-      return;
-    }
-
-    const [plugin] = args;
-
-    if (!this.validPlugins.includes(plugin as PluginType)) {
-      this.logger.error(`Invalid plugin: ${plugin}`);
-      this.logger.info(`Valid plugins: ${this.validPlugins.join(', ')}`);
-      return;
-    }
-
-    const entryPath = (options.path as string) || 'src/index.ts';
-    await this.addPlugin(plugin as PluginType, entryPath);
-  }
-
-  private async addPlugin(plugin: PluginType, entryPath: string): Promise<void> {
-    const fullPath = FileSystem.joinPath(process.cwd(), entryPath);
-    const config = this.pluginConfigs[plugin];
-
-    // Check if entry file exists
-    if (!(await FileSystem.exists(fullPath))) {
-      this.logger.error(`Entry file not found: ${fullPath}`);
-      this.logger.info('Use --path to specify your entry file');
-      return;
-    }
-
-    // Read current file
-    let content = await FileSystem.readFile(fullPath);
-
-    // Check if plugin is already added
-    if (content.includes(`app.plugin(${config.feature})`)) {
-      this.logger.info(`Plugin "${plugin}" is already added to your project`);
-      return;
-    }
-
-    // Check if import already exists
-    const importRegex = new RegExp(`import\\s*{([^}]*)}\\s*from\\s*['"]@engjts/nexus['"]`);
-    const importMatch = content.match(importRegex);
-
-    if (importMatch) {
-      const currentImports = importMatch[1];
-      if (!currentImports.includes(config.import)) {
-        // Add to existing import
-        const newImports = currentImports.trim() + ', ' + config.import;
-        content = content.replace(importRegex, `import {${newImports}} from '@engjts/nexus'`);
-      }
-    } else {
-      // Add new import at the top
-      content = `import { ${config.import} } from '@engjts/nexus';\n${content}`;
-    }
-
-    // Find where to add app.plugin()
-    // Look for existing app.plugin() calls or app.use() calls
-    const pluginPattern = /app\.plugin\([^)]+\);?\n?/g;
-    const usePattern = /app\.use\([^)]+\);?\n?/;
-    const listenPattern = /app\.listen\(/;
-
-    let insertPosition = -1;
-    let insertText = `app.plugin(${config.feature});\n`;
-
-    // Find last app.plugin() call
-    let lastPluginMatch: RegExpExecArray | null = null;
-    let match;
-    while ((match = pluginPattern.exec(content)) !== null) {
-      lastPluginMatch = match;
-    }
-
-    if (lastPluginMatch) {
-      // Insert after last plugin
-      insertPosition = lastPluginMatch.index + lastPluginMatch[0].length;
-    } else {
-      // Find app.use() or app.listen()
-      const useMatch = content.match(usePattern);
-      const listenMatch = content.match(listenPattern);
-
-      if (useMatch && useMatch.index !== undefined) {
-        // Insert before first app.use()
-        insertPosition = useMatch.index;
-        insertText = `// Plugins\napp.plugin(${config.feature});\n\n`;
-      } else if (listenMatch && listenMatch.index !== undefined) {
-        // Insert before app.listen()
-        insertPosition = listenMatch.index;
-        insertText = `// Plugins\napp.plugin(${config.feature});\n\n`;
-      }
-    }
-
-    if (insertPosition === -1) {
-      this.logger.error('Could not find a suitable location to add the plugin');
-      this.logger.info('Please add manually: app.plugin(' + config.feature + ')');
-      return;
-    }
-
-    // Insert the plugin call
-    content = content.slice(0, insertPosition) + insertText + content.slice(insertPosition);
-
-    // Write back
-    await FileSystem.writeFile(fullPath, content);
-
-    this.logger.success(`Added "${plugin}" plugin to your project`);
-    this.logger.info(`  ${config.description}`);
-  }
-
-  private showUsage(): void {
-    console.log(`
-${this.logger.colors.bright}Usage:${this.logger.colors.reset} nexus add <plugin> [options]
-
-${this.logger.colors.bright}Plugins:${this.logger.colors.reset}
-  playground   Add interactive API playground
-  postman      Add Postman collection export
-  swagger      Add Swagger/OpenAPI documentation
-
-${this.logger.colors.bright}Examples:${this.logger.colors.reset}
-  nexus add swagger
-  nexus add playground
-  nexus add postman
-  nexus add swagger --path src/app.ts
-
-${this.logger.colors.bright}Options:${this.logger.colors.reset}
-  --path, -p   Path to entry file (default: src/index.ts)
-`);
-  }
-}

package/src/cli/commands/build.ts

@@ -1,73 +0,0 @@
-import { Command } from '../cli';
-import { Logger } from '../utils/logger';
-import { FileSystem } from '../utils/file-system';
-import { spawnCommand } from '../utils/exec';
-
-export class BuildCommand implements Command {
-  name = 'build';
-  description = 'Build the project for production';
-  usage = 'nexus build [options]';
-  options = [
-    {
-      name: 'outDir',
-      alias: 'o',
-      description: 'Output directory',
-      defaultValue: 'dist',
-    },
-    {
-      name: 'minify',
-      description: 'Minify the output',
-      defaultValue: false,
-    },
-  ];
-
-  private logger = new Logger();
-
-  async execute(
-    args: string[],
-    options: Record<string, string | boolean>
-  ): Promise<void> {
-    const outDir = (options.outDir || options.o || 'dist') as string;
-
-    // Check if we're in a Nexus project
-    const packageJsonPath = FileSystem.joinPath(process.cwd(), 'package.json');
-    if (!(await FileSystem.exists(packageJsonPath))) {
-      this.logger.error('No package.json found. Are you in a Nexus project?');
-      return;
-    }
-
-    this.logger.header('Building Nexus Project');
-
-    // Check for tsconfig.json
-    const tsconfigPath = FileSystem.joinPath(process.cwd(), 'tsconfig.json');
-    if (!(await FileSystem.exists(tsconfigPath))) {
-      this.logger.warning('No tsconfig.json found, using default configuration');
-    }
-
-    // Clean output directory
-    this.logger.step(1, 3, 'Cleaning output directory...');
-    const outputPath = FileSystem.joinPath(process.cwd(), outDir);
-    await FileSystem.removeDirectory(outputPath);
-    this.logger.success(`Cleaned ${outDir}`);
-
-    // Run TypeScript compiler
-    this.logger.step(2, 3, 'Compiling TypeScript...');
-    const exitCode = await spawnCommand('npx', ['tsc', '--outDir', outDir], {
-      cwd: process.cwd(),
-    });
-
-    if (exitCode !== 0) {
-      this.logger.error('Build failed');
-      return;
-    }
-    this.logger.success('TypeScript compiled');
-
-    // Done
-    this.logger.step(3, 3, 'Finalizing...');
-    this.logger.success('Build completed!');
-
-    this.logger.blank();
-    this.logger.info(`Output directory: ${outDir}`);
-    this.logger.info('Run "npm start" or "node dist/index.js" to start the server');
-  }
-}

package/src/cli/commands/create.ts

@@ -1,166 +0,0 @@
-import { Command, CommandOption } from '../cli';
-import { Logger } from '../utils/logger';
-import { FileSystem } from '../utils/file-system';
-import { spawnCommand, checkCommandExists } from '../utils/exec';
-import { ProjectTemplates } from '../templates';
-
-export class CreateCommand implements Command {
-  name = 'create';
-  description = 'Create a new Nexus project';
-  usage = 'nexus create <project-name> [options]';
-  options: CommandOption[] = [
-    {
-      name: 'template',
-      alias: 't',
-      description: 'Project template (basic, api, fullstack)',
-      defaultValue: 'basic',
-    },
-    {
-      name: 'package-manager',
-      alias: 'pm',
-      description: 'Package manager to use (npm, yarn, pnpm, bun)',
-      defaultValue: 'npm',
-    },
-    {
-      name: 'skip-install',
-      description: 'Skip dependency installation',
-      defaultValue: false,
-    },
-    {
-      name: 'skip-git',
-      description: 'Skip git initialization',
-      defaultValue: false,
-    },
-  ];
-
-  private logger = new Logger();
-
-  async execute(
-    args: string[],
-    options: Record<string, string | boolean>
-  ): Promise<void> {
-    if (args.length === 0) {
-      this.logger.error('Project name is required');
-      this.logger.info('Usage: nexus create <project-name>');
-      return;
-    }
-
-    const projectName = args[0];
-    const template = (options.template || options.t || 'basic') as string;
-    const packageManager = (options['package-manager'] || options.pm || 'npm') as string;
-    const skipInstall = options['skip-install'] === true;
-    const skipGit = options['skip-git'] === true;
-
-    // Validate project name
-    if (!/^[a-z0-9-_]+$/i.test(projectName)) {
-      this.logger.error('Project name can only contain letters, numbers, hyphens, and underscores');
-      return;
-    }
-
-    const projectPath = FileSystem.resolvePath(process.cwd(), projectName);
-
-    // Check if directory already exists
-    if (await FileSystem.exists(projectPath)) {
-      this.logger.error(`Directory "${projectName}" already exists`);
-      return;
-    }
-
-    console.log(`
-╔═══════════════════════════════════════════════════════════╗
-║                                                           ║
-║   Creating new Nexus project: ${projectName.padEnd(25)}   ║
-║                                                           ║
-╚═══════════════════════════════════════════════════════════╝
-`);
-
-    const totalSteps = skipInstall ? (skipGit ? 2 : 3) : (skipGit ? 3 : 4);
-    let currentStep = 0;
-
-    // Step 1: Create project structure
-    this.logger.step(++currentStep, totalSteps, 'Creating project structure...');
-    await this.createProjectStructure(projectPath, projectName, template);
-    this.logger.success('Project structure created');
-
-    // Step 2: Initialize git
-    if (!skipGit) {
-      this.logger.step(++currentStep, totalSteps, 'Initializing git repository...');
-      if (await checkCommandExists('git')) {
-        await spawnCommand('git', ['init'], { cwd: projectPath, stdio: 'pipe' });
-        this.logger.success('Git repository initialized');
-      } else {
-        this.logger.warning('Git not found, skipping git initialization');
-      }
-    }
-
-    // Step 3: Install dependencies
-    if (!skipInstall) {
-      this.logger.step(++currentStep, totalSteps, `Installing dependencies with ${packageManager}...`);
-      
-      const installCommand = this.getInstallCommand(packageManager);
-      if (await checkCommandExists(packageManager)) {
-        await spawnCommand(installCommand.cmd, installCommand.args, { cwd: projectPath });
-        this.logger.success('Dependencies installed');
-      } else {
-        this.logger.warning(`${packageManager} not found, skipping dependency installation`);
-        this.logger.info(`Run "${packageManager} install" manually to install dependencies`);
-      }
-    }
-
-    // Step 4: Done!
-    this.logger.step(++currentStep, totalSteps, 'Finalizing...');
-    this.logger.success('Project created successfully!');
-
-    this.showNextSteps(projectName, packageManager);
-  }
-
-  private async createProjectStructure(
-    projectPath: string,
-    projectName: string,
-    template: string
-  ): Promise<void> {
-    const templates = new ProjectTemplates(projectName);
-    const files = templates.getTemplate(template);
-
-    for (const [filePath, content] of Object.entries(files)) {
-      await FileSystem.writeFile(
-        FileSystem.joinPath(projectPath, filePath),
-        content
-      );
-    }
-  }
-
-  private getInstallCommand(pm: string): { cmd: string; args: string[] } {
-    switch (pm) {
-      case 'yarn':
-        return { cmd: 'yarn', args: ['install'] };
-      case 'pnpm':
-        return { cmd: 'pnpm', args: ['install'] };
-      case 'bun':
-        return { cmd: 'bun', args: ['install'] };
-      default:
-        return { cmd: 'npm', args: ['install'] };
-    }
-  }
-
-  private showNextSteps(projectName: string, pm: string): void {
-    const runCmd = pm === 'npm' ? 'npm run' : pm;
-
-    console.log(`
-${this.logger.colors.green}✓ Success!${this.logger.colors.reset} Created ${this.logger.colors.cyan}${projectName}${this.logger.colors.reset}
-
-${this.logger.colors.bright}Next steps:${this.logger.colors.reset}
-
-  ${this.logger.colors.cyan}cd${this.logger.colors.reset} ${projectName}
-  ${this.logger.colors.cyan}${runCmd}${this.logger.colors.reset} dev
-
-${this.logger.colors.bright}Available commands:${this.logger.colors.reset}
-
-  ${this.logger.colors.cyan}${runCmd} dev${this.logger.colors.reset}      Start development server
-  ${this.logger.colors.cyan}${runCmd} build${this.logger.colors.reset}    Build for production
-  ${this.logger.colors.cyan}${runCmd} start${this.logger.colors.reset}    Start production server
-  ${this.logger.colors.cyan}${runCmd} test${this.logger.colors.reset}     Run tests
-
-${this.logger.colors.dim}Happy coding with Nexus! 🚀${this.logger.colors.reset}
-`);
-  }
-}

package/src/cli/commands/dev.ts

@@ -1,85 +0,0 @@
-import { Command } from '../cli';
-import { Logger } from '../utils/logger';
-import { FileSystem } from '../utils/file-system';
-import { spawnCommand } from '../utils/exec';
-
-export class DevCommand implements Command {
-  name = 'dev';
-  description = 'Start development server with hot reload';
-  usage = 'nexus dev [options]';
-  options = [
-    {
-      name: 'port',
-      alias: 'p',
-      description: 'Port to run the server on',
-      defaultValue: '3000',
-    },
-    {
-      name: 'host',
-      alias: 'H',
-      description: 'Host to bind the server to',
-      defaultValue: 'localhost',
-    },
-  ];
-
-  private logger = new Logger();
-
-  async execute(
-    args: string[],
-    options: Record<string, string | boolean>
-  ): Promise<void> {
-    const port = options.port || options.p || '3000';
-    const host = options.host || options.H || 'localhost';
-
-    // Check if we're in a Nexus project
-    const packageJsonPath = FileSystem.joinPath(process.cwd(), 'package.json');
-    if (!(await FileSystem.exists(packageJsonPath))) {
-      this.logger.error('No package.json found. Are you in a Nexus project?');
-      return;
-    }
-
-    // Check for main entry file
-    const possibleEntries = ['src/index.ts', 'src/main.ts', 'src/app.ts', 'index.ts'];
-    let entryFile: string | null = null;
-
-    for (const entry of possibleEntries) {
-      if (await FileSystem.exists(FileSystem.joinPath(process.cwd(), entry))) {
-        entryFile = entry;
-        break;
-      }
-    }
-
-    if (!entryFile) {
-      this.logger.error('No entry file found (src/index.ts, src/main.ts, etc.)');
-      return;
-    }
-
-    this.logger.header('Starting Nexus Development Server');
-    this.logger.info(`Entry: ${entryFile}`);
-    this.logger.info(`Server: http://${host}:${port}`);
-    this.logger.blank();
-
-    // Try to use ts-node-dev, tsx, or ts-node
-    const runners = [
-      { cmd: 'npx', args: ['tsx', 'watch', entryFile] },
-      { cmd: 'npx', args: ['ts-node-dev', '--respawn', '--transpile-only', entryFile] },
-      { cmd: 'npx', args: ['ts-node', entryFile] },
-    ];
-
-    for (const runner of runners) {
-      try {
-        await spawnCommand(runner.cmd, runner.args, {
-          cwd: process.cwd(),
-          env: {
-            PORT: String(port),
-            HOST: String(host),
-            NODE_ENV: 'development',
-          },
-        });
-        break;
-      } catch (error) {
-        continue;
-      }
-    }
-  }
-}