docta-package 1.0.2 → 1.1.0

package/build/enums/user-role.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumUserRole = void 0;
+var EnumUserRole;
+(function (EnumUserRole) {
+    EnumUserRole["PATIENT"] = "patient";
+    EnumUserRole["DOCTOR"] = "doctor";
+    EnumUserRole["ADMIN"] = "admin";
+})(EnumUserRole || (exports.EnumUserRole = EnumUserRole = {}));

package/build/errors/BadRequestError.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from ".";
+import { EnumStatusCode } from "../enums";
+import { ErrorResult } from "../utils";
+export declare class BadRequestError extends CustomError {
+    statusCode: number;
+    constructor(code?: EnumStatusCode, message?: string);
+    serializeErrors(): ErrorResult;
+}

package/build/errors/BadRequestError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = void 0;
+const _1 = require(".");
+const enums_1 = require("../enums");
+class BadRequestError extends _1.CustomError {
+    constructor(code = enums_1.EnumStatusCode.BAD_REQUEST, message = "Bad Request") {
+        super(message, code, 400);
+        this.statusCode = 400;
+    }
+    serializeErrors() {
+        return { code: this.code, message: this.message };
+    }
+}
+exports.BadRequestError = BadRequestError;

package/build/errors/CustomError.d.ts

@@ -0,0 +1,8 @@
+import { EnumStatusCode } from "../enums";
+import { ErrorResult } from "../utils";
+export declare abstract class CustomError extends Error {
+    readonly code: EnumStatusCode;
+    readonly statusCode: number;
+    constructor(message: string, code: EnumStatusCode, statusCode: number);
+    abstract serializeErrors(): ErrorResult;
+}

