docta-package 1.0.1

package/src/dto/output/specialty.ts

@@ -0,0 +1,53 @@
+import { ISpecialtyDocument } from "../../models";
+import { UserOutputDto } from ".";
+
+// Base DTO for everyone
+export class SpecialtyOutputDto {
+  id: string;
+  en: { name: string; description: string | null };
+  fr: { name: string; description: string | null } | null;
+
+  isDeleted: boolean;
+  createdAt: number;
+  updatedAt: number;
+
+  constructor(specialty: ISpecialtyDocument) {
+    this.id = specialty.id.toString();
+    this.en = {
+      name: specialty.en.name,
+      description: specialty.en.description || null,
+    };
+    this.fr = specialty.fr
+      ? {
+          name: specialty.fr.name,
+          description: specialty.fr.description || null,
+        }
+      : null;
+    this.isDeleted = specialty.isDeleted;
+    this.createdAt = specialty.createdAt;
+    this.updatedAt = specialty.updatedAt;
+  }
+}
+
+// Extended DTO for admin responses
+export class SpecialtyAdminOutputDto extends SpecialtyOutputDto {
+  createdBy: UserOutputDto | null;
+  updatedBy: UserOutputDto | null;
+  deletedBy: UserOutputDto | null;
+
+  constructor(specialty: ISpecialtyDocument) {
+    super(specialty); // call base constructor
+
+    this.createdBy = specialty.createdBy
+      ? new UserOutputDto(specialty.createdBy)
+      : null;
+
+    this.updatedBy = specialty.updatedBy
+      ? new UserOutputDto(specialty.updatedBy)
+      : null;
+
+    this.deletedBy = specialty.deletedBy
+      ? new UserOutputDto(specialty.deletedBy)
+      : null;
+  }
+}

package/src/dto/output/user.ts

@@ -0,0 +1,57 @@
+import { IUserDocument } from "../../models";
+
+// Base DTO for everyone
+export class UserOutputDto {
+  id: string;
+  name: string;
+  email: string;
+  role: string;
+  isActive: boolean;
+  isDeleted: boolean;
+  createdAt: number;
+  updatedAt: number;
+
+  constructor(user: IUserDocument) {
+    this.id = user.id.toString();
+    this.name = user.name;
+    this.email = user.email;
+    this.role = user.role;
+
+    this.isActive = user.isActive;
+    this.isDeleted = user.isDeleted;
+    this.createdAt = user.createdAt;
+    this.updatedAt = user.updatedAt;
+  }
+}
+
+// Extended DTO for admin responses
+export class UserAdminOutputDto extends UserOutputDto {
+  createdBy: UserOutputDto | null;
+  updatedBy: UserOutputDto | null;
+  deletedBy: UserOutputDto | null;
+
+  constructor(user: IUserDocument) {
+    super(user); // call base constructor
+
+    this.createdBy = user.createdBy ? new UserOutputDto(user.createdBy) : null;
+    this.updatedBy = user.updatedBy ? new UserOutputDto(user.updatedBy) : null;
+    this.deletedBy = user.deletedBy ? new UserOutputDto(user.deletedBy) : null;
+  }
+}
+
+// DTO for logged-in user responses
+export class LoggedInUserOutputDto {
+  user: UserOutputDto | UserAdminOutputDto;
+  accessToken: string;
+  refreshToken: string;
+
+  constructor(
+    user: UserOutputDto | UserAdminOutputDto,
+    accessToken: string,
+    refreshToken: string
+  ) {
+    this.user = user;
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken;
+  }
+}

package/src/enums/gender.ts

@@ -0,0 +1,4 @@
+export enum Gender {
+  MALE = "MALE",
+  FEMALE = "FEMALE",
+}

package/src/enums/index.ts

@@ -0,0 +1,4 @@
+export * from "./language-levels";
+export * from "./status-codes";
+export * from "./user-role";
+export * from "./gender";

package/src/enums/language-levels.ts

@@ -0,0 +1,9 @@
+export enum EnumLanguageLevel {
+  BEGINNER = "BEGINNER", // A1
+  ELEMENTARY = "ELEMENTARY", // A2
+  INTERMEDIATE = "INTERMEDIATE", // B1
+  UPPER_INTERMEDIATE = "UPPER_INTERMEDIATE", // B2
+  ADVANCED = "ADVANCED", // C1
+  PROFICIENT = "PROFICIENT", // C2
+}
+

package/src/enums/status-codes.ts

