servcraft 0.1.0 → 0.1.1

package/src/database/repositories/mongoose/user.repository.ts

@@ -0,0 +1,255 @@
+/**
+ * Mongoose User Repository
+ * Implements IRepository for User entity using Mongoose
+ */
+
+import { UserModel, type IUserDocument } from '../../models/mongoose/user.schema.js';
+import type { IRepository, PaginationOptions, PaginatedResult } from '../../interfaces/index.js';
+
+// User type matching application format (lowercase enums)
+export interface User {
+  id: string;
+  email: string;
+  password: string;
+  name: string;
+  role: 'user' | 'moderator' | 'admin' | 'super_admin';
+  status: 'active' | 'inactive' | 'suspended' | 'pending';
+  emailVerified: boolean;
+  emailVerifiedAt?: Date | null;
+  lastLoginAt?: Date | null;
+  metadata?: Record<string, unknown> | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Mongoose User Repository
+ */
+export class MongooseUserRepository implements IRepository<User> {
+  /**
+   * Convert Mongoose document to User
+   */
+  private toUser(doc: IUserDocument): User {
+    return {
+      id: doc._id.toString(),
+      email: doc.email,
+      password: doc.password,
+      name: doc.name,
+      role: doc.role,
+      status: doc.status,
+      emailVerified: doc.emailVerified,
+      emailVerifiedAt: doc.emailVerifiedAt || null,
+      lastLoginAt: doc.lastLoginAt || null,
+      metadata: doc.metadata || null,
+      createdAt: doc.createdAt,
+      updatedAt: doc.updatedAt,
+    };
+  }
+
+  /**
+   * Find user by ID
+   */
+  async findById(id: string): Promise<User | null> {
+    try {
+      const user = await UserModel.findById(id).select('+password');
+      return user ? this.toUser(user) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Find one user by filter
+   */
+  async findOne(filter: Record<string, unknown>): Promise<User | null> {
+    try {
+      const user = await UserModel.findOne(filter).select('+password');
+      return user ? this.toUser(user) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Find many users with pagination
+   */
+  async findMany(
+    filter: Record<string, unknown> = {},
+    options: PaginationOptions = {}
+  ): Promise<PaginatedResult<User>> {
+    const page = options.page || 1;
+    const limit = options.limit || 10;
+    const skip = (page - 1) * limit;
+
+    // Build sort
+    const sortBy = options.sortBy || 'createdAt';
+    const sortOrder = options.sortOrder === 'asc' ? 1 : -1;
+    const sort: Record<string, 1 | -1> = { [sortBy]: sortOrder };
+
+    // Execute queries
+    const [users, total] = await Promise.all([
+      UserModel.find(filter).sort(sort).skip(skip).limit(limit).exec(),
+      UserModel.countDocuments(filter),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+
+    return {
+      data: users.map((user) => this.toUser(user)),
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages,
+        hasNext: page < totalPages,
+        hasPrev: page > 1,
+      },
+    };
+  }
+
+  /**
+   * Create new user
+   */
+  async create(data: Partial<User>): Promise<User> {
+    const user = await UserModel.create({
+      email: data.email,
+      password: data.password,
+      name: data.name,
+      role: data.role || 'user',
+      status: data.status || 'active',
+      emailVerified: data.emailVerified || false,
+      emailVerifiedAt: data.emailVerifiedAt,
+      lastLoginAt: data.lastLoginAt,
+      metadata: data.metadata,
+    });
+
+    // Fetch with password included
+    const created = await UserModel.findById(user._id).select('+password');
+    if (!created) {
+      throw new Error('Failed to create user');
+    }
+
+    return this.toUser(created);
+  }
+
+  /**
+   * Update user by ID
+   */
+  async update(id: string, data: Partial<User>): Promise<User | null> {
+    try {
+      // Don't allow updating password directly (use separate method)
+      const updateData = { ...data };
+      delete updateData.password;
+
+      const user = await UserModel.findByIdAndUpdate(
+        id,
+        { $set: updateData },
+        { new: true, runValidators: true }
+      ).select('+password');
+
+      return user ? this.toUser(user) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Delete user by ID
+   */
+  async delete(id: string): Promise<boolean> {
+    try {
+      const result = await UserModel.findByIdAndDelete(id);
+      return result !== null;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Count users
+   */
+  async count(filter: Record<string, unknown> = {}): Promise<number> {
+    return UserModel.countDocuments(filter);
+  }
+
+  /**
+   * Check if user exists
+   */
+  async exists(id: string): Promise<boolean> {
+    const count = await UserModel.countDocuments({ _id: id });
+    return count > 0;
+  }
+
+  /**
+   * Find user by email
+   */
+  async findByEmail(email: string): Promise<User | null> {
+    return this.findOne({ email: email.toLowerCase() });
+  }
+
+  /**
+   * Update password
+   */
+  async updatePassword(id: string, newPassword: string): Promise<boolean> {
+    try {
+      const user = await UserModel.findById(id);
+      if (!user) {
+        return false;
+      }
+
+      user.password = newPassword;
+      await user.save(); // Will trigger pre-save hook to hash password
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Verify user password
+   */
+  async verifyPassword(id: string, password: string): Promise<boolean> {
+    try {
+      const user = await UserModel.findById(id).select('+password');
+      if (!user) {
+        return false;
+      }
+
+      return user.comparePassword(password);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Update last login
+   */
+  async updateLastLogin(id: string): Promise<boolean> {
+    try {
+      const result = await UserModel.findByIdAndUpdate(id, {
+        $set: { lastLoginAt: new Date() },
+      });
+      return result !== null;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Verify email
+   */
+  async verifyEmail(id: string): Promise<boolean> {
+    try {
+      const result = await UserModel.findByIdAndUpdate(id, {
+        $set: {
+          emailVerified: true,
+          emailVerifiedAt: new Date(),
+        },
+      });
+      return result !== null;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/database/seed.ts

@@ -26,7 +26,12 @@ async function main(): Promise<void> {
   // Create default settings
   const defaultSettings = [
     { key: 'app.name', value: 'Servcraft', type: 'string', group: 'general' },
-    { key: 'app.description', value: 'A modular Node.js backend framework', type: 'string', group: 'general' },
+    {
+      key: 'app.description',
+      value: 'A modular Node.js backend framework',
+      type: 'string',
+      group: 'general',
+    },
     { key: 'auth.registration_enabled', value: true, type: 'boolean', group: 'auth' },
     { key: 'auth.email_verification_required', value: false, type: 'boolean', group: 'auth' },
     { key: 'email.enabled', value: false, type: 'boolean', group: 'email' },

package/src/index.ts

@@ -1,10 +1,8 @@
-import { Server, createServer } from './core/server.js';
+import { createServer } from './core/server.js';
 import { logger } from './core/logger.js';
 import { config } from './config/index.js';
 import { registerSecurity, registerErrorHandler } from './middleware/index.js';
 import { registerAuthModule } from './modules/auth/index.js';
-import { registerUserModule } from './modules/user/index.js';
-import { registerSwagger } from './modules/swagger/index.js';
 
 async function bootstrap(): Promise<void> {
   // Create server instance
@@ -21,28 +19,19 @@ async function bootstrap(): Promise<void> {
   // Register security middleware
   await registerSecurity(app);
 
-  // Register Swagger documentation (auto-updates as routes are added)
-  await registerSwagger(app, {
-    enabled: config.swagger.enabled,
-    route: config.swagger.route,
-    title: config.swagger.title,
-    description: config.swagger.description,
-    version: config.swagger.version,
-  });
-
   // Register auth module
-  const authService = await registerAuthModule(app);
-
-  // Register user module (depends on auth for guard middleware)
-  await registerUserModule(app, authService);
+  await registerAuthModule(app);
 
   // Start server
   await server.start();
 
-  logger.info({
-    env: config.env.NODE_ENV,
-    port: config.server.port,
-  }, 'Servcraft server started');
+  logger.info(
+    {
+      env: config.env.NODE_ENV,
+      port: config.server.port,
+    },
+    'Servcraft server started'
+  );
 }
 
 bootstrap().catch((err) => {

package/src/middleware/security.ts

@@ -65,9 +65,7 @@ export async function registerSecurity(
       keyGenerator: (request) => {
         // Use X-Forwarded-For if behind proxy, otherwise use IP
         return (
-          request.headers['x-forwarded-for']?.toString().split(',')[0] ||
-          request.ip ||
-          'unknown'
+          request.headers['x-forwarded-for']?.toString().split(',')[0] || request.ip || 'unknown'
         );
       },
     });
@@ -94,9 +92,7 @@ export async function registerBruteForceProtection(
     timeWindow,
     keyGenerator: (request) => {
       const ip =
-        request.headers['x-forwarded-for']?.toString().split(',')[0] ||
-        request.ip ||
-        'unknown';
+        request.headers['x-forwarded-for']?.toString().split(',')[0] || request.ip || 'unknown';
       return `brute:${routePrefix}:${ip}`;
     },
     errorResponseBuilder: () => ({

package/src/modules/analytics/analytics.routes.ts

@@ -0,0 +1,80 @@
+import { Router } from 'express';
+import type { Request, Response } from 'express';
+import type { AnalyticsService } from './analytics.service.js';
+import type { AnalyticsEvent, MetricQuery } from './types.js';
+
+/**
+ * Create analytics routes
+ */
+export function createAnalyticsRoutes(analyticsService: AnalyticsService): Router {
+  const router = Router();
+
+  /**
+   * Track event
+   * POST /events
+   */
+  router.post('/events', (req: Request, res: Response) => {
+    const event = req.body as Omit<AnalyticsEvent, 'timestamp'>;
+    analyticsService.trackEvent(event);
+    res.json({ success: true });
+  });
+
+  /**
+   * Get events
+   * GET /events?limit=100
+   */
+  router.get('/events', (req: Request, res: Response) => {
+    const limit = req.query.limit ? parseInt(req.query.limit as string, 10) : 100;
+    const events = analyticsService.getEvents(limit);
+    res.json({ events, count: events.length });
+  });
+
+  /**
+   * Get counters
+   * GET /metrics/counters
+   */
+  router.get('/metrics/counters', (_req: Request, res: Response) => {
+    const counters = analyticsService.getCounters();
+    res.json({ counters, count: counters.length });
+  });
+
+  /**
+   * Get gauges
+   * GET /metrics/gauges
+   */
+  router.get('/metrics/gauges', (_req: Request, res: Response) => {
+    const gauges = analyticsService.getGauges();
+    res.json({ gauges, count: gauges.length });
+  });
+
+  /**
+   * Query metrics
+   * POST /metrics/query
+   */
+  router.post('/metrics/query', async (req: Request, res: Response) => {
+    const query = req.body as MetricQuery;
+    const result = await analyticsService.queryMetrics(query);
+    res.json(result);
+  });
+
+  /**
+   * Prometheus metrics endpoint
+   * GET /metrics
+   */
+  router.get('/metrics', (_req: Request, res: Response) => {
+    const metrics = analyticsService.getPrometheusMetrics();
+    res.set('Content-Type', 'text/plain');
+    res.send(metrics);
+  });
+
+  /**
+   * Clear all metrics
+   * POST /clear
+   */
+  router.post('/clear', (_req: Request, res: Response) => {
+    analyticsService.clear();
+    res.json({ success: true, message: 'All metrics cleared' });
+  });
+
+  return router;
+}