@morojs/moro 1.6.2 → 1.6.3

package/src/core/database/adapters/sqlite.ts

@@ -1,263 +0,0 @@
-// Database SQLite Adapter
-import { DatabaseAdapter, DatabaseTransaction } from '../../../types/database.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { resolveUserPackage } from '../../utilities/package-utils.js';
-
-interface SQLiteConfig {
-  filename?: string;
-  memory?: boolean;
-  readonly?: boolean;
-  fileMustExist?: boolean;
-  timeout?: number;
-  verbose?: boolean;
-}
-
-export class SQLiteAdapter implements DatabaseAdapter {
-  private db: any;
-  private logger = createFrameworkLogger('SQLite');
-  private initPromise: Promise<void>;
-
-  constructor(config: SQLiteConfig = {}) {
-    this.initPromise = this.initialize(config);
-  }
-
-  private async initialize(config: SQLiteConfig): Promise<void> {
-    try {
-      const sqlite3Path = resolveUserPackage('better-sqlite3');
-      const betterSqlite3 = await import(sqlite3Path);
-      const Database = betterSqlite3.default;
-      const filename = config.memory ? ':memory:' : config.filename || 'moro_app.db';
-      this.db = new Database(filename, {
-        readonly: config.readonly || false,
-        fileMustExist: config.fileMustExist || false,
-        timeout: config.timeout || 5000,
-        verbose: config.verbose ? this.logger.debug.bind(this.logger) : undefined,
-      });
-
-      // Enable foreign keys
-      this.db.pragma('foreign_keys = ON');
-
-      this.logger.info('SQLite connection established', 'Connection', {
-        filename,
-      });
-    } catch (error) {
-      throw new Error(
-        'better-sqlite3 package is required for SQLite adapter. Install it with: npm install better-sqlite3'
-      );
-    }
-  }
-
-  async connect(): Promise<void> {
-    await this.initPromise;
-    // SQLite doesn't require explicit connection - it's handled in constructor
-    this.logger.info('SQLite adapter ready', 'Connection');
-  }
-
-  async disconnect(): Promise<void> {
-    await this.initPromise;
-    this.db.close();
-  }
-
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    await this.initPromise;
-    try {
-      const stmt = this.db.prepare(sql);
-      const results = stmt.all(params || []);
-      return results as T[];
-    } catch (error) {
-      this.logger.error('SQLite query failed', 'Query', {
-        sql,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async queryOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
-    await this.initPromise;
-    try {
-      const stmt = this.db.prepare(sql);
-      const result = stmt.get(params || []);
-      return (result as T) || null;
-    } catch (error) {
-      this.logger.error('SQLite queryOne failed', 'Query', {
-        sql,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async insert<T = any>(table: string, data: Record<string, any>): Promise<T> {
-    await this.initPromise;
-    const keys = Object.keys(data);
-    const values = Object.values(data);
-    const placeholders = keys.map(() => '?').join(', ');
-
-    const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})`;
-
-    try {
-      const stmt = this.db.prepare(sql);
-      const info = stmt.run(values);
-
-      // Return the inserted record
-      const insertedRecord = await this.queryOne<T>(`SELECT * FROM ${table} WHERE rowid = ?`, [
-        info.lastInsertRowid,
-      ]);
-
-      return insertedRecord!;
-    } catch (error) {
-      this.logger.error('SQLite insert failed', 'Insert', {
-        table,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async update<T = any>(
-    table: string,
-    data: Record<string, any>,
-    where: Record<string, any>
-  ): Promise<T> {
-    await this.initPromise;
-    const setClause = Object.keys(data)
-      .map(key => `${key} = ?`)
-      .join(', ');
-    const whereClause = Object.keys(where)
-      .map(key => `${key} = ?`)
-      .join(' AND ');
-
-    const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`;
-    const params = [...Object.values(data), ...Object.values(where)];
-
-    try {
-      const stmt = this.db.prepare(sql);
-      stmt.run(params);
-
-      // Return the updated record
-      const updatedRecord = await this.queryOne<T>(
-        `SELECT * FROM ${table} WHERE ${whereClause}`,
-        Object.values(where)
-      );
-
-      return updatedRecord!;
-    } catch (error) {
-      this.logger.error('SQLite update failed', 'Update', {
-        table,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async delete(table: string, where: Record<string, any>): Promise<number> {
-    await this.initPromise;
-    const whereClause = Object.keys(where)
-      .map(key => `${key} = ?`)
-      .join(' AND ');
-    const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-
-    try {
-      const stmt = this.db.prepare(sql);
-      const info = stmt.run(Object.values(where));
-      return info.changes;
-    } catch (error) {
-      this.logger.error('SQLite delete failed', 'Delete', {
-        table,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    }
-  }
-
-  async transaction<T>(callback: (tx: DatabaseTransaction) => Promise<T>): Promise<T> {
-    await this.initPromise;
-    const transaction = this.db.transaction(async () => {
-      const tx = new SQLiteTransaction(this.db);
-      return await callback(tx);
-    });
-
-    return transaction();
-  }
-}
-
-class SQLiteTransaction implements DatabaseTransaction {
-  constructor(private db: any) {}
-
-  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    const stmt = this.db.prepare(sql);
-    const results = stmt.all(params || []);
-    return results as T[];
-  }
-
-  async queryOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
-    const stmt = this.db.prepare(sql);
-    const result = stmt.get(params || []);
-    return (result as T) || null;
-  }
-
-  async insert<T = any>(table: string, data: Record<string, any>): Promise<T> {
-    const keys = Object.keys(data);
-    const values = Object.values(data);
-    const placeholders = keys.map(() => '?').join(', ');
-
-    const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})`;
-    const stmt = this.db.prepare(sql);
-    const info = stmt.run(values);
-
-    const insertedRecord = await this.queryOne<T>(`SELECT * FROM ${table} WHERE rowid = ?`, [
-      info.lastInsertRowid,
-    ]);
-
-    return insertedRecord!;
-  }
-
-  async update<T = any>(
-    table: string,
-    data: Record<string, any>,
-    where: Record<string, any>
-  ): Promise<T> {
-    const setClause = Object.keys(data)
-      .map(key => `${key} = ?`)
-      .join(', ');
-    const whereClause = Object.keys(where)
-      .map(key => `${key} = ?`)
-      .join(' AND ');
-
-    const sql = `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`;
-    const params = [...Object.values(data), ...Object.values(where)];
-
-    const stmt = this.db.prepare(sql);
-    stmt.run(params);
-
-    const updatedRecord = await this.queryOne<T>(
-      `SELECT * FROM ${table} WHERE ${whereClause}`,
-      Object.values(where)
-    );
-
-    return updatedRecord!;
-  }
-
-  async delete(table: string, where: Record<string, any>): Promise<number> {
-    const whereClause = Object.keys(where)
-      .map(key => `${key} = ?`)
-      .join(' AND ');
-    const sql = `DELETE FROM ${table} WHERE ${whereClause}`;
-
-    const stmt = this.db.prepare(sql);
-    const info = stmt.run(Object.values(where));
-    return info.changes;
-  }
-
-  async commit(): Promise<void> {
-    // SQLite transactions are handled automatically by better-sqlite3
-    // This is just for interface compatibility
-  }
-
-  async rollback(): Promise<void> {
-    // SQLite transactions are handled automatically by better-sqlite3
-    // This is just for interface compatibility
-    throw new Error('Transaction rollback');
-  }
-}

package/src/core/database/index.ts

@@ -1,3 +0,0 @@
-// Database Module
-export * from './adapters/index.js';
-export * from '../../types/database.js';

package/src/core/docs/index.ts

@@ -1,231 +0,0 @@
-// Moro Framework Documentation System
-// Automatic API documentation generation from intelligent routes and Validation schemas
-
-import { CompiledRoute } from '../routing/index.js';
-import { IntelligentRoutingManager } from '../routing/app-integration.js';
-import {
-  OpenAPIGenerator,
-  generateOpenAPIFromRoutes,
-  GenerationOptions,
-  OpenAPISpec,
-  defaultSecuritySchemes,
-} from './openapi-generator.js';
-import { SwaggerUIMiddleware, SwaggerUIOptions, createDocsMiddleware } from './swagger-ui.js';
-import { createFrameworkLogger } from '../logger/index.js';
-
-const logger = createFrameworkLogger('DocumentationSystem');
-
-// Documentation configuration
-export interface DocsConfig {
-  title: string;
-  version: string;
-  description?: string;
-  basePath?: string;
-  servers?: Array<{ url: string; description?: string }>;
-  contact?: {
-    name?: string;
-    url?: string;
-    email?: string;
-  };
-  license?: {
-    name: string;
-    url?: string;
-  };
-  swaggerUI?: SwaggerUIOptions;
-  includeExamples?: boolean;
-  includeSchemas?: boolean;
-  enableAuth?: boolean;
-}
-
-// Main documentation system class
-export class DocumentationSystem {
-  private generator: OpenAPIGenerator;
-  private swaggerUI: SwaggerUIMiddleware;
-  private config: DocsConfig;
-
-  constructor(config: DocsConfig) {
-    this.config = {
-      basePath: '/docs',
-      includeExamples: true,
-      includeSchemas: true,
-      enableAuth: true,
-      ...config,
-    };
-
-    // Create OpenAPI generator
-    const generationOptions: GenerationOptions = {
-      info: {
-        title: this.config.title,
-        version: this.config.version,
-        description: this.config.description,
-        contact: this.config.contact,
-        license: this.config.license,
-      },
-      servers: this.config.servers,
-      includeExamples: this.config.includeExamples,
-      includeSchemas: this.config.includeSchemas,
-      securitySchemes: this.config.enableAuth ? defaultSecuritySchemes : undefined,
-    };
-
-    this.generator = new OpenAPIGenerator(generationOptions);
-
-    // Initialize with empty spec
-    const initialSpec = this.generator.generate();
-    this.swaggerUI = new SwaggerUIMiddleware(initialSpec, this.config.swaggerUI);
-
-    logger.info('Documentation system initialized', 'Initialization', {
-      title: this.config.title,
-      basePath: this.config.basePath,
-      includeExamples: this.config.includeExamples,
-    });
-  }
-
-  // Generate documentation from intelligent routing manager
-  generateFromRoutes(routes: CompiledRoute[]): OpenAPISpec {
-    this.generator.addRoutes(routes);
-    const spec = this.generator.generate();
-
-    // Update Swagger UI with new spec
-    this.swaggerUI.updateSpec(spec);
-
-    logger.info('Documentation generated from routes', 'Generation', {
-      routeCount: routes.length,
-      pathCount: Object.keys(spec.paths).length,
-    });
-
-    return spec;
-  }
-
-  // Create middleware that serves the documentation
-  createMiddleware() {
-    return this.swaggerUI.createMiddleware(this.config.basePath);
-  }
-
-  // Generate OpenAPI spec as JSON
-  getOpenAPIJSON(): string {
-    return this.generator.generateJSON();
-  }
-
-  // Generate OpenAPI spec as YAML
-  getOpenAPIYAML(): string {
-    return this.generator.generateYAML();
-  }
-
-  // Get the current OpenAPI spec
-  getSpec(): OpenAPISpec {
-    return this.generator.generate();
-  }
-
-  // Update configuration
-  updateConfig(newConfig: Partial<DocsConfig>): void {
-    this.config = { ...this.config, ...newConfig };
-    logger.debug('Documentation configuration updated', 'ConfigUpdate', {
-      title: this.config.title,
-      basePath: this.config.basePath,
-    });
-  }
-}
-
-// App integration mixin for documentation
-export interface AppWithDocs {
-  // Enable automatic API documentation
-  enableDocs(config: DocsConfig): void;
-
-  // Get the current OpenAPI specification
-  getOpenAPISpec(): OpenAPISpec;
-
-  // Get documentation as JSON
-  getDocsJSON(): string;
-
-  // Get documentation as YAML
-  getDocsYAML(): string;
-}
-
-// Documentation integration for apps
-export class AppDocumentationManager {
-  private docSystem?: DocumentationSystem;
-  private routingManager?: IntelligentRoutingManager;
-
-  // Initialize documentation system
-  enableDocs(config: DocsConfig, routingManager: IntelligentRoutingManager): void {
-    this.routingManager = routingManager;
-    this.docSystem = new DocumentationSystem(config);
-
-    // Generate docs from current routes
-    const routes = routingManager.getIntelligentRoutes();
-    this.docSystem.generateFromRoutes(routes);
-
-    logger.info('Documentation enabled for app', 'AppIntegration', {
-      title: config.title,
-      routeCount: routes.length,
-      basePath: config.basePath,
-    });
-  }
-
-  // Get documentation middleware
-  getDocsMiddleware() {
-    if (!this.docSystem) {
-      throw new Error('Documentation not enabled. Call enableDocs() first.');
-    }
-    return this.docSystem.createMiddleware();
-  }
-
-  // Refresh documentation (useful after adding new routes)
-  refreshDocs(): void {
-    if (!this.docSystem || !this.routingManager) {
-      throw new Error('Documentation not enabled. Call enableDocs() first.');
-    }
-
-    const routes = this.routingManager.getIntelligentRoutes();
-    this.docSystem.generateFromRoutes(routes);
-
-    logger.debug('Documentation refreshed', 'Refresh', {
-      routeCount: routes.length,
-    });
-  }
-
-  // Get current OpenAPI spec
-  getOpenAPISpec(): OpenAPISpec {
-    if (!this.docSystem) {
-      throw new Error('Documentation not enabled. Call enableDocs() first.');
-    }
-    return this.docSystem.getSpec();
-  }
-
-  // Get docs as JSON
-  getDocsJSON(): string {
-    if (!this.docSystem) {
-      throw new Error('Documentation not enabled. Call enableDocs() first.');
-    }
-    return this.docSystem.getOpenAPIJSON();
-  }
-
-  // Get docs as YAML
-  getDocsYAML(): string {
-    if (!this.docSystem) {
-      throw new Error('Documentation not enabled. Call enableDocs() first.');
-    }
-    return this.docSystem.getOpenAPIYAML();
-  }
-}
-
-// Convenience functions
-export function createDocumentationSystem(config: DocsConfig): DocumentationSystem {
-  return new DocumentationSystem(config);
-}
-
-export function generateDocsFromIntelligentRoutes(
-  routes: CompiledRoute[],
-  config: DocsConfig
-): { spec: OpenAPISpec; middleware: any } {
-  const docSystem = new DocumentationSystem(config);
-  const spec = docSystem.generateFromRoutes(routes);
-  const middleware = docSystem.createMiddleware();
-
-  return { spec, middleware };
-}
-
-// Export all types and functions
-export * from './openapi-generator.js';
-export * from './swagger-ui.js';
-export * from './zod-to-openapi.js';