@@ -0,0 +1,28 @@
+export enum EnumStatusCode {
+  BAD_REQUEST = "BAD_REQUEST",
+  SOMETHING_WENT_WRONG = "SOMETHING_WENT_WRONG",
+  UNAUTHORIZED = "UNAUTHORIZED",
+  VALIDATION_ERROR = "VALIDATION_ERROR",
+  EXISTS_ALREADY = "EXISTS_ALREADY",
+  CREATED_SUCCESSFULLY = "CREATED_SUCCESSFULLY",
+  UPDATED_SUCCESSFULLY = "UPDATED_SUCCESSFULLY",
+  NOT_FOUND = "NOT_FOUND",
+  SPECIALTY_NOT_FOUND = "SPECIALTY_NOT_FOUND",
+  NOT_ALLOWED = "NOT_ALLOWED",
+  DOCTOR_NOT_FOUND = "DOCTOR_NOT_FOUND",
+  ACCOUNT_DELETED = "ACCOUNT_DELETED",
+  ACCOUNT_DEACTIVATED = "ACCOUNT_DEACTIVATED",
+  TOKEN_REFRESHED = "TOKEN_REFRESHED",
+
+  NO_ACCESS_TOKEN = "NO_ACCESS_TOKEN",
+  ACCESS_TOKEN_EXPIRED = "ACCESS_TOKEN_EXPIRED",
+  CANNOT_DECODE_ACCESS_TOKEN = "CANNOT_DECODE_ACCESS_TOKEN",
+
+  RECOVERED_SUCCESSFULLY = "RECOVERED_SUCCESSFULLY",
+
+  FILE_TYPE_MISMATCH = "FILE_TYPE_MISMATCH",
+  FILE_TOO_LARGE = "FILE_TOO_LARGE",
+  NO_FILE_UPLOADED = "NO_FILE_UPLOADED",
+
+  DELETED_SUCCESSFULLY = "DELETED_SUCCESSFULLY",
+}

package/src/enums/user-role.ts

@@ -0,0 +1,5 @@
+export enum EnumUserRole {
+  PATIENT = "patient",
+  DOCTOR = "doctor",
+  ADMIN = "admin",
+}

package/src/errors/BadRequestError.ts

@@ -0,0 +1,18 @@
+import { CustomError } from ".";
+import { EnumStatusCode } from "../enums";
+import { ErrorResult } from "../utils";
+
+export class BadRequestError extends CustomError {
+  statusCode = 400;
+
+  constructor(
+    code: EnumStatusCode = EnumStatusCode.BAD_REQUEST,
+    message: string = "Bad Request"
+  ) {
+    super(message, code, 400);
+  }
+
+  serializeErrors(): ErrorResult {
+    return { code: this.code, message: this.message };
+  }
+}

package/src/errors/CustomError.ts

@@ -0,0 +1,18 @@
+import { EnumStatusCode } from "../enums";
+import { ErrorResult } from "../utils";
+
+export abstract class CustomError extends Error {
+  public readonly code: EnumStatusCode;
+  public readonly statusCode: number;
+
+  constructor(message: string, code: EnumStatusCode, statusCode: number) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+
+    // Maintains proper prototype chain for built-in Error
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+
+  abstract serializeErrors(): ErrorResult;
+}

package/src/errors/NotFoundError.ts

@@ -0,0 +1,18 @@
+import { CustomError } from ".";
+import { EnumStatusCode } from "../enums";
+import { ErrorResult } from "../utils";
+
+export class NotFoundError extends CustomError {
+  statusCode = 404;
+
+  constructor(
+    code: EnumStatusCode = EnumStatusCode.NOT_FOUND,
+    message: string = "Not Found"
+  ) {
+    super(message, code, 404);
+  }
+
+  serializeErrors(): ErrorResult {
+    return { code: this.code, message: this.message };
+  }
+}

package/src/errors/UnAuthorizedError.ts

@@ -0,0 +1,18 @@
+import { CustomError } from ".";
+import { EnumStatusCode } from "../enums";
+import { ErrorResult } from "../utils";
+
+export class UnAuthorizedError extends CustomError {
+  statusCode = 401;
+
+  constructor(
+    code: EnumStatusCode = EnumStatusCode.UNAUTHORIZED,
+    message: string = "Unauthorized"
+  ) {
+    super(message, code, 401);
+  }
+
+  serializeErrors(): ErrorResult {
+    return { code: this.code, message: this.message };
+  }
+}