package/build/errors/CustomError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomError = void 0;
+class CustomError extends Error {
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        // Maintains proper prototype chain for built-in Error
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.CustomError = CustomError;

package/build/errors/NotFoundError.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from ".";
+import { EnumStatusCode } from "../enums";
+import { ErrorResult } from "../utils";
+export declare class NotFoundError extends CustomError {
+    statusCode: number;
+    constructor(code?: EnumStatusCode, message?: string);
+    serializeErrors(): ErrorResult;
+}

package/build/errors/NotFoundError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const _1 = require(".");
+const enums_1 = require("../enums");
+class NotFoundError extends _1.CustomError {
+    constructor(code = enums_1.EnumStatusCode.NOT_FOUND, message = "Not Found") {
+        super(message, code, 404);
+        this.statusCode = 404;
+    }
+    serializeErrors() {
+        return { code: this.code, message: this.message };
+    }
+}
+exports.NotFoundError = NotFoundError;

package/build/errors/UnAuthorizedError.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from ".";
+import { EnumStatusCode } from "../enums";
+import { ErrorResult } from "../utils";
+export declare class UnAuthorizedError extends CustomError {
+    statusCode: number;
+    constructor(code?: EnumStatusCode, message?: string);
+    serializeErrors(): ErrorResult;
+}

package/build/errors/UnAuthorizedError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnAuthorizedError = void 0;
+const _1 = require(".");
+const enums_1 = require("../enums");
+class UnAuthorizedError extends _1.CustomError {
+    constructor(code = enums_1.EnumStatusCode.UNAUTHORIZED, message = "Unauthorized") {
+        super(message, code, 401);
+        this.statusCode = 401;
+    }
+    serializeErrors() {
+        return { code: this.code, message: this.message };
+    }
+}
+exports.UnAuthorizedError = UnAuthorizedError;

package/build/errors/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BadRequestError"), exports);
+__exportStar(require("./CustomError"), exports);
+__exportStar(require("./NotFoundError"), exports);
+__exportStar(require("./UnAuthorizedError"), exports);

package/{src/index.ts → build/index.d.ts}

@@ -1,6 +1,5 @@
 import "reflect-metadata";
 import { LoggedInUserTokenData } from "./interfaces";
-
 export * from "./errors";
 export * from "./middleware";
 export * from "./models";
@@ -9,11 +8,10 @@ export * from "./dto/output";
 export * from "./utils";
 export * from "./config";
 export * from "./interfaces";
-
 declare global {
-  namespace Express {
-    interface Request {
-      currentUser?: LoggedInUserTokenData;
+    namespace Express {
+        interface Request {
+            currentUser?: LoggedInUserTokenData;
+        }
     }
-  }
 }

package/build/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+__exportStar(require("./errors"), exports);
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./dto/input"), exports);
+__exportStar(require("./dto/output"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./interfaces"), exports);

package/build/interfaces/LoggedInUserToken.d.ts

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

package/build/interfaces/LoggedInUserToken.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/interfaces/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LoggedInUserToken"), exports);

package/build/middleware/errorHandler.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const errorHandler: (err: Error, req: Request, res: Response, next: NextFunction) => void;

package/build/middleware/errorHandler.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const errors_1 = require("../errors");
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+const errorHandler = (err, req, res, next) => {
+    if (err instanceof errors_1.CustomError) {
+        res.status(err.statusCode).json(err.serializeErrors());
+        return;
+    }
+    // Log the error with stack trace and request info
+    utils_1.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: enums_1.EnumStatusCode.SOMETHING_WENT_WRONG,
+        message: "Internal Server Error",
+    });
+};
+exports.errorHandler = errorHandler;

package/build/middleware/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errorHandler"), exports);
+__exportStar(require("./multer"), exports);
+__exportStar(require("./require-auth"), exports);
+__exportStar(require("./validate-request"), exports);
+__exportStar(require("./verify-roles"), exports);

package/build/middleware/multer.d.ts

@@ -0,0 +1,6 @@
+import multer from "multer";
+import { ErrorRequestHandler } from "express";
+export declare const imageUpload: multer.Multer;
+export declare const transformMulterError: ErrorRequestHandler;
+export declare const uploadSingleImage: (fieldName: string) => (ErrorRequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>)[];
+export declare const uploadArrayImages: (fieldName: string, maxCount: number) => (ErrorRequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>)[];

package/build/middleware/multer.js

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

package/build/middleware/require-auth.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from "express";
+export declare const requireAuth: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middleware/require-auth.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAuth = void 0;
+const enums_1 = require("../enums");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+const requireAuth = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const accessToken = (_a = req.header("Authorization")) === null || _a === void 0 ? void 0 : _a.replace("Bearer ", "");
+    if (!accessToken) {
+        throw new errors_1.UnAuthorizedError(enums_1.EnumStatusCode.NO_ACCESS_TOKEN, "No access token");
+    }
+    try {
+        const decoded = utils_1.TokenUtils.verifyAccessToken(accessToken);
+        if (!decoded) {
+            throw new errors_1.UnAuthorizedError(enums_1.EnumStatusCode.CANNOT_DECODE_ACCESS_TOKEN, "Cannot decode access token");
+        }
+        req.currentUser = decoded;
+        next();
+    }
+    catch (error) {
+        if (error.name === "TokenExpiredError") {
+            throw new errors_1.UnAuthorizedError(enums_1.EnumStatusCode.ACCESS_TOKEN_EXPIRED, "Access token has expired.");
+        }
+        else {
+            throw new errors_1.UnAuthorizedError(enums_1.EnumStatusCode.CANNOT_DECODE_ACCESS_TOKEN, "Cannot decode access token");
+        }
+    }
+});
+exports.requireAuth = requireAuth;

package/build/middleware/validate-request.d.ts

@@ -0,0 +1,2 @@
+import { RequestHandler } from "express";
+export declare const validationMiddleware: (type: any, skipMissingProperties?: boolean, whitelist?: boolean, forbidNonWhitelisted?: boolean) => RequestHandler;

package/build/middleware/validate-request.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationMiddleware = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const errors_1 = require("../errors");
+const enums_1 = require("../enums");
+const validationMiddleware = (type, skipMissingProperties = false, whitelist = true, forbidNonWhitelisted = true) => {
+    return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const object = (0, class_transformer_1.plainToInstance)(type, req.body);
+            const errors = yield (0, class_validator_1.validate)(object, {
+                skipMissingProperties,
+                whitelist,
+                forbidNonWhitelisted,
+            });
+            if (errors.length > 0) {
+                const message = errors
+                    .map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); })
+                    .flat()
+                    .join(", ");
+                return next(new errors_1.BadRequestError(enums_1.EnumStatusCode.VALIDATION_ERROR, message));
+            }
+            req.body = object;
+            next();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+};
+exports.validationMiddleware = validationMiddleware;

package/build/middleware/verify-roles.d.ts

