@engjts/nexus 0.1.7 → 0.1.9

package/src/cli/utils/file-system.ts

@@ -1,78 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export class FileSystem {
-  static async exists(filePath: string): Promise<boolean> {
-    try {
-      await fs.promises.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  static async createDirectory(dirPath: string): Promise<void> {
-    await fs.promises.mkdir(dirPath, { recursive: true });
-  }
-
-  static async writeFile(filePath: string, content: string): Promise<void> {
-    const dir = path.dirname(filePath);
-    await this.createDirectory(dir);
-    await fs.promises.writeFile(filePath, content, 'utf-8');
-  }
-
-  static async readFile(filePath: string): Promise<string> {
-    return fs.promises.readFile(filePath, 'utf-8');
-  }
-
-  static async copyDirectory(src: string, dest: string): Promise<void> {
-    await this.createDirectory(dest);
-    const entries = await fs.promises.readdir(src, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-
-      if (entry.isDirectory()) {
-        await this.copyDirectory(srcPath, destPath);
-      } else {
-        await fs.promises.copyFile(srcPath, destPath);
-      }
-    }
-  }
-
-  static async removeDirectory(dirPath: string): Promise<void> {
-    if (await this.exists(dirPath)) {
-      await fs.promises.rm(dirPath, { recursive: true, force: true });
-    }
-  }
-
-  static async listDirectory(dirPath: string): Promise<string[]> {
-    return fs.promises.readdir(dirPath);
-  }
-
-  static async isDirectory(filePath: string): Promise<boolean> {
-    try {
-      const stat = await fs.promises.stat(filePath);
-      return stat.isDirectory();
-    } catch {
-      return false;
-    }
-  }
-
-  static resolvePath(...paths: string[]): string {
-    return path.resolve(...paths);
-  }
-
-  static joinPath(...paths: string[]): string {
-    return path.join(...paths);
-  }
-
-  static getBasename(filePath: string): string {
-    return path.basename(filePath);
-  }
-
-  static getDirname(filePath: string): string {
-    return path.dirname(filePath);
-  }
-}

package/src/cli/utils/logger.ts

@@ -1,111 +0,0 @@
-export class Logger {
-  colors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    dim: '\x1b[2m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
-    cyan: '\x1b[36m',
-    white: '\x1b[37m',
-    bgRed: '\x1b[41m',
-    bgGreen: '\x1b[42m',
-    bgYellow: '\x1b[43m',
-    bgBlue: '\x1b[44m',
-  };
-
-  info(message: string): void {
-    console.log(`${this.colors.blue}ℹ${this.colors.reset} ${message}`);
-  }
-
-  success(message: string): void {
-    console.log(`${this.colors.green}✓${this.colors.reset} ${message}`);
-  }
-
-  warning(message: string): void {
-    console.log(`${this.colors.yellow}⚠${this.colors.reset} ${message}`);
-  }
-
-  error(message: string): void {
-    console.log(`${this.colors.red}✗${this.colors.reset} ${message}`);
-  }
-
-  step(step: number, total: number, message: string): void {
-    console.log(
-      `${this.colors.cyan}[${step}/${total}]${this.colors.reset} ${message}`
-    );
-  }
-
-  blank(): void {
-    console.log('');
-  }
-
-  header(text: string): void {
-    console.log(`\n${this.colors.bright}${this.colors.cyan}${text}${this.colors.reset}\n`);
-  }
-
-  list(items: string[]): void {
-    for (const item of items) {
-      console.log(`  ${this.colors.dim}•${this.colors.reset} ${item}`);
-    }
-  }
-
-  box(lines: string[]): void {
-    const maxLength = Math.max(...lines.map(l => l.length));
-    const border = '─'.repeat(maxLength + 2);
-    
-    console.log(`┌${border}┐`);
-    for (const line of lines) {
-      const padding = ' '.repeat(maxLength - line.length);
-      console.log(`│ ${line}${padding} │`);
-    }
-    console.log(`└${border}┘`);
-  }
-
-  spinner(message: string): Spinner {
-    return new Spinner(message, this);
-  }
-}
-
-export class Spinner {
-  private frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-  private frameIndex = 0;
-  private interval: ReturnType<typeof setInterval> | null = null;
-  private message: string;
-  private logger: Logger;
-
-  constructor(message: string, logger: Logger) {
-    this.message = message;
-    this.logger = logger;
-  }
-
-  start(): void {
-    process.stdout.write(`${this.logger.colors.cyan}${this.frames[0]}${this.logger.colors.reset} ${this.message}`);
-    this.interval = setInterval(() => {
-      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
-      process.stdout.clearLine(0);
-      process.stdout.cursorTo(0);
-      process.stdout.write(`${this.logger.colors.cyan}${this.frames[this.frameIndex]}${this.logger.colors.reset} ${this.message}`);
-    }, 80);
-  }
-
-  stop(success = true): void {
-    if (this.interval) {
-      clearInterval(this.interval);
-      this.interval = null;
-    }
-    process.stdout.clearLine(0);
-    process.stdout.cursorTo(0);
-    if (success) {
-      console.log(`${this.logger.colors.green}✓${this.logger.colors.reset} ${this.message}`);
-    } else {
-      console.log(`${this.logger.colors.red}✗${this.logger.colors.reset} ${this.message}`);
-    }
-  }
-
-  update(message: string): void {
-    this.message = message;
-  }
-}

package/src/core/adapter.ts

@@ -1,88 +0,0 @@
-/**
- * Adapter interfaces for extensibility
- * These interfaces define contracts that external implementations must follow
- */
-
-/**
- * Logger adapter interface
- * Allows plugging in different logging implementations (winston, pino, etc.)
- * 
- * @example
- * ```typescript
- * class PinoAdapter implements LoggerAdapter {
- *   private pino = require('pino')();
- *   info(message: string, meta?: any) { this.pino.info(meta, message); }
- *   // ...
- * }
- * app.adapter('logger', new PinoAdapter());
- * ```
- */
-export interface LoggerAdapter {
-    info(message: string, meta?: any): void;
-    warn(message: string, meta?: any): void;
-    error(message: string, error?: Error, meta?: any): void;
-    debug(message: string, meta?: any): void;
-}
-
-/**
- * Cache adapter interface
- * Allows plugging in different cache implementations (Redis, Memcached, etc.)
- * 
- * @example
- * ```typescript
- * class RedisAdapter implements CacheAdapter {
- *   constructor(private redis: Redis) {}
- *   async get<T>(key: string) { return JSON.parse(await this.redis.get(key)); }
- *   // ...
- * }
- * app.adapter('cache', new RedisAdapter(redis));
- * ```
- */
-export interface CacheAdapter {
-    get<T>(key: string): Promise<T | null>;
-    set<T>(key: string, value: T, ttl?: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    clear(): Promise<void>;
-}
-
-/**
- * Session adapter interface
- * Allows plugging in different session storage (Redis, Database, etc.)
- * 
- * @example
- * ```typescript
- * class DatabaseSessionAdapter implements SessionAdapter {
- *   async get(sessionId: string) { return await db.sessions.findById(sessionId); }
- *   // ...
- * }
- * app.adapter('session', new DatabaseSessionAdapter());
- * ```
- */
-export interface SessionAdapter {
-    get(sessionId: string): Promise<any>;
-    set(sessionId: string, data: any, ttl?: number): Promise<void>;
-    destroy(sessionId: string): Promise<void>;
-}
-
-/**
- * Adapter registry for managing all adapters
- */
-export class AdapterRegistry {
-    private adapters: Map<string, any> = new Map();
-
-    register<T>(name: string, adapter: T): void {
-        this.adapters.set(name, adapter);
-    }
-
-    get<T>(name: string): T | undefined {
-        return this.adapters.get(name) as T;
-    }
-
-    has(name: string): boolean {
-        return this.adapters.has(name);
-    }
-
-    remove(name: string): boolean {
-        return this.adapters.delete(name);
-    }
-}