package/src/errors/index.ts

@@ -0,0 +1,4 @@
+export * from "./BadRequestError";
+export * from "./CustomError";
+export * from "./NotFoundError";
+export * from "./UnAuthorizedError";

package/src/index.ts

@@ -0,0 +1,19 @@
+import "reflect-metadata";
+import { LoggedInUserTokenData } from "./interfaces";
+
+export * from "./errors";
+export * from "./middleware";
+export * from "./models";
+export * from "./dto/input";
+export * from "./dto/output";
+export * from "./utils";
+export * from "./config";
+export * from "./interfaces";
+
+declare global {
+  namespace Express {
+    interface Request {
+      currentUser?: LoggedInUserTokenData;
+    }
+  }
+}

package/src/interfaces/LoggedInUserToken.ts

@@ -0,0 +1,9 @@
+import { EnumUserRole } from "../enums";
+
+export interface LoggedInUserTokenData {
+  id: string;
+  email: string;
+  role: EnumUserRole;
+  //   doctorId?: string;
+  //   patientId?: string;
+}

package/src/interfaces/index.ts

@@ -0,0 +1 @@
+export * from "./LoggedInUserToken";

package/src/middleware/errorHandler.ts

@@ -0,0 +1,31 @@
+import { NextFunction, Request, Response } from "express";
+import { CustomError } from "../errors";
+import { EnumStatusCode } from "../enums";
+import { logger } from "../utils";
+
+export const errorHandler = (
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+): void => {
+  if (err instanceof CustomError) {
+    res.status(err.statusCode).json(err.serializeErrors());
+    return;
+  }
+
+  // Log the error with stack trace and request info
+  logger.error("Unhandled error", {
+    message: err.message,
+    stack: err.stack,
+    path: req.originalUrl,
+    method: req.method,
+    body: req.body,
+  });
+
+  console.error(err);
+  res.status(500).json({
+    code: EnumStatusCode.SOMETHING_WENT_WRONG,
+    message: "Internal Server Error",
+  });
+};

package/src/middleware/index.ts

@@ -0,0 +1,5 @@
+export * from "./errorHandler";
+export * from "./multer";
+export * from "./require-auth";
+export * from "./validate-request";
+export * from "./verify-roles";

package/src/middleware/multer.ts

@@ -0,0 +1,74 @@
+import multer from "multer";
+import { ErrorRequestHandler } from "express";
+import { BadRequestError } from "../errors";
+import { EnumStatusCode } from "../enums";
+
+// 5 MB file size limit
+const fileSize = 5 * 1024 * 1024;
+
+// Use memory storage since files are likely forwarded to S3
+const storage = multer.memoryStorage();
+
+const allowedTypes = [
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/bmp",
+  "image/webp",
+  "image/tiff",
+  "image/svg+xml",
+];
+
+// Base multer instance configured for images
+export const imageUpload = multer({
+  storage,
+  limits: { fileSize },
+  fileFilter(req, file, cb) {
+    if (!allowedTypes.includes(file.mimetype)) {
+      return cb(
+        new BadRequestError(
+          EnumStatusCode.FILE_TYPE_MISMATCH,
+          "Only image files are allowed!"
+        )
+      );
+    }
+    cb(null, true);
+  },
+});
+
+// Error transformer to convert Multer errors into our CustomError format
+export const transformMulterError: ErrorRequestHandler = (
+  err,
+  _req,
+  _res,
+  next
+) => {
+  // Multer throws MulterError for limits and other internal validations
+  if (err && (err as any).name === "MulterError") {
+    const multerErr = err as multer.MulterError;
+    if (multerErr.code === "LIMIT_FILE_SIZE") {
+      return next(
+        new BadRequestError(
+          EnumStatusCode.FILE_TOO_LARGE,
+          `File too large. Max ${Math.floor(fileSize / (1024 * 1024))}MB`
+        )
+      );
+    }
+    return next(
+      new BadRequestError(EnumStatusCode.BAD_REQUEST, multerErr.message)
+    );
+  }
+  // If it's already a CustomError or another error, pass it along
+  return next(err);
+};
+
+// Convenience helpers to use directly in routers
+export const uploadSingleImage = (fieldName: string) => [
+  imageUpload.single(fieldName),
+  transformMulterError,
+];
+
+export const uploadArrayImages = (fieldName: string, maxCount: number) => [
+  imageUpload.array(fieldName, maxCount),
+  transformMulterError,
+];