@@ -0,0 +1,3 @@
+import { Request, Response, NextFunction } from "express";
+import { EnumUserRole } from "../enums/user-role";
+export declare const verifyRoles: (roles: EnumUserRole[]) => (req: Request, res: Response, next: NextFunction) => void;

package/build/middleware/verify-roles.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyRoles = void 0;
+const errors_1 = require("../errors");
+const enums_1 = require("../enums");
+const verifyRoles = (roles) => {
+    return (req, res, next) => {
+        var _a;
+        if (roles.includes((_a = req.currentUser) === null || _a === void 0 ? void 0 : _a.role)) {
+            next();
+        }
+        else {
+            throw new errors_1.UnAuthorizedError(enums_1.EnumStatusCode.NOT_ALLOWED, "You are not allowed to perform this action.");
+        }
+    };
+};
+exports.verifyRoles = verifyRoles;

package/build/models/base.d.ts

@@ -0,0 +1,13 @@
+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;
+}
+export declare const BaseSchemaFields: SchemaDefinition;
+export declare function BaseSchemaPlugin(schema: Schema): void;

package/build/models/base.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSchemaFields = void 0;
+exports.BaseSchemaPlugin = BaseSchemaPlugin;
+const mongoose_1 = require("mongoose");
+// Base Schema
+exports.BaseSchemaFields = {
+    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: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: false,
+    },
+    updatedBy: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: false,
+    },
+    deletedBy: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: false,
+    },
+};
+function BaseSchemaPlugin(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/build/models/doctor.d.ts

@@ -0,0 +1,33 @@
+import { Document, Model } from "mongoose";
+import { ISpecialtyDocument } from ".";
+import { IUserDocument } from ".";
+import { IBaseModel } from ".";
+import { IEducation } from ".";
+import { IPosition } from ".";
+import { ILanguage } from ".";
+import { IFaq } from ".";
+import { 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> {
+}
+export declare const DoctorModel: IDoctorModel;

package/build/models/doctor.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoctorModel = void 0;
+const mongoose_1 = require("mongoose");
+const _1 = require(".");
+const _2 = require(".");
+const _3 = require(".");
+const _4 = require(".");
+const _5 = require(".");
+const _6 = require(".");
+const _7 = require(".");
+const _8 = require(".");
+const DoctorSchema = new mongoose_1.Schema(Object.assign(Object.assign({}, _3.BaseSchemaFields), { user: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: _2.UserModel,
+        required: true,
+        onDelete: "cascade",
+    }, specialty: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: _1.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: [_4.EducationSchema], required: true, default: [] }, positions: { type: [_5.PositionSchema], required: true, default: [] }, languages: { type: [_6.LanguageSchema], required: true, default: [] }, faqs: { type: [_7.FaqSchema], required: true, default: [] }, expertises: { type: [String], required: true, default: [] }, location: { type: _8.LocationSchema, required: false } }));
+const createSlug = (text) => text
+    .toLowerCase()
+    .trim()
+    .replace(/[\s\W-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+DoctorSchema.pre("validate", function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 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;
+        while (yield Doctor.exists({ slug })) {
+            counter += 1;
+            slug = `${baseSlug}-${counter}`;
+        }
+        this.slug = slug;
+        next();
+    });
+});
+DoctorSchema.plugin(_3.BaseSchemaPlugin);
+exports.DoctorModel = (0, mongoose_1.model)("Doctor", DoctorSchema);

package/build/models/education.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from "mongoose";
+export interface IEducation {
+    year: number;
+    title: string;
+}
+export declare const EducationSchema: Schema<IEducation, import("mongoose").Model<IEducation, any, any, any, import("mongoose").Document<unknown, any, IEducation, any, {}> & IEducation & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IEducation, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IEducation>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<IEducation> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/build/models/education.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EducationSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.EducationSchema = new mongoose_1.Schema({
+    year: { type: Number, required: true },
+    title: { type: String, required: true, trim: true },
+}, { _id: false });

package/build/models/faq.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from "mongoose";
+export interface IFaq {
+    title: string;
+    description: string;
+}
+export declare const FaqSchema: Schema<IFaq, import("mongoose").Model<IFaq, any, any, any, import("mongoose").Document<unknown, any, IFaq, any, {}> & IFaq & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IFaq, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IFaq>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<IFaq> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/build/models/faq.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaqSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.FaqSchema = new mongoose_1.Schema({
+    title: { type: String, required: true, trim: true },
+    description: { type: String, required: true, trim: true },
+}, { _id: false });