@engjts/nexus 0.1.8 → 0.1.9

package/src/cli/commands/generate.ts

@@ -1,99 +0,0 @@
-import { Command, CommandOption } from '../cli';
-import { Logger } from '../utils/logger';
-import { FileSystem } from '../utils/file-system';
-import { GeneratorTemplates } from '../templates/generators';
-
-type GeneratorType = 'route' | 'route-class' | 'middleware' | 'controller' | 'service' | 'model' | 'validator';
-
-export class GenerateCommand implements Command {
-  name = 'generate';
-  description = 'Generate components (route, middleware, controller, etc.)';
-  usage = 'nexus generate <type> <name> [options]';
-  options: CommandOption[] = [
-    {
-      name: 'path',
-      alias: 'p',
-      description: 'Custom path for the generated file',
-    },
-    {
-      name: 'methods',
-      alias: 'm',
-      description: 'HTTP methods for route (comma-separated)',
-      defaultValue: 'get',
-    },
-  ];
-
-  private logger = new Logger();
-  private validTypes: GeneratorType[] = ['route', 'route-class', 'middleware', 'controller', 'service', 'model', 'validator'];
-
-  async execute(
-    args: string[],
-    options: Record<string, string | boolean>
-  ): Promise<void> {
-    if (args.length < 2) {
-      this.showUsage();
-      return;
-    }
-
-    const [type, name] = args;
-
-    if (!this.validTypes.includes(type as GeneratorType)) {
-      this.logger.error(`Invalid type: ${type}`);
-      this.logger.info(`Valid types: ${this.validTypes.join(', ')}`);
-      return;
-    }
-
-    const customPath = options.path as string | undefined;
-    const methods = ((options.methods || 'get') as string).split(',').map(m => m.trim().toLowerCase());
-
-    await this.generate(type as GeneratorType, name, { customPath, methods });
-  }
-
-  private async generate(
-    type: GeneratorType,
-    name: string,
-    options: { customPath?: string; methods: string[] }
-  ): Promise<void> {
-    const generator = new GeneratorTemplates();
-    const { filePath, content } = generator.generate(type, name, options);
-
-    const targetPath = options.customPath 
-      ? FileSystem.joinPath(process.cwd(), options.customPath, `${name}.ts`)
-      : FileSystem.joinPath(process.cwd(), filePath);
-
-    // Check if file already exists
-    if (await FileSystem.exists(targetPath)) {
-      this.logger.error(`File already exists: ${targetPath}`);
-      return;
-    }
-
-    await FileSystem.writeFile(targetPath, content);
-    this.logger.success(`Created ${type}: ${targetPath}`);
-  }
-
-  private showUsage(): void {
-    console.log(`
-${this.logger.colors.bright}Usage:${this.logger.colors.reset} nexus generate <type> <name> [options]
-
-${this.logger.colors.bright}Types:${this.logger.colors.reset}
-  route        Generate a function-based route handler
-  route-class  Generate a class-based route (with meta, schema, onBefore)
-  middleware   Generate a middleware
-  controller   Generate a controller class
-  service      Generate a service class
-  model        Generate a model/entity
-  validator    Generate a validation schema
-
-${this.logger.colors.bright}Examples:${this.logger.colors.reset}
-  nexus generate route users
-  nexus generate route-class users
-  nexus generate controller UserController
-  nexus generate middleware auth
-  nexus generate route products --methods get,post,put,delete
-
-${this.logger.colors.bright}Options:${this.logger.colors.reset}
-  --path, -p    Custom output path
-  --methods, -m HTTP methods for routes (comma-separated)
-`);
-  }
-}

package/src/cli/commands/help.ts