package/src/middleware/require-auth.ts

@@ -0,0 +1,46 @@
+import { Request, Response, NextFunction } from "express";
+import { EnumStatusCode } from "../enums";
+import { UnAuthorizedError } from "../errors";
+import { TokenUtils } from "../utils";
+
+export const requireAuth = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  const accessToken = req.header("Authorization")?.replace("Bearer ", "");
+
+  if (!accessToken) {
+    throw new UnAuthorizedError(
+      EnumStatusCode.NO_ACCESS_TOKEN,
+      "No access token"
+    );
+  }
+
+  try {
+    const decoded = TokenUtils.verifyAccessToken(accessToken);
+
+    if (!decoded) {
+      throw new UnAuthorizedError(
+        EnumStatusCode.CANNOT_DECODE_ACCESS_TOKEN,
+        "Cannot decode access token"
+      );
+    }
+
+    req.currentUser = decoded;
+
+    next();
+  } catch (error: any) {
+    if (error.name === "TokenExpiredError") {
+      throw new UnAuthorizedError(
+        EnumStatusCode.ACCESS_TOKEN_EXPIRED,
+        "Access token has expired."
+      );
+    } else {
+      throw new UnAuthorizedError(
+        EnumStatusCode.CANNOT_DECODE_ACCESS_TOKEN,
+        "Cannot decode access token"
+      );
+    }
+  }
+};

package/src/middleware/validate-request.ts

@@ -0,0 +1,40 @@
+import { plainToInstance } from "class-transformer";
+import { validate, ValidationError } from "class-validator";
+import { Request, Response, NextFunction, RequestHandler } from "express";
+import { BadRequestError } from "../errors";
+import { EnumStatusCode } from "../enums";
+
+export const validationMiddleware = (
+  type: any,
+  skipMissingProperties = false,
+  whitelist = true,
+  forbidNonWhitelisted = true
+): RequestHandler => {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const object = plainToInstance(type, req.body);
+      const errors = await validate(object, {
+        skipMissingProperties,
+        whitelist,
+        forbidNonWhitelisted,
+      });
+
+      if (errors.length > 0) {
+        const message = errors
+          .map((error: ValidationError) =>
+            Object.values(error.constraints ?? {})
+          )
+          .flat()
+          .join(", ");
+        return next(
+          new BadRequestError(EnumStatusCode.VALIDATION_ERROR, message)
+        );
+      }
+
+      req.body = object;
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+};

package/src/middleware/verify-roles.ts

@@ -0,0 +1,17 @@
+import { Request, Response, NextFunction } from "express";
+import { EnumUserRole } from "../enums/user-role";
+import { UnAuthorizedError } from "../errors";
+import { EnumStatusCode } from "../enums";
+
+export const verifyRoles = (roles: EnumUserRole[]) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    if (roles.includes(req.currentUser?.role as EnumUserRole)) {
+      next();
+    } else {
+      throw new UnAuthorizedError(
+        EnumStatusCode.NOT_ALLOWED,
+        "You are not allowed to perform this action."
+      );
+    }
+  };
+};

package/src/models/base.ts

@@ -0,0 +1,52 @@
+import { Schema, SchemaDefinition } from "mongoose";
+import { IUserDocument } from ".";
+
+export interface IBaseModel {
+  isDeleted: boolean;
+  createdAt: number;
+  updatedAt: number;
+  deletedAt?: number;
+  createdBy?: IUserDocument;
+  updatedBy?: IUserDocument;
+  deletedBy?: IUserDocument;
+}
+
+// Base Schema
+export const BaseSchemaFields: SchemaDefinition = {
+  isDeleted: { type: Boolean, default: false },
+  createdAt: { type: Number, required: true, default: Date.now() },
+  updatedAt: { type: Number, required: true },
+  deletedAt: { type: Number, required: false },
+  createdBy: {
+    type: Schema.Types.ObjectId,
+    ref: "User",
+    required: false,
+  },
+  updatedBy: {
+    type: Schema.Types.ObjectId,
+    ref: "User",
+    required: false,
+  },
+  deletedBy: {
+    type: Schema.Types.ObjectId,
+    ref: "User",
+    required: false,
+  },
+};
+
+export function BaseSchemaPlugin(schema: Schema) {
+  schema.add({
+    isDeleted: { type: Boolean, default: false },
+    createdAt: { type: Number, default: () => Date.now() },
+    updatedAt: { type: Number, default: () => Date.now() },
+    deletedAt: { type: Number },
+  });
+
+  schema.pre("save", function () {
+    this.updatedAt = Date.now();
+  });
+
+  schema.pre("findOneAndUpdate", function () {
+    this.set({ updatedAt: Date.now() });
+  });
+}

