servcraft 0.1.0 → 0.1.3

package/src/config/database.config.ts

@@ -0,0 +1,183 @@
+/**
+ * Database Configuration
+ * Centralized database configuration management
+ */
+
+import type { DatabaseConfig } from '../database/interfaces/index.js';
+
+/**
+ * Load database configuration from environment variables
+ */
+export function loadDatabaseConfig(): DatabaseConfig {
+  const orm = (process.env.DATABASE_ORM || 'prisma') as DatabaseConfig['orm'];
+  const database = (process.env.DATABASE_TYPE || 'postgresql') as DatabaseConfig['database'];
+
+  // Primary configuration: DATABASE_URL
+  if (process.env.DATABASE_URL) {
+    return {
+      orm,
+      database,
+      url: process.env.DATABASE_URL,
+      logging: process.env.DATABASE_LOGGING === 'true',
+      ssl: process.env.DATABASE_SSL === 'true',
+    };
+  }
+
+  // Fallback: individual environment variables
+  const config: DatabaseConfig = {
+    orm,
+    database,
+    host: process.env.DATABASE_HOST || 'localhost',
+    port: process.env.DATABASE_PORT ? parseInt(process.env.DATABASE_PORT) : undefined,
+    username: process.env.DATABASE_USER,
+    password: process.env.DATABASE_PASSWORD,
+    databaseName: process.env.DATABASE_NAME,
+    logging: process.env.DATABASE_LOGGING === 'true',
+    ssl: process.env.DATABASE_SSL === 'true',
+  };
+
+  // MongoDB specific URL fallback
+  if (database === 'mongodb' && process.env.MONGODB_URI) {
+    config.url = process.env.MONGODB_URI;
+  }
+
+  // Set default ports if not specified
+  if (!config.port && !config.url) {
+    switch (database) {
+      case 'postgresql':
+        config.port = 5432;
+        break;
+      case 'mysql':
+      case 'mariadb':
+        config.port = 3306;
+        break;
+      case 'mongodb':
+        config.port = 27017;
+        break;
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Validate database configuration
+ * @throws Error if configuration is invalid
+ */
+export function validateDatabaseConfig(config: DatabaseConfig): void {
+  // Check required fields
+  if (!config.orm) {
+    throw new Error('DATABASE_ORM is required');
+  }
+
+  if (!config.database) {
+    throw new Error('DATABASE_TYPE is required');
+  }
+
+  // Validate ORM compatibility with database
+  const compatibility: Record<DatabaseConfig['orm'], DatabaseConfig['database'][]> = {
+    prisma: ['postgresql', 'mysql', 'sqlite', 'mongodb'],
+    mongoose: ['mongodb'],
+    sequelize: ['postgresql', 'mysql', 'sqlite', 'mariadb'],
+    typeorm: ['postgresql', 'mysql', 'sqlite', 'mongodb', 'mariadb'],
+  };
+
+  if (!compatibility[config.orm]?.includes(config.database)) {
+    throw new Error(
+      `ORM '${config.orm}' does not support database '${config.database}'. ` +
+        `Supported: ${compatibility[config.orm]?.join(', ') || 'none'}`
+    );
+  }
+
+  // Check connection details
+  if (!config.url) {
+    if (config.database !== 'sqlite') {
+      if (!config.host) {
+        throw new Error('DATABASE_HOST or DATABASE_URL is required');
+      }
+      if (!config.databaseName) {
+        throw new Error('DATABASE_NAME or DATABASE_URL is required');
+      }
+    } else {
+      // SQLite needs at least a database name/path
+      if (!config.databaseName) {
+        config.databaseName = './dev.db';
+      }
+    }
+  }
+
+  // Validate Mongoose specific
+  if (config.orm === 'mongoose' && config.database !== 'mongodb') {
+    throw new Error('Mongoose can only be used with MongoDB');
+  }
+
+  // Validate MongoDB specific
+  if (
+    config.database === 'mongodb' &&
+    config.orm !== 'mongoose' &&
+    config.orm !== 'prisma' &&
+    config.orm !== 'typeorm'
+  ) {
+    throw new Error(`MongoDB requires Mongoose, Prisma, or TypeORM (got ${config.orm})`);
+  }
+}
+
+/**
+ * Get recommended ORM for a database
+ */
+export function getRecommendedOrm(database: DatabaseConfig['database']): DatabaseConfig['orm'] {
+  switch (database) {
+    case 'mongodb':
+      return 'mongoose';
+    case 'postgresql':
+    case 'mysql':
+    case 'sqlite':
+      return 'prisma';
+    case 'mariadb':
+      return 'sequelize';
+    default:
+      return 'prisma';
+  }
+}
+
+/**
+ * Get supported databases for an ORM
+ */
+export function getSupportedDatabases(orm: DatabaseConfig['orm']): DatabaseConfig['database'][] {
+  const support: Record<DatabaseConfig['orm'], DatabaseConfig['database'][]> = {
+    prisma: ['postgresql', 'mysql', 'sqlite', 'mongodb'],
+    mongoose: ['mongodb'],
+    sequelize: ['postgresql', 'mysql', 'sqlite', 'mariadb'],
+    typeorm: ['postgresql', 'mysql', 'sqlite', 'mongodb', 'mariadb'],
+  };
+
+  return support[orm] || [];
+}
+
+/**
+ * Example .env template generator
+ */
+export function generateEnvTemplate(config: DatabaseConfig): string {
+  const lines: string[] = [
+    '# Database Configuration',
+    `DATABASE_ORM=${config.orm}`,
+    `DATABASE_TYPE=${config.database}`,
+    '',
+  ];
+
+  if (config.url) {
+    lines.push(`DATABASE_URL=${config.url}`);
+  } else {
+    lines.push(
+      `DATABASE_HOST=${config.host || 'localhost'}`,
+      `DATABASE_PORT=${config.port || ''}`,
+      `DATABASE_USER=${config.username || ''}`,
+      `DATABASE_PASSWORD=${config.password || ''}`,
+      `DATABASE_NAME=${config.databaseName || 'mydb'}`
+    );
+  }
+
+  lines.push('', '# Optional', 'DATABASE_LOGGING=false', 'DATABASE_SSL=false');
+
+  return lines.join('\n');
+}

package/src/config/env.ts

@@ -34,16 +34,6 @@ const envSchema = z.object({
   // Redis (optional)
   REDIS_URL: z.string().optional(),
 
-  // Swagger/OpenAPI
-  SWAGGER_ENABLED: z
-    .union([z.literal('true'), z.literal('false')])
-    .default('true')
-    .transform((val) => val === 'true'),
-  SWAGGER_ROUTE: z.string().default('/docs'),
-  SWAGGER_TITLE: z.string().default('Servcraft API'),
-  SWAGGER_DESCRIPTION: z.string().default('API documentation'),
-  SWAGGER_VERSION: z.string().default('1.0.0'),
-
   // Logging
   LOG_LEVEL: z.enum(['fatal', 'error', 'warn', 'info', 'debug', 'trace']).default('info'),
 });

package/src/config/index.ts

@@ -32,13 +32,6 @@ export interface AppConfig {
   redis: {
     url?: string;
   };
-  swagger: {
-    enabled: boolean;
-    route: string;
-    title: string;
-    description: string;
-    version: string;
-  };
 }
 
 function parseCorsOrigin(origin: string): string | string[] {
@@ -81,13 +74,6 @@ export function createConfig(): AppConfig {
     redis: {
       url: env.REDIS_URL,
     },
-    swagger: {
-      enabled: env.SWAGGER_ENABLED,
-      route: env.SWAGGER_ROUTE,
-      title: env.SWAGGER_TITLE,
-      description: env.SWAGGER_DESCRIPTION,
-      version: env.SWAGGER_VERSION,
-    },
   };
 }
 

package/src/core/server.ts

@@ -1,6 +1,6 @@
 import Fastify from 'fastify';
 import type { FastifyInstance, FastifyServerOptions } from 'fastify';
-import { logger, createLogger } from './logger.js';
+import { logger } from './logger.js';
 import type { Logger } from './logger.js';
 
 export interface ServerConfig {

package/src/database/adapters/mongoose.adapter.ts

@@ -0,0 +1,132 @@
+/**
+ * Mongoose Database Adapter
+ * Implements IDatabaseAdapter for Mongoose ORM (MongoDB)
+ */
+
+import mongoose from 'mongoose';
+import { logger } from '../../core/logger.js';
+import type { IDatabaseAdapter, DatabaseConfig } from '../interfaces/index.js';
+import { getDatabaseUrl } from '../connection.js';
+
+export class MongooseAdapter implements IDatabaseAdapter {
+  private connection: typeof mongoose | null = null;
+  private config: DatabaseConfig;
+  private connected: boolean = false;
+
+  constructor(config: DatabaseConfig) {
+    this.config = config;
+
+    if (config.database !== 'mongodb') {
+      throw new Error('MongooseAdapter only supports MongoDB');
+    }
+  }
+
+  /**
+   * Connect to MongoDB using Mongoose
+   */
+  async connect(): Promise<void> {
+    if (this.connected && this.connection) {
+      logger.warn('Mongoose already connected');
+      return;
+    }
+
+    try {
+      const url = this.config.url || getDatabaseUrl(this.config);
+
+      this.connection = await mongoose.connect(url, {
+        // Modern Mongoose options
+        maxPoolSize: this.config.pool?.max || 10,
+        minPoolSize: this.config.pool?.min || 2,
+        socketTimeoutMS: 45000,
+        serverSelectionTimeoutMS: 5000,
+      });
+
+      this.connected = true;
+
+      logger.info({ host: this.connection.connection.host }, 'Mongoose connected to MongoDB');
+    } catch (error) {
+      logger.error({ err: error }, 'Failed to connect Mongoose');
+      throw new Error(
+        `Mongoose connection failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+      );
+    }
+  }
+
+  /**
+   * Disconnect from MongoDB
+   */
+  async disconnect(): Promise<void> {
+    if (!this.connection) {
+      return;
+    }
+
+    try {
+      await mongoose.disconnect();
+      this.connection = null;
+      this.connected = false;
+
+      logger.info('Mongoose disconnected from MongoDB');
+    } catch (error) {
+      logger.error({ err: error }, 'Error disconnecting Mongoose');
+      throw error;
+    }
+  }
+
+  /**
+   * Health check
+   */
+  async healthCheck(): Promise<boolean> {
+    if (!this.connection || !this.connected) {
+      return false;
+    }
+
+    try {
+      // Check connection state
+      return mongoose.connection.readyState === 1; // 1 = connected
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get ORM type
+   */
+  getType(): 'mongoose' {
+    return 'mongoose';
+  }
+
+  /**
+   * Get database type
+   */
+  getDatabaseType(): 'mongodb' {
+    return 'mongodb';
+  }
+
+  /**
+   * Get raw Mongoose instance
+   * Use with caution - breaks abstraction
+   */
+  getRawClient(): typeof mongoose {
+    if (!this.connection) {
+      throw new Error('Mongoose not initialized. Call connect() first.');
+    }
+    return this.connection;
+  }
+
+  /**
+   * Get Mongoose instance (typed helper)
+   */
+  getMongoose(): typeof mongoose {
+    return this.getRawClient();
+  }
+
+  /**
+   * Get native MongoDB connection
+   */
+  getConnection(): mongoose.Connection {
+    if (!this.connection) {
+      throw new Error('Mongoose not initialized. Call connect() first.');
+    }
+    return this.connection.connection;
+  }
+}

package/src/database/adapters/prisma.adapter.ts

@@ -0,0 +1,118 @@
+/**
+ * Prisma Database Adapter
+ * Implements IDatabaseAdapter for Prisma ORM
+ */
+
+import { PrismaClient } from '@prisma/client';
+import { logger } from '../../core/logger.js';
+import type { IDatabaseAdapter, DatabaseConfig } from '../interfaces/index.js';
+
+export class PrismaAdapter implements IDatabaseAdapter {
+  private client: PrismaClient | null = null;
+  private config: DatabaseConfig;
+  private connected: boolean = false;
+
+  constructor(config: DatabaseConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Connect to database using Prisma
+   */
+  async connect(): Promise<void> {
+    if (this.connected && this.client) {
+      logger.warn('Prisma client already connected');
+      return;
+    }
+
+    try {
+      this.client = new PrismaClient({
+        datasources: {
+          db: {
+            url: this.config.url,
+          },
+        },
+        log: this.config.logging ? ['query', 'info', 'warn', 'error'] : ['error'],
+      });
+
+      await this.client.$connect();
+      this.connected = true;
+
+      logger.info({ database: this.config.database }, 'Prisma connected successfully');
+    } catch (error) {
+      logger.error({ err: error }, 'Failed to connect Prisma');
+      throw new Error(
+        `Prisma connection failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+      );
+    }
+  }
+
+  /**
+   * Disconnect from database
+   */
+  async disconnect(): Promise<void> {
+    if (!this.client) {
+      return;
+    }
+
+    try {
+      await this.client.$disconnect();
+      this.client = null;
+      this.connected = false;
+
+      logger.info('Prisma disconnected');
+    } catch (error) {
+      logger.error({ err: error }, 'Error disconnecting Prisma');
+      throw error;
+    }
+  }
+
+  /**
+   * Health check
+   */
+  async healthCheck(): Promise<boolean> {
+    if (!this.client || !this.connected) {
+      return false;
+    }
+
+    try {
+      // Try a simple query
+      await this.client.$queryRaw`SELECT 1`;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get ORM type
+   */
+  getType(): 'prisma' {
+    return 'prisma';
+  }
+
+  /**
+   * Get database type
+   */
+  getDatabaseType(): DatabaseConfig['database'] {
+    return this.config.database;
+  }
+
+  /**
+   * Get raw Prisma client
+   * Use with caution - breaks abstraction
+   */
+  getRawClient(): PrismaClient {
+    if (!this.client) {
+      throw new Error('Prisma client not initialized. Call connect() first.');
+    }
+    return this.client;
+  }
+
+  /**
+   * Get Prisma client (typed helper)
+   */
+  getClient(): PrismaClient {
+    return this.getRawClient();
+  }
+}

package/src/database/connection.ts

@@ -0,0 +1,190 @@
+/**
+ * Database Connection Factory
+ * Creates appropriate adapter based on configuration
+ */
+
+import { logger } from '../core/logger.js';
+import type { IDatabaseAdapter, DatabaseConfig } from './interfaces/index.js';
+
+// Lazy imports to avoid loading unused ORMs
+let PrismaAdapter: any;
+let MongooseAdapter: any;
+
+/**
+ * Database Factory
+ * Singleton factory for creating and managing database adapters
+ */
+export class DatabaseFactory {
+  private static adapter: IDatabaseAdapter | null = null;
+  private static config: DatabaseConfig | null = null;
+
+  /**
+   * Create database adapter based on configuration
+   * @param config - Database configuration
+   * @returns Database adapter instance
+   */
+  static async createAdapter(config: DatabaseConfig): Promise<IDatabaseAdapter> {
+    this.config = config;
+
+    logger.info({ orm: config.orm, database: config.database }, 'Creating database adapter');
+
+    switch (config.orm) {
+      case 'prisma':
+        return this.createPrismaAdapter(config);
+
+      case 'mongoose':
+        return this.createMongooseAdapter(config);
+
+      case 'sequelize':
+        throw new Error('Sequelize support coming soon! Use Prisma or Mongoose for now.');
+
+      case 'typeorm':
+        throw new Error('TypeORM support coming soon! Use Prisma or Mongoose for now.');
+
+      default:
+        throw new Error(`Unsupported ORM: ${config.orm}`);
+    }
+  }
+
+  /**
+   * Create Prisma adapter
+   */
+  private static async createPrismaAdapter(config: DatabaseConfig): Promise<IDatabaseAdapter> {
+    // Validate Prisma supports this database
+    if (!['postgresql', 'mysql', 'sqlite', 'mongodb'].includes(config.database)) {
+      throw new Error(
+        `Prisma does not support ${config.database}. Use PostgreSQL, MySQL, SQLite, or MongoDB.`
+      );
+    }
+
+    // Lazy load Prisma adapter
+    if (!PrismaAdapter) {
+      const module = await import('./adapters/prisma.adapter.js');
+      PrismaAdapter = module.PrismaAdapter;
+    }
+
+    return new PrismaAdapter(config);
+  }
+
+  /**
+   * Create Mongoose adapter
+   */
+  private static async createMongooseAdapter(config: DatabaseConfig): Promise<IDatabaseAdapter> {
+    // Validate Mongoose only supports MongoDB
+    if (config.database !== 'mongodb') {
+      throw new Error('Mongoose only supports MongoDB database.');
+    }
+
+    // Lazy load Mongoose adapter
+    if (!MongooseAdapter) {
+      const module = await import('./adapters/mongoose.adapter.js');
+      MongooseAdapter = module.MongooseAdapter;
+    }
+
+    return new MongooseAdapter(config);
+  }
+
+  /**
+   * Get current adapter instance (singleton)
+   * @throws Error if no adapter initialized
+   */
+  static getAdapter(): IDatabaseAdapter {
+    if (!this.adapter) {
+      throw new Error('Database adapter not initialized. Call DatabaseFactory.initialize() first.');
+    }
+    return this.adapter;
+  }
+
+  /**
+   * Initialize database connection
+   * @param config - Database configuration
+   */
+  static async initialize(config: DatabaseConfig): Promise<IDatabaseAdapter> {
+    if (this.adapter) {
+      logger.warn('Database adapter already initialized. Disconnecting previous connection.');
+      await this.disconnect();
+    }
+
+    this.adapter = await this.createAdapter(config);
+    await this.adapter.connect();
+
+    logger.info({ orm: config.orm, database: config.database }, 'Database initialized');
+
+    return this.adapter;
+  }
+
+  /**
+   * Disconnect from database
+   */
+  static async disconnect(): Promise<void> {
+    if (this.adapter) {
+      await this.adapter.disconnect();
+      this.adapter = null;
+      logger.info('Database disconnected');
+    }
+  }
+
+  /**
+   * Check database health
+   */
+  static async healthCheck(): Promise<boolean> {
+    if (!this.adapter) {
+      return false;
+    }
+    return this.adapter.healthCheck();
+  }
+
+  /**
+   * Get current configuration
+   */
+  static getConfig(): DatabaseConfig | null {
+    return this.config;
+  }
+}
+
+/**
+ * Helper function to get database connection URL from config
+ */
+export function getDatabaseUrl(config: DatabaseConfig): string {
+  if (config.url) {
+    return config.url;
+  }
+
+  // Build URL from components
+  const { database, host, port, username, password, databaseName } = config;
+
+  switch (database) {
+    case 'postgresql':
+      return `postgresql://${username}:${password}@${host}:${port || 5432}/${databaseName}`;
+
+    case 'mysql':
+    case 'mariadb':
+      return `mysql://${username}:${password}@${host}:${port || 3306}/${databaseName}`;
+
+    case 'sqlite':
+      return `file:${databaseName || './dev.db'}`;
+
+    case 'mongodb':
+      return `mongodb://${host}:${port || 27017}/${databaseName}`;
+
+    default:
+      throw new Error(`Cannot build URL for database: ${database}`);
+  }
+}
+
+/**
+ * Validate ORM and database compatibility
+ */
+export function validateCompatibility(
+  orm: DatabaseConfig['orm'],
+  database: DatabaseConfig['database']
+): boolean {
+  const compatibility: Record<DatabaseConfig['orm'], DatabaseConfig['database'][]> = {
+    prisma: ['postgresql', 'mysql', 'sqlite', 'mongodb'],
+    mongoose: ['mongodb'],
+    sequelize: ['postgresql', 'mysql', 'sqlite', 'mariadb'],
+    typeorm: ['postgresql', 'mysql', 'sqlite', 'mongodb', 'mariadb'],
+  };
+
+  return compatibility[orm]?.includes(database) || false;
+}