@@ -1,95 +0,0 @@
-import { Command } from '../cli';
-import { Logger } from '../utils/logger';
-
-export class HelpCommand implements Command {
-  name = 'help';
-  description = 'Show help information';
-  usage = 'nexus help [command]';
-
-  private logger = new Logger();
-  private getCommands: () => Map<string, Command>;
-
-  constructor(getCommands: () => Map<string, Command>) {
-    this.getCommands = getCommands;
-  }
-
-  async execute(
-    args: string[],
-    options: Record<string, string | boolean>
-  ): Promise<void> {
-    const commands = this.getCommands();
-
-    if (args.length > 0) {
-      const commandName = args[0];
-      const command = commands.get(commandName);
-
-      if (!command) {
-        this.logger.error(`Unknown command: ${commandName}`);
-        return;
-      }
-
-      this.showCommandHelp(command);
-      return;
-    }
-
-    this.showGeneralHelp(commands);
-  }
-
-  private showGeneralHelp(commands: Map<string, Command>): void {
-    console.log(`
-${this.logger.colors.bright}Nexus CLI${this.logger.colors.reset} - Async-First Web Framework
-
-${this.logger.colors.bright}Usage:${this.logger.colors.reset}
-  nexus <command> [options]
-
-${this.logger.colors.bright}Commands:${this.logger.colors.reset}
-`);
-
-    for (const [name, command] of commands) {
-      console.log(`  ${this.logger.colors.cyan}${name.padEnd(12)}${this.logger.colors.reset} ${command.description}`);
-    }
-
-    console.log(`
-${this.logger.colors.bright}Global Options:${this.logger.colors.reset}
-  --help, -h     Show help
-  --version, -v  Show version
-
-${this.logger.colors.bright}Examples:${this.logger.colors.reset}
-  ${this.logger.colors.dim}# Create a new project${this.logger.colors.reset}
-  nexus create my-app
-
-  ${this.logger.colors.dim}# Create with specific template${this.logger.colors.reset}
-  nexus create my-api --template api
-
-  ${this.logger.colors.dim}# Generate a route${this.logger.colors.reset}
-  nexus generate route users
-
-  ${this.logger.colors.dim}# Start development server${this.logger.colors.reset}
-  nexus dev
-
-Run ${this.logger.colors.cyan}nexus help <command>${this.logger.colors.reset} for more information on a specific command.
-`);
-  }
-
-  private showCommandHelp(command: Command): void {
-    console.log(`
-${this.logger.colors.bright}${command.name}${this.logger.colors.reset} - ${command.description}
-
-${this.logger.colors.bright}Usage:${this.logger.colors.reset}
-  ${command.usage}
-`);
-
-    if (command.options && command.options.length > 0) {
-      console.log(`${this.logger.colors.bright}Options:${this.logger.colors.reset}`);
-      for (const option of command.options) {
-        const aliasStr = option.alias ? `, -${option.alias}` : '';
-        const defaultStr = option.defaultValue !== undefined 
-          ? ` (default: ${option.defaultValue})` 
-          : '';
-        console.log(`  --${option.name}${aliasStr}`);
-        console.log(`      ${option.description}${defaultStr}`);
-      }
-      console.log('');
-    }
-  }
-}

package/src/cli/commands/init.ts