package/src/models/doctor.ts

@@ -0,0 +1,96 @@
+import { Schema, model, Document, Model } from "mongoose";
+import { ISpecialtyDocument, SpecialtyModel } from ".";
+import { IUserDocument, UserModel } from ".";
+import { BaseSchemaFields, BaseSchemaPlugin, IBaseModel } from ".";
+import { EducationSchema, IEducation } from ".";
+import { PositionSchema, IPosition } from ".";
+import { LanguageSchema, ILanguage } from ".";
+import { FaqSchema, IFaq } from ".";
+import { LocationSchema, ILocation } from ".";
+
+export interface IDoctor extends IBaseModel {
+  name: string;
+  slug: string;
+  isActive: boolean;
+  user: IUserDocument;
+  specialty: ISpecialtyDocument;
+  biography: string;
+  consultationFee: number;
+  isVerified: boolean;
+  isVisible: boolean;
+  isDeactivatedByAdmin: boolean;
+  photo?: string;
+  educations: IEducation[];
+  positions: IPosition[];
+  languages: ILanguage[];
+  faqs: IFaq[];
+  expertises: string[];
+  location?: ILocation;
+}
+
+export interface IDoctorDocument extends IDoctor, Document {}
+
+export interface IDoctorModel extends Model<IDoctorDocument> {}
+
+const DoctorSchema = new Schema<IDoctorDocument>({
+  ...BaseSchemaFields,
+  user: {
+    type: Schema.Types.ObjectId,
+    ref: UserModel,
+    required: true,
+    onDelete: "cascade",
+  },
+  specialty: {
+    type: Schema.Types.ObjectId,
+    ref: SpecialtyModel,
+    required: true,
+  },
+  name: { type: String, required: true, trim: true },
+  biography: { type: String, required: false },
+  slug: { type: String, required: true, unique: true, trim: true },
+  isActive: { type: Boolean, default: false },
+  consultationFee: { type: Number, required: false },
+  isVerified: { type: Boolean, default: false },
+  isVisible: { type: Boolean, default: true },
+  isDeactivatedByAdmin: { type: Boolean, default: false },
+  photo: { type: String, required: false },
+  educations: { type: [EducationSchema], required: true, default: [] },
+  positions: { type: [PositionSchema], required: true, default: [] },
+  languages: { type: [LanguageSchema], required: true, default: [] },
+  faqs: { type: [FaqSchema], required: true, default: [] },
+  expertises: { type: [String], required: true, default: [] },
+  location: { type: LocationSchema, required: false },
+});
+
+const createSlug = (text: string): string =>
+  text
+    .toLowerCase()
+    .trim()
+    .replace(/[\s\W-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+DoctorSchema.pre<IDoctorDocument>("validate", async function (next) {
+  // Only set slug if it hasn't been set before
+  if (this.slug) return next();
+
+  const baseSlug = createSlug(this.name);
+  let slug = baseSlug;
+  let counter = 0;
+
+  const Doctor = this.constructor as IDoctorModel;
+
+  while (await Doctor.exists({ slug })) {
+    counter += 1;
+    slug = `${baseSlug}-${counter}`;
+  }
+
+  this.slug = slug;
+  next();
+});
+
+DoctorSchema.plugin(BaseSchemaPlugin);
+
+export const DoctorModel = model<IDoctorDocument, IDoctorModel>(
+  "Doctor",
+  DoctorSchema
+);

package/src/models/education.ts

@@ -0,0 +1,14 @@
+import { Schema } from "mongoose";
+
+export interface IEducation {
+  year: number;
+  title: string;
+}
+
+export const EducationSchema = new Schema<IEducation>(
+  {
+    year: { type: Number, required: true },
+    title: { type: String, required: true, trim: true },
+  },
+  { _id: false }
+);

package/src/models/faq.ts

@@ -0,0 +1,14 @@
+import { Schema } from "mongoose";
+
+export interface IFaq {
+  title: string;
+  description: string;
+}
+
+export const FaqSchema = new Schema<IFaq>(
+  {
+    title: { type: String, required: true, trim: true },
+    description: { type: String, required: true, trim: true },
+  },
+  { _id: false }
+);