@engjts/nexus 0.1.0

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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,88 @@
+/**
+ * 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);
+    }
+}