@@ -1,91 +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 InitCommand implements Command {
-  name = 'init';
-  description = 'Initialize Nexus in the current directory';
-  usage = 'nexus init [options]';
-  options: CommandOption[] = [
-    {
-      name: 'template',
-      alias: 't',
-      description: 'Project template (basic, api, fullstack)',
-      defaultValue: 'basic',
-    },
-    {
-      name: 'force',
-      alias: 'f',
-      description: 'Force initialization even if directory is not empty',
-      defaultValue: false,
-    },
-  ];
-
-  private logger = new Logger();
-
-  async execute(
-    args: string[],
-    options: Record<string, string | boolean>
-  ): Promise<void> {
-    const template = (options.template || options.t || 'basic') as string;
-    const force = options.force === true || options.f === true;
-    const projectPath = process.cwd();
-    const projectName = FileSystem.getBasename(projectPath);
-
-    // Check if directory is not empty
-    const files = await FileSystem.listDirectory(projectPath);
-    const hasFiles = files.filter(f => !f.startsWith('.')).length > 0;
-
-    if (hasFiles && !force) {
-      this.logger.error('Directory is not empty');
-      this.logger.info('Use --force to initialize anyway');
-      return;
-    }
-
-    this.logger.header(`Initializing Nexus project in ${projectPath}`);
-
-    // Create project structure
-    this.logger.step(1, 2, 'Creating project files...');
-    await this.createProjectFiles(projectPath, projectName, template);
-    this.logger.success('Project files created');
-
-    // Initialize git if not exists
-    this.logger.step(2, 2, 'Checking git repository...');
-    const gitExists = await FileSystem.exists(FileSystem.joinPath(projectPath, '.git'));
-    if (!gitExists && await checkCommandExists('git')) {
-      await spawnCommand('git', ['init'], { cwd: projectPath, stdio: 'pipe' });
-      this.logger.success('Git repository initialized');
-    } else if (gitExists) {
-      this.logger.info('Git repository already exists');
-    }
-
-    this.logger.blank();
-    this.logger.success('Nexus project initialized successfully!');
-    this.logger.blank();
-    this.logger.info('Run "npm install" to install dependencies');
-    this.logger.info('Run "npm run dev" to start the development server');
-  }
-
-  private async createProjectFiles(
-    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)) {
-      const fullPath = FileSystem.joinPath(projectPath, filePath);
-      
-      // Skip if file already exists
-      if (await FileSystem.exists(fullPath)) {
-        this.logger.warning(`Skipping ${filePath} (already exists)`);
-        continue;
-      }
-
-      await FileSystem.writeFile(fullPath, content);
-    }
-  }
-}

package/src/cli/commands/version.ts

@@ -1,38 +0,0 @@
-import { Command } from '../cli';
-import { Logger } from '../utils/logger';
-import { FileSystem } from '../utils/file-system';
-
-export class VersionCommand implements Command {
-  name = 'version';
-  description = 'Show Nexus CLI version';
-  usage = 'nexus version';
-
-  private logger = new Logger();
-
-  async execute(
-    args: string[],
-    options: Record<string, string | boolean>
-  ): Promise<void> {
-    // Try to read version from package.json
-    let version = '0.1.0';
-    
-    try {
-      // Check for local package.json first
-      const localPackage = FileSystem.joinPath(process.cwd(), 'node_modules', '@engjts/nexus', 'package.json');
-      if (await FileSystem.exists(localPackage)) {
-        const content = await FileSystem.readFile(localPackage);
-        const pkg = JSON.parse(content);
-        version = pkg.version;
-      }
-    } catch {
-      // Use default version
-    }
-
-    console.log(`
-${this.logger.colors.cyan}Nexus CLI${this.logger.colors.reset} v${version}
-
-${this.logger.colors.dim}Node:${this.logger.colors.reset}    ${process.version}
-${this.logger.colors.dim}OS:${this.logger.colors.reset}      ${process.platform} ${process.arch}
-`);
-  }
-}

package/src/cli/index.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-
-import { CLI } from './cli';
-
-const cli = new CLI();
-cli.run(process.argv.slice(2));

package/src/cli/templates/generators.ts

