@goweekdays/core 0.0.1

package/dist/index.js

@@ -0,0 +1,4580 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ACCESS_TOKEN_EXPIRY: () => ACCESS_TOKEN_EXPIRY,
+  ACCESS_TOKEN_SECRET: () => ACCESS_TOKEN_SECRET,
+  APP_ACCOUNT: () => APP_ACCOUNT,
+  AppError: () => AppError,
+  BadRequestError: () => BadRequestError,
+  DEFAULT_USER_EMAIL: () => DEFAULT_USER_EMAIL,
+  DEFAULT_USER_FIRST_NAME: () => DEFAULT_USER_FIRST_NAME,
+  DEFAULT_USER_LAST_NAME: () => DEFAULT_USER_LAST_NAME,
+  DEFAULT_USER_PASSWORD: () => DEFAULT_USER_PASSWORD,
+  InternalServerError: () => InternalServerError,
+  MAILER_EMAIL: () => MAILER_EMAIL,
+  MAILER_PASSWORD: () => MAILER_PASSWORD,
+  MAILER_TRANSPORT_HOST: () => MAILER_TRANSPORT_HOST,
+  MAILER_TRANSPORT_PORT: () => MAILER_TRANSPORT_PORT,
+  MAILER_TRANSPORT_SECURE: () => MAILER_TRANSPORT_SECURE,
+  MCapBldgAct: () => MCapBldgAct,
+  MComment: () => MComment,
+  MEntity: () => MEntity,
+  MFile: () => MFile,
+  MONGO_DB: () => MONGO_DB,
+  MONGO_URI: () => MONGO_URI,
+  MRole: () => MRole,
+  MToken: () => MToken,
+  MUser: () => MUser,
+  MUserRole: () => MUserRole,
+  MVerification: () => MVerification,
+  MWorkflow: () => MWorkflow,
+  NotFoundError: () => NotFoundError,
+  PORT: () => PORT,
+  REDIS_HOST: () => REDIS_HOST,
+  REDIS_PASSWORD: () => REDIS_PASSWORD,
+  REDIS_PORT: () => REDIS_PORT,
+  REFRESH_TOKEN_EXPIRY: () => REFRESH_TOKEN_EXPIRY,
+  REFRESH_TOKEN_SECRET: () => REFRESH_TOKEN_SECRET,
+  SECRET_KEY: () => SECRET_KEY,
+  SPACES_ACCESS_KEY: () => SPACES_ACCESS_KEY,
+  SPACES_BUCKET: () => SPACES_BUCKET,
+  SPACES_ENDPOINT: () => SPACES_ENDPOINT,
+  SPACES_REGION: () => SPACES_REGION,
+  SPACES_SECRET_KEY: () => SPACES_SECRET_KEY,
+  UnauthorizedError: () => UnauthorizedError,
+  VERIFICATION_FORGET_PASSWORD_DURATION: () => VERIFICATION_FORGET_PASSWORD_DURATION,
+  VERIFICATION_USER_INVITE_DURATION: () => VERIFICATION_USER_INVITE_DURATION,
+  authMiddleware: () => authMiddleware,
+  comparePassword: () => comparePassword,
+  compileHandlebar: () => compileHandlebar,
+  errorHandler: () => errorHandler,
+  generateToken: () => generateToken,
+  getDirectory: () => getDirectory,
+  hashPassword: () => hashPassword,
+  initRedisClient: () => initRedisClient,
+  isDev: () => isDev,
+  logger: () => logger,
+  paginate: () => paginate,
+  prependZeros: () => prependZeros,
+  toObjectId: () => toObjectId,
+  useAtlas: () => useAtlas,
+  useAuthController: () => useAuthController,
+  useAuthService: () => useAuthService,
+  useCapBldgActController: () => useCapBldgActController,
+  useCapBldgActRepo: () => useCapBldgActRepo,
+  useCapBldgActService: () => useCapBldgActService,
+  useCommentController: () => useCommentController,
+  useCommentRepo: () => useCommentRepo,
+  useCommentService: () => useCommentService,
+  useEntityController: () => useEntityController,
+  useEntityRepo: () => useEntityRepo,
+  useEntityService: () => useEntityService,
+  useFileController: () => useFileController,
+  useFileRepo: () => useFileRepo,
+  useFileService: () => useFileService,
+  useMailer: () => useMailer,
+  useRedisClient: () => useRedisClient,
+  useRoleController: () => useRoleController,
+  useRoleRepo: () => useRoleRepo,
+  useRoleService: () => useRoleService,
+  useS3: () => useS3,
+  useTokenRepo: () => useTokenRepo,
+  useUserController: () => useUserController,
+  useUserRepo: () => useUserRepo,
+  useUserService: () => useUserService,
+  useVerificationController: () => useVerificationController,
+  useVerificationRepo: () => useVerificationRepo,
+  useVerificationService: () => useVerificationService,
+  useWorkflowController: () => useWorkflowController,
+  useWorkflowRepo: () => useWorkflowRepo,
+  useWorkflowService: () => useWorkflowService
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils/error.ts
+var AppError = class extends Error {
+  constructor(message, statusCode, isOperational = true) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    Error.captureStackTrace(this);
+  }
+};
+var BadRequestError = class extends AppError {
+  constructor(message = "Bad Request") {
+    super(message, 400);
+  }
+};
+var UnauthorizedError = class extends AppError {
+  constructor(message = "Unauthorized") {
+    super(message, 401);
+  }
+};
+var NotFoundError = class extends AppError {
+  constructor(message = "Not Found") {
+    super(message, 404);
+  }
+};
+var InternalServerError = class extends AppError {
+  constructor(message = "Internal Server Error") {
+    super(message, 500);
+  }
+};
+
+// src/utils/logger.ts
+var winston = __toESM(require("winston"));
+var logger = winston.createLogger({
+  level: "info",
+  format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
+  transports: [
+    // File transport (optional)
+    new winston.transports.File({ filename: "error.log", level: "error" }),
+    new winston.transports.File({ filename: "combined.log" })
+  ]
+});
+
+// src/utils/errorHandler.middleware.ts
+var errorHandler = (err, req, res, next) => {
+  if (err.isOperational) {
+    res.status(err.statusCode).json({
+      status: "error",
+      message: err.message
+    });
+    return;
+  } else {
+    logger.log({ level: "error", message: err.message });
+    res.status(500).json({
+      status: "error",
+      message: "Internal Server Error"
+    });
+    return;
+  }
+};
+
+// src/utils/authorization.middleware.ts
+var import_jsonwebtoken = __toESM(require("jsonwebtoken"));
+function authMiddleware(access_token_secret = "") {
+  return (req, res, next) => {
+    if (!access_token_secret) {
+      res.status(401).json({ message: "Access token secret is required" });
+      return;
+    }
+    const authorization = req.headers["authorization"];
+    const token = authorization && authorization.split(" ")[1];
+    if (!token) {
+      res.status(401).json({ message: "Unauthorized" });
+      return;
+    }
+    import_jsonwebtoken.default.verify(token, access_token_secret, (err, user) => {
+      if (err) {
+        res.status(401).json({ message: "Authorization token expired" });
+        return;
+      }
+      req.headers["user"] = user.user;
+      next();
+    });
+  };
+}
+
+// src/utils/hash-password.ts
+var import_bcrypt = __toESM(require("bcrypt"));
+var saltRounds = 10;
+function hashPassword(password) {
+  return __async(this, null, function* () {
+    try {
+      return yield import_bcrypt.default.hash(password, saltRounds);
+    } catch (error) {
+      throw new Error("Failed to hash password.");
+    }
+  });
+}
+
+// src/utils/compare-password.ts
+var import_bcrypt2 = __toESM(require("bcrypt"));
+function comparePassword(password, hashedPassword) {
+  return __async(this, null, function* () {
+    return new Promise((resolve) => {
+      import_bcrypt2.default.compare(password, hashedPassword, (err, result) => {
+        if (err) {
+          resolve(false);
+        }
+        resolve(result);
+      });
+    });
+  });
+}
+
+// src/utils/mailer.ts
+var import_nodemailer = require("nodemailer");
+var useMailer = class {
+  constructor(config2) {
+    this.config = config2;
+    this.transporter = (0, import_nodemailer.createTransport)({
+      host: config2.host,
+      port: config2.port,
+      secure: config2.secure,
+      auth: {
+        user: config2.email,
+        pass: config2.password
+      }
+    });
+  }
+  sendMail(_0) {
+    return __async(this, arguments, function* ({
+      to,
+      subject,
+      text,
+      html,
+      sender
+    }) {
+      const mailOptions = {
+        from: sender ? `${sender} <${this.config.email}>` : this.config.email,
+        to,
+        subject
+      };
+      if (text) {
+        mailOptions.text = text;
+      }
+      if (html) {
+        mailOptions.html = html;
+      }
+      try {
+        yield this.transporter.sendMail(mailOptions);
+        return "Email sent successfully";
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+};
+
+// src/utils/generate-token.ts
+var import_jsonwebtoken2 = __toESM(require("jsonwebtoken"));
+function generateToken({ metadata = {}, secret = "", options = {} } = {}) {
+  if (!secret)
+    throw new Error("Missing secret.");
+  return import_jsonwebtoken2.default.sign(metadata, secret, options);
+}
+
+// src/utils/paginate.ts
+function paginate(items, page = 0, limit = 10, length) {
+  if (length === 0) {
+    return {
+      items: [],
+      pages: 0,
+      pageRange: `0-0 of 0`
+    };
+  }
+  const startIndex = page * limit + 1;
+  const endIndex = Math.min(startIndex + limit - 1, length);
+  return {
+    items,
+    pages: Math.ceil(length / limit),
+    pageRange: `${startIndex}-${endIndex} of ${length}`
+  };
+}
+
+// src/utils/redis.ts
+var import_redis = require("redis");
+
+// src/config.ts
+var dotenv = __toESM(require("dotenv"));
+dotenv.config();
+var MONGO_URI = process.env.MONGO_URI || "mongodb://localhost:27017";
+var MONGO_DB = process.env.MONGO_DB || "default";
+var PORT = Number(process.env.PORT || 3001);
+var SECRET_KEY = process.env.SECRET_KEY;
+var isDev = process.env.NODE_ENV !== "production";
+var MAILER_TRANSPORT_HOST = process.env.MAILER_TRANSPORT_HOST;
+var MAILER_TRANSPORT_PORT = Number(
+  process.env.MAILER_TRANSPORT_PORT || 465
+);
+var MAILER_TRANSPORT_SECURE = process.env.MAILER_TRANSPORT_SECURE === "true";
+var MAILER_EMAIL = process.env.MAILER_EMAIL;
+var MAILER_PASSWORD = process.env.MAILER_PASSWORD;
+var ACCESS_TOKEN_SECRET = process.env.ACCESS_TOKEN_SECRET || "access_token_secret";
+var REFRESH_TOKEN_SECRET = process.env.REFRESH_TOKEN_SECRET || "refresh_token_secret";
+var ACCESS_TOKEN_EXPIRY = process.env.ACCESS_TOKEN_EXPIRY || "15s";
+var REFRESH_TOKEN_EXPIRY = process.env.REFRESH_TOKEN_EXPIRY || "30d";
+var APP_ACCOUNT = process.env.APP_ACCOUNT || "http://localhost:3000";
+var VERIFICATION_FORGET_PASSWORD_DURATION = process.env.VERIFICATION_FORGET_PASSWORD_DURATION || "10 minutes";
+var VERIFICATION_USER_INVITE_DURATION = process.env.VERIFICATION_USER_INVITE_DURATION || "3 days";
+var REDIS_HOST = process.env.REDIS_HOST;
+var REDIS_PORT = Number(process.env.REDIS_PORT || 6379);
+var REDIS_PASSWORD = process.env.REDIS_PASSWORD;
+var DEFAULT_USER_EMAIL = process.env.DEFAULT_USER_EMAIL;
+var DEFAULT_USER_PASSWORD = process.env.DEFAULT_USER_PASSWORD;
+var DEFAULT_USER_FIRST_NAME = process.env.DEFAULT_USER_FIRST_NAME;
+var DEFAULT_USER_LAST_NAME = process.env.DEFAULT_USER_LAST_NAME;
+var SPACES_ACCESS_KEY = process.env.SPACES_ACCESS_KEY;
+var SPACES_SECRET_KEY = process.env.SPACES_SECRET_KEY;
+var SPACES_ENDPOINT = process.env.SPACES_ENDPOINT;
+var SPACES_REGION = process.env.SPACES_REGION;
+var SPACES_BUCKET = process.env.SPACES_BUCKET;
+
+// src/utils/redis.ts
+var redisClient;
+function initRedisClient() {
+  return __async(this, null, function* () {
+    redisClient = yield (0, import_redis.createClient)({
+      password: REDIS_PASSWORD,
+      socket: {
+        host: REDIS_HOST,
+        port: REDIS_PORT
+      }
+    });
+  });
+}
+function useRedisClient() {
+  return redisClient;
+}
+
+// src/utils/compile-handlebar.ts
+var import_handlebars = __toESM(require("handlebars"));
+var import_fs = __toESM(require("fs"));
+function compileHandlebar({ context = {}, filePath = "" } = {}) {
+  const templateSource = import_fs.default.readFileSync(filePath, "utf8");
+  const template = import_handlebars.default.compile(templateSource);
+  return template(context);
+}
+
+// src/utils/get-directory.ts
+var import_path = __toESM(require("path"));
+function getDirectory(directory, filePath) {
+  return import_path.default.resolve(directory, `${filePath}.hbs`);
+}
+
+// src/utils/s3.ts
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_stream = require("stream");
+var useS3 = class {
+  constructor(config2) {
+    this.config = config2;
+    this.client = new import_client_s3.S3Client({
+      endpoint: config2.endpoint,
+      region: config2.region,
+      credentials: {
+        accessKeyId: config2.accessKeyId,
+        secretAccessKey: config2.secretAccessKey
+      },
+      forcePathStyle: false
+      // Optional, based on usage
+    });
+  }
+  uploadObject(_0) {
+    return __async(this, arguments, function* ({
+      key,
+      body,
+      metadata = {},
+      contentType
+    }) {
+      const buffer = import_stream.Readable.from(body);
+      try {
+        yield this.client.send(new import_client_s3.PutObjectCommand({
+          Bucket: this.config.bucket,
+          Key: key,
+          Body: buffer,
+          ACL: "public-read",
+          Metadata: metadata,
+          ContentType: contentType,
+          ContentLength: Buffer.byteLength(body)
+        }));
+        return "Successfully uploaded file.";
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+  deleteObject(key = "") {
+    return __async(this, null, function* () {
+      try {
+        yield this.client.send(new import_client_s3.DeleteObjectCommand({ Key: key, Bucket: this.config.bucket }));
+        return "Successfully deleted file.";
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+};
+
+// src/utils/atlas.ts
+var import_mongodb = require("mongodb");
+var useAtlas = class {
+  // Initialize the MongoDB connection with the provided config
+  static initialize(config2) {
+    return __async(this, null, function* () {
+      if (this.client) {
+        console.warn(`Client is already initialized. Skipping initialization.`);
+        return;
+      }
+      const { uri, db } = config2;
+      this.client = new import_mongodb.MongoClient(uri, { maxPoolSize: 10, maxIdleTimeMS: 6e4, connectTimeoutMS: 6e4 });
+      try {
+        yield this.client.connect();
+        this.database = this.client.db(db);
+        console.log(`Connected to database "${db}".`);
+      } catch (error) {
+        this.client = null;
+        throw error;
+      }
+    });
+  }
+  // Get the MongoDB client
+  static getClient() {
+    return this.client;
+  }
+  // Get the database
+  static getDb() {
+    return this.database;
+  }
+  // Close the connection
+  static close() {
+    return __async(this, null, function* () {
+      if (this.client) {
+        yield this.client.close();
+        this.client = null;
+        this.database = null;
+        console.log(`Closed connection to the database.`);
+      } else {
+        console.warn(`No client is currently initialized.`);
+      }
+    });
+  }
+};
+useAtlas.client = null;
+useAtlas.database = null;
+
+// src/utils/prepend-zero.ts
+function prependZeros(value, length = 6) {
+  let numberStr = value.toString();
+  let numZeros = Math.max(0, length - numberStr.length);
+  return numberStr.padStart(numZeros + numberStr.length, "0");
+}
+
+// src/utils/to-object-id.ts
+var import_mongodb2 = require("mongodb");
+function toObjectId(value) {
+  if (!value) {
+    throw new BadRequestError("Valid is required.");
+  }
+  const instanceOfObjectId = value instanceof import_mongodb2.ObjectId;
+  if (!instanceOfObjectId) {
+    const isValidHex = /^[0-9a-fA-F]{24}$/.test(value);
+    if (!isValidHex) {
+      throw new BadRequestError("Invalid value, expecting a hex value.");
+    }
+  }
+  try {
+    return new import_mongodb2.ObjectId(value);
+  } catch (error) {
+    throw new BadRequestError("Invalid ID.");
+  }
+}
+
+// src/models/verification.model.ts
+var import_mongodb3 = require("mongodb");
+var MVerification = class {
+  constructor(value) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    this._id = (_a = value._id) != null ? _a : new import_mongodb3.ObjectId();
+    this.type = (_b = value.type) != null ? _b : "";
+    this.email = (_c = value.email) != null ? _c : "";
+    this.metadata = (_d = value.metadata) != null ? _d : {};
+    this.status = (_e = value.status) != null ? _e : "pending";
+    this.createdAt = (_f = value.createdAt) != null ? _f : /* @__PURE__ */ new Date();
+    this.updatedAt = (_g = value.updatedAt) != null ? _g : null;
+    this.expireAt = (_h = value.expireAt) != null ? _h : new Date(Date.now() + 3600 * 1e3);
+  }
+};
+
+// src/repositories/verification.repository.ts
+var import_utils = require("@goweekdays/utils");
+var import_mongodb4 = require("mongodb");
+function useVerificationRepo() {
+  const db = import_utils.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("verifications");
+  function createTextIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({
+          email: "text"
+        });
+      } catch (error) {
+        throw new Error("Failed to create text index on email.");
+      }
+    });
+  }
+  function add(value, session) {
+    return __async(this, null, function* () {
+      value = new MVerification(value);
+      try {
+        const res = yield collection.insertOne(value, { session });
+        return res.insertedId;
+      } catch (error) {
+        import_utils.logger.log({
+          level: "info",
+          message: String(error)
+        });
+        throw new import_utils.InternalServerError("Server internal error.");
+      }
+    });
+  }
+  function getById(_id) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb4.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils.BadRequestError("Invalid ID.");
+      }
+      try {
+        return yield collection.findOne({ _id });
+      } catch (error) {
+        throw new import_utils.InternalServerError(
+          "Internal server error, failed to retrieve verification."
+        );
+      }
+    });
+  }
+  function getVerifications() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      limit = 10,
+      sort = {},
+      status = "active",
+      type = ""
+    } = {}) {
+      page = page > 0 ? page - 1 : 0;
+      const query = { status };
+      sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+      if (search) {
+        query.$text = { $search: search };
+      }
+      if (type) {
+        query.type = type;
+      }
+      try {
+        const items = yield collection.aggregate([
+          { $match: query },
+          { $sort: sort },
+          { $skip: page * limit },
+          { $limit: limit },
+          {
+            $project: {
+              _id: 1,
+              createdAt: 1,
+              email: 1,
+              type: 1,
+              metadata: 1,
+              status: 1
+            }
+          }
+        ]).toArray();
+        const length = yield collection.countDocuments(query);
+        return (0, import_utils.paginate)(items, page, limit, length);
+      } catch (error) {
+        import_utils.logger.log({ level: "error", message: `${error}` });
+        throw error;
+      }
+    });
+  }
+  function getByIdByType(type) {
+    return __async(this, null, function* () {
+      try {
+        return yield collection.find({ type }).toArray();
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+  function updateStatusById(_id, status, session) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb4.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils.BadRequestError("Invalid ID.");
+      }
+      try {
+        return yield collection.updateOne(
+          { _id },
+          { $set: { status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+          { session }
+        );
+      } catch (error) {
+        throw new import_utils.InternalServerError("Error updating verification status.");
+      }
+    });
+  }
+  return {
+    createTextIndex,
+    add,
+    getVerifications,
+    getById,
+    getByIdByType,
+    updateStatusById
+  };
+}
+
+// src/services/verification.service.ts
+var import_utils4 = require("@goweekdays/utils");
+
+// src/repositories/user.repository.ts
+var import_mongodb6 = require("mongodb");
+
+// src/models/user.model.ts
+var import_mongodb5 = require("mongodb");
+var import_utils2 = require("@goweekdays/utils");
+var MUserRole = class {
+  constructor(value) {
+    var _a, _b, _c, _d;
+    this.name = (_a = value.name) != null ? _a : "";
+    this.app = (_b = value.app) != null ? _b : "";
+    this.role = (_c = value.role) != null ? _c : "";
+    this.status = (_d = value.status) != null ? _d : "active";
+  }
+};
+var MUser = class {
+  constructor(value) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
+    this._id = (_a = value._id) != null ? _a : new import_mongodb5.ObjectId();
+    this.email = (_b = value.email) != null ? _b : "";
+    this.password = (_c = value.password) != null ? _c : "";
+    this.prefix = (_d = value.prefix) != null ? _d : "";
+    this.firstName = (_e = value.firstName) != null ? _e : "";
+    this.middleName = (_f = value.middleName) != null ? _f : "";
+    this.lastName = (_g = value.lastName) != null ? _g : "";
+    this.suffix = (_h = value.suffix) != null ? _h : "";
+    this.birthMonth = (_i = value.birthMonth) != null ? _i : "";
+    this.birthDay = (_j = value.birthDay) != null ? _j : 0;
+    this.birthYear = (_k = value.birthYear) != null ? _k : 0;
+    this.gender = (_l = value.gender) != null ? _l : "";
+    this.type = (_m = value.type) != null ? _m : "";
+    this.roles = (_n = value.roles) != null ? _n : [];
+    if (value.roles && value.roles.length) {
+      value.roles.forEach((role) => {
+        var _a2;
+        try {
+          role.role = new import_mongodb5.ObjectId(role.role);
+        } catch (error) {
+          throw new import_utils2.BadRequestError("Invalid role ID.");
+        }
+        if (!role.app) {
+          throw new import_utils2.BadRequestError("App is required.");
+        }
+        if (!role.name) {
+          throw new import_utils2.BadRequestError("Name is required.");
+        }
+        role.status = (_a2 = role.status) != null ? _a2 : "active";
+      });
+    }
+    this.roles = (_o = value.roles) != null ? _o : [];
+    this.status = (_p = value.status) != null ? _p : "";
+    this.createdAt = (_q = value.createdAt) != null ? _q : (/* @__PURE__ */ new Date()).toISOString();
+    this.updatedAt = (_r = value.updatedAt) != null ? _r : "";
+    this.deletedAt = (_s = value.deletedAt) != null ? _s : "";
+  }
+};
+
+// src/repositories/user.repository.ts
+var import_utils3 = require("@goweekdays/utils");
+function useUserRepo() {
+  const db = import_utils3.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils3.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("users");
+  function createTextIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({
+          firstName: "text",
+          middleName: "text",
+          lastName: "text",
+          email: "text"
+        });
+      } catch (error) {
+        throw new Error("Failed to create text index on email.");
+      }
+    });
+  }
+  function createUniqueIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex(
+          { email: 1, deletedAt: 1 },
+          { unique: true }
+        );
+      } catch (error) {
+        throw new Error("Failed to create unique index on email.");
+      }
+    });
+  }
+  function createUser(value, session) {
+    return __async(this, null, function* () {
+      try {
+        value = new MUser(value);
+        const res = yield collection.insertOne(value, { session });
+        return res.insertedId;
+      } catch (error) {
+        import_utils3.logger.log({ level: "error", message: `${error}` });
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_utils3.BadRequestError("Item name already exists");
+        }
+        throw new import_utils3.InternalServerError("Internal server error.");
+      }
+    });
+  }
+  function getUserByEmail(email) {
+    return __async(this, null, function* () {
+      try {
+        return yield collection.findOne({ email });
+      } catch (error) {
+        throw new Error("Failed to get user by email.");
+      }
+    });
+  }
+  function getByEmailApp(email, app) {
+    return __async(this, null, function* () {
+      try {
+        return yield collection.findOne({ email, "roles.app": app });
+      } catch (error) {
+        throw new Error("Failed to get user by email.");
+      }
+    });
+  }
+  function getUserById(_id) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb6.ObjectId(_id);
+      } catch (error) {
+        throw new Error("Invalid user ID.");
+      }
+      try {
+        return yield collection.findOne({ _id });
+      } catch (error) {
+        throw new Error("Failed to get user by email.");
+      }
+    });
+  }
+  function getUsers() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      limit = 10,
+      sort = {},
+      status = "active",
+      type = ""
+    } = {}) {
+      page = page > 0 ? page - 1 : 0;
+      const query = { status };
+      sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+      if (search) {
+        query.$text = { $search: search };
+      }
+      if (type) {
+        query.type = type;
+      }
+      try {
+        const items = yield collection.aggregate([
+          { $match: query },
+          { $sort: sort },
+          { $skip: page * limit },
+          { $limit: limit },
+          {
+            $project: {
+              _id: 1,
+              name: {
+                $concat: ["$firstName", " ", "$lastName"]
+              },
+              email: 1,
+              type: 1,
+              status: 1
+            }
+          }
+        ]).toArray();
+        const length = yield collection.countDocuments(query);
+        return (0, import_utils3.paginate)(items, page, limit, length);
+      } catch (error) {
+        import_utils3.logger.log({ level: "error", message: `${error}` });
+        throw error;
+      }
+    });
+  }
+  function updatePassword() {
+    return __async(this, arguments, function* ({ _id, password } = {}, session) {
+      try {
+        _id = new import_mongodb6.ObjectId(_id);
+      } catch (error) {
+        throw new Error("Invalid user ID.");
+      }
+      try {
+        return yield collection.updateOne(
+          { _id },
+          { $set: { password } },
+          { session }
+        );
+      } catch (error) {
+        throw new Error("Failed to update user password.");
+      }
+    });
+  }
+  function updateName() {
+    return __async(this, arguments, function* ({ _id, firstName, lastName } = {}, session) {
+      try {
+        _id = new import_mongodb6.ObjectId(_id);
+      } catch (error) {
+        throw new Error("Invalid user ID.");
+      }
+      try {
+        return yield collection.updateOne(
+          { _id },
+          { $set: { firstName, lastName } },
+          { session }
+        );
+      } catch (error) {
+        throw new Error("Failed to update user profile.");
+      }
+    });
+  }
+  function updateBirthday() {
+    return __async(this, arguments, function* ({ _id, month, day, year } = {}, session) {
+      try {
+        _id = new import_mongodb6.ObjectId(_id);
+      } catch (error) {
+        throw new Error("Invalid user ID.");
+      }
+      try {
+        return yield collection.updateOne(
+          { _id },
+          { $set: { birthMonth: month, birthDay: day, birthYear: year } },
+          { session }
+        );
+      } catch (error) {
+        throw new Error("Failed to update user birthday.");
+      }
+    });
+  }
+  function updateUserFieldById() {
+    return __async(this, arguments, function* ({ _id, field, value } = {}, session) {
+      const allowedFields = ["gender", "email", "contact", "profile"];
+      if (!allowedFields.includes(field)) {
+        throw new import_utils3.BadRequestError(
+          `Field "${field}" is not allowed to be updated.`
+        );
+      }
+      try {
+        _id = new import_mongodb6.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils3.BadRequestError("Invalid ID.");
+      }
+      try {
+        yield collection.updateOne(
+          { _id },
+          { $set: { [field]: value } },
+          // Dynamically set the field
+          { session }
+        );
+        return `Successfully updated user ${field}.`;
+      } catch (error) {
+        throw new import_utils3.InternalServerError(`Failed to update user ${field}.`);
+      }
+    });
+  }
+  function addUserRole() {
+    return __async(this, arguments, function* ({ _id, role } = {}, session) {
+      try {
+        _id = new import_mongodb6.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils3.BadRequestError("Invalid user ID.");
+      }
+      role = new MUserRole(role);
+      try {
+        yield collection.updateOne(
+          { _id, "roles.app": { $ne: role.app } },
+          // @ts-ignore
+          { $push: { roles: role } },
+          { session }
+        );
+      } catch (error) {
+        throw new import_utils3.InternalServerError("Failed to add user role.");
+      }
+    });
+  }
+  return {
+    createTextIndex,
+    createUniqueIndex,
+    createUser,
+    getUserByEmail,
+    getUserById,
+    getUsers,
+    updatePassword,
+    updateName,
+    updateBirthday,
+    updateUserFieldById,
+    addUserRole,
+    getByEmailApp
+  };
+}
+
+// src/services/verification.service.ts
+function useVerificationService() {
+  const MailerConfig = {
+    host: MAILER_TRANSPORT_HOST,
+    port: MAILER_TRANSPORT_PORT,
+    secure: MAILER_TRANSPORT_SECURE,
+    email: MAILER_EMAIL,
+    password: MAILER_PASSWORD
+  };
+  const mailer = new import_utils4.useMailer(MailerConfig);
+  const {
+    add,
+    getById: _getById,
+    updateStatusById: _updateStatusById,
+    getVerifications: _getVerifications
+  } = useVerificationRepo();
+  const { addUserRole, getUserByEmail, getByEmailApp } = useUserRepo();
+  function createUserInvite(_0) {
+    return __async(this, arguments, function* ({
+      email,
+      metadata
+    }) {
+      const value = {
+        type: "user-invite",
+        email,
+        metadata,
+        expireAt: new Date(
+          (/* @__PURE__ */ new Date()).getTime() + 72 * 60 * 60 * 1e3
+        ).toISOString(),
+        // 72 hours (3 days) from now
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      try {
+        const user = yield getByEmailApp(email, metadata.app);
+        if (user) {
+          throw new import_utils4.BadRequestError(
+            `User already a user in ${metadata.app} app.`
+          );
+        }
+        const res = yield add(value);
+        const dir = __dirname;
+        const filePath = (0, import_utils4.getDirectory)(dir, "./public/handlebars/user-invite");
+        const emailContent = (0, import_utils4.compileHandlebar)({
+          context: {
+            validity: VERIFICATION_USER_INVITE_DURATION,
+            link: `${APP_ACCOUNT}/verify/invitation/${res}`
+          },
+          filePath
+        });
+        mailer.sendMail({
+          to: email,
+          subject: "User Invite",
+          html: emailContent,
+          sender: "Education Ecosystem"
+        }).catch((error) => {
+          import_utils4.logger.log({
+            level: "error",
+            message: `Error sending user invite email: ${error}`
+          });
+        });
+        return res;
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function createForgetPassword(email) {
+    return __async(this, null, function* () {
+      const value = {
+        type: "forget-password",
+        email,
+        expireAt: new Date((/* @__PURE__ */ new Date()).getTime() + 10 * 60 * 1e3).toISOString(),
+        // 10 minutes from now
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      try {
+        const res = yield add(value);
+        const dir = __dirname;
+        const filePath = (0, import_utils4.getDirectory)(dir, "./public/handlebars/forget-password");
+        const emailContent = (0, import_utils4.compileHandlebar)({
+          context: {
+            validity: VERIFICATION_FORGET_PASSWORD_DURATION,
+            link: `${APP_ACCOUNT}/reset-password/${res}`
+          },
+          filePath
+        });
+        mailer.sendMail({ to: email, subject: "Forget Password", html: emailContent }).catch((error) => {
+          import_utils4.logger.log({
+            level: "error",
+            message: `Error sending forget password email: ${error}`
+          });
+        });
+        return res;
+      } catch (error) {
+        throw new import_utils4.InternalServerError("Error creating one-time password");
+      }
+    });
+  }
+  function getById(id) {
+    return __async(this, null, function* () {
+      try {
+        const _id = yield _getById(id);
+        if (!_id) {
+          throw new import_utils4.NotFoundError("Verification not found.");
+        }
+        return _id;
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getVerifications() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      status = "",
+      type = "",
+      limit = 10
+    } = {}) {
+      try {
+        return yield _getVerifications({ search, page, status, type, limit });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function errorByType(type, status) {
+    if (type === "user-invite" && status === "expired") {
+      throw new import_utils4.BadRequestError(
+        "Invitation has already expired, please contact admin to resend the invitation."
+      );
+    }
+    if (type === "user-invite" && status === "complete") {
+      throw new import_utils4.BadRequestError(
+        "User already registered, please login to continue."
+      );
+    }
+    throw new import_utils4.BadRequestError("Invalid verification.");
+  }
+  function verify(id) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const session = (_a = import_utils4.useAtlas.getClient()) == null ? void 0 : _a.startSession();
+      session == null ? void 0 : session.startTransaction();
+      try {
+        const _id = yield _getById(id);
+        if (!_id) {
+          throw new import_utils4.NotFoundError("Verification not found.");
+        }
+        if (_id.status === "expired") {
+          errorByType(_id.type, "expired");
+        }
+        if (_id.status === "complete") {
+          throw new import_utils4.BadRequestError("Verification already completed.");
+        }
+        const expiration = new Date(_id.expireAt).getTime();
+        const now = (/* @__PURE__ */ new Date()).getTime();
+        if (now > expiration) {
+          yield _updateStatusById(id, "expired");
+          errorByType(_id.type, "expired");
+        }
+        const user = yield getUserByEmail(_id.email);
+        const appMember = (_b = user == null ? void 0 : user.roles) == null ? void 0 : _b.filter((i) => {
+          var _a2;
+          return i.app === ((_a2 = _id.metadata) == null ? void 0 : _a2.app);
+        });
+        if ((appMember == null ? void 0 : appMember.length) === 0 && user && _id.type === "user-invite") {
+          yield addUserRole(
+            {
+              _id: (_c = user._id) == null ? void 0 : _c.toString(),
+              role: {
+                name: (_d = _id.metadata) == null ? void 0 : _d.name,
+                app: (_e = _id.metadata) == null ? void 0 : _e.app,
+                role: (_f = _id.metadata) == null ? void 0 : _f.role
+              }
+            },
+            session
+          );
+          yield _updateStatusById(id, "complete", session);
+          yield session == null ? void 0 : session.commitTransaction();
+          return "Successfully added user role.";
+        }
+        if ((appMember == null ? void 0 : appMember.length) && _id.type === "user-invite") {
+          yield _updateStatusById(id, "expired");
+          throw new import_utils4.BadRequestError(
+            `Invalid user invitation. User is already a user in the ${(_g = _id.metadata) == null ? void 0 : _g.app} app.`
+          );
+        }
+        return _id;
+      } catch (error) {
+        yield session == null ? void 0 : session.abortTransaction();
+        import_utils4.logger.log({
+          level: "info",
+          message: `Error verifying user invitation: ${error}`
+        });
+        throw error;
+      } finally {
+        session == null ? void 0 : session.endSession();
+      }
+    });
+  }
+  function cancelUserInvitation(id) {
+    return __async(this, null, function* () {
+      try {
+        yield updateStatusById(id, "cancelled");
+      } catch (error) {
+        throw new import_utils4.InternalServerError(
+          `Error cancelling user invitation: ${error}`
+        );
+      }
+    });
+  }
+  function updateStatusById(_id, status) {
+    return __async(this, null, function* () {
+      try {
+        yield _updateStatusById(_id, status);
+        return "Successfully updated verification status.";
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  return {
+    createForgetPassword,
+    createUserInvite,
+    verify,
+    getById,
+    getVerifications,
+    cancelUserInvitation,
+    updateStatusById
+  };
+}
+
+// src/controllers/verification.controller.ts
+var import_utils5 = require("@goweekdays/utils");
+var import_joi = __toESM(require("joi"));
+var import_mongodb7 = require("mongodb");
+function useVerificationController() {
+  const {
+    createUserInvite: _createUserInvite,
+    createForgetPassword: _createForgetPassword,
+    cancelUserInvitation: _cancelUserInvitation,
+    verify: _verify,
+    getVerifications: _getVerifications
+  } = useVerificationService();
+  function createUserInvite(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const email = (_a = req.body.email) != null ? _a : "";
+      const app = (_b = req.body.app) != null ? _b : "";
+      const role = (_c = req.body.role) != null ? _c : "";
+      const name = (_d = req.body.name) != null ? _d : "";
+      const validation = import_joi.default.object({
+        email: import_joi.default.string().email().required(),
+        app: import_joi.default.string().optional().allow("", null),
+        role: import_joi.default.string().hex().optional().allow("", null),
+        name: import_joi.default.string().optional().allow("", null)
+      });
+      const { error } = validation.validate({
+        email,
+        app,
+        role,
+        name
+      });
+      if (error) {
+        next(new import_utils5.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _createUserInvite({
+          email,
+          metadata: {
+            app,
+            role,
+            name
+          }
+        });
+        res.json({ message: "Successfully invited user." });
+        return;
+      } catch (error2) {
+        console.log(error2);
+        next(error2);
+      }
+    });
+  }
+  function createForgetPassword(req, res, next) {
+    return __async(this, null, function* () {
+      const email = req.body.email || "";
+      const validation = import_joi.default.string().email().required();
+      const { error } = validation.validate(email);
+      if (error) {
+        next(new import_utils5.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _createForgetPassword(email);
+        res.json({
+          message: "Check your email to verify it before resetting your password."
+        });
+        return;
+      } catch (error2) {
+        if (error2 instanceof import_utils5.AppError) {
+          next(error2);
+        } else {
+          next(new import_utils5.InternalServerError("An unexpected error occurred"));
+        }
+      }
+    });
+  }
+  function getVerifications(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const status = (_a = req.query.status) != null ? _a : "";
+      const search = (_b = req.query.search) != null ? _b : "";
+      const page = (_c = Number(req.query.page)) != null ? _c : 1;
+      const validation = import_joi.default.object({
+        status: import_joi.default.string().required(),
+        search: import_joi.default.string().optional().allow("", null),
+        page: import_joi.default.number().required()
+      });
+      const { error } = validation.validate({ status, search, page });
+      if (error) {
+        next(new import_utils5.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const items = yield _getVerifications({ status, search, page });
+        res.json(items);
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function verify(req, res, next) {
+    return __async(this, null, function* () {
+      const id = req.params.id || "";
+      const validation = import_joi.default.string().hex().required();
+      const { error } = validation.validate(id);
+      if (error) {
+        next(new import_utils5.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const message = yield _verify(id);
+        res.json({ message });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function cancelUserInvitation(req, res, next) {
+    return __async(this, null, function* () {
+      const otpId = req.params.id || "";
+      const validation = import_joi.default.string().hex().required();
+      const { error } = validation.validate(otpId);
+      if (error) {
+        next(new import_utils5.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const otpObjectId = new import_mongodb7.ObjectId(otpId);
+        yield _cancelUserInvitation(otpObjectId);
+        return res.json({
+          message: "User invite has been cancelled."
+        });
+      } catch (error2) {
+        throw error2;
+      }
+    });
+  }
+  return {
+    getVerifications,
+    createUserInvite,
+    createForgetPassword,
+    verify,
+    cancelUserInvitation
+  };
+}
+
+// src/models/token.model.ts
+var import_mongodb8 = require("mongodb");
+var MToken = class {
+  constructor(value) {
+    var _a, _b, _c;
+    this.token = (_a = value.token) != null ? _a : "";
+    this.user = (_b = value.user) != null ? _b : new import_mongodb8.ObjectId();
+    this.createdAt = (_c = value.createdAt) != null ? _c : (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+
+// src/repositories/token.repository.ts
+var import_utils6 = require("@goweekdays/utils");
+var import_mongodb9 = require("mongodb");
+function useTokenRepo() {
+  const db = import_utils6.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils6.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("tokens");
+  function createToken() {
+    return __async(this, arguments, function* ({ token, user } = {}) {
+      try {
+        user = new import_mongodb9.ObjectId(user);
+      } catch (error) {
+        return Promise.reject("Invalid user ID");
+      }
+      try {
+        yield collection.insertOne({ token, user });
+        return "Token created";
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+  function getToken(token) {
+    return __async(this, null, function* () {
+      try {
+        return yield collection.findOne({ token });
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+  function deleteToken(token) {
+    return __async(this, null, function* () {
+      try {
+        return yield collection.deleteOne({ token });
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+  return {
+    createToken,
+    getToken,
+    deleteToken
+  };
+}
+
+// src/services/user.service.ts
+var import_utils8 = require("@goweekdays/utils");
+
+// src/repositories/file.repository.ts
+var import_utils7 = require("@goweekdays/utils");
+
+// src/models/file.model.ts
+var MFile = class {
+  constructor(value) {
+    var _a, _b, _c, _d;
+    this._id = value._id;
+    this.name = (_a = value.name) != null ? _a : "";
+    this.type = (_b = value.type) != null ? _b : "public";
+    this.status = (_c = value.status) != null ? _c : "active";
+    this.createdAt = (_d = value.createdAt) != null ? _d : (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+
+// src/repositories/file.repository.ts
+var import_mongodb10 = require("mongodb");
+function useFileRepo() {
+  const db = import_utils7.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils7.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("files");
+  function createFile(value, session) {
+    return __async(this, null, function* () {
+      try {
+        value = new MFile(value);
+        const res = yield collection.insertOne(value, { session });
+        return res.insertedId.toString();
+      } catch (error) {
+        throw new import_utils7.InternalServerError("Failed to create file.");
+      }
+    });
+  }
+  function deleteFileById(_id, session) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb10.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils7.BadRequestError("Invalid file id.");
+      }
+      try {
+        yield collection.deleteOne({ _id }, { session });
+        return "File deleted successfully";
+      } catch (error) {
+        throw new import_utils7.InternalServerError("Failed to delete file.");
+      }
+    });
+  }
+  function getAllDraftedFiles() {
+    return __async(this, null, function* () {
+      try {
+        return yield collection.find({ $and: [{ status: "draft" }, { status: null }] }).toArray();
+      } catch (error) {
+        throw new import_utils7.InternalServerError("Failed to get drafted files.");
+      }
+    });
+  }
+  return {
+    createFile,
+    deleteFileById,
+    getAllDraftedFiles
+  };
+}
+
+// src/services/user.service.ts
+function useUserService() {
+  const {
+    createUser: _createUser,
+    getUserByEmail,
+    getUserById: _getById,
+    updateName: _updateName,
+    updateBirthday: _updateBirthday,
+    updateUserFieldById: _updateUserFieldById,
+    getUsers: _getUsers
+  } = useUserRepo();
+  function getUserById(id) {
+    return __async(this, null, function* () {
+      try {
+        return yield _getById(id);
+      } catch (error) {
+        throw new import_utils8.InternalServerError();
+      }
+    });
+  }
+  function getUsers() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      status = "",
+      type = "",
+      limit = 10
+    } = {}) {
+      try {
+        return yield _getUsers({ search, page, status, type, limit });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function createUser(value) {
+    return __async(this, null, function* () {
+      var _a;
+      const session = (_a = import_utils8.useAtlas.getClient()) == null ? void 0 : _a.startSession();
+      session == null ? void 0 : session.startTransaction();
+      try {
+        const _user = yield getUserByEmail(value.email);
+        if (_user) {
+          throw new import_utils8.BadRequestError(`User already exists: ${value.email}.`);
+        }
+        const hashedPassword = yield (0, import_utils8.hashPassword)(value.password);
+        const user = {
+          email: value.email,
+          password: hashedPassword,
+          prefix: value.prefix,
+          firstName: value.firstName,
+          middleName: value.middleName,
+          lastName: value.lastName,
+          suffix: value.suffix,
+          type: value.type,
+          roles: value.roles,
+          status: "active",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const userId = yield _createUser(user, session);
+        yield session == null ? void 0 : session.commitTransaction();
+        return userId;
+      } catch (error) {
+        yield session == null ? void 0 : session.abortTransaction();
+        throw error;
+      } finally {
+        session == null ? void 0 : session.endSession();
+      }
+    });
+  }
+  const { getById: _getVerificationById, updateStatusById: _updateStatusById } = useVerificationRepo();
+  function createUserByInvite() {
+    return __async(this, arguments, function* ({
+      id = "",
+      firstName = "",
+      lastName = "",
+      password = ""
+    } = {}) {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const session = (_a = import_utils8.useAtlas.getClient()) == null ? void 0 : _a.startSession();
+      session == null ? void 0 : session.startTransaction();
+      try {
+        const invitation = yield _getVerificationById(id);
+        if (!invitation || !((_b = invitation.metadata) == null ? void 0 : _b.app) || !((_c = invitation.metadata) == null ? void 0 : _c.role)) {
+          throw new import_utils8.BadRequestError("Invalid invitation.");
+        }
+        if (invitation.status === "complete") {
+          throw new import_utils8.BadRequestError("Invitation already used.");
+        }
+        const expired = new Date(invitation.expireAt) < /* @__PURE__ */ new Date();
+        if (invitation.status === "expired" || expired) {
+          throw new import_utils8.BadRequestError("Invitation expired.");
+        }
+        const email = invitation.email;
+        const _user = yield getUserByEmail(invitation.email);
+        if (_user) {
+          throw new import_utils8.BadRequestError(`User already exists: ${email}.`);
+        }
+        const hashedPassword = yield (0, import_utils8.hashPassword)(password);
+        const user = {
+          email,
+          password: hashedPassword,
+          firstName,
+          lastName,
+          type: (_d = invitation.metadata) == null ? void 0 : _d.app,
+          status: "active",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          roles: [
+            {
+              name: (_e = invitation.metadata) == null ? void 0 : _e.name,
+              app: (_f = invitation.metadata) == null ? void 0 : _f.app,
+              role: (_g = invitation.metadata) == null ? void 0 : _g.role
+            }
+          ]
+        };
+        const userId = yield _createUser(user, session);
+        yield _updateStatusById(id, "complete", session);
+        yield session == null ? void 0 : session.commitTransaction();
+        return userId;
+      } catch (error) {
+        yield session == null ? void 0 : session.abortTransaction();
+        throw error;
+      } finally {
+        session == null ? void 0 : session.endSession();
+      }
+    });
+  }
+  const { verify, getById, updateStatusById } = useVerificationService();
+  function resetPassword(id, newPassword, passwordConfirmation) {
+    return __async(this, null, function* () {
+      try {
+        yield verify(id);
+      } catch (error) {
+        throw error;
+      }
+      if (newPassword !== passwordConfirmation) {
+        throw new import_utils8.BadRequestError("Passwords do not match");
+      }
+      let hashedPassword;
+      try {
+        hashedPassword = yield (0, import_utils8.hashPassword)(newPassword);
+      } catch (error) {
+        throw new import_utils8.InternalServerError(`Error hashing password: ${error}`);
+      }
+      try {
+        const otpDoc = yield getById(id);
+        if (!otpDoc) {
+          throw new import_utils8.NotFoundError("OTP not found");
+        }
+        if (otpDoc.status === "used") {
+          throw new import_utils8.BadRequestError("Invalid OTP, already used.");
+        }
+        yield updateStatusById(id, "used");
+        return "Updated password successfully";
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function updateName(_id, firstName, lastName) {
+    return __async(this, null, function* () {
+      var _a;
+      if (!_id) {
+        throw new import_utils8.BadRequestError("Invalid user ID");
+      }
+      if (!firstName) {
+        throw new import_utils8.BadRequestError("Invalid firstName");
+      }
+      if (!lastName) {
+        throw new import_utils8.BadRequestError("Invalid lastName");
+      }
+      const session = (_a = import_utils8.useAtlas.getClient()) == null ? void 0 : _a.startSession();
+      session == null ? void 0 : session.startTransaction();
+      try {
+        yield _updateName({ _id, firstName, lastName }, session);
+        yield session == null ? void 0 : session.commitTransaction();
+        return "Successfully updated name.";
+      } catch (error) {
+        yield session == null ? void 0 : session.abortTransaction();
+        throw error;
+      } finally {
+        session == null ? void 0 : session.endSession();
+      }
+    });
+  }
+  function updateBirthday(_id, month, day, year) {
+    return __async(this, null, function* () {
+      if (!_id) {
+        throw new import_utils8.BadRequestError("Invalid user ID");
+      }
+      if (!month) {
+        throw new import_utils8.BadRequestError("Invalid birth month.");
+      }
+      if (!day) {
+        throw new import_utils8.BadRequestError("Invalid birthday.");
+      }
+      if (!year) {
+        throw new import_utils8.BadRequestError("Invalid birth year.");
+      }
+      try {
+        yield _updateBirthday({ _id, month, day, year });
+        return "Successfully updated birthday.";
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function updateUserFieldById() {
+    return __async(this, arguments, function* ({ _id, field, value } = {}) {
+      try {
+        return yield _updateUserFieldById({ _id, field, value });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  const { createFile: _createFile, deleteFileById } = useFileRepo();
+  const s3 = new import_utils8.useS3({
+    accessKeyId: SPACES_ACCESS_KEY,
+    secretAccessKey: SPACES_SECRET_KEY,
+    endpoint: SPACES_ENDPOINT,
+    region: SPACES_REGION,
+    bucket: SPACES_BUCKET
+  });
+  function updateUserProfile() {
+    return __async(this, arguments, function* ({ file, user, previousProfile } = {}) {
+      var _a;
+      const session = (_a = import_utils8.useAtlas.getClient()) == null ? void 0 : _a.startSession();
+      session == null ? void 0 : session.startTransaction();
+      const _file = {
+        name: file.originalname,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      try {
+        const id = yield _createFile(_file, session);
+        yield s3.uploadObject({
+          key: id,
+          body: file.buffer,
+          contentType: file.mimetype
+        });
+        if (previousProfile) {
+          yield deleteFileById(previousProfile, session);
+          yield s3.deleteObject(previousProfile);
+        }
+        yield _updateUserFieldById(
+          { _id: user, field: "profile", value: id },
+          session
+        );
+        yield session == null ? void 0 : session.commitTransaction();
+        return id;
+      } catch (error) {
+        yield session == null ? void 0 : session.abortTransaction();
+        throw error;
+      } finally {
+        session == null ? void 0 : session.endSession();
+      }
+    });
+  }
+  return {
+    getUserById,
+    getUsers,
+    createUser,
+    resetPassword,
+    updateName,
+    updateBirthday,
+    updateUserFieldById,
+    updateUserProfile,
+    createUserByInvite
+  };
+}
+
+// src/controllers/user.controller.ts
+var import_utils9 = require("@goweekdays/utils");
+var import_joi2 = __toESM(require("joi"));
+function useUserController() {
+  const {
+    getUserById: _getUserById,
+    updateName: _updateName,
+    updateBirthday: _updateBirthday,
+    updateUserFieldById: _updateUserFieldById,
+    updateUserProfile: _updateUserProfile,
+    getUsers: _getUsers,
+    createUserByInvite: _createUserByInvite
+  } = useUserService();
+  function getUsers(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const status = (_a = req.query.status) != null ? _a : "";
+      const search = (_b = req.query.search) != null ? _b : "";
+      const page = (_c = Number(req.query.page)) != null ? _c : 1;
+      const validation = import_joi2.default.object({
+        status: import_joi2.default.string().required(),
+        search: import_joi2.default.string().optional().allow("", null),
+        page: import_joi2.default.number().required()
+      });
+      const { error } = validation.validate({ status, search, page });
+      if (error) {
+        next(new import_utils9.BadRequestError(error.message));
+      }
+      try {
+        const items = yield _getUsers({ status, search, page });
+        res.json(items);
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function getUserById(req, res, next) {
+    return __async(this, null, function* () {
+      const id = req.params.id || "";
+      const validation = import_joi2.default.string().hex().validate(id);
+      if (validation.error) {
+        throw new import_utils9.BadRequestError("Invalid id.");
+      }
+      try {
+        const user = yield _getUserById(id);
+        if (!user) {
+          throw new import_utils9.BadRequestError("User not found.");
+        }
+        res.json(user);
+      } catch (error) {
+        next(error);
+      }
+    });
+  }
+  function updateName(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const id = (_a = req.headers.user) != null ? _a : "";
+      const firstName = (_b = req.body.firstName) != null ? _b : "";
+      const lastName = (_c = req.body.lastName) != null ? _c : "";
+      const validation = import_joi2.default.object({
+        firstName: import_joi2.default.string().required(),
+        lastName: import_joi2.default.string().required()
+      });
+      const { error } = validation.validate({ firstName, lastName });
+      if (error) {
+        next(new import_utils9.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const message = yield _updateName(id, firstName, lastName);
+        res.json({ message });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function updateBirthday(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const id = (_a = req.headers.user) != null ? _a : "";
+      const month = (_b = req.body.month) != null ? _b : "";
+      const day = (_c = req.body.day) != null ? _c : 0;
+      const year = (_d = req.body.year) != null ? _d : 0;
+      const validation = import_joi2.default.object({
+        month: import_joi2.default.string().required(),
+        day: import_joi2.default.number().integer().min(1).max(31).required(),
+        year: import_joi2.default.number().integer().min(1900).max((/* @__PURE__ */ new Date()).getFullYear()).required()
+      });
+      const { error } = validation.validate({ month, day, year });
+      if (error) {
+        next(new import_utils9.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const message = yield _updateBirthday(id, month, day, year);
+        res.json({ message });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function updateUserFieldById(req, res, next) {
+    return __async(this, null, function* () {
+      const _id = req.params.id;
+      const { field, value } = req.body;
+      const validation = import_joi2.default.object({
+        _id: import_joi2.default.string().hex().required(),
+        field: import_joi2.default.string().valid("gender", "email", "contact", "profile").required(),
+        value: import_joi2.default.alternatives().conditional("field", {
+          is: "email",
+          then: import_joi2.default.string().email().required(),
+          otherwise: import_joi2.default.string().required()
+        })
+      });
+      const { error } = validation.validate({ _id, field, value });
+      if (error) {
+        next(new import_utils9.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const message = yield _updateUserFieldById({ _id, field, value });
+        res.json({ message });
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function updateUserProfile(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (!req.file) {
+        res.status(400).send("File is required!");
+        return;
+      }
+      const previousProfile = (_a = req.body.previousProfile) != null ? _a : "";
+      const validation = import_joi2.default.object({
+        previousProfile: import_joi2.default.string().hex().optional().allow("", null)
+      });
+      const { error } = validation.validate({ previousProfile });
+      if (error) {
+        next(new import_utils9.BadRequestError(error.message));
+        return;
+      }
+      const user = (_b = req.headers["user"]) != null ? _b : "";
+      try {
+        yield _updateUserProfile({
+          file: req.file,
+          user,
+          previousProfile
+        });
+        res.json({ message: "Successfully updated profile picture." });
+        return;
+      } catch (error2) {
+        if (error2 instanceof import_utils9.AppError) {
+          next(error2);
+        } else {
+          next(new import_utils9.InternalServerError(error2));
+        }
+      }
+    });
+  }
+  function createUserByInvite(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const firstName = (_a = req.body.firstName) != null ? _a : "";
+      const lastName = (_b = req.body.lastName) != null ? _b : "";
+      const password = (_c = req.body.password) != null ? _c : "";
+      const id = (_d = req.params.id) != null ? _d : "";
+      const validation = import_joi2.default.object({
+        firstName: import_joi2.default.string().required(),
+        lastName: import_joi2.default.string().required(),
+        password: import_joi2.default.string().required(),
+        id: import_joi2.default.string().hex().required()
+      });
+      const { error } = validation.validate({
+        firstName,
+        lastName,
+        password,
+        id
+      });
+      if (error) {
+        next(new import_utils9.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _createUserByInvite({ firstName, lastName, password, id });
+        res.json({ message: "Successfully created account." });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  return {
+    getUsers,
+    getUserById,
+    updateName,
+    updateBirthday,
+    updateUserFieldById,
+    updateUserProfile,
+    createUserByInvite
+  };
+}
+
+// src/services/auth.service.ts
+var import_utils10 = require("@goweekdays/utils");
+var import_jsonwebtoken3 = __toESM(require("jsonwebtoken"));
+function useAuthService() {
+  const expiresIn = "1m";
+  function login() {
+    return __async(this, arguments, function* ({ email, password } = {}) {
+      var _a;
+      if (!email) {
+        throw new import_utils10.BadRequestError("Email is required");
+      }
+      if (!password) {
+        throw new import_utils10.BadRequestError("Password is required");
+      }
+      let _user;
+      try {
+        _user = yield useUserRepo().getUserByEmail(email);
+      } catch (error) {
+        if (error instanceof import_utils10.AppError) {
+          throw error;
+        } else {
+          throw new import_utils10.InternalServerError(`${error}`);
+        }
+      }
+      if (!_user) {
+        throw new import_utils10.NotFoundError(
+          "Invalid user email. Please check your email and try again."
+        );
+      }
+      if (_user.status === "suspended") {
+        throw new import_utils10.BadRequestError(
+          "Your account is currently suspended. Please contact support for assistance."
+        );
+      }
+      const isPasswordValid = yield (0, import_utils10.comparePassword)(password, _user.password);
+      if (!isPasswordValid) {
+        throw new import_utils10.BadRequestError("Invalid password");
+      }
+      const metadata = { user: _user._id };
+      let refreshToken2;
+      try {
+        refreshToken2 = (0, import_utils10.generateToken)({
+          secret: REFRESH_TOKEN_SECRET,
+          metadata,
+          options: { expiresIn: "7d" }
+        });
+      } catch (error) {
+        throw new import_utils10.BadRequestError("Error generating refresh token");
+      }
+      let accessToken;
+      try {
+        accessToken = (0, import_utils10.generateToken)({
+          secret: ACCESS_TOKEN_SECRET,
+          metadata,
+          options: { expiresIn }
+        });
+      } catch (error) {
+        throw new import_utils10.BadRequestError("Error generating access token");
+      }
+      const user = (_a = _user._id) != null ? _a : "";
+      try {
+        yield useTokenRepo().createToken({ token: refreshToken2, user });
+      } catch (error) {
+        throw new import_utils10.BadRequestError("Error creating refresh token");
+      }
+      return { accessToken, refreshToken: refreshToken2, id: _user._id };
+    });
+  }
+  function refreshToken(token) {
+    return __async(this, null, function* () {
+      let decoded;
+      try {
+        decoded = yield import_jsonwebtoken3.default.verify(token, REFRESH_TOKEN_SECRET);
+      } catch (error) {
+        throw new import_utils10.BadRequestError("Invalid refresh token");
+      }
+      let _token;
+      try {
+        _token = yield useTokenRepo().getToken(token);
+        if (!_token) {
+          throw new import_utils10.NotFoundError("Invalid token");
+        }
+      } catch (error) {
+        if (error instanceof import_utils10.AppError) {
+          throw error;
+        } else {
+          throw new import_utils10.InternalServerError(`${error}`);
+        }
+      }
+      let accessToken;
+      try {
+        accessToken = (0, import_utils10.generateToken)({
+          secret: ACCESS_TOKEN_SECRET,
+          metadata: { user: decoded.user },
+          options: { expiresIn }
+        });
+      } catch (error) {
+        throw new import_utils10.BadRequestError("Error generating access token");
+      }
+      return accessToken;
+    });
+  }
+  function logout(token) {
+    return __async(this, null, function* () {
+      let _token;
+      try {
+        _token = yield useTokenRepo().getToken(token);
+        if (!_token) {
+          throw new import_utils10.NotFoundError("Invalid token");
+        }
+      } catch (error) {
+        if (error instanceof import_utils10.AppError) {
+          throw error;
+        } else {
+          throw new import_utils10.InternalServerError(`${error}`);
+        }
+      }
+      try {
+        yield useTokenRepo().deleteToken(token);
+      } catch (error) {
+        throw new import_utils10.InternalServerError("Error deleting token");
+      }
+      return "Logged out successfully";
+    });
+  }
+  return {
+    login,
+    refreshToken,
+    logout
+  };
+}
+
+// src/controllers/auth.controller.ts
+var import_joi3 = __toESM(require("joi"));
+var import_utils11 = require("@goweekdays/utils");
+function useAuthController() {
+  function login(req, res, next) {
+    return __async(this, null, function* () {
+      const email = req.body.email;
+      const password = req.body.password;
+      const validation = import_joi3.default.object({
+        email: import_joi3.default.string().email().required(),
+        password: import_joi3.default.string().required()
+      });
+      const { error } = validation.validate({ email, password });
+      if (error) {
+        next(new import_utils11.BadRequestError(error.message));
+      }
+      try {
+        const token = yield useAuthService().login({ email, password });
+        res.json(token);
+      } catch (error2) {
+        if (error2 instanceof import_utils11.AppError) {
+          next(error2);
+        } else {
+          next(new import_utils11.InternalServerError("An unexpected error occurred"));
+        }
+      }
+    });
+  }
+  function refreshToken(req, res, next) {
+    return __async(this, null, function* () {
+      const refreshToken2 = req.body.token;
+      if (!refreshToken2) {
+        next(new import_utils11.BadRequestError("Refresh token is required"));
+        return;
+      }
+      try {
+        const newRefreshToken = yield useAuthService().refreshToken(refreshToken2);
+        res.json({ token: newRefreshToken });
+      } catch (error) {
+        if (error instanceof import_utils11.AppError) {
+          next(error);
+        } else {
+          next(new import_utils11.InternalServerError("An unexpected error occurred"));
+        }
+      }
+    });
+  }
+  function logout(req, res, next) {
+    return __async(this, null, function* () {
+      const token = req.params.id || "";
+      if (!token) {
+        next(new import_utils11.BadRequestError("Token is required"));
+        return;
+      }
+      try {
+        yield useAuthService().logout(token);
+        res.json({ message: "Logged out successfully" });
+      } catch (error) {
+        if (error instanceof import_utils11.AppError) {
+          next(error);
+        } else {
+          next(new import_utils11.InternalServerError("An unexpected error occurred"));
+        }
+      }
+    });
+  }
+  function resetPassword(req, res, next) {
+    return __async(this, null, function* () {
+      const otp = req.body.otp || "";
+      const newPassword = req.body.newPassword || "";
+      const passwordConfirmation = req.body.passwordConfirmation || "";
+      const validation = import_joi3.default.object({
+        otp: import_joi3.default.string().hex().required(),
+        newPassword: import_joi3.default.string().required().min(8),
+        passwordConfirmation: import_joi3.default.string().required().min(8)
+      });
+      const { error } = validation.validate({
+        otp,
+        newPassword,
+        passwordConfirmation
+      });
+      if (error) {
+        next(new import_utils11.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const message = yield useUserService().resetPassword(
+          otp,
+          newPassword,
+          passwordConfirmation
+        );
+        res.json({ message });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  return {
+    login,
+    refreshToken,
+    logout,
+    resetPassword
+  };
+}
+
+// src/models/role.model.ts
+var import_mongodb11 = require("mongodb");
+var MRole = class {
+  constructor(value) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (typeof value._id === "string") {
+      try {
+        value._id = new import_mongodb11.ObjectId(value._id);
+      } catch (error) {
+        throw new Error("Invalid _id.");
+      }
+    }
+    this._id = (_a = value._id) != null ? _a : new import_mongodb11.ObjectId();
+    this.name = (_b = value.name) != null ? _b : "";
+    this.permissions = (_c = value.permissions) != null ? _c : [];
+    this.type = value.type ? value.type : "account";
+    this.status = (_d = value.status) != null ? _d : "active";
+    if (value.createdBy) {
+      try {
+        value.createdBy = new import_mongodb11.ObjectId(value.createdBy);
+      } catch (error) {
+        throw new Error("Invalid createdBy.");
+      }
+    }
+    this.createdBy = (_e = value.createdBy) != null ? _e : "";
+    this.createdAt = (_f = value.createdAt) != null ? _f : (/* @__PURE__ */ new Date()).toISOString();
+    this.updatedAt = (_g = value.updatedAt) != null ? _g : "";
+    this.deletedAt = (_h = value.deletedAt) != null ? _h : "";
+  }
+};
+
+// src/repositories/role.repository.ts
+var import_utils12 = require("@goweekdays/utils");
+var import_mongodb12 = require("mongodb");
+function useRoleRepo() {
+  const db = import_utils12.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils12.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("roles");
+  function createIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({ name: 1 });
+        yield collection.createIndex({ type: 1 });
+        yield collection.createIndex({ status: 1 });
+      } catch (error) {
+        throw new import_utils12.InternalServerError("Failed to create index on role.");
+      }
+    });
+  }
+  function createTextIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({ name: "text" });
+      } catch (error) {
+        throw new import_utils12.InternalServerError("Failed to create text index on role.");
+      }
+    });
+  }
+  function createUniqueIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({ name: 1, type: 1 }, { unique: true });
+      } catch (error) {
+        throw new import_utils12.InternalServerError("Failed to create unique index on role.");
+      }
+    });
+  }
+  function addRole(value, session) {
+    return __async(this, null, function* () {
+      value = new MRole(value);
+      try {
+        const res = yield collection.insertOne(value, { session });
+        return res.insertedId;
+      } catch (error) {
+        import_utils12.logger.log({ level: "error", message: `${error}` });
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_utils12.BadRequestError("Item role already exists");
+        }
+        throw new import_utils12.InternalServerError("Failed to create role.");
+      }
+    });
+  }
+  function getRoleByUserId(value) {
+    return __async(this, null, function* () {
+      try {
+        value = new import_mongodb12.ObjectId(value);
+      } catch (error) {
+        throw new import_utils12.BadRequestError("Invalid user ID.");
+      }
+      try {
+        return yield collection.findOne({ user: value });
+      } catch (error) {
+        throw new import_utils12.InternalServerError("Failed to retrieve role by user ID.");
+      }
+    });
+  }
+  function getRoleById(_id) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb12.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils12.BadRequestError("Invalid ID.");
+      }
+      try {
+        return yield collection.findOne({ _id });
+      } catch (error) {
+        throw new import_utils12.InternalServerError("Failed to retrieve role by ID.");
+      }
+    });
+  }
+  function getRoleByName(name) {
+    return __async(this, null, function* () {
+      if (!name) {
+        throw new import_utils12.BadRequestError("Role name is required.");
+      }
+      try {
+        return yield collection.findOne({ name });
+      } catch (error) {
+        throw new import_utils12.InternalServerError("Failed to retrieve role by name.");
+      }
+    });
+  }
+  function getRoles() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      limit = 10,
+      sort = {},
+      type = ""
+    } = {}) {
+      page = page > 0 ? page - 1 : 0;
+      const query = { status: "active" };
+      sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+      if (search) {
+        query.$text = { $search: search };
+      }
+      if (type) {
+        query.type = type;
+      }
+      try {
+        const items = yield collection.aggregate([
+          { $match: query },
+          { $sort: sort },
+          { $skip: page * limit },
+          { $limit: limit }
+        ]).toArray();
+        const length = yield collection.countDocuments(query);
+        return (0, import_utils12.paginate)(items, page, limit, length);
+      } catch (error) {
+        import_utils12.logger.log({ level: "error", message: `${error}` });
+        throw error;
+      }
+    });
+  }
+  function updateRole(_id, value, session) {
+    return __async(this, null, function* () {
+      if (!_id) {
+        throw new import_utils12.BadRequestError("Role ID is required.");
+      }
+      try {
+        _id = new import_mongodb12.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils12.BadRequestError("Invalid role ID.");
+      }
+      if (!value.name) {
+        delete value.name;
+      }
+      if (!value.permissions) {
+        delete value.permissions;
+      }
+      if (value.name || value.permissions) {
+        try {
+          yield collection.updateOne({ _id }, { $set: value }, { session });
+          return "Successfully updated role.";
+        } catch (error) {
+          throw new import_utils12.InternalServerError("Failed to update role.");
+        }
+      } else {
+        throw new import_utils12.BadRequestError("No fields to update.");
+      }
+    });
+  }
+  function deleteRole(_id, session) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb12.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils12.BadRequestError("Invalid ID.");
+      }
+      try {
+        yield collection.deleteOne(
+          { _id },
+          {
+            session
+          }
+        );
+        return "Successfully deleted role.";
+      } catch (error) {
+        throw new import_utils12.InternalServerError("Failed to delete role.");
+      }
+    });
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createUniqueIndex,
+    addRole,
+    getRoles,
+    getRoleByUserId,
+    getRoleById,
+    getRoleByName,
+    updateRole,
+    deleteRole
+  };
+}
+
+// src/services/file.service.ts
+var import_utils13 = require("@goweekdays/utils");
+var import_node_cron = __toESM(require("node-cron"));
+function useFileService() {
+  const {
+    createFile: _createFile,
+    deleteFileById,
+    getAllDraftedFiles
+  } = useFileRepo();
+  const s3 = new import_utils13.useS3({
+    accessKeyId: SPACES_ACCESS_KEY,
+    secretAccessKey: SPACES_SECRET_KEY,
+    endpoint: SPACES_ENDPOINT,
+    region: SPACES_REGION,
+    bucket: SPACES_BUCKET
+  });
+  function createFile(value) {
+    return __async(this, null, function* () {
+      var _a;
+      const session = (_a = import_utils13.useAtlas.getClient()) == null ? void 0 : _a.startSession();
+      session == null ? void 0 : session.startTransaction();
+      const file = {
+        name: value.originalname,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      try {
+        const id = yield _createFile(file, session);
+        yield s3.uploadObject({
+          key: id,
+          body: value.buffer,
+          contentType: value.mimetype
+        });
+        yield session == null ? void 0 : session.commitTransaction();
+        return id;
+      } catch (error) {
+        yield session == null ? void 0 : session.abortTransaction();
+        throw error;
+      } finally {
+        session == null ? void 0 : session.endSession();
+      }
+    });
+  }
+  function deleteFile(id) {
+    return __async(this, null, function* () {
+      var _a;
+      const session = (_a = import_utils13.useAtlas.getClient()) == null ? void 0 : _a.startSession();
+      session == null ? void 0 : session.startTransaction();
+      try {
+        yield deleteFileById(id, session);
+        yield s3.deleteObject(id);
+        yield session == null ? void 0 : session.commitTransaction();
+        return "File deleted successfully";
+      } catch (error) {
+        yield session == null ? void 0 : session.abortTransaction();
+        throw error;
+      } finally {
+        session == null ? void 0 : session.endSession();
+      }
+    });
+  }
+  function deleteDraft() {
+    import_node_cron.default.schedule("0 0 * * *", () => __async(this, null, function* () {
+      const files = yield getAllDraftedFiles();
+      for (let index = 0; index < files.length; index++) {
+        const file = files[index];
+        try {
+          yield deleteFile(file._id.toString());
+          yield import_utils13.logger.log({
+            level: "info",
+            message: "Successfully deleted draft files."
+          });
+        } catch (error) {
+          import_utils13.logger.log({
+            level: "info",
+            message: "Successfully deleted draft files."
+          });
+          return;
+        }
+      }
+    }));
+  }
+  return {
+    createFile,
+    deleteFile,
+    deleteDraft
+  };
+}
+
+// src/controllers/file.controller.ts
+var import_utils14 = require("@goweekdays/utils");
+var import_joi4 = __toESM(require("joi"));
+function useFileController() {
+  const { createFile, deleteFile: _deleteFile } = useFileService();
+  function upload(req, res, next) {
+    return __async(this, null, function* () {
+      if (!req.file) {
+        res.status(400).send("File is required!");
+        return;
+      }
+      try {
+        const id = yield createFile(req.file);
+        res.json({ message: "Successfully uploaded file", id });
+        return;
+      } catch (error) {
+        if (error instanceof import_utils14.AppError) {
+          next(error);
+        } else {
+          next(new import_utils14.InternalServerError(error));
+        }
+      }
+    });
+  }
+  function deleteFile(req, res, next) {
+    return __async(this, null, function* () {
+      const id = req.params.id;
+      const validation = import_joi4.default.string().required();
+      const { error } = validation.validate(id);
+      if (error) {
+        next(new import_utils14.BadRequestError(error.message));
+      }
+      try {
+        const message = yield _deleteFile(id);
+        res.json({ message });
+        return;
+      } catch (error2) {
+        if (error2 instanceof import_utils14.AppError) {
+          next(error2);
+        } else {
+          next(new import_utils14.InternalServerError(error2));
+        }
+      }
+    });
+  }
+  return {
+    upload,
+    deleteFile
+  };
+}
+
+// src/services/role.service.ts
+function useRoleService() {
+  const {
+    addRole,
+    getRoles: _getRoles,
+    getRoleByUserId: _getRoleByUserId,
+    getRoleById: _getRoleById,
+    getRoleByName: _getRoleByName,
+    updateRole: _updateRole,
+    deleteRole: _deleteRole
+  } = useRoleRepo();
+  function createRole(value) {
+    return __async(this, null, function* () {
+      try {
+        return yield addRole(value);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getRoles() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      limit = 10,
+      type = ""
+    } = {}) {
+      try {
+        return yield _getRoles({ search, page, limit, type });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getRoleByUserId(value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _getRoleByUserId(value);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getRoleById(_id) {
+    return __async(this, null, function* () {
+      try {
+        return yield _getRoleById(_id);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getRoleByName(name) {
+    return __async(this, null, function* () {
+      try {
+        return yield _getRoleByName(name);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function updateRole(_id, value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _updateRole(_id, value);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function deleteRole(_id) {
+    return __async(this, null, function* () {
+      try {
+        return yield _deleteRole(_id);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  return {
+    createRole,
+    getRoles,
+    getRoleByUserId,
+    getRoleById,
+    getRoleByName,
+    updateRole,
+    deleteRole
+  };
+}
+
+// src/controllers/role.controller.ts
+var import_joi5 = __toESM(require("joi"));
+var import_utils15 = require("@goweekdays/utils");
+function useRoleController() {
+  const {
+    createRole: _createRole,
+    getRoleById: _getRoleById,
+    getRoleByUserId: _getRoleByUserId,
+    getRoles: _getRoles,
+    updateRole: _updateRole,
+    deleteRole: _deleteRole
+  } = useRoleService();
+  function createRole(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const name = (_a = req.body.name) != null ? _a : "";
+      const permissions = (_b = req.body.permissions) != null ? _b : [];
+      const type = (_c = req.body.type) != null ? _c : "";
+      const validation = import_joi5.default.object({
+        name: import_joi5.default.string().required(),
+        permissions: import_joi5.default.array().items(import_joi5.default.string()).required(),
+        type: import_joi5.default.string().optional().allow("", null)
+      });
+      const { error } = validation.validate({ name, permissions, type });
+      if (error) {
+        next(new import_utils15.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const role = yield _createRole({ name, permissions, type });
+        res.json({ message: "Successfully created role.", data: { role } });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function getRoles(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const search = (_a = req.query.search) != null ? _a : "";
+      const page = parseInt((_b = req.query.page) != null ? _b : "1");
+      const limit = parseInt((_c = req.query.limit) != null ? _c : "10");
+      const type = (_d = req.query.type) != null ? _d : "";
+      const validation = import_joi5.default.object({
+        search: import_joi5.default.string().optional().allow("", null),
+        page: import_joi5.default.number().required(),
+        limit: import_joi5.default.number().required(),
+        type: import_joi5.default.string().optional().allow("", null)
+      });
+      const { error } = validation.validate({ search, page, limit, type });
+      if (error) {
+        next(new import_utils15.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const data = yield _getRoles({ search, page, limit, type });
+        res.json(data);
+        return;
+      } catch (error2) {
+        console.log(error2);
+        next(error2);
+      }
+    });
+  }
+  function getRoleByUserId(req, res, next) {
+    return __async(this, null, function* () {
+      const userId = req.params.userId;
+      const validation = import_joi5.default.object({
+        userId: import_joi5.default.string().required()
+      });
+      const { error } = validation.validate({ userId });
+      if (error) {
+        next(new import_utils15.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const role = yield _getRoleByUserId(userId);
+        res.json({ message: "Successfully retrieved role.", data: { role } });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function getRoleById(req, res, next) {
+    return __async(this, null, function* () {
+      const _id = req.params.id;
+      const validation = import_joi5.default.object({
+        _id: import_joi5.default.string().hex().required()
+      });
+      const { error } = validation.validate({ _id });
+      if (error) {
+        next(new import_utils15.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const data = yield _getRoleById(_id);
+        res.json(data);
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function updateRole(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const _id = req.params.id;
+      const name = (_a = req.body.name) != null ? _a : "";
+      const permissions = (_b = req.body.permissions) != null ? _b : [];
+      const validation = import_joi5.default.object({
+        _id: import_joi5.default.string().required(),
+        name: import_joi5.default.string().required(),
+        permissions: import_joi5.default.array().items(import_joi5.default.string()).required()
+      });
+      const { error } = validation.validate({ _id, name, permissions });
+      if (error) {
+        next(new import_utils15.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const role = yield _updateRole(_id, { name, permissions });
+        res.json({ message: "Successfully updated role.", data: { role } });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function deleteRole(req, res, next) {
+    return __async(this, null, function* () {
+      const _id = req.params.id;
+      const validation = import_joi5.default.object({
+        _id: import_joi5.default.string().required()
+      });
+      const { error } = validation.validate({ _id });
+      if (error) {
+        next(new import_utils15.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const message = yield _deleteRole(_id);
+        res.json({ message });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  return {
+    createRole,
+    getRoles,
+    getRoleByUserId,
+    getRoleById,
+    updateRole,
+    deleteRole
+  };
+}
+
+// src/models/entity.model.ts
+var import_mongodb13 = require("mongodb");
+var MEntity = class {
+  constructor(value) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    this._id = (_a = value._id) != null ? _a : new import_mongodb13.ObjectId();
+    this.name = (_b = value.name) != null ? _b : "";
+    this.username = (_c = value.username) != null ? _c : "";
+    this.type = value.type;
+    this.createdAt = (_d = value.createdAt) != null ? _d : (/* @__PURE__ */ new Date()).toISOString();
+    this.updatedAt = (_e = value.updatedAt) != null ? _e : "";
+    this.deletedAt = (_f = value.deletedAt) != null ? _f : "";
+    this.status = (_g = value.status) != null ? _g : "active";
+  }
+};
+
+// src/repositories/entity.repository.ts
+var import_mongodb14 = require("mongodb");
+var import_utils16 = require("@goweekdays/utils");
+function useEntityRepo() {
+  const db = import_utils16.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils16.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("entities");
+  function createIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({ name: 1 });
+        yield collection.createIndex({ status: 1 });
+      } catch (error) {
+        throw new Error("Failed to create index for entity.");
+      }
+    });
+  }
+  function createUniqueIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({ name: 1, deletedAt: 1 }, { unique: true });
+      } catch (error) {
+        throw new Error("Failed to create unique index on email.");
+      }
+    });
+  }
+  function createEntity(value, session) {
+    return __async(this, null, function* () {
+      try {
+        value = new MEntity(value);
+        const res = yield collection.insertOne(value, {
+          session
+        });
+        return res.insertedId.toString();
+      } catch (error) {
+        import_utils16.logger.log({ level: "error", message: `${error}` });
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_utils16.BadRequestError("Entity name already exists.");
+        }
+        throw new import_utils16.InternalServerError("Failed to create entity.");
+      }
+    });
+  }
+  function getEntities() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      limit = 10,
+      sort = {}
+    } = {}) {
+      page = page > 0 ? page - 1 : 0;
+      const query = { status: "active" };
+      sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+      if (search) {
+        query.$text = { $search: search };
+      }
+      try {
+        const items = yield collection.aggregate([
+          { $match: query },
+          { $sort: sort },
+          { $skip: page * limit },
+          { $limit: limit }
+        ]).toArray();
+        const length = yield collection.countDocuments(query);
+        return (0, import_utils16.paginate)(items, page, limit, length);
+      } catch (error) {
+        import_utils16.logger.log({ level: "error", message: `${error}` });
+        throw error;
+      }
+    });
+  }
+  function updateEntityFieldById() {
+    return __async(this, arguments, function* ({ _id, field, value } = {}, session) {
+      const allowedFields = ["name"];
+      if (!allowedFields.includes(field)) {
+        throw new import_utils16.BadRequestError(
+          `Field "${field}" is not allowed to be updated.`
+        );
+      }
+      try {
+        _id = new import_mongodb14.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils16.BadRequestError("Invalid ID.");
+      }
+      try {
+        yield collection.updateOne(
+          { _id },
+          { $set: { [field]: value } },
+          // Dynamically set the field
+          { session }
+        );
+        return `Successfully updated entity ${field}.`;
+      } catch (error) {
+        throw new import_utils16.InternalServerError(`Failed to update entity ${field}.`);
+      }
+    });
+  }
+  function deleteEntity(_id) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb14.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils16.BadRequestError("Invalid entity ID.");
+      }
+      try {
+        return yield collection.updateOne(
+          { _id },
+          { $set: { status: "deleted", deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+        );
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+  return {
+    createIndex,
+    createUniqueIndex,
+    createEntity,
+    getEntities,
+    updateEntityFieldById,
+    deleteEntity
+  };
+}
+
+// src/services/entity.service.ts
+var import_utils17 = require("@goweekdays/utils");
+function useEntityService() {
+  const {
+    createEntity: _createEntity,
+    getEntities: _getEntities,
+    updateEntityFieldById: _updateEntityFieldById,
+    deleteEntity: _deleteEntity
+  } = useEntityRepo();
+  function createEntity(value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _createEntity(value);
+      } catch (error) {
+        throw new import_utils17.InternalServerError();
+      }
+    });
+  }
+  function getEntities(value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _getEntities(value);
+      } catch (error) {
+        throw new import_utils17.InternalServerError();
+      }
+    });
+  }
+  function updateEntityFieldById(_id, field, value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _updateEntityFieldById({ _id, field, value });
+      } catch (error) {
+        throw new import_utils17.InternalServerError();
+      }
+    });
+  }
+  function deleteEntity(_id) {
+    return __async(this, null, function* () {
+      try {
+        return yield _deleteEntity(_id);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  return {
+    createEntity,
+    getEntities,
+    updateEntityFieldById,
+    deleteEntity
+  };
+}
+
+// src/controllers/entity.controller.ts
+var import_joi6 = __toESM(require("joi"));
+var import_utils18 = require("@goweekdays/utils");
+function useEntityController() {
+  const {
+    createEntity: _createEntity,
+    getEntities: _getEntities,
+    updateEntityFieldById: _updateEntityFieldById,
+    deleteEntity: _deleteEntity
+  } = useEntityService();
+  function createEntity(req, res, next) {
+    return __async(this, null, function* () {
+      const value = req.body;
+      const validation = import_joi6.default.object({
+        name: import_joi6.default.string().required(),
+        type: import_joi6.default.string().valid(
+          "strand",
+          "office",
+          "bureau",
+          "service",
+          "person"
+        )
+      });
+      const { error } = validation.validate(value);
+      if (error) {
+        next(new import_utils18.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const id = yield _createEntity(value);
+        res.json({ message: "Successfully created entity.", id });
+        return;
+      } catch (error2) {
+        console.log(error2);
+        next(error2);
+        return;
+      }
+    });
+  }
+  function getEntities(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const search = (_a = req.query.search) != null ? _a : "";
+      const page = (_b = Number(req.query.page)) != null ? _b : 1;
+      const limit = (_c = Number(req.query.limit)) != null ? _c : 10;
+      const validation = import_joi6.default.object({
+        search: import_joi6.default.string().allow(""),
+        page: import_joi6.default.number().min(1),
+        limit: import_joi6.default.number().min(1)
+      });
+      const { error } = validation.validate(req.query);
+      if (error) {
+        next(new import_utils18.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const entities = yield _getEntities({
+          search,
+          page,
+          limit
+        });
+        res.json(entities);
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  function updateEntityFieldById(req, res, next) {
+    return __async(this, null, function* () {
+      const { id, field, value } = req.body;
+      const validation = import_joi6.default.object({
+        id: import_joi6.default.string().required(),
+        field: import_joi6.default.string().required(),
+        value: import_joi6.default.string().required()
+      });
+      const { error } = validation.validate({ id, field, value });
+      if (error) {
+        next(new import_utils18.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _updateEntityFieldById(id, field, value);
+        res.json({ message: "Entity updated." });
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  function deleteEntity(req, res, next) {
+    return __async(this, null, function* () {
+      const { id } = req.params;
+      const validation = import_joi6.default.object({
+        id: import_joi6.default.string().required()
+      });
+      const { error } = validation.validate({ id });
+      if (error) {
+        next(new import_utils18.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _deleteEntity(id);
+        res.json({ message: "Entity deleted." });
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  return {
+    createEntity,
+    getEntities,
+    updateEntityFieldById,
+    deleteEntity
+  };
+}
+
+// src/models/workflow.model.ts
+var import_mongodb15 = require("mongodb");
+var MWorkflow = class {
+  constructor(value) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    this._id = (_a = value._id) != null ? _a : new import_mongodb15.ObjectId();
+    this.name = (_b = value.name) != null ? _b : "";
+    this.steps = (_c = value.steps) != null ? _c : [];
+    this.status = (_d = value.status) != null ? _d : "active";
+    this.createdAt = (_e = value.createdAt) != null ? _e : (/* @__PURE__ */ new Date()).toISOString();
+    this.updatedAt = (_f = value.updatedAt) != null ? _f : "";
+    this.deletedAt = (_g = value.deletedAt) != null ? _g : "";
+  }
+};
+
+// src/repositories/workflow.repository.ts
+var import_mongodb16 = require("mongodb");
+var import_utils19 = require("@goweekdays/utils");
+function useWorkflowRepo() {
+  const db = import_utils19.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils19.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("workflows");
+  function createIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({ name: 1 });
+        yield collection.createIndex({ status: 1 });
+      } catch (error) {
+        throw new Error("Failed to create index for workflow.");
+      }
+    });
+  }
+  function createUniqueIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({ name: 1, deletedAt: 1 }, { unique: true });
+      } catch (error) {
+        throw new Error("Failed to create unique index for workflow.");
+      }
+    });
+  }
+  function createWorkflow(value) {
+    return __async(this, null, function* () {
+      try {
+        value = new MWorkflow(value);
+        const res = yield collection.insertOne(value);
+        return res.insertedId.toString();
+      } catch (error) {
+        const duplicated = error.message.includes("duplicate");
+        if (duplicated) {
+          throw new import_utils19.BadRequestError("Workflow name already exists.");
+        }
+        throw new import_utils19.InternalServerError("Failed to create workflow.");
+      }
+    });
+  }
+  function getWorkflows() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      limit = 10,
+      sort = {}
+    } = {}) {
+      page = page > 0 ? page - 1 : 0;
+      const query = { status: "active" };
+      sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+      if (search) {
+        query.$text = { $search: search };
+      }
+      try {
+        const items = yield collection.aggregate([
+          { $match: query },
+          { $sort: sort },
+          { $skip: page * limit },
+          { $limit: limit }
+        ]).toArray();
+        const length = yield collection.countDocuments(query);
+        return (0, import_utils19.paginate)(items, page, limit, length);
+      } catch (error) {
+        import_utils19.logger.log({ level: "error", message: `${error}` });
+        throw error;
+      }
+    });
+  }
+  function getWorkflowById(_id) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb16.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils19.BadRequestError("Invalid workflow ID.");
+      }
+      try {
+        return yield collection.findOne({ _id });
+      } catch (error) {
+        throw new import_utils19.InternalServerError("Failed to get workflow.");
+      }
+    });
+  }
+  function updateWorkflowFieldById() {
+    return __async(this, arguments, function* ({ _id, field, value } = {}, session) {
+      const allowedFields = ["name"];
+      if (!allowedFields.includes(field)) {
+        throw new import_utils19.BadRequestError(
+          `Field "${field}" is not allowed to be updated.`
+        );
+      }
+      try {
+        _id = new import_mongodb16.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils19.BadRequestError("Invalid ID.");
+      }
+      try {
+        yield collection.updateOne(
+          { _id },
+          { $set: { [field]: value } },
+          // Dynamically set the field
+          { session }
+        );
+        return `Successfully updated entity ${field}.`;
+      } catch (error) {
+        throw new import_utils19.InternalServerError(`Failed to update entity ${field}.`);
+      }
+    });
+  }
+  function deleteWorkflow(_id) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb16.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils19.BadRequestError("Invalid entity ID.");
+      }
+      try {
+        return yield collection.updateOne(
+          { _id },
+          { $set: { status: "deleted", deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+        );
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+  return {
+    createIndex,
+    createUniqueIndex,
+    createWorkflow,
+    getWorkflows,
+    getWorkflowById,
+    updateWorkflowFieldById,
+    deleteWorkflow
+  };
+}
+
+// src/services/workflow.service.ts
+function useWorkflowService() {
+  const {
+    createWorkflow: _createWorkflow,
+    getWorkflows: _getWorkflows,
+    getWorkflowById: _getWorkflowById,
+    updateWorkflowFieldById: _updateWorkflowFieldById,
+    deleteWorkflow: _deleteWorkflow
+  } = useWorkflowRepo();
+  function createWorkflow(value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _createWorkflow(value);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getWorkflows() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      limit = 10,
+      sort = {}
+    } = {}) {
+      try {
+        return yield _getWorkflows({ search, page, limit, sort });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getWorkflowById(_id) {
+    return __async(this, null, function* () {
+      try {
+        return yield _getWorkflowById(_id);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function updateWorkflowFieldById(_id, field, value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _updateWorkflowFieldById({ _id, field, value });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function deleteWorkflow(_id) {
+    return __async(this, null, function* () {
+      try {
+        return yield _deleteWorkflow(_id);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  return {
+    createWorkflow,
+    getWorkflows,
+    getWorkflowById,
+    updateWorkflowFieldById,
+    deleteWorkflow
+  };
+}
+
+// src/controllers/workflow.controller.ts
+var import_joi7 = __toESM(require("joi"));
+function useWorkflowController() {
+  const {
+    createWorkflow: _createWorkflow,
+    getWorkflows: _getWorkflows,
+    getWorkflowById: _getWorkflowById,
+    updateWorkflowFieldById: _updateWorkflowFieldById,
+    deleteWorkflow: _deleteWorkflow
+  } = useWorkflowService();
+  function createWorkflow(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const name = (_a = req.body.name) != null ? _a : "";
+      const steps = (_b = req.body.steps) != null ? _b : [];
+      const validation = import_joi7.default.object({
+        name: import_joi7.default.string().required(),
+        steps: import_joi7.default.array().items(
+          import_joi7.default.object({
+            name: import_joi7.default.string().required(),
+            assignedTo: import_joi7.default.string().optional(),
+            nextStep: import_joi7.default.string().optional
+          })
+        ).min(3).required()
+      });
+      const { error } = validation.validate({ name, steps });
+      if (error) {
+        next(error);
+        return;
+      }
+      try {
+        const id = yield _createWorkflow({ name, steps });
+        res.json({ message: "Successfully created workflow.", id });
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  function getWorkflows(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const search = (_a = req.query.search) != null ? _a : "";
+      const page = (_b = Number(req.query.page)) != null ? _b : 1;
+      const limit = (_c = Number(req.query.limit)) != null ? _c : 10;
+      const validation = import_joi7.default.object({
+        search: import_joi7.default.string().allow(""),
+        page: import_joi7.default.number().min(1),
+        limit: import_joi7.default.number().min(10)
+      });
+      const { error } = validation.validate(req.query);
+      if (error) {
+        next(error);
+        return;
+      }
+      try {
+        const workflows = yield _getWorkflows({ search, page, limit });
+        res.json(workflows);
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  function getWorkflowById(req, res, next) {
+    return __async(this, null, function* () {
+      var _a;
+      const id = (_a = req.params.id) != null ? _a : "";
+      const validation = import_joi7.default.object({
+        id: import_joi7.default.string().required()
+      });
+      const { error } = validation.validate({ id });
+      if (error) {
+        next(error);
+        return;
+      }
+      try {
+        const workflow = yield _getWorkflowById(id);
+        res.json(workflow);
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  function updateWorkflowFieldById(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const id = (_a = req.body.id) != null ? _a : "";
+      const field = (_b = req.body.field) != null ? _b : "";
+      const value = (_c = req.body.value) != null ? _c : "";
+      const validation = import_joi7.default.object({
+        id: import_joi7.default.string().required(),
+        field: import_joi7.default.string().required(),
+        value: import_joi7.default.string().required()
+      });
+      const { error } = validation.validate({ id, field, value });
+      if (error) {
+        next(error);
+        return;
+      }
+      try {
+        yield _updateWorkflowFieldById(id, field, value);
+        res.json({ message: "Successfully updated workflow." });
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  function deleteWorkflow(req, res, next) {
+    return __async(this, null, function* () {
+      var _a;
+      const id = (_a = req.body.id) != null ? _a : "";
+      const validation = import_joi7.default.object({
+        id: import_joi7.default.string().required()
+      });
+      const { error } = validation.validate({ id });
+      if (error) {
+        next(error);
+        return;
+      }
+      try {
+        yield _deleteWorkflow(id);
+        res.json({ message: "Successfully deleted workflow." });
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  return {
+    createWorkflow,
+    getWorkflows,
+    getWorkflowById,
+    updateWorkflowFieldById,
+    deleteWorkflow
+  };
+}
+
+// src/models/cap-bldg-act.model.ts
+var import_mongodb17 = require("mongodb");
+var MCapBldgAct = class {
+  constructor(value) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q;
+    this._id = (_a = value._id) != null ? _a : new import_mongodb17.ObjectId();
+    this.title = (_b = value.title) != null ? _b : "";
+    this.subject = (_c = value.subject) != null ? _c : "";
+    this.PMISActivityCode = (_d = value.PMISActivityCode) != null ? _d : "";
+    this.type = (_e = value.type) != null ? _e : "";
+    this.strandMandateAddressed = (_f = value.strandMandateAddressed) != null ? _f : "";
+    this.objectives = (_g = value.objectives) != null ? _g : [];
+    this.withCPDUnits = (_h = value.withCPDUnits) != null ? _h : false;
+    this.completeStaffWorkReport = (_i = value.completeStaffWorkReport) != null ? _i : "";
+    this.withATC = (_j = value.withATC) != null ? _j : null;
+    this.ATC = (_k = value.ATC) != null ? _k : "";
+    this.conceptNote = (_l = value.conceptNote) != null ? _l : "";
+    this.certOfFundAvailability = (_m = value.certOfFundAvailability) != null ? _m : "";
+    this.budgetProposal = (_n = value.budgetProposal) != null ? _n : "";
+    this.targets = (_o = value.targets) != null ? _o : [];
+    this.PRCFormsTemplate = (_p = value.PRCFormsTemplate) != null ? _p : "";
+    this.HGDGTool = (_q = value.HGDGTool) != null ? _q : "";
+    this.EXECOMLeadEndorsement = (_r = value.EXECOMLeadEndorsement) != null ? _r : "";
+    this.individualResults = (_s = value.individualResults) != null ? _s : [];
+    this.organizationalResults = (_t = value.organizationalResults) != null ? _t : [];
+    this.indicative = (_u = value.indicative) != null ? _u : "";
+    this.tentative = (_v = value.tentative) != null ? _v : { month: "", day: 0 };
+    this.tentativeOption = (_w = value.tentativeOption) != null ? _w : { month: "", day: 0 };
+    this.tentativeYear = (_x = value.tentativeYear) != null ? _x : 0;
+    this.GADAttrRate = (_y = value.GADAttrRate) != null ? _y : 0;
+    this.GADAttrRateAmount = (_z = value.GADAttrRateAmount) != null ? _z : 0;
+    this.NTPCO = (_A = value.NTPCO) != null ? _A : {
+      teaching: 0,
+      nonteaching: 0,
+      teachingRelated: 0
+    };
+    this.NTPRO = (_B = value.NTPRO) != null ? _B : {
+      teaching: 0,
+      nonteaching: 0,
+      teachingRelated: 0
+    };
+    this.NTPSDO = (_C = value.NTPSDO) != null ? _C : {
+      teaching: 0,
+      nonteaching: 0,
+      teachingRelated: 0
+    };
+    this.NTPSchool = (_D = value.NTPSchool) != null ? _D : {
+      teaching: 0,
+      nonteaching: 0,
+      teachingRelated: 0
+    };
+    this.withSkeletonWorkforce = (_E = value.withSkeletonWorkforce) != null ? _E : null;
+    this.skeletonWorkforce = (_F = value.skeletonWorkforce) != null ? _F : "";
+    this.roles = (_G = value.roles) != null ? _G : [];
+    this.rolesRate = (_H = value.rolesRate) != null ? _H : [];
+    this.skills = (_I = value.skills) != null ? _I : [];
+    this.skillsRate = (_J = value.skillsRate) != null ? _J : [];
+    this.resourceEfficiencyRate = (_K = value.resourceEfficiencyRate) != null ? _K : [];
+    this.AOOR = (_L = value.AOOR) != null ? _L : [];
+    this.AOOS = (_M = value.AOOS) != null ? _M : [];
+    this.status = (_N = value.status) != null ? _N : "draft";
+    if (value.createdBy instanceof import_mongodb17.ObjectId) {
+      try {
+        value.createdBy = new import_mongodb17.ObjectId(value.createdBy);
+      } catch (error) {
+        throw new Error("Invalid createdBy ObjectId.");
+      }
+    }
+    this.createdBy = value.createdBy;
+    this.createdAt = (_O = value.createdAt) != null ? _O : (/* @__PURE__ */ new Date()).toISOString();
+    this.updatedAt = (_P = value.updatedAt) != null ? _P : "";
+    this.deletedAt = (_Q = value.deletedAt) != null ? _Q : "";
+  }
+};
+
+// src/repositories/cap-bldg-act.repository.ts
+var import_mongodb18 = require("mongodb");
+var import_utils20 = require("@goweekdays/utils");
+function useCapBldgActRepo() {
+  const db = import_utils20.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils20.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("cap-bldg-acts");
+  function createIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({ title: 1 });
+        yield collection.createIndex({ subject: 1 });
+        yield collection.createIndex({ type: 1 });
+        yield collection.createIndex({ status: 1 });
+      } catch (error) {
+        throw new Error("Failed to create index for cap-bldg-acts.");
+      }
+    });
+  }
+  function createTextIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({
+          title: "text",
+          subject: "text",
+          type: "text"
+        });
+      } catch (error) {
+        throw new Error("Failed to create text index on cap-bldg-acts.");
+      }
+    });
+  }
+  function createCapBldgAct(value, session) {
+    return __async(this, null, function* () {
+      try {
+        value = new MCapBldgAct(value);
+        const res = yield collection.insertOne(value, {
+          session
+        });
+        return res.insertedId.toString();
+      } catch (error) {
+        import_utils20.logger.log({ level: "error", message: `${error}` });
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_utils20.BadRequestError("CapBldgAct name already exists.");
+        }
+        throw new import_utils20.InternalServerError("Failed to create CapBldgAct.");
+      }
+    });
+  }
+  function updateCapBldgActBasicInfo() {
+    return __async(this, arguments, function* ({ _id, value } = {}, session) {
+      try {
+        _id = new import_mongodb18.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      }
+      try {
+        yield collection.updateOne(
+          { _id },
+          { $set: value },
+          {
+            session
+          }
+        );
+      } catch (error) {
+        import_utils20.logger.log({ level: "error", message: `${error}` });
+        throw new import_utils20.InternalServerError("Failed to update CapBldgAct basic info.");
+      }
+    });
+  }
+  function updateCapBldgActInitRevEval() {
+    return __async(this, arguments, function* ({ _id, value } = {}, session) {
+      try {
+        _id = new import_mongodb18.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      }
+      try {
+        yield collection.updateOne(
+          { _id },
+          { $set: value },
+          {
+            session
+          }
+        );
+      } catch (error) {
+        import_utils20.logger.log({ level: "error", message: `${error}` });
+        throw new import_utils20.InternalServerError(
+          "Failed to update CapBldgAct initial review and evaluation."
+        );
+      }
+    });
+  }
+  function updateCapBldgActAssmtCriteria() {
+    return __async(this, arguments, function* ({ _id, value } = {}, session) {
+      try {
+        _id = new import_mongodb18.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      }
+      try {
+        yield collection.updateOne(
+          { _id },
+          { $set: value },
+          {
+            session
+          }
+        );
+      } catch (error) {
+        import_utils20.logger.log({ level: "error", message: `${error}` });
+        throw new import_utils20.InternalServerError(
+          "Failed to update CapBldgAct assessment criteria."
+        );
+      }
+    });
+  }
+  function getById(_id) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb18.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      }
+      try {
+        return yield collection.findOne({ _id });
+      } catch (error) {
+        import_utils20.logger.log({ level: "error", message: `${error}` });
+        throw new import_utils20.InternalServerError("Failed to create CapBldgAct.");
+      }
+    });
+  }
+  function getCapBldgActs() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      limit = 10,
+      sort = {},
+      status = "draft"
+    } = {}) {
+      page = page > 0 ? page - 1 : 0;
+      const query = { status };
+      if (status === "ongoing") {
+        query.status = {
+          $in: [
+            "for-internal-review",
+            "for-initial-evaluation",
+            "for-endorsement",
+            "for-final-review",
+            "for-final-evaluation",
+            "for-clearance",
+            "for-signature",
+            "for-approval"
+          ]
+        };
+      }
+      sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+      if (search) {
+        query.$text = { $search: search };
+      }
+      try {
+        const items = yield collection.aggregate([
+          { $match: query },
+          { $sort: sort },
+          { $skip: page * limit },
+          { $limit: limit }
+        ]).toArray();
+        const length = yield collection.countDocuments(query);
+        return (0, import_utils20.paginate)(items, page, limit, length);
+      } catch (error) {
+        import_utils20.logger.log({ level: "error", message: `${error}` });
+        throw error;
+      }
+    });
+  }
+  function updateCapBldgActFieldById() {
+    return __async(this, arguments, function* ({ _id, field, value } = {}, session) {
+      const allowedFields = [
+        "completeStaffWorkReport",
+        "ATC",
+        "certOfFundAvailability",
+        "conceptNote",
+        "budgetProposal",
+        "PRCFormsTemplate",
+        "HGDGTool",
+        "EXECOMLeadEndorsement",
+        "skeletonWorkforce",
+        "status"
+      ];
+      if (!allowedFields.includes(field)) {
+        throw new import_utils20.BadRequestError(
+          `Field "${field}" is not allowed to be updated.`
+        );
+      }
+      try {
+        _id = new import_mongodb18.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils20.BadRequestError("Invalid ID.");
+      }
+      try {
+        yield collection.updateOne(
+          { _id },
+          { $set: { [field]: value } },
+          // Dynamically set the field
+          { session }
+        );
+        return `Successfully updated CapBldgAct ${field}.`;
+      } catch (error) {
+        throw new import_utils20.InternalServerError(`Failed to update CapBldgAct ${field}.`);
+      }
+    });
+  }
+  function deleteCapBldgAct(_id) {
+    return __async(this, null, function* () {
+      try {
+        _id = new import_mongodb18.ObjectId(_id);
+      } catch (error) {
+        throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      }
+      try {
+        return yield collection.updateOne(
+          { _id },
+          { $set: { status: "deleted", deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+        );
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createCapBldgAct,
+    getById,
+    getCapBldgActs,
+    updateCapBldgActFieldById,
+    deleteCapBldgAct,
+    updateCapBldgActBasicInfo,
+    updateCapBldgActInitRevEval,
+    updateCapBldgActAssmtCriteria
+  };
+}
+
+// src/services/cap-bldg-act.service.ts
+var import_utils21 = require("@goweekdays/utils");
+function useCapBldgActService() {
+  const {
+    createCapBldgAct: _createCapBldgAct,
+    getCapBldgActs: _getCapBldgActs,
+    getById: _getById,
+    updateCapBldgActFieldById: _updateCapBldgActFieldById,
+    deleteCapBldgAct: _deleteCapBldgAct,
+    updateCapBldgActBasicInfo: _updateCapBldgActBasicInfo,
+    updateCapBldgActInitRevEval: _updateCapBldgActInitRevEval,
+    updateCapBldgActAssmtCriteria: _updateCapBldgActAssmt
+  } = useCapBldgActRepo();
+  function createCapBldgAct(value) {
+    return __async(this, null, function* () {
+      try {
+        value = new MCapBldgAct(value);
+        return yield _createCapBldgAct(value);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function updateCapBldgActBasicInfo(_id, value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _updateCapBldgActBasicInfo({ _id, value });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function updateCapBldgActInitRevEval(_id, value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _updateCapBldgActInitRevEval({ _id, value });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function updateCapBldgActAssmtCriteria(_id, value) {
+    return __async(this, null, function* () {
+      try {
+        return yield _updateCapBldgActAssmt({ _id, value });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getCapBldgActs() {
+    return __async(this, arguments, function* ({
+      search = "",
+      page = 1,
+      status = "",
+      limit = 10
+    } = {}) {
+      try {
+        return yield _getCapBldgActs({ search, page, status, limit });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getById(id) {
+    return __async(this, null, function* () {
+      try {
+        return yield _getById(id);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function updateCapBldgActFieldById() {
+    return __async(this, arguments, function* ({
+      _id = "",
+      field = "",
+      value = ""
+    } = {}) {
+      try {
+        return yield _updateCapBldgActFieldById({ _id, field, value });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function deleteCapBldgAct(id) {
+    return __async(this, null, function* () {
+      try {
+        return yield _deleteCapBldgAct(id);
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  const s3 = new import_utils21.useS3({
+    accessKeyId: SPACES_ACCESS_KEY,
+    secretAccessKey: SPACES_SECRET_KEY,
+    endpoint: SPACES_ENDPOINT,
+    region: SPACES_REGION,
+    bucket: SPACES_BUCKET
+  });
+  const { createFile: _createFile, deleteFileById } = useFileRepo();
+  function uploadAttachment(value, id, field) {
+    return __async(this, null, function* () {
+      var _a;
+      const session = (_a = import_utils21.useAtlas.getClient()) == null ? void 0 : _a.startSession();
+      session == null ? void 0 : session.startTransaction();
+      const file = {
+        name: value.originalname,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      try {
+        const _id = yield _createFile(file, session);
+        yield s3.uploadObject({
+          key: _id,
+          body: value.buffer,
+          contentType: value.mimetype
+        });
+        yield _updateCapBldgActFieldById({ _id: id, field, value: _id }, session);
+        yield session == null ? void 0 : session.commitTransaction();
+        return id;
+      } catch (error) {
+        yield session == null ? void 0 : session.abortTransaction();
+        throw error;
+      } finally {
+        session == null ? void 0 : session.endSession();
+      }
+    });
+  }
+  function deleteAttachment(attachment, id, field) {
+    return __async(this, null, function* () {
+      var _a;
+      const session = (_a = import_utils21.useAtlas.getClient()) == null ? void 0 : _a.startSession();
+      session == null ? void 0 : session.startTransaction();
+      try {
+        yield deleteFileById(attachment, session);
+        yield _updateCapBldgActFieldById({ _id: id, field, value: "" }, session);
+        yield s3.deleteObject(attachment);
+        yield session == null ? void 0 : session.commitTransaction();
+        return "Attachment successfully deleted.";
+      } catch (error) {
+        yield session == null ? void 0 : session.abortTransaction();
+        throw error;
+      } finally {
+        session == null ? void 0 : session.endSession();
+      }
+    });
+  }
+  return {
+    createCapBldgAct,
+    getCapBldgActs,
+    getById,
+    updateCapBldgActFieldById,
+    deleteCapBldgAct,
+    updateCapBldgActBasicInfo,
+    updateCapBldgActInitRevEval,
+    updateCapBldgActAssmtCriteria,
+    uploadAttachment,
+    deleteAttachment
+  };
+}
+
+// src/controllers/cap-bldg-act.controller.ts
+var import_joi8 = __toESM(require("joi"));
+var import_utils22 = require("@goweekdays/utils");
+function useCapBldgActController() {
+  const {
+    createCapBldgAct: _createCapBldgAct,
+    getCapBldgActs: _getCapBldgActs,
+    getById: _getById,
+    updateCapBldgActBasicInfo: _updateBasicInformation,
+    updateCapBldgActInitRevEval: _updateInitRevEval,
+    updateCapBldgActAssmtCriteria: _updateAssmtCriteria,
+    updateCapBldgActFieldById: _updateFieldById,
+    uploadAttachment: _uploadAttachment,
+    deleteAttachment: _deleteAttachment
+  } = useCapBldgActService();
+  function createCapBldgAct(req, res, next) {
+    return __async(this, null, function* () {
+      const value = req.body;
+      const validation = import_joi8.default.object({
+        title: import_joi8.default.string().required(),
+        subject: import_joi8.default.string().required(),
+        PMISActivityCode: import_joi8.default.string().required(),
+        type: import_joi8.default.string().required(),
+        strandMandateAddressed: import_joi8.default.string().required(),
+        objectives: import_joi8.default.array().items(import_joi8.default.string()).min(3).max(3).required(),
+        withCPDUnits: import_joi8.default.boolean().required(),
+        createdBy: import_joi8.default.string().hex().required()
+      });
+      const { error } = validation.validate(value);
+      if (error) {
+        next(new import_utils22.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _createCapBldgAct(value);
+        res.json({ message: "Successfully created CBA request." });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function updateBasicInformation(req, res, next) {
+    return __async(this, null, function* () {
+      var _a;
+      const value = req.body;
+      const id = (_a = req.params.id) != null ? _a : "";
+      const validation = import_joi8.default.object({
+        id: import_joi8.default.string().hex().required(),
+        title: import_joi8.default.string().required(),
+        subject: import_joi8.default.string().required(),
+        PMISActivityCode: import_joi8.default.string().required(),
+        type: import_joi8.default.string().required(),
+        strandMandateAddressed: import_joi8.default.string().required(),
+        objectives: import_joi8.default.array().items(import_joi8.default.string()).min(3).max(3).required(),
+        withCPDUnits: import_joi8.default.boolean().required()
+      });
+      const { error } = validation.validate(__spreadProps(__spreadValues({}, value), { id }));
+      if (error) {
+        next(new import_utils22.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _updateBasicInformation(id, value);
+        res.json({ message: "Successfully updated CBA basic information." });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function updateInitRevEval(req, res, next) {
+    return __async(this, null, function* () {
+      var _a;
+      const value = req.body;
+      const id = (_a = req.params.id) != null ? _a : "";
+      const NTP = import_joi8.default.object({
+        teaching: import_joi8.default.number().required(),
+        nonteaching: import_joi8.default.number().required(),
+        teachingRelated: import_joi8.default.number().required()
+      }).required();
+      const tentative = import_joi8.default.object({
+        month: import_joi8.default.string().required(),
+        day: import_joi8.default.number().required()
+      }).required();
+      const list = import_joi8.default.array().items(import_joi8.default.string()).min(3).max(3).required();
+      const validation = import_joi8.default.object({
+        id: import_joi8.default.string().hex().required(),
+        completeStaffWorkReport: import_joi8.default.string().required(),
+        withATC: import_joi8.default.boolean().required(),
+        ATC: import_joi8.default.string().required(),
+        conceptNote: import_joi8.default.string().required(),
+        certOfFundAvailability: import_joi8.default.string().required(),
+        budgetProposal: import_joi8.default.string().required(),
+        targets: list,
+        PRCFormsTemplate: import_joi8.default.string().required(),
+        HGDGTool: import_joi8.default.string().required(),
+        EXECOMLeadEndorsement: import_joi8.default.string().required(),
+        individualResults: list,
+        organizationalResults: list,
+        indicative: import_joi8.default.string().required(),
+        tentative,
+        tentativeOption: tentative,
+        tentativeYear: import_joi8.default.number().required(),
+        GADAttrRate: import_joi8.default.number().required(),
+        GADAttrRateAmount: import_joi8.default.number().required(),
+        NTPCO: NTP,
+        NTPRO: NTP,
+        NTPSDO: NTP,
+        NTPSchool: NTP,
+        withSkeletonWorkforce: import_joi8.default.boolean().required(),
+        skeletonWorkforce: import_joi8.default.string().required()
+      });
+      const { error } = validation.validate(__spreadProps(__spreadValues({}, value), { id }));
+      if (error) {
+        next(new import_utils22.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _updateInitRevEval(id, value);
+        res.json({
+          message: "Successfully updated CBA initial review and evaluation."
+        });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function updateAssmtCriteria(req, res, next) {
+    return __async(this, null, function* () {
+      var _a;
+      const value = req.body;
+      const id = (_a = req.params.id) != null ? _a : "";
+      const list = import_joi8.default.array().items(import_joi8.default.string()).min(3).max(3).required();
+      const listOptional = import_joi8.default.array().items(import_joi8.default.number().optional().allow(null)).optional().min(0).max(3);
+      const validation = import_joi8.default.object({
+        id: import_joi8.default.string().hex().required(),
+        roles: list,
+        rolesRate: listOptional,
+        skills: list,
+        skillsRate: listOptional,
+        resourceEfficiencyRate: listOptional,
+        AOOR: import_joi8.default.array().items(import_joi8.default.number().optional().allow(null)).optional().min(0).max(5),
+        AOOS: import_joi8.default.array().items(import_joi8.default.string().optional().allow(null)).min(0).max(5)
+      });
+      const { error } = validation.validate(__spreadProps(__spreadValues({}, value), { id }));
+      if (error) {
+        next(new import_utils22.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _updateAssmtCriteria(id, value);
+        res.json({
+          message: "Successfully updated CBA assessment criteria."
+        });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function getCapBldgActs(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const search = (_a = req.query.search) != null ? _a : "";
+      const page = req.query.page ? Number(req.query.page) : 1;
+      const limit = req.query.limit ? Number(req.query.limit) : 10;
+      const status = (_b = req.query.status) != null ? _b : "";
+      const validation = import_joi8.default.object({
+        search: import_joi8.default.string().allow(""),
+        page: import_joi8.default.number().min(1),
+        limit: import_joi8.default.number().min(1),
+        status: import_joi8.default.string().allow("")
+      });
+      const { error } = validation.validate(req.query);
+      if (error) {
+        next(new import_utils22.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const data = yield _getCapBldgActs({ search, page, limit, status });
+        res.json(data);
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function getById(req, res, next) {
+    return __async(this, null, function* () {
+      const { id } = req.params;
+      const validation = import_joi8.default.object({
+        id: import_joi8.default.string().required()
+      });
+      const { error } = validation.validate({ id });
+      if (error) {
+        next(new import_utils22.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const data = yield _getById(id);
+        res.json(data);
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function updateFieldById(req, res, next) {
+    return __async(this, null, function* () {
+      const _id = req.params.id;
+      const { field, value } = req.body;
+      const validation = import_joi8.default.object({
+        _id: import_joi8.default.string().hex().required(),
+        field: import_joi8.default.string().valid(
+          "completeStaffWorkReport",
+          "ATC",
+          "certOfFundAvailability",
+          "conceptNote",
+          "budgetProposal",
+          "PRCFormsTemplate",
+          "HGDGTool",
+          "EXECOMLeadEndorsement",
+          "skeletonWorkforce",
+          "status"
+        ).required(),
+        value: import_joi8.default.string().required()
+      });
+      const { error } = validation.validate({ _id, field, value });
+      if (error) {
+        next(new import_utils22.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const message = yield _updateFieldById({ _id, field, value });
+        res.json({ message });
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function uploadAttachment(req, res, next) {
+    return __async(this, null, function* () {
+      const file = req.file;
+      if (!file) {
+        res.status(400).send("File is required!");
+        return;
+      }
+      const id = req.params.id;
+      const field = req.body.field;
+      const validation = import_joi8.default.object({
+        id: import_joi8.default.string().required(),
+        field: import_joi8.default.string().required()
+      });
+      const { error } = validation.validate({ id, field });
+      if (error) {
+        next(new import_utils22.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const _file = yield _uploadAttachment(file, id, field);
+        res.json({ message: "Successfully uploaded attachment.", id: _file });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  function deleteAttachment(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const id = req.params.id;
+      const attachment = (_a = req.body.attachment) != null ? _a : "";
+      const field = (_b = req.body.field) != null ? _b : "";
+      const validation = import_joi8.default.string().required();
+      const { error } = validation.validate(id);
+      if (error) {
+        next(new import_utils22.BadRequestError(error.message));
+      }
+      try {
+        const message = yield _deleteAttachment(attachment, id, field);
+        res.json({ message });
+        return;
+      } catch (error2) {
+        next(error2);
+      }
+    });
+  }
+  return {
+    createCapBldgAct,
+    getCapBldgActs,
+    getById,
+    updateBasicInformation,
+    updateInitRevEval,
+    updateAssmtCriteria,
+    updateFieldById,
+    uploadAttachment,
+    deleteAttachment
+  };
+}
+
+// src/models/comment.model.ts
+var import_mongodb19 = require("mongodb");
+var MComment = class {
+  constructor(value) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    this._id = (_a = value._id) != null ? _a : new import_mongodb19.ObjectId();
+    this.comment = (_b = value.comment) != null ? _b : "";
+    this.type = (_c = value.type) != null ? _c : "common";
+    if (typeof value.user === "string") {
+      try {
+        value.user = new import_mongodb19.ObjectId(value.user);
+      } catch (error) {
+        throw new Error("Invalid user ID.");
+      }
+    }
+    this.user = (_d = value.user) != null ? _d : "";
+    this.collection = (_e = value.collection) != null ? _e : "";
+    if (typeof value.document === "string") {
+      try {
+        value.document = new import_mongodb19.ObjectId(value.document);
+      } catch (error) {
+        throw new Error("Invalid document ID.");
+      }
+    }
+    this.document = value.document;
+    this.createdAt = (_f = value.createdAt) != null ? _f : (/* @__PURE__ */ new Date()).toISOString();
+    this.updatedAt = (_g = value.updatedAt) != null ? _g : "";
+    this.deletedAt = (_h = value.deletedAt) != null ? _h : "";
+  }
+};
+
+// src/repositories/comment.repository.ts
+var import_mongodb20 = require("mongodb");
+var import_utils23 = require("@goweekdays/utils");
+function useCommentRepo() {
+  const db = import_utils23.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Database not initialized");
+  }
+  const collection = db.collection("comments");
+  function createIndex() {
+    return __async(this, null, function* () {
+      try {
+        yield collection.createIndex({ deletedAt: 1, document: 1 });
+      } catch (error) {
+        throw new Error("Failed to create index for cap-bldg-acts.");
+      }
+    });
+  }
+  function addComment(value) {
+    return __async(this, null, function* () {
+      try {
+        value = new MComment(value);
+        yield collection.insertOne(value);
+        return "Comment added successfully.";
+      } catch (error) {
+        throw new import_utils23.InternalServerError("Failed to add comment.");
+      }
+    });
+  }
+  function getComments() {
+    return __async(this, arguments, function* ({ search = "", page = 1, limit = 10, sort = {}, document = "" } = {}) {
+      page = page > 0 ? page - 1 : 0;
+      if (document) {
+        try {
+          document = new import_mongodb20.ObjectId(document);
+        } catch (error) {
+          throw new Error("Invalid document ID.");
+        }
+      }
+      const query = { deletedAt: "", document };
+      sort = Object.keys(sort).length > 0 ? sort : { _id: 1 };
+      if (search) {
+        query.$text = { $search: search };
+      }
+      try {
+        const items = yield collection.aggregate([
+          { $match: query },
+          { $sort: sort },
+          { $skip: page * limit },
+          { $limit: limit }
+        ]).toArray();
+        const length = yield collection.countDocuments(query);
+        return (0, import_utils23.paginate)(items, page, limit, length);
+      } catch (error) {
+        import_utils23.logger.log({ level: "error", message: `${error}` });
+        throw error;
+      }
+    });
+  }
+  return {
+    createIndex,
+    addComment,
+    getComments
+  };
+}
+
+// src/services/comment.service.ts
+function useCommentService() {
+  const { addComment: _addComment, getComments: _getComments } = useCommentRepo();
+  function addComment() {
+    return __async(this, arguments, function* ({ comment, type, user, collection, document } = {}) {
+      try {
+        return yield _addComment({
+          comment,
+          type,
+          user,
+          collection,
+          document
+        });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  function getComments() {
+    return __async(this, arguments, function* ({ page = 1, document = "" } = {}) {
+      try {
+        return yield _getComments({ page, document });
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  return {
+    addComment,
+    getComments
+  };
+}
+
+// src/controllers/comment.controller.ts
+var import_joi9 = __toESM(require("joi"));
+var import_utils24 = require("@goweekdays/utils");
+function useCommentController() {
+  const { addComment: _addComment, getComments: _getComments } = useCommentService();
+  function addComment(req, res, next) {
+    return __async(this, null, function* () {
+      const value = req.body;
+      const validation = import_joi9.default.object({
+        comment: import_joi9.default.string().required(),
+        type: import_joi9.default.string().valid("comment", "approve", "request-changes"),
+        user: import_joi9.default.string().hex().required(),
+        collection: import_joi9.default.string().required(),
+        document: import_joi9.default.string().hex().required()
+      });
+      const { error } = validation.validate(value);
+      if (error) {
+        next(new import_utils24.BadRequestError(error.message));
+        return;
+      }
+      try {
+        yield _addComment({
+          comment: value.comment,
+          type: value.type,
+          user: value.user,
+          collection: value.collection,
+          document: value.document
+        });
+        res.json({ message: "Successfully added comment." });
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  function getComments(req, res, next) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const page = (_a = Number(req.query.page)) != null ? _a : 1;
+      const document = (_b = req.query.document) != null ? _b : "";
+      const validation = import_joi9.default.object({
+        page: import_joi9.default.number().min(1),
+        document: import_joi9.default.string().hex().required()
+      });
+      const { error } = validation.validate({ page, document });
+      if (error) {
+        next(new import_utils24.BadRequestError(error.message));
+        return;
+      }
+      try {
+        const comments = yield _getComments({ page, document });
+        res.json(comments);
+        return;
+      } catch (error2) {
+        next(error2);
+        return;
+      }
+    });
+  }
+  return {
+    addComment,
+    getComments
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACCESS_TOKEN_EXPIRY,
+  ACCESS_TOKEN_SECRET,
+  APP_ACCOUNT,
+  AppError,
+  BadRequestError,
+  DEFAULT_USER_EMAIL,
+  DEFAULT_USER_FIRST_NAME,
+  DEFAULT_USER_LAST_NAME,
+  DEFAULT_USER_PASSWORD,
+  InternalServerError,
+  MAILER_EMAIL,
+  MAILER_PASSWORD,
+  MAILER_TRANSPORT_HOST,
+  MAILER_TRANSPORT_PORT,
+  MAILER_TRANSPORT_SECURE,
+  MCapBldgAct,
+  MComment,
+  MEntity,
+  MFile,
+  MONGO_DB,
+  MONGO_URI,
+  MRole,
+  MToken,
+  MUser,
+  MUserRole,
+  MVerification,
+  MWorkflow,
+  NotFoundError,
+  PORT,
+  REDIS_HOST,
+  REDIS_PASSWORD,
+  REDIS_PORT,
+  REFRESH_TOKEN_EXPIRY,
+  REFRESH_TOKEN_SECRET,
+  SECRET_KEY,
+  SPACES_ACCESS_KEY,
+  SPACES_BUCKET,
+  SPACES_ENDPOINT,
+  SPACES_REGION,
+  SPACES_SECRET_KEY,
+  UnauthorizedError,
+  VERIFICATION_FORGET_PASSWORD_DURATION,
+  VERIFICATION_USER_INVITE_DURATION,
+  authMiddleware,
+  comparePassword,
+  compileHandlebar,
+  errorHandler,
+  generateToken,
+  getDirectory,
+  hashPassword,
+  initRedisClient,
+  isDev,
+  logger,
+  paginate,
+  prependZeros,
+  toObjectId,
+  useAtlas,
+  useAuthController,
+  useAuthService,
+  useCapBldgActController,
+  useCapBldgActRepo,
+  useCapBldgActService,
+  useCommentController,
+  useCommentRepo,
+  useCommentService,
+  useEntityController,
+  useEntityRepo,
+  useEntityService,
+  useFileController,
+  useFileRepo,
+  useFileService,
+  useMailer,
+  useRedisClient,
+  useRoleController,
+  useRoleRepo,
+  useRoleService,
+  useS3,
+  useTokenRepo,
+  useUserController,
+  useUserRepo,
+  useUserService,
+  useVerificationController,
+  useVerificationRepo,
+  useVerificationService,
+  useWorkflowController,
+  useWorkflowRepo,
+  useWorkflowService
+});
+//# sourceMappingURL=index.js.map