docta-package 1.0.2 → 1.2.0

package/src/enums/language-levels.ts

@@ -1,9 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

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

package/src/errors/BadRequestError.ts

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/interfaces/LoggedInUserToken.ts

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

package/src/middleware/errorHandler.ts

@@ -1,31 +0,0 @@
-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/multer.ts

@@ -1,74 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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 }
-);

package/src/models/language.ts

@@ -1,20 +0,0 @@
-import { Schema } from "mongoose";
-import { EnumLanguageLevel } from "../enums";
-
-export interface ILanguage {
-  title: string;
-  level: EnumLanguageLevel;
-}
-
-export const LanguageSchema = new Schema<ILanguage>(
-  {
-    title: { type: String, required: true, trim: true },
-    level: {
-      type: String,
-      enum: Object.values(EnumLanguageLevel),
-      required: true,
-      trim: true,
-    },
-  },
-  { _id: false }
-);

package/src/models/patient.ts

@@ -1,35 +0,0 @@
-import { Schema, model, Document, Model } from "mongoose";
-import { IUserDocument, UserModel } from ".";
-import { BaseSchemaFields, BaseSchemaPlugin, IBaseModel } from ".";
-import { Gender } from "../enums";
-
-export interface IPatient extends IBaseModel {
-  user: IUserDocument;
-  dob?: number;
-  gender?: Gender;
-  phoneNumber?: string;
-}
-
-export interface IPatientDocument extends IPatient, Document {}
-
-export interface IPatientModel extends Model<IPatientDocument> {}
-
-const PatientSchema = new Schema<IPatientDocument>({
-  ...BaseSchemaFields,
-  user: {
-    type: Schema.Types.ObjectId,
-    ref: UserModel.modelName,
-    required: true,
-    onDelete: "cascade",
-  },
-  dob: { type: Number, required: false },
-  phoneNumber: { type: String, required: false },
-  gender: { type: String, enum: Object.values(Gender), required: false },
-});
-
-PatientSchema.plugin(BaseSchemaPlugin);
-
-export const PatientModel = model<IPatientDocument, IPatientModel>(
-  "Patient",
-  PatientSchema
-);

package/src/models/position.ts

@@ -1,19 +0,0 @@
-import { Schema } from "mongoose";
-
-export interface IPosition {
-  startDate: number; // timestamp (ms)
-  endDate?: number; // timestamp (ms), optional
-  title: string;
-  company: string;
-}
-
-export const PositionSchema = new Schema<IPosition>(
-  {
-    startDate: { type: Number, required: true },
-    endDate: { type: Number, required: false },
-    title: { type: String, required: true, trim: true },
-    company: { type: String, required: true, trim: true },
-  },
-  { _id: false }
-);
-

package/src/models/specialty.ts

@@ -1,37 +0,0 @@
-import { Schema, model, Document, Model } from "mongoose";
-import { BaseSchemaFields, BaseSchemaPlugin, IBaseModel } from ".";
-
-export interface ILocalizedSpecialtyFields {
-  name: string;
-  description?: string | null;
-}
-
-export interface ISpecialty extends IBaseModel {
-  en: ILocalizedSpecialtyFields;
-  fr?: ILocalizedSpecialtyFields;
-}
-
-export interface ISpecialtyDocument extends ISpecialty, Document {}
-
-export interface ISpecialtyModel extends Model<ISpecialtyDocument> {}
-
-const LocalizedFieldsSchema = new Schema<ILocalizedSpecialtyFields>(
-  {
-    name: { type: String, required: true },
-    description: { type: String, default: null },
-  },
-  { _id: false }
-);
-
-const SpecialtySchema = new Schema<ISpecialtyDocument>({
-  ...BaseSchemaFields,
-  en: { type: LocalizedFieldsSchema, required: true },
-  fr: { type: LocalizedFieldsSchema, required: false, default: null },
-});
-
-SpecialtySchema.plugin(BaseSchemaPlugin);
-
-export const SpecialtyModel = model<ISpecialtyDocument, ISpecialtyModel>(
-  "Specialty",
-  SpecialtySchema
-);