@@ -1,359 +0,0 @@
-type GeneratorType = 'route' | 'route-class' | 'middleware' | 'controller' | 'service' | 'model' | 'validator';
-
-interface GeneratorResult {
-  filePath: string;
-  content: string;
-}
-
-interface GeneratorOptions {
-  customPath?: string;
-  methods: string[];
-}
-
-export class GeneratorTemplates {
-  generate(type: GeneratorType, name: string, options: GeneratorOptions): GeneratorResult {
-    switch (type) {
-      case 'route':
-        return this.generateRoute(name, options.methods);
-      case 'route-class':
-        return this.generateRouteClass(name, options.methods);
-      case 'middleware':
-        return this.generateMiddleware(name);
-      case 'controller':
-        return this.generateController(name);
-      case 'service':
-        return this.generateService(name);
-      case 'model':
-        return this.generateModel(name);
-      case 'validator':
-        return this.generateValidator(name);
-      default:
-        throw new Error(`Unknown generator type: ${type}`);
-    }
-  }
-
-  private toPascalCase(str: string): string {
-    return str
-      .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
-      .replace(/^(.)/, (_, c) => c.toUpperCase());
-  }
-
-  private toCamelCase(str: string): string {
-    return str
-      .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
-      .replace(/^(.)/, (_, c) => c.toLowerCase());
-  }
-
-  private generateRoute(name: string, methods: string[]): GeneratorResult {
-    const routeName = this.toCamelCase(name);
-    const routeHandlers = methods
-      .map((method) => {
-        return `
-// ${method.toUpperCase()} /${name}
-${routeName}Routes.${method}('/', async (ctx) => {
-  return {
-    message: '${method.toUpperCase()} /${name}',
-  };
-});`;
-      })
-      .join('\n');
-
-    const content = `import { Router } from '@engjts/nexus';
-
-export const ${routeName}Routes = new Router();
-${routeHandlers}
-`;
-
-    return {
-      filePath: `src/routes/${name}.ts`,
-      content,
-    };
-  }
-
-  private generateRouteClass(name: string, methods: string[]): GeneratorResult {
-    const className = this.toPascalCase(name);
-    const baseName = name.toLowerCase();
-    const method = methods[0] || 'get';
-
-    const content = `import { Route, Context, z } from '@engjts/nexus';
-
-export class ${className}Route extends Route {
-  pathName = '/${baseName}';
-
-  meta() {
-    return {
-      summary: '${className} route',
-      description: '${className} route description',
-      tags: ['${className}'],
-    };
-  }
-
-  schema() {
-    return {
-      // params: z.object({}),
-      // query: z.object({}),
-      // body: z.object({}),
-    };
-  }
-
-  async onBefore(ctx: Context) {
-    // Hook sebelum handler
-    // Return value untuk skip handler dan langsung return response
-  }
-
-  async handler(ctx: Context) {
-    return {
-      message: '${method.toUpperCase()} /${baseName}',
-    };
-  }
-}
-`;
-
-    return {
-      filePath: `src/routes/${name}.ts`,
-      content,
-    };
-  }
-
-  private generateMiddleware(name: string): GeneratorResult {
-    const middlewareName = this.toCamelCase(name);
-
-    const content = `import { Middleware, Context } from '@engjts/nexus';
-
-export const ${middlewareName}Middleware: Middleware = async (ctx: Context, next) => {
-  // Before handler
-  console.log(\`[${name}] Before: \${ctx.method} \${ctx.path}\`);
-  
-  // Call next middleware/handler
-  const response = await next();
-  
-  // After handler
-  console.log(\`[${name}] After: \${ctx.method} \${ctx.path}\`);
-  
-  return response;
-};
-`;
-
-    return {
-      filePath: `src/middleware/${name}.ts`,
-      content,
-    };
-  }
-
-  private generateController(name: string): GeneratorResult {
-    const className = this.toPascalCase(name);
-    const baseName = name.replace(/controller$/i, '').toLowerCase();
-
-    const content = `import { Controller, Get, Post, Put, Delete, Context } from '@engjts/nexus';
-
-@Controller('/${baseName}')
-export class ${className} {
-  @Get('/')
-  async getAll() {
-    return {
-      message: 'Get all ${baseName}',
-      data: [],
-    };
-  }
-
-  @Get('/:id')
-  async getById(ctx: Context) {
-    const { id } = ctx.params;
-    return {
-      message: \`Get ${baseName} by id: \${id}\`,
-      data: null,
-    };
-  }
-
-  @Post('/')
-  async create(ctx: Context) {
-    const body = await ctx.body();
-    return {
-      status: 201,
-      data: {
-        message: 'Create ${baseName}',
-        data: body,
-      },
-    };
-  }
-
-  @Put('/:id')
-  async update(ctx: Context) {
-    const { id } = ctx.params;
-    const body = await ctx.body();
-    return {
-      message: \`Update ${baseName}: \${id}\`,
-      data: body,
-    };
-  }
-
-  @Delete('/:id')
-  async delete(ctx: Context) {
-    const { id } = ctx.params;
-    return {
-      message: \`Delete ${baseName}: \${id}\`,
-    };
-  }
-}
-`;
-
-    return {
-      filePath: `src/controllers/${name}.ts`,
-      content,
-    };
-  }
-
-  private generateService(name: string): GeneratorResult {
-    const className = this.toPascalCase(name);
-    const baseName = name.replace(/service$/i, '').toLowerCase();
-
-    const content = `export interface ${this.toPascalCase(baseName)} {
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export interface Create${this.toPascalCase(baseName)}Dto {
-  // Add your create DTO properties here
-}
-
-export interface Update${this.toPascalCase(baseName)}Dto {
-  // Add your update DTO properties here
-}
-
-export class ${className} {
-  private items: Map<string, ${this.toPascalCase(baseName)}> = new Map();
-  private idCounter = 1;
-
-  async findAll(): Promise<${this.toPascalCase(baseName)}[]> {
-    return Array.from(this.items.values());
-  }
-
-  async findById(id: string): Promise<${this.toPascalCase(baseName)} | null> {
-    return this.items.get(id) || null;
-  }
-
-  async create(data: Create${this.toPascalCase(baseName)}Dto): Promise<${this.toPascalCase(baseName)}> {
-    const id = String(this.idCounter++);
-    const item: ${this.toPascalCase(baseName)} = {
-      id,
-      ...data,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    } as ${this.toPascalCase(baseName)};
-    
-    this.items.set(id, item);
-    return item;
-  }
-
-  async update(id: string, data: Update${this.toPascalCase(baseName)}Dto): Promise<${this.toPascalCase(baseName)} | null> {
-    const item = this.items.get(id);
-    
-    if (!item) {
-      return null;
-    }
-    
-    const updated: ${this.toPascalCase(baseName)} = {
-      ...item,
-      ...data,
-      updatedAt: new Date(),
-    };
-    
-    this.items.set(id, updated);
-    return updated;
-  }
-
-  async delete(id: string): Promise<boolean> {
-    return this.items.delete(id);
-  }
-}
-`;
-
-    return {
-      filePath: `src/services/${name}.ts`,
-      content,
-    };
-  }
-
-  private generateModel(name: string): GeneratorResult {
-    const className = this.toPascalCase(name);
-
-    const content = `export interface ${className} {
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-  // Add your model properties here
-}
-
-export interface Create${className}Input {
-  // Add required fields for creation
-}
-
-export interface Update${className}Input {
-  // Add optional fields for updates
-}
-
-// Database table name
-export const ${className}Table = '${name.toLowerCase()}s';
-
-// Field definitions (useful for query builders)
-export const ${className}Fields = {
-  id: 'id',
-  createdAt: 'created_at',
-  updatedAt: 'updated_at',
-} as const;
-`;
-
-    return {
-      filePath: `src/models/${name}.ts`,
-      content,
-    };
-  }
-
-  private generateValidator(name: string): GeneratorResult {
-    const baseName = name.replace(/validator$/i, '');
-    const pascalName = this.toPascalCase(baseName);
-
-    const content = `import { z } from 'zod';
-
-// Create schema
-export const create${pascalName}Schema = z.object({
-  // Add your validation rules here
-  // Example:
-  // name: z.string().min(2).max(100),
-  // email: z.string().email(),
-});
-
-// Update schema
-export const update${pascalName}Schema = z.object({
-  // Add optional fields for updates
-  // Example:
-  // name: z.string().min(2).max(100).optional(),
-});
-
-// Query params schema
-export const ${this.toCamelCase(baseName)}QuerySchema = z.object({
-  page: z.coerce.number().min(1).default(1),
-  limit: z.coerce.number().min(1).max(100).default(10),
-  search: z.string().optional(),
-  sortBy: z.string().optional(),
-  sortOrder: z.enum(['asc', 'desc']).default('asc'),
-});
-
-// ID param schema
-export const ${this.toCamelCase(baseName)}IdSchema = z.object({
-  id: z.string().uuid(),
-});
-
-// Type exports
-export type Create${pascalName}Input = z.infer<typeof create${pascalName}Schema>;
-export type Update${pascalName}Input = z.infer<typeof update${pascalName}Schema>;
-export type ${pascalName}Query = z.infer<typeof ${this.toCamelCase(baseName)}QuerySchema>;
-`;
-
-    return {
-      filePath: `src/validators/${name}.ts`,
-      content,
-    };
-  }
-}