servcraft 0.1.0 → 0.1.1

package/src/database/models/mongoose/user.schema.ts

@@ -0,0 +1,154 @@
+/**
+ * Mongoose User Schema
+ * MongoDB schema for User entity
+ */
+
+import { Schema, model, type Document } from 'mongoose';
+import bcrypt from 'bcryptjs';
+
+/**
+ * User interface for Mongoose
+ */
+export interface IUserDocument extends Document {
+  email: string;
+  password: string;
+  name: string;
+  role: 'user' | 'moderator' | 'admin' | 'super_admin';
+  status: 'active' | 'inactive' | 'suspended' | 'pending';
+  emailVerified: boolean;
+  emailVerifiedAt?: Date;
+  lastLoginAt?: Date;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+
+  // Methods
+  comparePassword(candidatePassword: string): Promise<boolean>;
+}
+
+/**
+ * User Schema
+ */
+const userSchema = new Schema<IUserDocument>(
+  {
+    email: {
+      type: String,
+      required: [true, 'Email is required'],
+      unique: true,
+      lowercase: true,
+      trim: true,
+      match: [/^\S+@\S+\.\S+$/, 'Please provide a valid email'],
+      index: true,
+    },
+    password: {
+      type: String,
+      required: [true, 'Password is required'],
+      minlength: [6, 'Password must be at least 6 characters'],
+      select: false, // Don't include password by default
+    },
+    name: {
+      type: String,
+      required: [true, 'Name is required'],
+      trim: true,
+      maxlength: [100, 'Name cannot exceed 100 characters'],
+    },
+    role: {
+      type: String,
+      enum: {
+        values: ['user', 'moderator', 'admin', 'super_admin'],
+        message: '{VALUE} is not a valid role',
+      },
+      default: 'user',
+      index: true,
+    },
+    status: {
+      type: String,
+      enum: {
+        values: ['active', 'inactive', 'suspended', 'pending'],
+        message: '{VALUE} is not a valid status',
+      },
+      default: 'active',
+      index: true,
+    },
+    emailVerified: {
+      type: Boolean,
+      default: false,
+    },
+    emailVerifiedAt: {
+      type: Date,
+      default: null,
+    },
+    lastLoginAt: {
+      type: Date,
+      default: null,
+    },
+    metadata: {
+      type: Schema.Types.Mixed,
+      default: null,
+    },
+  },
+  {
+    timestamps: true, // Automatically add createdAt and updatedAt
+    collection: 'users',
+    toJSON: {
+      virtuals: true,
+      transform: (_doc, ret): Record<string, unknown> => {
+        const id = ret._id.toString();
+        const { password, _id: mongoId, __v, ...rest } = ret;
+        void password; // Intentionally excluded from output
+        void mongoId;
+        void __v;
+        return { id, ...rest };
+      },
+    },
+    toObject: {
+      virtuals: true,
+      transform: (_doc, ret): Record<string, unknown> => {
+        const { _id, ...rest } = ret;
+        return { id: _id.toString(), ...rest };
+      },
+    },
+  }
+);
+
+/**
+ * Pre-save middleware to hash password
+ */
+userSchema.pre('save', async function (next) {
+  // Only hash the password if it has been modified (or is new)
+  if (!this.isModified('password')) {
+    return next();
+  }
+
+  try {
+    const salt = await bcrypt.genSalt(10);
+    this.password = await bcrypt.hash(this.password, salt);
+    next();
+  } catch (error) {
+    next(error as Error);
+  }
+});
+
+/**
+ * Method to compare password
+ */
+userSchema.methods.comparePassword = async function (candidatePassword: string): Promise<boolean> {
+  try {
+    return await bcrypt.compare(candidatePassword, this.password);
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Indexes for better query performance
+ * Note: email index is already defined via unique: true in schema
+ * role and status indexes are defined via index: true in schema
+ */
+userSchema.index({ role: 1, status: 1 }); // Compound index for filtering
+userSchema.index({ createdAt: -1 }); // For sorting by creation date
+
+/**
+ * User Model
+ */
+export const UserModel = model<IUserDocument>('User', userSchema);

package/src/database/prisma.ts

@@ -3,15 +3,12 @@ import { logger } from '../core/logger.js';
 import { isProduction } from '../config/index.js';
 
 declare global {
-  // eslint-disable-next-line no-var
   var __prisma: PrismaClient | undefined;
 }
 
 const prismaClientSingleton = (): PrismaClient => {
   return new PrismaClient({
-    log: isProduction()
-      ? ['error']
-      : ['query', 'info', 'warn', 'error'],
+    log: isProduction() ? ['error'] : ['query', 'info', 'warn', 'error'],
     errorFormat: isProduction() ? 'minimal' : 'pretty',
   });
 };

package/src/database/redis.ts

@@ -0,0 +1,101 @@
+/**
+ * Redis Client Module
+ * Shared Redis connection for all services
+ */
+import { Redis } from 'ioredis';
+import { logger } from '../core/logger.js';
+
+export interface RedisConfig {
+  host: string;
+  port: number;
+  password?: string;
+  db?: number;
+  tls?: boolean;
+  connectTimeout?: number;
+  maxRetries?: number;
+  keyPrefix?: string;
+}
+
+let redisClient: Redis | null = null;
+
+/**
+ * Initialize the Redis connection
+ */
+export function initRedis(config: RedisConfig): Redis {
+  if (redisClient) {
+    return redisClient;
+  }
+
+  redisClient = new Redis({
+    host: config.host,
+    port: config.port,
+    password: config.password,
+    db: config.db || 0,
+    keyPrefix: config.keyPrefix,
+    connectTimeout: config.connectTimeout || 10000,
+    retryStrategy: (times: number) => {
+      const maxRetries = config.maxRetries || 10;
+      if (times > maxRetries) {
+        logger.error('Redis max retries reached, giving up');
+        return null;
+      }
+      const delay = Math.min(times * 50, 2000);
+      return delay;
+    },
+    ...(config.tls && { tls: {} }),
+  });
+
+  redisClient.on('connect', () => {
+    logger.info({ host: config.host, port: config.port }, 'Redis connected');
+  });
+
+  redisClient.on('error', (error: Error) => {
+    logger.error({ err: error }, 'Redis error');
+  });
+
+  redisClient.on('close', () => {
+    logger.warn('Redis connection closed');
+  });
+
+  redisClient.on('reconnecting', () => {
+    logger.info('Redis reconnecting');
+  });
+
+  return redisClient;
+}
+
+/**
+ * Get the Redis client instance
+ * Creates a default connection if not initialized
+ */
+export function getRedis(): Redis {
+  if (!redisClient) {
+    // Initialize with default/env config
+    const config: RedisConfig = {
+      host: process.env.REDIS_HOST || 'localhost',
+      port: parseInt(process.env.REDIS_PORT || '6379', 10),
+      password: process.env.REDIS_PASSWORD,
+      db: parseInt(process.env.REDIS_DB || '0', 10),
+    };
+    return initRedis(config);
+  }
+  return redisClient;
+}
+
+/**
+ * Close the Redis connection
+ */
+export async function closeRedis(): Promise<void> {
+  if (redisClient) {
+    await redisClient.quit();
+    redisClient = null;
+    logger.info('Redis connection closed');
+  }
+}
+
+/**
+ * Check if Redis is connected
+ */
+export function isRedisConnected(): boolean {
+  return redisClient?.status === 'ready';
+}

package/src/database/repositories/mongoose/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Mongoose Repositories Export
+ * Central export for all Mongoose repositories
+ */
+
+export * from './user.repository.js';
+export * from './payment.repository.js';

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

@@ -0,0 +1,380 @@
+/**
+ * Mongoose Payment Repository
+ * Implements payment operations using Mongoose
+ */
+
+import {
+  PaymentModel,
+  SubscriptionModel,
+  PlanModel,
+  WebhookModel,
+  type IPaymentDocument,
+  type ISubscriptionDocument,
+  type IPlanDocument,
+} from '../../models/mongoose/payment.schema.js';
+import type { IRepository, PaginationOptions, PaginatedResult } from '../../interfaces/index.js';
+
+// Payment types matching application format
+export interface Payment {
+  id: string;
+  userId: string;
+  provider: 'stripe' | 'paypal' | 'mobile_money' | 'manual';
+  method: 'card' | 'bank_transfer' | 'mobile_money' | 'paypal' | 'other';
+  status: 'pending' | 'processing' | 'completed' | 'failed' | 'refunded' | 'cancelled';
+  amount: number;
+  currency: string;
+  description?: string | null;
+  providerPaymentId?: string | null;
+  providerCustomerId?: string | null;
+  metadata?: Record<string, unknown> | null;
+  failureReason?: string | null;
+  refundedAt?: Date | null;
+  completedAt?: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface Subscription {
+  id: string;
+  userId: string;
+  planId: string;
+  provider: 'stripe' | 'paypal' | 'mobile_money' | 'manual';
+  status: 'active' | 'cancelled' | 'expired' | 'suspended' | 'trialing';
+  currentPeriodStart: Date;
+  currentPeriodEnd: Date;
+  cancelledAt?: Date | null;
+  providerSubscriptionId?: string | null;
+  metadata?: Record<string, unknown> | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface Plan {
+  id: string;
+  name: string;
+  amount: number;
+  currency: string;
+  interval: 'day' | 'week' | 'month' | 'year';
+  intervalCount: number;
+  trialPeriodDays?: number | null;
+  active: boolean;
+  metadata?: Record<string, unknown> | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Mongoose Payment Repository
+ */
+export class MongoosePaymentRepository implements IRepository<Payment> {
+  // ==========================================
+  // PAYMENT METHODS
+  // ==========================================
+
+  private toPayment(doc: IPaymentDocument): Payment {
+    return {
+      id: doc._id.toString(),
+      userId: doc.userId,
+      provider: doc.provider,
+      method: doc.method,
+      status: doc.status,
+      amount: doc.amount,
+      currency: doc.currency,
+      description: doc.description || null,
+      providerPaymentId: doc.providerPaymentId || null,
+      providerCustomerId: doc.providerCustomerId || null,
+      metadata: doc.metadata || null,
+      failureReason: doc.failureReason || null,
+      refundedAt: doc.refundedAt || null,
+      completedAt: doc.completedAt || null,
+      createdAt: doc.createdAt,
+      updatedAt: doc.updatedAt,
+    };
+  }
+
+  async findById(id: string): Promise<Payment | null> {
+    try {
+      const payment = await PaymentModel.findById(id);
+      return payment ? this.toPayment(payment) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  async findOne(filter: Record<string, unknown>): Promise<Payment | null> {
+    try {
+      const payment = await PaymentModel.findOne(filter);
+      return payment ? this.toPayment(payment) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  async findMany(
+    filter: Record<string, unknown> = {},
+    options: PaginationOptions = {}
+  ): Promise<PaginatedResult<Payment>> {
+    const page = options.page || 1;
+    const limit = options.limit || 10;
+    const skip = (page - 1) * limit;
+
+    const sortBy = options.sortBy || 'createdAt';
+    const sortOrder = options.sortOrder === 'asc' ? 1 : -1;
+    const sort: Record<string, 1 | -1> = { [sortBy]: sortOrder };
+
+    const [payments, total] = await Promise.all([
+      PaymentModel.find(filter).sort(sort).skip(skip).limit(limit).exec(),
+      PaymentModel.countDocuments(filter),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+
+    return {
+      data: payments.map((p) => this.toPayment(p)),
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages,
+        hasNext: page < totalPages,
+        hasPrev: page > 1,
+      },
+    };
+  }
+
+  async create(data: Partial<Payment>): Promise<Payment> {
+    const payment = await PaymentModel.create(data);
+    return this.toPayment(payment);
+  }
+
+  async update(id: string, data: Partial<Payment>): Promise<Payment | null> {
+    try {
+      const payment = await PaymentModel.findByIdAndUpdate(
+        id,
+        { $set: data },
+        { new: true, runValidators: true }
+      );
+      return payment ? this.toPayment(payment) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  async delete(id: string): Promise<boolean> {
+    try {
+      const result = await PaymentModel.findByIdAndDelete(id);
+      return result !== null;
+    } catch {
+      return false;
+    }
+  }
+
+  async count(filter: Record<string, unknown> = {}): Promise<number> {
+    return PaymentModel.countDocuments(filter);
+  }
+
+  async exists(id: string): Promise<boolean> {
+    const count = await PaymentModel.countDocuments({ _id: id });
+    return count > 0;
+  }
+
+  /**
+   * Find payment by provider payment ID
+   */
+  async findByProviderPaymentId(providerPaymentId: string): Promise<Payment | null> {
+    return this.findOne({ providerPaymentId });
+  }
+
+  /**
+   * Find payments by user ID
+   */
+  async findByUserId(
+    userId: string,
+    options: PaginationOptions = {}
+  ): Promise<PaginatedResult<Payment>> {
+    return this.findMany({ userId }, options);
+  }
+
+  /**
+   * Update payment status
+   */
+  async updateStatus(
+    id: string,
+    status: Payment['status'],
+    data?: Partial<Payment>
+  ): Promise<Payment | null> {
+    const updateData: Partial<Payment> = { status, ...data };
+
+    if (status === 'completed' && !data?.completedAt) {
+      updateData.completedAt = new Date();
+    }
+    if (status === 'refunded' && !data?.refundedAt) {
+      updateData.refundedAt = new Date();
+    }
+
+    return this.update(id, updateData);
+  }
+
+  // ==========================================
+  // SUBSCRIPTION METHODS
+  // ==========================================
+
+  private toSubscription(doc: ISubscriptionDocument): Subscription {
+    return {
+      id: doc._id.toString(),
+      userId: doc.userId,
+      planId: doc.planId,
+      provider: doc.provider,
+      status: doc.status,
+      currentPeriodStart: doc.currentPeriodStart,
+      currentPeriodEnd: doc.currentPeriodEnd,
+      cancelledAt: doc.cancelledAt || null,
+      providerSubscriptionId: doc.providerSubscriptionId || null,
+      metadata: doc.metadata || null,
+      createdAt: doc.createdAt,
+      updatedAt: doc.updatedAt,
+    };
+  }
+
+  async createSubscription(data: Partial<Subscription>): Promise<Subscription> {
+    const subscription = await SubscriptionModel.create(data);
+    return this.toSubscription(subscription);
+  }
+
+  async findSubscriptionById(id: string): Promise<Subscription | null> {
+    try {
+      const subscription = await SubscriptionModel.findById(id);
+      return subscription ? this.toSubscription(subscription) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  async findSubscriptionsByUserId(
+    userId: string,
+    options: PaginationOptions = {}
+  ): Promise<PaginatedResult<Subscription>> {
+    const page = options.page || 1;
+    const limit = options.limit || 10;
+    const skip = (page - 1) * limit;
+
+    const [subscriptions, total] = await Promise.all([
+      SubscriptionModel.find({ userId }).sort({ createdAt: -1 }).skip(skip).limit(limit).exec(),
+      SubscriptionModel.countDocuments({ userId }),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+
+    return {
+      data: subscriptions.map((s) => this.toSubscription(s)),
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages,
+        hasNext: page < totalPages,
+        hasPrev: page > 1,
+      },
+    };
+  }
+
+  async updateSubscription(id: string, data: Partial<Subscription>): Promise<Subscription | null> {
+    try {
+      const subscription = await SubscriptionModel.findByIdAndUpdate(
+        id,
+        { $set: data },
+        { new: true, runValidators: true }
+      );
+      return subscription ? this.toSubscription(subscription) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  async cancelSubscription(id: string): Promise<Subscription | null> {
+    return this.updateSubscription(id, {
+      status: 'cancelled',
+      cancelledAt: new Date(),
+    });
+  }
+
+  // ==========================================
+  // PLAN METHODS
+  // ==========================================
+
+  private toPlan(doc: IPlanDocument): Plan {
+    return {
+      id: doc._id.toString(),
+      name: doc.name,
+      amount: doc.amount,
+      currency: doc.currency,
+      interval: doc.interval,
+      intervalCount: doc.intervalCount,
+      trialPeriodDays: doc.trialPeriodDays || null,
+      active: doc.active,
+      metadata: doc.metadata || null,
+      createdAt: doc.createdAt,
+      updatedAt: doc.updatedAt,
+    };
+  }
+
+  async createPlan(data: Partial<Plan>): Promise<Plan> {
+    const plan = await PlanModel.create(data);
+    return this.toPlan(plan);
+  }
+
+  async findPlanById(id: string): Promise<Plan | null> {
+    try {
+      const plan = await PlanModel.findById(id);
+      return plan ? this.toPlan(plan) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  async findActivePlans(): Promise<Plan[]> {
+    const plans = await PlanModel.find({ active: true }).sort({ createdAt: -1 });
+    return plans.map((p) => this.toPlan(p));
+  }
+
+  async updatePlan(id: string, data: Partial<Plan>): Promise<Plan | null> {
+    try {
+      const plan = await PlanModel.findByIdAndUpdate(
+        id,
+        { $set: data },
+        { new: true, runValidators: true }
+      );
+      return plan ? this.toPlan(plan) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // ==========================================
+  // WEBHOOK METHODS
+  // ==========================================
+
+  async storeWebhookEvent(data: {
+    provider: 'stripe' | 'paypal' | 'mobile_money' | 'manual';
+    type: string;
+    data: Record<string, unknown>;
+  }): Promise<{ id: string }> {
+    const webhook = await WebhookModel.create(data);
+    return { id: webhook._id.toString() };
+  }
+
+  async markWebhookProcessed(id: string, error?: string): Promise<boolean> {
+    try {
+      const result = await WebhookModel.findByIdAndUpdate(id, {
+        $set: {
+          processed: true,
+          processedAt: new Date(),
+          ...(error && { error }),
+        },
+      });
+      return result !== null;
+    } catch {
+      return false;
+    }
+  }
+}