@goweekdays/core 0.0.4 → 0.0.5

package/dist/index.js

@@ -11334,12 +11334,16 @@ __export(src_exports, {
   MAILER_TRANSPORT_HOST: () => MAILER_TRANSPORT_HOST,
   MAILER_TRANSPORT_PORT: () => MAILER_TRANSPORT_PORT,
   MAILER_TRANSPORT_SECURE: () => MAILER_TRANSPORT_SECURE,
+  MAddress: () => MAddress,
   MCapBldgAct: () => MCapBldgAct,
   MComment: () => MComment,
   MEntity: () => MEntity,
   MFile: () => MFile,
+  MMember: () => MMember,
   MONGO_DB: () => MONGO_DB,
   MONGO_URI: () => MONGO_URI,
+  MOrg: () => MOrg,
+  MPaymentMethod: () => MPaymentMethod,
   MRole: () => MRole,
   MSubscription: () => MSubscription,
   MToken: () => MToken,
@@ -11364,7 +11368,11 @@ __export(src_exports, {
   SPACES_SECRET_KEY: () => SPACES_SECRET_KEY,
   VERIFICATION_FORGET_PASSWORD_DURATION: () => VERIFICATION_FORGET_PASSWORD_DURATION,
   VERIFICATION_USER_INVITE_DURATION: () => VERIFICATION_USER_INVITE_DURATION,
+  XENDIT_BASE_URL: () => XENDIT_BASE_URL,
+  XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
   isDev: () => isDev,
+  useAddressController: () => useAddressController,
+  useAddressRepo: () => useAddressRepo,
   useAuthController: () => useAuthController,
   useAuthService: () => useAuthService,
   useCapBldgActController: () => useCapBldgActController,
@@ -11379,6 +11387,13 @@ __export(src_exports, {
   useFileController: () => useFileController,
   useFileRepo: () => useFileRepo,
   useFileService: () => useFileService,
+  useMemberRepo: () => useMemberRepo,
+  useOrgController: () => useOrgController,
+  useOrgRepo: () => useOrgRepo,
+  useOrgService: () => useOrgService,
+  usePaymentMethodController: () => usePaymentMethodController,
+  usePaymentMethodRepo: () => usePaymentMethodRepo,
+  usePaymentMethodService: () => usePaymentMethodService,
   useRoleController: () => useRoleController,
   useRoleRepo: () => useRoleRepo,
   useRoleService: () => useRoleService,
@@ -11394,17 +11409,26 @@ __export(src_exports, {
   useVerificationService: () => useVerificationService,
   useWorkflowController: () => useWorkflowController,
   useWorkflowRepo: () => useWorkflowRepo,
-  useWorkflowService: () => useWorkflowService
+  useWorkflowService: () => useWorkflowService,
+  useXenditService: () => useXenditService
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/models/verification.model.ts
+var import_utils = require("@goweekdays/utils");
 var import_mongodb = require("mongodb");
 var MVerification = class {
   constructor(value) {
     this._id = value._id ?? new import_mongodb.ObjectId();
     this.type = value.type ?? "";
     this.email = value.email ?? "";
+    if (this.metadata?.org) {
+      try {
+        this.metadata.org = new import_mongodb.ObjectId(this.metadata?.org);
+      } catch (error) {
+        throw new import_utils.BadRequestError("Invalid org ID.");
+      }
+    }
     this.metadata = value.metadata ?? {};
     this.status = value.status ?? "pending";
     this.createdAt = value.createdAt ?? /* @__PURE__ */ new Date();
@@ -11414,14 +11438,26 @@ var MVerification = class {
 };
 
 // src/repositories/verification.repository.ts
-var import_utils = require("@goweekdays/utils");
+var import_utils2 = require("@goweekdays/utils");
 var import_mongodb2 = require("mongodb");
 function useVerificationRepo() {
-  const db = import_utils.useAtlas.getDb();
+  const db = import_utils2.useAtlas.getDb();
   if (!db) {
-    throw new import_utils.InternalServerError("Unable to connect to server.");
+    throw new import_utils2.InternalServerError("Unable to connect to server.");
   }
   const collection = db.collection("verifications");
+  async function createIndex() {
+    try {
+      await collection.createIndex([
+        { email: 1 },
+        { type: 1 },
+        { status: 1 },
+        { "metadata.org": 1 }
+      ]);
+    } catch (error) {
+      throw new import_utils2.InternalServerError("Failed to create index.");
+    }
+  }
   async function createTextIndex() {
     try {
       await collection.createIndex({
@@ -11437,23 +11473,23 @@ function useVerificationRepo() {
       const res = await collection.insertOne(value, { session });
       return res.insertedId;
     } catch (error) {
-      import_utils.logger.log({
+      import_utils2.logger.log({
         level: "info",
         message: String(error)
       });
-      throw new import_utils.InternalServerError("Server internal error.");
+      throw new import_utils2.InternalServerError("Server internal error.");
     }
   }
   async function getById(_id) {
     try {
       _id = new import_mongodb2.ObjectId(_id);
     } catch (error) {
-      throw new import_utils.BadRequestError("Invalid ID.");
+      throw new import_utils2.BadRequestError("Invalid ID.");
     }
     try {
       return await collection.findOne({ _id });
     } catch (error) {
-      throw new import_utils.InternalServerError(
+      throw new import_utils2.InternalServerError(
         "Internal server error, failed to retrieve verification."
       );
     }
@@ -11464,7 +11500,8 @@ function useVerificationRepo() {
     limit = 10,
     sort = {},
     status = "active",
-    type = ""
+    type = "",
+    email = ""
   } = {}) {
     page = page > 0 ? page - 1 : 0;
     const query = { status };
@@ -11475,6 +11512,9 @@ function useVerificationRepo() {
     if (type) {
       query.type = type;
     }
+    if (email) {
+      query.email = email;
+    }
     try {
       const items = await collection.aggregate([
         { $match: query },
@@ -11493,9 +11533,9 @@ function useVerificationRepo() {
         }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      return (0, import_utils.paginate)(items, page, limit, length);
+      return (0, import_utils2.paginate)(items, page, limit, length);
     } catch (error) {
-      import_utils.logger.log({ level: "error", message: `${error}` });
+      import_utils2.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -11510,7 +11550,7 @@ function useVerificationRepo() {
     try {
       _id = new import_mongodb2.ObjectId(_id);
     } catch (error) {
-      throw new import_utils.BadRequestError("Invalid ID.");
+      throw new import_utils2.BadRequestError("Invalid ID.");
     }
     try {
       return await collection.updateOne(
@@ -11519,10 +11559,11 @@ function useVerificationRepo() {
         { session }
       );
     } catch (error) {
-      throw new import_utils.InternalServerError("Error updating verification status.");
+      throw new import_utils2.InternalServerError("Error updating verification status.");
     }
   }
   return {
+    createIndex,
     createTextIndex,
     add,
     getVerifications,
@@ -11533,7 +11574,7 @@ function useVerificationRepo() {
 }
 
 // src/services/verification.service.ts
-var import_utils4 = require("@goweekdays/utils");
+var import_utils5 = require("@goweekdays/utils");
 
 // src/config.ts
 var dotenv = __toESM(require("dotenv"));
@@ -11573,13 +11614,15 @@ var SPACES_BUCKET = process.env.SPACES_BUCKET;
 var PAYPAL_CLIENT_ID = process.env.PAYPAL_CLIENT_ID ?? "";
 var PAYPAL_CLIENT_SECRET = process.env.PAYPAL_CLIENT_SECRET ?? "";
 var PAYPAL_API_URL = process.env.PAYPAL_API_URL ?? "https://api-m.sandbox.paypal.com";
+var XENDIT_SECRET_KEY = process.env.XENDIT_SECRET_KEY ?? "";
+var XENDIT_BASE_URL = process.env.XENDIT_BASE_URL ?? "https://api.xendit.co";
 
 // src/repositories/user.repository.ts
 var import_mongodb4 = require("mongodb");
 
 // src/models/user.model.ts
 var import_mongodb3 = require("mongodb");
-var import_utils2 = require("@goweekdays/utils");
+var import_utils3 = require("@goweekdays/utils");
 var MUserRole = class {
   constructor(value) {
     this.name = value.name ?? "";
@@ -11608,13 +11651,13 @@ var MUser = class {
         try {
           role.role = new import_mongodb3.ObjectId(role.role);
         } catch (error) {
-          throw new import_utils2.BadRequestError("Invalid role ID.");
+          throw new import_utils3.BadRequestError("Invalid role ID.");
         }
         if (!role.app) {
-          throw new import_utils2.BadRequestError("App is required.");
+          throw new import_utils3.BadRequestError("App is required.");
         }
         if (!role.name) {
-          throw new import_utils2.BadRequestError("Name is required.");
+          throw new import_utils3.BadRequestError("Name is required.");
         }
         role.status = role.status ?? "active";
       });
@@ -11630,11 +11673,11 @@ var MUser = class {
 };
 
 // src/repositories/user.repository.ts
-var import_utils3 = require("@goweekdays/utils");
+var import_utils4 = require("@goweekdays/utils");
 function useUserRepo() {
-  const db = import_utils3.useAtlas.getDb();
+  const db = import_utils4.useAtlas.getDb();
   if (!db) {
-    throw new import_utils3.InternalServerError("Unable to connect to server.");
+    throw new import_utils4.InternalServerError("Unable to connect to server.");
   }
   const collection = db.collection("users");
   async function createTextIndex() {
@@ -11665,12 +11708,12 @@ function useUserRepo() {
       const res = await collection.insertOne(value, { session });
       return res.insertedId;
     } catch (error) {
-      import_utils3.logger.log({ level: "error", message: `${error}` });
+      import_utils4.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_utils4.BadRequestError("Item name already exists");
       }
-      throw new import_utils3.InternalServerError("Internal server error.");
+      throw new import_utils4.InternalServerError("Internal server error.");
     }
   }
   async function getUserByEmail(email) {
@@ -11742,9 +11785,9 @@ function useUserRepo() {
         }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      return (0, import_utils3.paginate)(items, page, limit, length);
+      return (0, import_utils4.paginate)(items, page, limit, length);
     } catch (error) {
-      import_utils3.logger.log({ level: "error", message: `${error}` });
+      import_utils4.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -11799,14 +11842,14 @@ function useUserRepo() {
   async function updateUserFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["gender", "email", "contact", "profile"];
     if (!allowedFields.includes(field)) {
-      throw new import_utils3.BadRequestError(
+      throw new import_utils4.BadRequestError(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
       _id = new import_mongodb4.ObjectId(_id);
     } catch (error) {
-      throw new import_utils3.BadRequestError("Invalid ID.");
+      throw new import_utils4.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -11817,14 +11860,14 @@ function useUserRepo() {
       );
       return `Successfully updated user ${field}.`;
     } catch (error) {
-      throw new import_utils3.InternalServerError(`Failed to update user ${field}.`);
+      throw new import_utils4.InternalServerError(`Failed to update user ${field}.`);
     }
   }
   async function addUserRole({ _id, role } = {}, session) {
     try {
       _id = new import_mongodb4.ObjectId(_id);
     } catch (error) {
-      throw new import_utils3.BadRequestError("Invalid user ID.");
+      throw new import_utils4.BadRequestError("Invalid user ID.");
     }
     role = new MUserRole(role);
     try {
@@ -11835,7 +11878,7 @@ function useUserRepo() {
         { session }
       );
     } catch (error) {
-      throw new import_utils3.InternalServerError("Failed to add user role.");
+      throw new import_utils4.InternalServerError("Failed to add user role.");
     }
   }
   return {
@@ -11864,7 +11907,7 @@ function useVerificationService() {
     email: MAILER_EMAIL,
     password: MAILER_PASSWORD
   };
-  const mailer = new import_utils4.useMailer(MailerConfig);
+  const mailer = new import_utils5.useMailer(MailerConfig);
   const {
     add,
     getById: _getById,
@@ -11889,14 +11932,14 @@ function useVerificationService() {
     try {
       const user = await getByEmailApp(email, metadata.app);
       if (user) {
-        throw new import_utils4.BadRequestError(
+        throw new import_utils5.BadRequestError(
           `User already a user in ${metadata.app} app.`
         );
       }
       const res = await add(value);
       const dir = __dirname;
-      const filePath = (0, import_utils4.getDirectory)(dir, "./public/handlebars/user-invite");
-      const emailContent = (0, import_utils4.compileHandlebar)({
+      const filePath = (0, import_utils5.getDirectory)(dir, "./public/handlebars/user-invite");
+      const emailContent = (0, import_utils5.compileHandlebar)({
         context: {
           validity: VERIFICATION_USER_INVITE_DURATION,
           link: `${APP_MAIN}/verify/invitation/${res}`
@@ -11909,7 +11952,7 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekDays"
       }).catch((error) => {
-        import_utils4.logger.log({
+        import_utils5.logger.log({
           level: "error",
           message: `Error sending user invite email: ${error}`
         });
@@ -11930,8 +11973,8 @@ function useVerificationService() {
     try {
       const res = await add(value);
       const dir = __dirname;
-      const filePath = (0, import_utils4.getDirectory)(dir, "./public/handlebars/forget-password");
-      const emailContent = (0, import_utils4.compileHandlebar)({
+      const filePath = (0, import_utils5.getDirectory)(dir, "./public/handlebars/forget-password");
+      const emailContent = (0, import_utils5.compileHandlebar)({
         context: {
           validity: VERIFICATION_FORGET_PASSWORD_DURATION,
           link: `${APP_MAIN}/reset-password/${res}`
@@ -11944,21 +11987,21 @@ function useVerificationService() {
         from: "GoWeekdays",
         html: emailContent
       }).catch((error) => {
-        import_utils4.logger.log({
+        import_utils5.logger.log({
           level: "error",
           message: `Error sending forget password email: ${error}`
         });
       });
       return "Successfully created a link to reset password. Please check your email.";
     } catch (error) {
-      throw new import_utils4.InternalServerError("Failed to create forget password link.");
+      throw new import_utils5.InternalServerError("Failed to create forget password link.");
     }
   }
   async function getById(id) {
     try {
       const _id = await _getById(id);
       if (!_id) {
-        throw new import_utils4.NotFoundError("Verification not found.");
+        throw new import_utils5.NotFoundError("Verification not found.");
       }
       return _id;
     } catch (error) {
@@ -11970,55 +12013,63 @@ function useVerificationService() {
     page = 1,
     status = "",
     type = "",
+    email = "",
     limit = 10
   } = {}) {
     try {
-      return await _getVerifications({ search, page, status, type, limit });
+      return await _getVerifications({
+        search,
+        page,
+        status,
+        type,
+        limit,
+        email
+      });
     } catch (error) {
       throw error;
     }
   }
   function errorByType(type, status) {
     if (type === "user-invite" && status === "expired") {
-      throw new import_utils4.BadRequestError(
+      throw new import_utils5.BadRequestError(
         "Invitation has already expired, please contact admin to resend the invitation."
       );
     }
     if (type === "user-sign-up" && status === "expired") {
-      throw new import_utils4.BadRequestError(
+      throw new import_utils5.BadRequestError(
         "Sign up verification has expired, please sign up again to get a new verification link."
       );
     }
     if (type === "user-invite" && status === "complete") {
-      throw new import_utils4.BadRequestError(
+      throw new import_utils5.BadRequestError(
         "User already registered, please login to continue."
       );
     }
     if (type === "forget-password" && status === "complete") {
-      throw new import_utils4.BadRequestError(
+      throw new import_utils5.BadRequestError(
         "Forget password verification has already been used, please request a new one."
       );
     }
     if (type === "forget-password" && status === "expired") {
-      throw new import_utils4.BadRequestError(
+      throw new import_utils5.BadRequestError(
         "Forget password verification has expired, please request a new one."
       );
     }
-    throw new import_utils4.BadRequestError("Invalid verification.");
+    throw new import_utils5.BadRequestError("Invalid verification.");
   }
   async function verify(id) {
-    const session = import_utils4.useAtlas.getClient()?.startSession();
+    const session = import_utils5.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const _id = await _getById(id);
       if (!_id) {
-        throw new import_utils4.NotFoundError("Verification not found.");
+        throw new import_utils5.NotFoundError("Verification not found.");
       }
       if (_id.status === "expired") {
         errorByType(_id.type, "expired");
       }
       if (_id.status === "complete") {
-        throw new import_utils4.BadRequestError("Verification already completed.");
+        throw new import_utils5.BadRequestError("Verification already completed.");
       }
       const expiration = new Date(_id.expireAt).getTime();
       const now = (/* @__PURE__ */ new Date()).getTime();
@@ -12046,14 +12097,14 @@ function useVerificationService() {
       }
       if (appMember?.length && _id.type === "user-invite") {
         await _updateStatusById(id, "expired");
-        throw new import_utils4.BadRequestError(
+        throw new import_utils5.BadRequestError(
           `Invalid user invitation. User is already a user in the ${_id.metadata?.app} app.`
         );
       }
       return _id;
     } catch (error) {
       await session?.abortTransaction();
-      import_utils4.logger.log({
+      import_utils5.logger.log({
         level: "info",
         message: `Error verifying user invitation: ${error}`
       });
@@ -12066,7 +12117,7 @@ function useVerificationService() {
     try {
       await updateStatusById(id, "cancelled");
     } catch (error) {
-      throw new import_utils4.InternalServerError(
+      throw new import_utils5.InternalServerError(
         `Error cancelling user invitation: ${error}`
       );
     }
@@ -12087,12 +12138,12 @@ function useVerificationService() {
       if (metadata && metadata.referralCode && typeof metadata.referralCode === "string") {
         const code = await getUserByReferralCode(metadata.referralCode);
         if (!code) {
-          throw new import_utils4.BadRequestError("Invalid referral code.");
+          throw new import_utils5.BadRequestError("Invalid referral code.");
         }
       }
       const user = await getUserByEmail(email);
       if (user) {
-        throw new import_utils4.BadRequestError(
+        throw new import_utils5.BadRequestError(
           `Email ${email} is already registered, please login to continue.`
         );
       }
@@ -12106,8 +12157,8 @@ function useVerificationService() {
       };
       const res = await add(value);
       const dir = __dirname;
-      const filePath = (0, import_utils4.getDirectory)(dir, "./public/handlebars/sign-up");
-      const emailContent = (0, import_utils4.compileHandlebar)({
+      const filePath = (0, import_utils5.getDirectory)(dir, "./public/handlebars/sign-up");
+      const emailContent = (0, import_utils5.compileHandlebar)({
         context: {
           validity: "5 minutes",
           link: `${APP_MAIN}/sign-up/${res}`
@@ -12120,7 +12171,7 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error) => {
-        import_utils4.logger.log({
+        import_utils5.logger.log({
           level: "error",
           message: `Error sending user invite email: ${error}`
         });
@@ -12143,7 +12194,7 @@ function useVerificationService() {
 }
 
 // src/controllers/verification.controller.ts
-var import_utils5 = require("@goweekdays/utils");
+var import_utils6 = require("@goweekdays/utils");
 var import_joi = __toESM(require("joi"));
 function useVerificationController() {
   const {
@@ -12171,7 +12222,7 @@ function useVerificationController() {
       name
     });
     if (error) {
-      next(new import_utils5.BadRequestError(error.message));
+      next(new import_utils6.BadRequestError(error.message));
       return;
     }
     try {
@@ -12195,7 +12246,7 @@ function useVerificationController() {
     const validation = import_joi.default.string().email().required();
     const { error } = validation.validate(email);
     if (error) {
-      next(new import_utils5.BadRequestError(error.message));
+      next(new import_utils6.BadRequestError(error.message));
       return;
     }
     try {
@@ -12205,10 +12256,10 @@ function useVerificationController() {
       });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils5.AppError) {
+      if (error2 instanceof import_utils6.AppError) {
         next(error2);
       } else {
-        next(new import_utils5.InternalServerError("An unexpected error occurred"));
+        next(new import_utils6.InternalServerError("An unexpected error occurred"));
       }
     }
   }
@@ -12216,18 +12267,34 @@ function useVerificationController() {
     const status = req.query.status ?? "";
     const search = req.query.search ?? "";
     const page = Number(req.query.page) ?? 1;
+    const type = req.query.type ?? "";
+    const email = req.query.email ?? "";
     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()
+      page: import_joi.default.number().required(),
+      type: import_joi.default.string().optional().allow("", null),
+      email: import_joi.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({
+      status,
+      search,
+      page,
+      type,
+      email
     });
-    const { error } = validation.validate({ status, search, page });
     if (error) {
-      next(new import_utils5.BadRequestError(error.message));
+      next(new import_utils6.BadRequestError(error.message));
       return;
     }
     try {
-      const items = await _getVerifications({ status, search, page });
+      const items = await _getVerifications({
+        status,
+        search,
+        page,
+        type,
+        email
+      });
       res.json(items);
       return;
     } catch (error2) {
@@ -12239,7 +12306,7 @@ function useVerificationController() {
     const validation = import_joi.default.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils5.BadRequestError(error.message));
+      next(new import_utils6.BadRequestError(error.message));
       return;
     }
     try {
@@ -12255,7 +12322,7 @@ function useVerificationController() {
     const validation = import_joi.default.string().hex().required();
     const { error } = validation.validate(otpId);
     if (error) {
-      next(new import_utils5.BadRequestError(error.message));
+      next(new import_utils6.BadRequestError(error.message));
       return;
     }
     try {
@@ -12287,12 +12354,12 @@ var MToken = class {
 };
 
 // src/repositories/token.repository.ts
-var import_utils6 = require("@goweekdays/utils");
+var import_utils7 = require("@goweekdays/utils");
 var import_mongodb6 = require("mongodb");
 function useTokenRepo() {
-  const db = import_utils6.useAtlas.getDb();
+  const db = import_utils7.useAtlas.getDb();
   if (!db) {
-    throw new import_utils6.InternalServerError("Unable to connect to server.");
+    throw new import_utils7.InternalServerError("Unable to connect to server.");
   }
   const collection = db.collection("tokens");
   async function createToken({ token, user } = {}) {
@@ -12330,10 +12397,10 @@ function useTokenRepo() {
 }
 
 // src/services/user.service.ts
-var import_utils8 = require("@goweekdays/utils");
+var import_utils9 = require("@goweekdays/utils");
 
 // src/repositories/file.repository.ts
-var import_utils7 = require("@goweekdays/utils");
+var import_utils8 = require("@goweekdays/utils");
 
 // src/models/file.model.ts
 var MFile = class {
@@ -12349,9 +12416,9 @@ var MFile = class {
 // src/repositories/file.repository.ts
 var import_mongodb7 = require("mongodb");
 function useFileRepo() {
-  const db = import_utils7.useAtlas.getDb();
+  const db = import_utils8.useAtlas.getDb();
   if (!db) {
-    throw new import_utils7.InternalServerError("Unable to connect to server.");
+    throw new import_utils8.InternalServerError("Unable to connect to server.");
   }
   const collection = db.collection("files");
   async function createFile(value, session) {
@@ -12360,27 +12427,27 @@ function useFileRepo() {
       const res = await collection.insertOne(value, { session });
       return res.insertedId.toString();
     } catch (error) {
-      throw new import_utils7.InternalServerError("Failed to create file.");
+      throw new import_utils8.InternalServerError("Failed to create file.");
     }
   }
   async function deleteFileById(_id, session) {
     try {
       _id = new import_mongodb7.ObjectId(_id);
     } catch (error) {
-      throw new import_utils7.BadRequestError("Invalid file id.");
+      throw new import_utils8.BadRequestError("Invalid file id.");
     }
     try {
       await collection.deleteOne({ _id }, { session });
       return "File deleted successfully";
     } catch (error) {
-      throw new import_utils7.InternalServerError("Failed to delete file.");
+      throw new import_utils8.InternalServerError("Failed to delete file.");
     }
   }
   async function getAllDraftedFiles() {
     try {
       return await collection.find({ $and: [{ status: "draft" }, { status: null }] }).toArray();
     } catch (error) {
-      throw new import_utils7.InternalServerError("Failed to get drafted files.");
+      throw new import_utils8.InternalServerError("Failed to get drafted files.");
     }
   }
   return {
@@ -12406,7 +12473,7 @@ function useUserService() {
     try {
       return await _getById(id);
     } catch (error) {
-      throw new import_utils8.InternalServerError();
+      throw new import_utils9.InternalServerError();
     }
   }
   async function getUsers({
@@ -12423,14 +12490,14 @@ function useUserService() {
     }
   }
   async function createUser(value) {
-    const session = import_utils8.useAtlas.getClient()?.startSession();
+    const session = import_utils9.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const _user = await getUserByEmail(value.email);
       if (_user) {
-        throw new import_utils8.BadRequestError(`User already exists: ${value.email}.`);
+        throw new import_utils9.BadRequestError(`User already exists: ${value.email}.`);
       }
-      const hashedPassword = await (0, import_utils8.hashPassword)(value.password);
+      const hashedPassword = await (0, import_utils9.hashPassword)(value.password);
       const user = {
         email: value.email,
         password: hashedPassword,
@@ -12461,26 +12528,26 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = import_utils8.useAtlas.getClient()?.startSession();
+    const session = import_utils9.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const invitation = await _getVerificationById(id);
       if (!invitation || !invitation.metadata?.app || !invitation.metadata?.role) {
-        throw new import_utils8.BadRequestError("Invalid invitation.");
+        throw new import_utils9.BadRequestError("Invalid invitation.");
       }
       if (invitation.status === "complete") {
-        throw new import_utils8.BadRequestError("Invitation already used.");
+        throw new import_utils9.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.");
+        throw new import_utils9.BadRequestError("Invitation expired.");
       }
       const email = invitation.email;
       const _user = await getUserByEmail(invitation.email);
       if (_user) {
-        throw new import_utils8.BadRequestError(`User already exists: ${email}.`);
+        throw new import_utils9.BadRequestError(`User already exists: ${email}.`);
       }
-      const hashedPassword = await (0, import_utils8.hashPassword)(password);
+      const hashedPassword = await (0, import_utils9.hashPassword)(password);
       const user = {
         email,
         password: hashedPassword,
@@ -12514,28 +12581,28 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = import_utils8.useAtlas.getClient()?.startSession();
+    const session = import_utils9.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const signUp = await _getVerificationById(id);
       if (!signUp) {
-        throw new import_utils8.BadRequestError("Invalid sign up link.");
+        throw new import_utils9.BadRequestError("Invalid sign up link.");
       }
       if (signUp.status === "complete") {
-        throw new import_utils8.BadRequestError(
+        throw new import_utils9.BadRequestError(
           "You have already an account created using this link."
         );
       }
       const expired = new Date(signUp.expireAt) < /* @__PURE__ */ new Date();
       if (signUp.status === "expired" || expired) {
-        throw new import_utils8.BadRequestError("Sign up link expired.");
+        throw new import_utils9.BadRequestError("Sign up link expired.");
       }
       const email = signUp.email;
       const _user = await getUserByEmail(signUp.email);
       if (_user) {
-        throw new import_utils8.BadRequestError(`User already exists: ${email}.`);
+        throw new import_utils9.BadRequestError(`User already exists: ${email}.`);
       }
-      const hashedPassword = await (0, import_utils8.hashPassword)(password);
+      const hashedPassword = await (0, import_utils9.hashPassword)(password);
       const user = {
         email,
         password: hashedPassword,
@@ -12565,21 +12632,21 @@ function useUserService() {
       throw error;
     }
     if (newPassword !== passwordConfirmation) {
-      throw new import_utils8.BadRequestError("Passwords do not match.");
+      throw new import_utils9.BadRequestError("Passwords do not match.");
     }
     let hashedPassword;
     try {
-      hashedPassword = await (0, import_utils8.hashPassword)(newPassword);
+      hashedPassword = await (0, import_utils9.hashPassword)(newPassword);
     } catch (error) {
-      throw new import_utils8.InternalServerError(`Error hashing password: ${error}`);
+      throw new import_utils9.InternalServerError(`Error hashing password: ${error}`);
     }
     try {
       const otpDoc = await getById(id);
       if (!otpDoc) {
-        throw new import_utils8.NotFoundError("You are using an invalid reset link.");
+        throw new import_utils9.NotFoundError("You are using an invalid reset link.");
       }
       if (otpDoc.status === "used") {
-        throw new import_utils8.BadRequestError("This link has already been invalidated.");
+        throw new import_utils9.BadRequestError("This link has already been invalidated.");
       }
       await updateStatusById(id, "used");
       return "Successfully reset password.";
@@ -12589,15 +12656,15 @@ function useUserService() {
   }
   async function updateName(_id, firstName, lastName) {
     if (!_id) {
-      throw new import_utils8.BadRequestError("Invalid user ID");
+      throw new import_utils9.BadRequestError("Invalid user ID");
     }
     if (!firstName) {
-      throw new import_utils8.BadRequestError("Invalid firstName");
+      throw new import_utils9.BadRequestError("Invalid firstName");
     }
     if (!lastName) {
-      throw new import_utils8.BadRequestError("Invalid lastName");
+      throw new import_utils9.BadRequestError("Invalid lastName");
     }
-    const session = import_utils8.useAtlas.getClient()?.startSession();
+    const session = import_utils9.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       await _updateName({ _id, firstName, lastName }, session);
@@ -12612,16 +12679,16 @@ function useUserService() {
   }
   async function updateBirthday(_id, month, day, year) {
     if (!_id) {
-      throw new import_utils8.BadRequestError("Invalid user ID");
+      throw new import_utils9.BadRequestError("Invalid user ID");
     }
     if (!month) {
-      throw new import_utils8.BadRequestError("Invalid birth month.");
+      throw new import_utils9.BadRequestError("Invalid birth month.");
     }
     if (!day) {
-      throw new import_utils8.BadRequestError("Invalid birthday.");
+      throw new import_utils9.BadRequestError("Invalid birthday.");
     }
     if (!year) {
-      throw new import_utils8.BadRequestError("Invalid birth year.");
+      throw new import_utils9.BadRequestError("Invalid birth year.");
     }
     try {
       await _updateBirthday({ _id, month, day, year });
@@ -12638,7 +12705,7 @@ function useUserService() {
     }
   }
   const { createFile: _createFile, deleteFileById } = useFileRepo();
-  const s3 = new import_utils8.useS3({
+  const s3 = new import_utils9.useS3({
     accessKeyId: SPACES_ACCESS_KEY,
     secretAccessKey: SPACES_SECRET_KEY,
     endpoint: SPACES_ENDPOINT,
@@ -12646,7 +12713,7 @@ function useUserService() {
     bucket: SPACES_BUCKET
   });
   async function updateUserProfile({ file, user, previousProfile } = {}) {
-    const session = import_utils8.useAtlas.getClient()?.startSession();
+    const session = import_utils9.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     const _file = {
       name: file.originalname,
@@ -12691,7 +12758,7 @@ function useUserService() {
 }
 
 // src/controllers/user.controller.ts
-var import_utils9 = require("@goweekdays/utils");
+var import_utils10 = require("@goweekdays/utils");
 var import_joi2 = __toESM(require("joi"));
 function useUserController() {
   const {
@@ -12715,7 +12782,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ status, search, page });
     if (error) {
-      next(new import_utils9.BadRequestError(error.message));
+      next(new import_utils10.BadRequestError(error.message));
     }
     try {
       const items = await _getUsers({ status, search, page });
@@ -12729,12 +12796,12 @@ function useUserController() {
     const id = req.params.id || "";
     const validation = import_joi2.default.string().hex().validate(id);
     if (validation.error) {
-      throw new import_utils9.BadRequestError("Invalid id.");
+      throw new import_utils10.BadRequestError("Invalid id.");
     }
     try {
       const user = await _getUserById(id);
       if (!user) {
-        throw new import_utils9.BadRequestError("User not found.");
+        throw new import_utils10.BadRequestError("User not found.");
       }
       res.json(user);
     } catch (error) {
@@ -12751,7 +12818,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ firstName, lastName });
     if (error) {
-      next(new import_utils9.BadRequestError(error.message));
+      next(new import_utils10.BadRequestError(error.message));
       return;
     }
     try {
@@ -12774,7 +12841,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ month, day, year });
     if (error) {
-      next(new import_utils9.BadRequestError(error.message));
+      next(new import_utils10.BadRequestError(error.message));
       return;
     }
     try {
@@ -12799,7 +12866,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new import_utils9.BadRequestError(error.message));
+      next(new import_utils10.BadRequestError(error.message));
       return;
     }
     try {
@@ -12820,7 +12887,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ previousProfile });
     if (error) {
-      next(new import_utils9.BadRequestError(error.message));
+      next(new import_utils10.BadRequestError(error.message));
       return;
     }
     const user = req.headers["user"] ?? "";
@@ -12833,10 +12900,10 @@ function useUserController() {
       res.json({ message: "Successfully updated profile picture." });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils9.AppError) {
+      if (error2 instanceof import_utils10.AppError) {
         next(error2);
       } else {
-        next(new import_utils9.InternalServerError(error2));
+        next(new import_utils10.InternalServerError(error2));
       }
     }
   }
@@ -12861,7 +12928,7 @@ function useUserController() {
       type
     });
     if (error) {
-      next(new import_utils9.BadRequestError(error.message));
+      next(new import_utils10.BadRequestError(error.message));
       return;
     }
     try {
@@ -12894,67 +12961,67 @@ function useUserController() {
 }
 
 // src/services/auth.service.ts
-var import_utils10 = require("@goweekdays/utils");
+var import_utils11 = require("@goweekdays/utils");
 var import_jsonwebtoken = __toESM(require("jsonwebtoken"));
 function useAuthService() {
   const expiresIn = "1m";
   async function login({ email, password } = {}) {
     if (!email) {
-      throw new import_utils10.BadRequestError("Email is required");
+      throw new import_utils11.BadRequestError("Email is required");
     }
     if (!password) {
-      throw new import_utils10.BadRequestError("Password is required");
+      throw new import_utils11.BadRequestError("Password is required");
     }
     let _user;
     try {
       _user = await useUserRepo().getUserByEmail(email);
     } catch (error) {
-      if (error instanceof import_utils10.AppError) {
+      if (error instanceof import_utils11.AppError) {
         throw error;
       } else {
-        throw new import_utils10.InternalServerError(`${error}`);
+        throw new import_utils11.InternalServerError(`${error}`);
       }
     }
     if (!_user) {
-      throw new import_utils10.NotFoundError(
+      throw new import_utils11.NotFoundError(
         "Invalid user email. Please check your email and try again."
       );
     }
     if (_user.status === "suspended") {
-      throw new import_utils10.BadRequestError(
+      throw new import_utils11.BadRequestError(
         "Your account is currently suspended. Please contact support for assistance."
       );
     }
-    const isPasswordValid = await (0, import_utils10.comparePassword)(password, _user.password);
+    const isPasswordValid = await (0, import_utils11.comparePassword)(password, _user.password);
     if (!isPasswordValid) {
-      throw new import_utils10.BadRequestError("Invalid password");
+      throw new import_utils11.BadRequestError("Invalid password");
     }
     const metadata = { user: _user._id };
     let refreshToken2;
     try {
-      refreshToken2 = (0, import_utils10.generateToken)({
+      refreshToken2 = (0, import_utils11.generateToken)({
         secret: REFRESH_TOKEN_SECRET,
         metadata,
         options: { expiresIn: "7d" }
       });
     } catch (error) {
-      throw new import_utils10.BadRequestError("Error generating refresh token");
+      throw new import_utils11.BadRequestError("Error generating refresh token");
     }
     let accessToken;
     try {
-      accessToken = (0, import_utils10.generateToken)({
+      accessToken = (0, import_utils11.generateToken)({
         secret: ACCESS_TOKEN_SECRET,
         metadata,
         options: { expiresIn }
       });
     } catch (error) {
-      throw new import_utils10.BadRequestError("Error generating access token");
+      throw new import_utils11.BadRequestError("Error generating access token");
     }
     const user = _user._id ?? "";
     try {
       await useTokenRepo().createToken({ token: refreshToken2, user });
     } catch (error) {
-      throw new import_utils10.BadRequestError("Error creating refresh token");
+      throw new import_utils11.BadRequestError("Error creating refresh token");
     }
     return { accessToken, refreshToken: refreshToken2, id: _user._id };
   }
@@ -12963,30 +13030,30 @@ function useAuthService() {
     try {
       decoded = await import_jsonwebtoken.default.verify(token, REFRESH_TOKEN_SECRET);
     } catch (error) {
-      throw new import_utils10.BadRequestError("Invalid refresh token");
+      throw new import_utils11.BadRequestError("Invalid refresh token");
     }
     let _token;
     try {
       _token = await useTokenRepo().getToken(token);
       if (!_token) {
-        throw new import_utils10.NotFoundError("Invalid token");
+        throw new import_utils11.NotFoundError("Invalid token");
       }
     } catch (error) {
-      if (error instanceof import_utils10.AppError) {
+      if (error instanceof import_utils11.AppError) {
         throw error;
       } else {
-        throw new import_utils10.InternalServerError(`${error}`);
+        throw new import_utils11.InternalServerError(`${error}`);
       }
     }
     let accessToken;
     try {
-      accessToken = (0, import_utils10.generateToken)({
+      accessToken = (0, import_utils11.generateToken)({
         secret: ACCESS_TOKEN_SECRET,
         metadata: { user: decoded.user },
         options: { expiresIn }
       });
     } catch (error) {
-      throw new import_utils10.BadRequestError("Error generating access token");
+      throw new import_utils11.BadRequestError("Error generating access token");
     }
     return accessToken;
   }
@@ -12995,19 +13062,19 @@ function useAuthService() {
     try {
       _token = await useTokenRepo().getToken(token);
       if (!_token) {
-        throw new import_utils10.NotFoundError("Invalid token");
+        throw new import_utils11.NotFoundError("Invalid token");
       }
     } catch (error) {
-      if (error instanceof import_utils10.AppError) {
+      if (error instanceof import_utils11.AppError) {
         throw error;
       } else {
-        throw new import_utils10.InternalServerError(`${error}`);
+        throw new import_utils11.InternalServerError(`${error}`);
       }
     }
     try {
       await useTokenRepo().deleteToken(token);
     } catch (error) {
-      throw new import_utils10.InternalServerError("Error deleting token");
+      throw new import_utils11.InternalServerError("Error deleting token");
     }
     return "Logged out successfully";
   }
@@ -13020,7 +13087,7 @@ function useAuthService() {
 
 // src/controllers/auth.controller.ts
 var import_joi3 = __toESM(require("joi"));
-var import_utils11 = require("@goweekdays/utils");
+var import_utils12 = require("@goweekdays/utils");
 function useAuthController() {
   const { signUp: _signUp } = useVerificationService();
   async function login(req, res, next) {
@@ -13032,50 +13099,50 @@ function useAuthController() {
     });
     const { error } = validation.validate({ email, password });
     if (error) {
-      next(new import_utils11.BadRequestError(error.message));
+      next(new import_utils12.BadRequestError(error.message));
     }
     try {
       const token = await useAuthService().login({ email, password });
       res.json(token);
     } catch (error2) {
-      if (error2 instanceof import_utils11.AppError) {
+      if (error2 instanceof import_utils12.AppError) {
         next(error2);
       } else {
-        next(new import_utils11.InternalServerError("An unexpected error occurred"));
+        next(new import_utils12.InternalServerError("An unexpected error occurred"));
       }
     }
   }
   async function refreshToken(req, res, next) {
     const refreshToken2 = req.body.token;
     if (!refreshToken2) {
-      next(new import_utils11.BadRequestError("Refresh token is required"));
+      next(new import_utils12.BadRequestError("Refresh token is required"));
       return;
     }
     try {
       const newRefreshToken = await useAuthService().refreshToken(refreshToken2);
       res.json({ token: newRefreshToken });
     } catch (error) {
-      if (error instanceof import_utils11.AppError) {
+      if (error instanceof import_utils12.AppError) {
         next(error);
       } else {
-        next(new import_utils11.InternalServerError("An unexpected error occurred"));
+        next(new import_utils12.InternalServerError("An unexpected error occurred"));
       }
     }
   }
   async function logout(req, res, next) {
     const token = req.params.id || "";
     if (!token) {
-      next(new import_utils11.BadRequestError("Token is required"));
+      next(new import_utils12.BadRequestError("Token is required"));
       return;
     }
     try {
       await useAuthService().logout(token);
       res.json({ message: "Logged out successfully" });
     } catch (error) {
-      if (error instanceof import_utils11.AppError) {
+      if (error instanceof import_utils12.AppError) {
         next(error);
       } else {
-        next(new import_utils11.InternalServerError("An unexpected error occurred"));
+        next(new import_utils12.InternalServerError("An unexpected error occurred"));
       }
     }
   }
@@ -13094,7 +13161,7 @@ function useAuthController() {
       passwordConfirmation
     });
     if (error) {
-      next(new import_utils11.BadRequestError(error.message));
+      next(new import_utils12.BadRequestError(error.message));
       return;
     }
     try {
@@ -13118,7 +13185,7 @@ function useAuthController() {
     });
     const { error } = validation.validate({ email, referralCode });
     if (error) {
-      next(new import_utils11.BadRequestError(error.message));
+      next(new import_utils12.BadRequestError(error.message));
       return;
     }
     try {
@@ -13154,8 +13221,17 @@ var MRole = class {
         throw new Error("Invalid _id.");
       }
     }
+    if (typeof value.org === "string") {
+      try {
+        value.org = new import_mongodb8.ObjectId(value.org);
+      } catch (error) {
+        throw new Error("Invalid org.");
+      }
+    }
+    this.org = value.org ?? "";
     this._id = value._id ?? new import_mongodb8.ObjectId();
     this.name = value.name ?? "";
+    this.description = value.description ?? "";
     this.permissions = value.permissions ?? [];
     this.type = value.type ? value.type : "account";
     this.status = value.status ?? "active";
@@ -13174,12 +13250,12 @@ var MRole = class {
 };
 
 // src/repositories/role.repository.ts
-var import_utils12 = require("@goweekdays/utils");
+var import_utils13 = require("@goweekdays/utils");
 var import_mongodb9 = require("mongodb");
 function useRoleRepo() {
-  const db = import_utils12.useAtlas.getDb();
+  const db = import_utils13.useAtlas.getDb();
   if (!db) {
-    throw new import_utils12.InternalServerError("Unable to connect to server.");
+    throw new import_utils13.InternalServerError("Unable to connect to server.");
   }
   const collection = db.collection("roles");
   async function createIndex() {
@@ -13188,21 +13264,21 @@ function useRoleRepo() {
       await collection.createIndex({ type: 1 });
       await collection.createIndex({ status: 1 });
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to create index on role.");
+      throw new import_utils13.InternalServerError("Failed to create index on role.");
     }
   }
   async function createTextIndex() {
     try {
       await collection.createIndex({ name: "text" });
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to create text index on role.");
+      throw new import_utils13.InternalServerError("Failed to create text index on role.");
     }
   }
   async function createUniqueIndex() {
     try {
       await collection.createIndex({ name: 1, type: 1 }, { unique: true });
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to create unique index on role.");
+      throw new import_utils13.InternalServerError("Failed to create unique index on role.");
     }
   }
   async function addRole(value, session) {
@@ -13211,46 +13287,46 @@ function useRoleRepo() {
       const res = await collection.insertOne(value, { session });
       return res.insertedId;
     } catch (error) {
-      import_utils12.logger.log({ level: "error", message: `${error}` });
+      import_utils13.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_utils13.BadRequestError("Item role already exists");
       }
-      throw new import_utils12.InternalServerError("Failed to create role.");
+      throw new import_utils13.InternalServerError("Failed to create role.");
     }
   }
   async function getRoleByUserId(value) {
     try {
       value = new import_mongodb9.ObjectId(value);
     } catch (error) {
-      throw new import_utils12.BadRequestError("Invalid user ID.");
+      throw new import_utils13.BadRequestError("Invalid user ID.");
     }
     try {
       return await collection.findOne({ user: value });
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to retrieve role by user ID.");
+      throw new import_utils13.InternalServerError("Failed to retrieve role by user ID.");
     }
   }
   async function getRoleById(_id) {
     try {
       _id = new import_mongodb9.ObjectId(_id);
     } catch (error) {
-      throw new import_utils12.BadRequestError("Invalid ID.");
+      throw new import_utils13.BadRequestError("Invalid ID.");
     }
     try {
       return await collection.findOne({ _id });
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to retrieve role by ID.");
+      throw new import_utils13.InternalServerError("Failed to retrieve role by ID.");
     }
   }
   async function getRoleByName(name) {
     if (!name) {
-      throw new import_utils12.BadRequestError("Role name is required.");
+      throw new import_utils13.BadRequestError("Role name is required.");
     }
     try {
       return await collection.findOne({ name });
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to retrieve role by name.");
+      throw new import_utils13.InternalServerError("Failed to retrieve role by name.");
     }
   }
   async function getRoles({
@@ -13277,20 +13353,20 @@ function useRoleRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      return (0, import_utils12.paginate)(items, page, limit, length);
+      return (0, import_utils13.paginate)(items, page, limit, length);
     } catch (error) {
-      import_utils12.logger.log({ level: "error", message: `${error}` });
+      import_utils13.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function updateRole(_id, value, session) {
     if (!_id) {
-      throw new import_utils12.BadRequestError("Role ID is required.");
+      throw new import_utils13.BadRequestError("Role ID is required.");
     }
     try {
       _id = new import_mongodb9.ObjectId(_id);
     } catch (error) {
-      throw new import_utils12.BadRequestError("Invalid role ID.");
+      throw new import_utils13.BadRequestError("Invalid role ID.");
     }
     if (!value.name) {
       delete value.name;
@@ -13303,17 +13379,17 @@ function useRoleRepo() {
         await collection.updateOne({ _id }, { $set: value }, { session });
         return "Successfully updated role.";
       } catch (error) {
-        throw new import_utils12.InternalServerError("Failed to update role.");
+        throw new import_utils13.InternalServerError("Failed to update role.");
       }
     } else {
-      throw new import_utils12.BadRequestError("No fields to update.");
+      throw new import_utils13.BadRequestError("No fields to update.");
     }
   }
   async function deleteRole(_id, session) {
     try {
       _id = new import_mongodb9.ObjectId(_id);
     } catch (error) {
-      throw new import_utils12.BadRequestError("Invalid ID.");
+      throw new import_utils13.BadRequestError("Invalid ID.");
     }
     try {
       await collection.deleteOne(
@@ -13324,7 +13400,7 @@ function useRoleRepo() {
       );
       return "Successfully deleted role.";
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to delete role.");
+      throw new import_utils13.InternalServerError("Failed to delete role.");
     }
   }
   return {
@@ -13342,7 +13418,7 @@ function useRoleRepo() {
 }
 
 // src/services/file.service.ts
-var import_utils13 = require("@goweekdays/utils");
+var import_utils14 = require("@goweekdays/utils");
 var import_node_cron = __toESM(require("node-cron"));
 function useFileService() {
   const {
@@ -13350,7 +13426,7 @@ function useFileService() {
     deleteFileById,
     getAllDraftedFiles
   } = useFileRepo();
-  const s3 = new import_utils13.useS3({
+  const s3 = new import_utils14.useS3({
     accessKeyId: SPACES_ACCESS_KEY,
     secretAccessKey: SPACES_SECRET_KEY,
     endpoint: SPACES_ENDPOINT,
@@ -13358,7 +13434,7 @@ function useFileService() {
     bucket: SPACES_BUCKET
   });
   async function createFile(value) {
-    const session = import_utils13.useAtlas.getClient()?.startSession();
+    const session = import_utils14.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     const file = {
       name: value.originalname,
@@ -13381,7 +13457,7 @@ function useFileService() {
     }
   }
   async function deleteFile(id) {
-    const session = import_utils13.useAtlas.getClient()?.startSession();
+    const session = import_utils14.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       await deleteFileById(id, session);
@@ -13402,12 +13478,12 @@ function useFileService() {
         const file = files[index];
         try {
           await deleteFile(file._id.toString());
-          await import_utils13.logger.log({
+          await import_utils14.logger.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
         } catch (error) {
-          import_utils13.logger.log({
+          import_utils14.logger.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
@@ -13424,7 +13500,7 @@ function useFileService() {
 }
 
 // src/controllers/file.controller.ts
-var import_utils14 = require("@goweekdays/utils");
+var import_utils15 = require("@goweekdays/utils");
 var import_joi4 = __toESM(require("joi"));
 function useFileController() {
   const { createFile, deleteFile: _deleteFile } = useFileService();
@@ -13438,10 +13514,10 @@ function useFileController() {
       res.json({ message: "Successfully uploaded file", id });
       return;
     } catch (error) {
-      if (error instanceof import_utils14.AppError) {
+      if (error instanceof import_utils15.AppError) {
         next(error);
       } else {
-        next(new import_utils14.InternalServerError(error));
+        next(new import_utils15.InternalServerError(error));
       }
     }
   }
@@ -13450,17 +13526,17 @@ function useFileController() {
     const validation = import_joi4.default.string().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils14.BadRequestError(error.message));
+      next(new import_utils15.BadRequestError(error.message));
     }
     try {
       const message = await _deleteFile(id);
       res.json({ message });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils14.AppError) {
+      if (error2 instanceof import_utils15.AppError) {
         next(error2);
       } else {
-        next(new import_utils14.InternalServerError(error2));
+        next(new import_utils15.InternalServerError(error2));
       }
     }
   }
@@ -13548,7 +13624,7 @@ function useRoleService() {
 
 // src/controllers/role.controller.ts
 var import_joi5 = __toESM(require("joi"));
-var import_utils15 = require("@goweekdays/utils");
+var import_utils16 = require("@goweekdays/utils");
 function useRoleController() {
   const {
     createRole: _createRole,
@@ -13569,7 +13645,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ name, permissions, type });
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     try {
@@ -13593,7 +13669,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ search, page, limit, type });
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     try {
@@ -13612,7 +13688,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ userId });
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     try {
@@ -13630,7 +13706,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     try {
@@ -13652,7 +13728,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ _id, name, permissions });
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     try {
@@ -13670,7 +13746,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     try {
@@ -13708,11 +13784,11 @@ var MEntity = class {
 
 // src/repositories/entity.repository.ts
 var import_mongodb11 = require("mongodb");
-var import_utils16 = require("@goweekdays/utils");
+var import_utils17 = require("@goweekdays/utils");
 function useEntityRepo() {
-  const db = import_utils16.useAtlas.getDb();
+  const db = import_utils17.useAtlas.getDb();
   if (!db) {
-    throw new import_utils16.InternalServerError("Unable to connect to server.");
+    throw new import_utils17.InternalServerError("Unable to connect to server.");
   }
   const collection = db.collection("entities");
   async function createIndex() {
@@ -13738,12 +13814,12 @@ function useEntityRepo() {
       });
       return res.insertedId.toString();
     } catch (error) {
-      import_utils16.logger.log({ level: "error", message: `${error}` });
+      import_utils17.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_utils17.BadRequestError("Entity name already exists.");
       }
-      throw new import_utils16.InternalServerError("Failed to create entity.");
+      throw new import_utils17.InternalServerError("Failed to create entity.");
     }
   }
   async function getEntities({
@@ -13766,23 +13842,23 @@ function useEntityRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      return (0, import_utils16.paginate)(items, page, limit, length);
+      return (0, import_utils17.paginate)(items, page, limit, length);
     } catch (error) {
-      import_utils16.logger.log({ level: "error", message: `${error}` });
+      import_utils17.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function updateEntityFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["name"];
     if (!allowedFields.includes(field)) {
-      throw new import_utils16.BadRequestError(
+      throw new import_utils17.BadRequestError(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
       _id = new import_mongodb11.ObjectId(_id);
     } catch (error) {
-      throw new import_utils16.BadRequestError("Invalid ID.");
+      throw new import_utils17.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -13793,14 +13869,14 @@ function useEntityRepo() {
       );
       return `Successfully updated entity ${field}.`;
     } catch (error) {
-      throw new import_utils16.InternalServerError(`Failed to update entity ${field}.`);
+      throw new import_utils17.InternalServerError(`Failed to update entity ${field}.`);
     }
   }
   async function deleteEntity(_id) {
     try {
       _id = new import_mongodb11.ObjectId(_id);
     } catch (error) {
-      throw new import_utils16.BadRequestError("Invalid entity ID.");
+      throw new import_utils17.BadRequestError("Invalid entity ID.");
     }
     try {
       return await collection.updateOne(
@@ -13822,7 +13898,7 @@ function useEntityRepo() {
 }
 
 // src/services/entity.service.ts
-var import_utils17 = require("@goweekdays/utils");
+var import_utils18 = require("@goweekdays/utils");
 function useEntityService() {
   const {
     createEntity: _createEntity,
@@ -13834,21 +13910,21 @@ function useEntityService() {
     try {
       return await _createEntity(value);
     } catch (error) {
-      throw new import_utils17.InternalServerError();
+      throw new import_utils18.InternalServerError();
     }
   }
   async function getEntities(value) {
     try {
       return await _getEntities(value);
     } catch (error) {
-      throw new import_utils17.InternalServerError();
+      throw new import_utils18.InternalServerError();
     }
   }
   async function updateEntityFieldById(_id, field, value) {
     try {
       return await _updateEntityFieldById({ _id, field, value });
     } catch (error) {
-      throw new import_utils17.InternalServerError();
+      throw new import_utils18.InternalServerError();
     }
   }
   async function deleteEntity(_id) {
@@ -13868,7 +13944,7 @@ function useEntityService() {
 
 // src/controllers/entity.controller.ts
 var import_joi6 = __toESM(require("joi"));
-var import_utils18 = require("@goweekdays/utils");
+var import_utils19 = require("@goweekdays/utils");
 function useEntityController() {
   const {
     createEntity: _createEntity,
@@ -13890,7 +13966,7 @@ function useEntityController() {
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_utils18.BadRequestError(error.message));
+      next(new import_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -13914,7 +13990,7 @@ function useEntityController() {
     });
     const { error } = validation.validate(req.query);
     if (error) {
-      next(new import_utils18.BadRequestError(error.message));
+      next(new import_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -13939,7 +14015,7 @@ function useEntityController() {
     });
     const { error } = validation.validate({ id, field, value });
     if (error) {
-      next(new import_utils18.BadRequestError(error.message));
+      next(new import_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -13958,7 +14034,7 @@ function useEntityController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils18.BadRequestError(error.message));
+      next(new import_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -13994,11 +14070,11 @@ var MWorkflow = class {
 
 // src/repositories/workflow.repository.ts
 var import_mongodb13 = require("mongodb");
-var import_utils19 = require("@goweekdays/utils");
+var import_utils20 = require("@goweekdays/utils");
 function useWorkflowRepo() {
-  const db = import_utils19.useAtlas.getDb();
+  const db = import_utils20.useAtlas.getDb();
   if (!db) {
-    throw new import_utils19.InternalServerError("Unable to connect to server.");
+    throw new import_utils20.InternalServerError("Unable to connect to server.");
   }
   const collection = db.collection("workflows");
   async function createIndex() {
@@ -14024,9 +14100,9 @@ function useWorkflowRepo() {
     } catch (error) {
       const duplicated = error.message.includes("duplicate");
       if (duplicated) {
-        throw new import_utils19.BadRequestError("Workflow name already exists.");
+        throw new import_utils20.BadRequestError("Workflow name already exists.");
       }
-      throw new import_utils19.InternalServerError("Failed to create workflow.");
+      throw new import_utils20.InternalServerError("Failed to create workflow.");
     }
   }
   async function getWorkflows({
@@ -14049,9 +14125,9 @@ function useWorkflowRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      return (0, import_utils19.paginate)(items, page, limit, length);
+      return (0, import_utils20.paginate)(items, page, limit, length);
     } catch (error) {
-      import_utils19.logger.log({ level: "error", message: `${error}` });
+      import_utils20.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -14059,25 +14135,25 @@ function useWorkflowRepo() {
     try {
       _id = new import_mongodb13.ObjectId(_id);
     } catch (error) {
-      throw new import_utils19.BadRequestError("Invalid workflow ID.");
+      throw new import_utils20.BadRequestError("Invalid workflow ID.");
     }
     try {
       return await collection.findOne({ _id });
     } catch (error) {
-      throw new import_utils19.InternalServerError("Failed to get workflow.");
+      throw new import_utils20.InternalServerError("Failed to get workflow.");
     }
   }
   async function updateWorkflowFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["name"];
     if (!allowedFields.includes(field)) {
-      throw new import_utils19.BadRequestError(
+      throw new import_utils20.BadRequestError(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
       _id = new import_mongodb13.ObjectId(_id);
     } catch (error) {
-      throw new import_utils19.BadRequestError("Invalid ID.");
+      throw new import_utils20.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -14088,14 +14164,14 @@ function useWorkflowRepo() {
       );
       return `Successfully updated entity ${field}.`;
     } catch (error) {
-      throw new import_utils19.InternalServerError(`Failed to update entity ${field}.`);
+      throw new import_utils20.InternalServerError(`Failed to update entity ${field}.`);
     }
   }
   async function deleteWorkflow(_id) {
     try {
       _id = new import_mongodb13.ObjectId(_id);
     } catch (error) {
-      throw new import_utils19.BadRequestError("Invalid entity ID.");
+      throw new import_utils20.BadRequestError("Invalid entity ID.");
     }
     try {
       return await collection.updateOne(
@@ -14381,11 +14457,11 @@ var MCapBldgAct = class {
 
 // src/repositories/cap-bldg-act.repository.ts
 var import_mongodb15 = require("mongodb");
-var import_utils20 = require("@goweekdays/utils");
+var import_utils21 = require("@goweekdays/utils");
 function useCapBldgActRepo() {
-  const db = import_utils20.useAtlas.getDb();
+  const db = import_utils21.useAtlas.getDb();
   if (!db) {
-    throw new import_utils20.InternalServerError("Unable to connect to server.");
+    throw new import_utils21.InternalServerError("Unable to connect to server.");
   }
   const collection = db.collection("cap-bldg-acts");
   async function createIndex() {
@@ -14417,19 +14493,19 @@ function useCapBldgActRepo() {
       });
       return res.insertedId.toString();
     } catch (error) {
-      import_utils20.logger.log({ level: "error", message: `${error}` });
+      import_utils21.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_utils21.BadRequestError("CapBldgAct name already exists.");
       }
-      throw new import_utils20.InternalServerError("Failed to create CapBldgAct.");
+      throw new import_utils21.InternalServerError("Failed to create CapBldgAct.");
     }
   }
   async function updateCapBldgActBasicInfo({ _id, value } = {}, session) {
     try {
       _id = new import_mongodb15.ObjectId(_id);
     } catch (error) {
-      throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      throw new import_utils21.BadRequestError("Invalid CapBldgAct ID.");
     }
     try {
       await collection.updateOne(
@@ -14440,15 +14516,15 @@ function useCapBldgActRepo() {
         }
       );
     } catch (error) {
-      import_utils20.logger.log({ level: "error", message: `${error}` });
-      throw new import_utils20.InternalServerError("Failed to update CapBldgAct basic info.");
+      import_utils21.logger.log({ level: "error", message: `${error}` });
+      throw new import_utils21.InternalServerError("Failed to update CapBldgAct basic info.");
     }
   }
   async function updateCapBldgActInitRevEval({ _id, value } = {}, session) {
     try {
       _id = new import_mongodb15.ObjectId(_id);
     } catch (error) {
-      throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      throw new import_utils21.BadRequestError("Invalid CapBldgAct ID.");
     }
     try {
       await collection.updateOne(
@@ -14459,8 +14535,8 @@ function useCapBldgActRepo() {
         }
       );
     } catch (error) {
-      import_utils20.logger.log({ level: "error", message: `${error}` });
-      throw new import_utils20.InternalServerError(
+      import_utils21.logger.log({ level: "error", message: `${error}` });
+      throw new import_utils21.InternalServerError(
         "Failed to update CapBldgAct initial review and evaluation."
       );
     }
@@ -14469,7 +14545,7 @@ function useCapBldgActRepo() {
     try {
       _id = new import_mongodb15.ObjectId(_id);
     } catch (error) {
-      throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      throw new import_utils21.BadRequestError("Invalid CapBldgAct ID.");
     }
     try {
       await collection.updateOne(
@@ -14480,8 +14556,8 @@ function useCapBldgActRepo() {
         }
       );
     } catch (error) {
-      import_utils20.logger.log({ level: "error", message: `${error}` });
-      throw new import_utils20.InternalServerError(
+      import_utils21.logger.log({ level: "error", message: `${error}` });
+      throw new import_utils21.InternalServerError(
         "Failed to update CapBldgAct assessment criteria."
       );
     }
@@ -14490,13 +14566,13 @@ function useCapBldgActRepo() {
     try {
       _id = new import_mongodb15.ObjectId(_id);
     } catch (error) {
-      throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      throw new import_utils21.BadRequestError("Invalid CapBldgAct ID.");
     }
     try {
       return await collection.findOne({ _id });
     } catch (error) {
-      import_utils20.logger.log({ level: "error", message: `${error}` });
-      throw new import_utils20.InternalServerError("Failed to create CapBldgAct.");
+      import_utils21.logger.log({ level: "error", message: `${error}` });
+      throw new import_utils21.InternalServerError("Failed to create CapBldgAct.");
     }
   }
   async function getCapBldgActs({
@@ -14534,9 +14610,9 @@ function useCapBldgActRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      return (0, import_utils20.paginate)(items, page, limit, length);
+      return (0, import_utils21.paginate)(items, page, limit, length);
     } catch (error) {
-      import_utils20.logger.log({ level: "error", message: `${error}` });
+      import_utils21.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -14554,14 +14630,14 @@ function useCapBldgActRepo() {
       "status"
     ];
     if (!allowedFields.includes(field)) {
-      throw new import_utils20.BadRequestError(
+      throw new import_utils21.BadRequestError(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
       _id = new import_mongodb15.ObjectId(_id);
     } catch (error) {
-      throw new import_utils20.BadRequestError("Invalid ID.");
+      throw new import_utils21.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -14572,14 +14648,14 @@ function useCapBldgActRepo() {
       );
       return `Successfully updated CapBldgAct ${field}.`;
     } catch (error) {
-      throw new import_utils20.InternalServerError(`Failed to update CapBldgAct ${field}.`);
+      throw new import_utils21.InternalServerError(`Failed to update CapBldgAct ${field}.`);
     }
   }
   async function deleteCapBldgAct(_id) {
     try {
       _id = new import_mongodb15.ObjectId(_id);
     } catch (error) {
-      throw new import_utils20.BadRequestError("Invalid CapBldgAct ID.");
+      throw new import_utils21.BadRequestError("Invalid CapBldgAct ID.");
     }
     try {
       return await collection.updateOne(
@@ -14605,7 +14681,7 @@ function useCapBldgActRepo() {
 }
 
 // src/services/cap-bldg-act.service.ts
-var import_utils21 = require("@goweekdays/utils");
+var import_utils22 = require("@goweekdays/utils");
 function useCapBldgActService() {
   const {
     createCapBldgAct: _createCapBldgAct,
@@ -14683,7 +14759,7 @@ function useCapBldgActService() {
       throw error;
     }
   }
-  const s3 = new import_utils21.useS3({
+  const s3 = new import_utils22.useS3({
     accessKeyId: SPACES_ACCESS_KEY,
     secretAccessKey: SPACES_SECRET_KEY,
     endpoint: SPACES_ENDPOINT,
@@ -14692,7 +14768,7 @@ function useCapBldgActService() {
   });
   const { createFile: _createFile, deleteFileById } = useFileRepo();
   async function uploadAttachment(value, id, field) {
-    const session = import_utils21.useAtlas.getClient()?.startSession();
+    const session = import_utils22.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     const file = {
       name: value.originalname,
@@ -14716,7 +14792,7 @@ function useCapBldgActService() {
     }
   }
   async function deleteAttachment(attachment, id, field) {
-    const session = import_utils21.useAtlas.getClient()?.startSession();
+    const session = import_utils22.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       await deleteFileById(attachment, session);
@@ -14747,7 +14823,7 @@ function useCapBldgActService() {
 
 // src/controllers/cap-bldg-act.controller.ts
 var import_joi8 = __toESM(require("joi"));
-var import_utils22 = require("@goweekdays/utils");
+var import_utils23 = require("@goweekdays/utils");
 function useCapBldgActController() {
   const {
     createCapBldgAct: _createCapBldgAct,
@@ -14774,7 +14850,7 @@ function useCapBldgActController() {
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_utils22.BadRequestError(error.message));
+      next(new import_utils23.BadRequestError(error.message));
       return;
     }
     try {
@@ -14800,7 +14876,7 @@ function useCapBldgActController() {
     });
     const { error } = validation.validate({ ...value, id });
     if (error) {
-      next(new import_utils22.BadRequestError(error.message));
+      next(new import_utils23.BadRequestError(error.message));
       return;
     }
     try {
@@ -14853,7 +14929,7 @@ function useCapBldgActController() {
     });
     const { error } = validation.validate({ ...value, id });
     if (error) {
-      next(new import_utils22.BadRequestError(error.message));
+      next(new import_utils23.BadRequestError(error.message));
       return;
     }
     try {
@@ -14883,7 +14959,7 @@ function useCapBldgActController() {
     });
     const { error } = validation.validate({ ...value, id });
     if (error) {
-      next(new import_utils22.BadRequestError(error.message));
+      next(new import_utils23.BadRequestError(error.message));
       return;
     }
     try {
@@ -14909,7 +14985,7 @@ function useCapBldgActController() {
     });
     const { error } = validation.validate(req.query);
     if (error) {
-      next(new import_utils22.BadRequestError(error.message));
+      next(new import_utils23.BadRequestError(error.message));
       return;
     }
     try {
@@ -14927,7 +15003,7 @@ function useCapBldgActController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils22.BadRequestError(error.message));
+      next(new import_utils23.BadRequestError(error.message));
       return;
     }
     try {
@@ -14959,7 +15035,7 @@ function useCapBldgActController() {
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new import_utils22.BadRequestError(error.message));
+      next(new import_utils23.BadRequestError(error.message));
       return;
     }
     try {
@@ -14983,7 +15059,7 @@ function useCapBldgActController() {
     });
     const { error } = validation.validate({ id, field });
     if (error) {
-      next(new import_utils22.BadRequestError(error.message));
+      next(new import_utils23.BadRequestError(error.message));
       return;
     }
     try {
@@ -15001,7 +15077,7 @@ function useCapBldgActController() {
     const validation = import_joi8.default.string().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils22.BadRequestError(error.message));
+      next(new import_utils23.BadRequestError(error.message));
     }
     try {
       const message = await _deleteAttachment(attachment, id, field);
@@ -15056,9 +15132,9 @@ var MComment = class {
 
 // src/repositories/comment.repository.ts
 var import_mongodb17 = require("mongodb");
-var import_utils23 = require("@goweekdays/utils");
+var import_utils24 = require("@goweekdays/utils");
 function useCommentRepo() {
-  const db = import_utils23.useAtlas.getDb();
+  const db = import_utils24.useAtlas.getDb();
   if (!db) {
     throw new Error("Database not initialized");
   }
@@ -15076,7 +15152,7 @@ function useCommentRepo() {
       await collection.insertOne(value);
       return "Comment added successfully.";
     } catch (error) {
-      throw new import_utils23.InternalServerError("Failed to add comment.");
+      throw new import_utils24.InternalServerError("Failed to add comment.");
     }
   }
   async function getComments({ search = "", page = 1, limit = 10, sort = {}, document: document2 = "" } = {}) {
@@ -15101,9 +15177,9 @@ function useCommentRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      return (0, import_utils23.paginate)(items, page, limit, length);
+      return (0, import_utils24.paginate)(items, page, limit, length);
     } catch (error) {
-      import_utils23.logger.log({ level: "error", message: `${error}` });
+      import_utils24.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -15145,7 +15221,7 @@ function useCommentService() {
 
 // src/controllers/comment.controller.ts
 var import_joi9 = __toESM(require("joi"));
-var import_utils24 = require("@goweekdays/utils");
+var import_utils25 = require("@goweekdays/utils");
 function useCommentController() {
   const { addComment: _addComment, getComments: _getComments } = useCommentService();
   async function addComment(req, res, next) {
@@ -15159,7 +15235,7 @@ function useCommentController() {
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_utils24.BadRequestError(error.message));
+      next(new import_utils25.BadRequestError(error.message));
       return;
     }
     try {
@@ -15186,7 +15262,7 @@ function useCommentController() {
     });
     const { error } = validation.validate({ page, document: document2 });
     if (error) {
-      next(new import_utils24.BadRequestError(error.message));
+      next(new import_utils25.BadRequestError(error.message));
       return;
     }
     try {
@@ -15205,24 +15281,34 @@ function useCommentController() {
 }
 
 // src/models/subscription.model.ts
-var import_utils25 = require("@goweekdays/utils");
+var import_utils26 = require("@goweekdays/utils");
 var import_mongodb18 = require("mongodb");
 function MSubscription(value) {
   if (value._id) {
     try {
       value._id = new import_mongodb18.ObjectId(value._id);
     } catch (error) {
-      throw new import_utils25.BadRequestError("Invalid ID.");
+      throw new import_utils26.BadRequestError("Invalid ID.");
     }
   }
-  try {
-    value.user = new import_mongodb18.ObjectId(value.user);
-  } catch (error) {
-    throw new import_utils25.BadRequestError("Invalid user ID.");
+  if (value.user) {
+    try {
+      value.user = new import_mongodb18.ObjectId(value.user);
+    } catch (error) {
+      throw new import_utils26.BadRequestError("Invalid user ID.");
+    }
+  }
+  if (value.org) {
+    try {
+      value.org = new import_mongodb18.ObjectId(value.org);
+    } catch (error) {
+      throw new import_utils26.BadRequestError("Invalid org ID.");
+    }
   }
   return {
     _id: value._id,
-    user: value.user,
+    user: value.user ?? "",
+    org: value.org ?? "",
     subscriptionId: value.subscriptionId,
     status: "active",
     createdAt: value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
@@ -15232,12 +15318,12 @@ function MSubscription(value) {
 }
 
 // src/repositories/subscription.repository.ts
-var import_utils26 = require("@goweekdays/utils");
+var import_utils27 = require("@goweekdays/utils");
 var import_mongodb19 = require("mongodb");
 function useSubscriptionRepo() {
-  const db = import_utils26.useAtlas.getDb();
+  const db = import_utils27.useAtlas.getDb();
   if (!db) {
-    throw new import_utils26.BadRequestError("Unable to connect to server.");
+    throw new import_utils27.BadRequestError("Unable to connect to server.");
   }
   const collection = db.collection("subscriptions");
   async function createIndex() {
@@ -15248,56 +15334,56 @@ function useSubscriptionRepo() {
         { status: 1 }
       ]);
     } catch (error) {
-      throw new import_utils26.BadRequestError("Failed to create index on subscription.");
+      throw new import_utils27.BadRequestError("Failed to create index on subscription.");
     }
   }
   async function createUniqueIndex() {
     try {
       await collection.createIndex({ user: 1, status: 1 }, { unique: true });
     } catch (error) {
-      throw new import_utils26.BadRequestError(
+      throw new import_utils27.BadRequestError(
         "Failed to create unique index on subscription."
       );
     }
   }
-  async function add(value) {
+  async function add(value, session) {
     try {
       value = MSubscription(value);
-      const res = await collection.insertOne(value);
+      const res = await collection.insertOne(value, { session });
       return res.insertedId;
     } catch (error) {
-      throw new import_utils26.BadRequestError("Failed to create subscription.");
+      throw new import_utils27.BadRequestError("Failed to create subscription.");
     }
   }
   async function getById(_id) {
     try {
       _id = new import_mongodb19.ObjectId(_id);
     } catch (error) {
-      throw new import_utils26.BadRequestError("Invalid ID.");
+      throw new import_utils27.BadRequestError("Invalid ID.");
     }
     try {
       return await collection.findOne({ _id });
     } catch (error) {
-      throw new import_utils26.BadRequestError("Failed to get subscription by ID.");
+      throw new import_utils27.BadRequestError("Failed to get subscription by ID.");
     }
   }
   async function getByUserId(user) {
     try {
       user = new import_mongodb19.ObjectId(user);
     } catch (error) {
-      throw new import_utils26.BadRequestError("Invalid user ID.");
+      throw new import_utils27.BadRequestError("Invalid user ID.");
     }
     try {
       return await collection.findOne({ user });
     } catch (error) {
-      throw new import_utils26.BadRequestError("Failed to get subscription by ID.");
+      throw new import_utils27.BadRequestError("Failed to get subscription by ID.");
     }
   }
   async function getBySubscriptionId(subscriptionId) {
     try {
       return await collection.findOne({ subscriptionId });
     } catch (error) {
-      throw new import_utils26.BadRequestError(
+      throw new import_utils27.BadRequestError(
         "Failed to get subscription by subscription ID."
       );
     }
@@ -15323,9 +15409,9 @@ function useSubscriptionRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      return (0, import_utils26.paginate)(items, page, limit, length);
+      return (0, import_utils27.paginate)(items, page, limit, length);
     } catch (error) {
-      import_utils26.logger.log({ level: "error", message: `${error}` });
+      import_utils27.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -15333,13 +15419,13 @@ function useSubscriptionRepo() {
     try {
       _id = new import_mongodb19.ObjectId(_id);
     } catch (error) {
-      throw new import_utils26.BadRequestError("Invalid ID.");
+      throw new import_utils27.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne({ _id }, { $set: { status } });
       return "Successfully updated subscription status.";
     } catch (error) {
-      throw new import_utils26.BadRequestError("Failed to update subscription status.");
+      throw new import_utils27.BadRequestError("Failed to update subscription status.");
     }
   }
   return {
@@ -15355,7 +15441,7 @@ function useSubscriptionRepo() {
 }
 
 // src/services/subscription.service.ts
-var import_utils53 = require("@goweekdays/utils");
+var import_utils61 = require("@goweekdays/utils");
 
 // node_modules/axios/lib/helpers/bind.js
 function bind(fn, thisArg) {
@@ -18658,177 +18744,1232 @@ var {
   mergeConfig: mergeConfig2
 } = axios_default;
 
-// src/services/subscription.service.ts
-function useSubscriptionService() {
-  const { getByUserId: _getByUserId } = useSubscriptionRepo();
-  async function getByUserId(id) {
+// src/services/xendit.service.ts
+var import_utils54 = require("@goweekdays/utils");
+var import_mongodb20 = require("mongodb");
+function useXenditService() {
+  const basicAuth = Buffer.from(`${XENDIT_SECRET_KEY}:`).toString("base64");
+  const axios2 = axios_default.create({
+    baseURL: XENDIT_BASE_URL,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Basic ${basicAuth}`
+    }
+  });
+  async function createCustomer({
+    mobile_number = "",
+    email = "",
+    type = "INDIVIDUAL",
+    given_names = "",
+    surname = ""
+  } = {}) {
     try {
-      const subscription = await _getByUserId(id);
-      if (!subscription) {
-        throw new import_utils53.BadRequestError("Subscription not found.");
-      }
-      return subscription;
+      const res = await axios2.post("/customers", {
+        reference_id: new import_mongodb20.ObjectId().toString(),
+        mobile_number,
+        email,
+        type,
+        individual_detail: {
+          given_names,
+          surname
+        }
+      });
+      return res.data;
     } catch (error) {
-      throw error;
+      throw new import_utils54.BadRequestError("Failed to create customer.");
     }
   }
-  async function getPayPalAccessToken() {
+  async function linkPaymentMethodEWallet({
+    customerId = "",
+    type = "GCASH",
+    success_return_url = `${APP_ACCOUNT}/payment-methods`,
+    failure_return_url = `${APP_ACCOUNT}/payment-methods`,
+    cancel_return_url = `${APP_ACCOUNT}/payment-methods`
+  } = {}) {
     try {
-      const auth = Buffer.from(
-        `${PAYPAL_CLIENT_ID}:${PAYPAL_CLIENT_SECRET}`
-      ).toString("base64");
-      const response = await axios_default.post(
-        `${PAYPAL_API_URL}/v1/oauth2/token`,
-        "grant_type=client_credentials",
-        {
-          headers: {
-            Authorization: `Basic ${auth}`,
-            "Content-Type": "application/x-www-form-urlencoded"
+      const res = await axios2.post("/v2/payment_methods", {
+        type: "EWALLET",
+        reusability: "MULTIPLE_USE",
+        customer_id: customerId,
+        ewallet: {
+          channel_code: type,
+          channel_properties: {
+            success_return_url,
+            failure_return_url,
+            cancel_return_url
           }
         }
-      );
-      return response.data.access_token;
+      });
+      return res.data;
+    } catch (error) {
+      throw new import_utils54.BadRequestError("Failed to initiate GCash linking.");
+    }
+  }
+  async function linkPaymentMethodCard({
+    success_return_url = `${APP_ACCOUNT}/payment-methods`,
+    failure_return_url = `${APP_ACCOUNT}/payment-methods`,
+    card_number = "",
+    expiry_month = "",
+    expiry_year = "",
+    cvv = "",
+    cardholder_name = "",
+    currency = "PHP"
+  } = {}) {
+    try {
+      const res = await axios2.post("/v2/payment_methods", {
+        type: "CARD",
+        card: {
+          currency,
+          channel_properties: {
+            skip_three_d_secure: true,
+            success_return_url,
+            failure_return_url
+          },
+          card_information: {
+            card_number,
+            expiry_month,
+            expiry_year,
+            cvv,
+            cardholder_name
+          }
+        },
+        reusability: "MULTIPLE_USE",
+        description: "Linking card to GoWeekdays account."
+      });
+      return res.data;
     } catch (error) {
-      throw new import_utils53.BadRequestError("Failed to retrieve PayPal access token");
+      throw new import_utils54.BadRequestError("Failed to initiate card linking..");
     }
   }
-  async function getSubscriptionStatus(subscriptionId) {
+  async function eWalletSubsequentPayment({
+    amount = 0,
+    currency = "PHP",
+    payment_method_id = "",
+    customer_id = "",
+    description = ""
+  } = {}) {
     try {
-      const accessToken = await getPayPalAccessToken();
-      const response = await axios_default.get(
-        `${PAYPAL_API_URL}/v1/billing/subscriptions/${subscriptionId}`,
-        {
-          headers: {
-            Authorization: `Bearer ${accessToken}`,
-            "Content-Type": "application/json"
-          }
+      const res = await axios2.post("/payment_requests", {
+        amount,
+        currency,
+        payment_method_id,
+        customer_id,
+        description
+      });
+      return res.data;
+    } catch (error) {
+      console.log(error);
+      throw new import_utils54.BadRequestError(
+        "Failed to initiate GCash linking and payment request."
+      );
+    }
+  }
+  async function initGCashLinkingAndPaymentRequest({
+    amount = 0,
+    currency = "PHP",
+    countryCode = "PH",
+    customerId = "",
+    success_return_url = `${APP_MAIN}/checkout/success`,
+    failure_return_url = `${APP_MAIN}/checkout/failed`
+  } = {}) {
+    try {
+      const res = await axios2.post("/payment_requests", {
+        amount,
+        currency,
+        country: countryCode,
+        customer_id: customerId,
+        payment_method: {
+          type: "EWALLET",
+          ewallet: {
+            channel_code: "GCASH",
+            channel_properties: {
+              success_return_url,
+              failure_return_url
+            }
+          },
+          reusability: "MULTIPLE_USE"
         }
+      });
+      return res.data;
+    } catch (error) {
+      console.log(error);
+      throw new import_utils54.BadRequestError(
+        "Failed to initiate GCash linking and payment request."
       );
-      return response.data.status;
+    }
+  }
+  async function initSubscription({
+    customer = "",
+    currency = "PHP",
+    amount = 0,
+    paymentMethod = "",
+    description = "",
+    interval = "MONTH"
+  } = {}) {
+    try {
+      const res = await axios2.post("/recurring/plans", {
+        reference_id: new import_mongodb20.ObjectId().toString(),
+        customer_id: customer,
+        recurring_action: "PAYMENT",
+        currency,
+        amount,
+        payment_methods: [
+          {
+            payment_method_id: paymentMethod,
+            rank: 1
+          }
+        ],
+        schedule: {
+          reference_id: new import_mongodb20.ObjectId().toString(),
+          interval,
+          interval_count: 1,
+          anchor_date: "2022-02-15T09:44:19.546Z",
+          retry_interval: "DAY",
+          retry_interval_count: 1,
+          total_retry: 3,
+          failed_attempt_notifications: [1, 3]
+        },
+        notification_config: {
+          locale: "en",
+          recurring_created: ["WHATSAPP", "EMAIL"],
+          recurring_succeeded: ["WHATSAPP", "EMAIL"],
+          recurring_failed: ["WHATSAPP", "EMAIL"]
+        },
+        failed_cycle_action: "STOP",
+        immediate_action_type: "FULL_AMOUNT",
+        metadata: null,
+        description
+      });
+      return res.data;
+    } catch (error) {
+      console.log(error);
+      throw new import_utils54.BadRequestError("Failed to create subscription.");
+    }
+  }
+  async function checkSubscriptionStatus(subscriptionId) {
+    try {
+      const res = await axios2.get(`/recurring/plans/${subscriptionId}`);
+      return res.data.status;
     } catch (error) {
-      throw new import_utils53.BadRequestError("Failed to fetch subscription status");
+      throw new import_utils54.BadRequestError("Failed to get subscription status.");
     }
   }
   async function cancelSubscription(subscriptionId) {
     try {
-      const accessToken = await getPayPalAccessToken();
-      await console.log("accessToken", accessToken);
-      const response = await axios_default.post(
-        `${PAYPAL_API_URL}/v1/billing/subscriptions/${subscriptionId}/cancel`,
-        {},
-        {
-          headers: {
-            Authorization: `Bearer ${accessToken}`,
-            "Content-Type": "application/json"
-          }
-        }
+      const res = await axios2.get(
+        `/recurring/plans/${subscriptionId}/deactivate`
       );
-      if (response.status === 204) {
-        return { message: "Subscription canceled successfully." };
-      } else {
-        throw new import_utils53.BadRequestError("Failed to cancel subscription.");
-      }
+      return res.data.status;
     } catch (error) {
-      throw new import_utils53.BadRequestError("Failed to cancel subscription.");
+      throw new import_utils54.BadRequestError("Failed to get subscription status.");
     }
   }
   return {
-    getByUserId,
-    getSubscriptionStatus,
+    createCustomer,
+    linkPaymentMethodEWallet,
+    initGCashLinkingAndPaymentRequest,
+    initSubscription,
+    linkPaymentMethodCard,
+    eWalletSubsequentPayment,
+    checkSubscriptionStatus,
     cancelSubscription
   };
 }
 
-// src/controllers/subscription.controller.ts
-var import_joi10 = __toESM(require("joi"));
-var import_utils54 = require("@goweekdays/utils");
-function useSubscriptionController() {
-  const { add: _add, getSubscriptions: _getSubscriptions } = useSubscriptionRepo();
-  const {
-    getByUserId: _getByUserId,
-    getSubscriptionStatus: _getSubscriptionStatus,
-    cancelSubscription: _cancelSubscription
-  } = useSubscriptionService();
-  async function add(req, res, next) {
-    const value = req.body;
-    const validation = import_joi10.default.object({
-      user: import_joi10.default.string().required(),
-      subscriptionId: import_joi10.default.string().required()
-    });
-    const { error } = validation.validate(value);
-    if (error) {
-      next(new import_utils54.BadRequestError(error.message));
-    }
+// src/repositories/payment-method.repository.ts
+var import_utils56 = require("@goweekdays/utils");
+
+// src/models/payment-method.model.ts
+var import_utils55 = require("@goweekdays/utils");
+var import_mongodb21 = require("mongodb");
+function MPaymentMethod(value) {
+  if (value.user) {
     try {
-      const value2 = req.body;
-      const id = await _add(value2);
-      res.json({ message: "Successfully added subscription.", id });
-      return;
-    } catch (error2) {
-      next(error2);
+      value.user = new import_mongodb21.ObjectId(value.user);
+    } catch (error) {
+      throw new import_utils55.BadRequestError("Invalid user ID.");
     }
   }
-  async function getByUserId(req, res, next) {
-    const id = req.params.id;
-    const validation = import_joi10.default.string().required();
-    const { error } = validation.validate(id);
-    if (error) {
-      next(new import_utils54.BadRequestError(error.message));
-    }
+  if (value.org) {
     try {
-      const subscription = await _getByUserId(id);
-      res.json(subscription);
-      return;
-    } catch (error2) {
-      next(error2);
+      value.org = new import_mongodb21.ObjectId(value.org);
+    } catch (error) {
+      throw new import_utils55.BadRequestError("Invalid org ID.");
     }
   }
-  async function getSubscriptions(req, res, next) {
-    const status = req.query.status ?? "";
-    const search = req.query.search ?? "";
-    const page = Number(req.query.page) ?? 1;
-    const validation = import_joi10.default.object({
-      status: import_joi10.default.string().required(),
-      search: import_joi10.default.string().optional().allow("", null),
-      page: import_joi10.default.number().required()
-    });
-    const { error } = validation.validate({ status, search, page });
-    if (error) {
-      next(new import_utils54.BadRequestError(error.message));
-    }
+  return {
+    _id: value._id ?? new import_mongodb21.ObjectId(),
+    user: value.user ?? "",
+    org: value.org ?? "",
+    name: value.name,
+    description: value.description,
+    type: value.type,
+    paymentId: value.paymentId ?? "",
+    customerId: value.customerId ?? "",
+    number: value.number,
+    expiry: value.expiry ?? "",
+    cvv: value.cvv ?? "",
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/payment-method.repository.ts
+var import_mongodb22 = require("mongodb");
+function usePaymentMethodRepo() {
+  const db = import_utils56.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils56.BadRequestError("Unable to connect to server.");
+  }
+  const collection = db.collection("payment-methods");
+  async function createIndex() {
     try {
-      const subscriptions = await _getSubscriptions({ status, search, page });
-      res.json(subscriptions);
-      return;
-    } catch (error2) {
-      next(error2);
+      await collection.createIndex([{ user: 1 }]);
+    } catch (error) {
+      throw new import_utils56.BadRequestError("Failed to create index on payment method.");
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        {
+          user: 1,
+          org: 1,
+          name: 1,
+          paymentId: 1,
+          number: 1
+        },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new import_utils56.BadRequestError(
+        "Failed to create unique index on payment method."
+      );
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MPaymentMethod(value);
+      await collection.insertOne(value, { session });
+      return "Successfully added payment method.";
+    } catch (error) {
+      import_utils56.logger.log({ level: "error", message: `${error}` });
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_utils56.BadRequestError("Payment method already exist.");
+      }
+      throw new import_utils56.InternalServerError("Failed to add payment method.");
+    }
+  }
+  function getByUser(user) {
+    try {
+      user = new import_mongodb22.ObjectId(user);
+    } catch (error) {
+      throw new import_utils56.BadRequestError("Invalid user ID.");
+    }
+    try {
+      return collection.aggregate([
+        { $match: { user } },
+        { $sort: { createdAt: -1 } },
+        {
+          $project: {
+            _id: 1,
+            name: 1,
+            type: 1,
+            number: 1,
+            paymentId: 1,
+            customerId: 1,
+            status: 1
+          }
+        }
+      ]).toArray();
+    } catch (error) {
+      throw new import_utils56.BadRequestError("Failed to get payment methods.");
+    }
+  }
+  async function getByPaymentMethodId(paymentId) {
+    if (!paymentId) {
+      throw new import_utils56.BadRequestError("Invalid payment method ID.");
+    }
+    try {
+      return await collection.findOne({ paymentId });
+    } catch (error) {
+      throw new import_utils56.BadRequestError("Failed to retrieve payment method.");
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new import_mongodb22.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils56.BadRequestError("Invalid payment method ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      return "Successfully deleted payment method.";
+    } catch (error) {
+      throw new import_utils56.BadRequestError("Failed to delete payment method.");
+    }
+  }
+  return {
+    createIndex,
+    add,
+    getByUser,
+    deleteById,
+    createUniqueIndex,
+    getByPaymentMethodId
+  };
+}
+
+// src/repositories/organization.repository.ts
+var import_utils58 = require("@goweekdays/utils");
+
+// src/models/organization.model.ts
+var import_utils57 = require("@goweekdays/utils");
+var import_joi10 = __toESM(require("joi"));
+var import_mongodb23 = require("mongodb");
+function MOrg(value) {
+  const schema = import_joi10.default.object({
+    _id: import_joi10.default.string().hex().optional().allow("", null),
+    name: import_joi10.default.string().required(),
+    email: import_joi10.default.string().email().required(),
+    contact: import_joi10.default.string().required(),
+    type: import_joi10.default.string().required(),
+    busInst: import_joi10.default.string().optional().allow("", null),
+    description: import_joi10.default.string().optional().allow("", null),
+    status: import_joi10.default.string().optional().allow("", null),
+    createdAt: import_joi10.default.string().optional().allow("", null),
+    updatedAt: import_joi10.default.string().optional().allow("", null),
+    deletedAt: import_joi10.default.string().optional().allow("", null)
+  });
+  const { error } = schema.validate(value);
+  if (error) {
+    throw new import_utils57.BadRequestError(error.message);
+  }
+  if (value._id) {
+    try {
+      value._id = new import_mongodb23.ObjectId(value._id);
+    } catch (error2) {
+      throw new import_utils57.BadRequestError("Invalid ID.");
+    }
+  }
+  return {
+    _id: value._id,
+    name: value.name,
+    description: value.description,
+    type: value.type,
+    email: value.email,
+    contact: value.contact,
+    status: value.status || "active",
+    createdAt: value.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
+
+// src/repositories/organization.repository.ts
+var import_mongodb24 = require("mongodb");
+function useOrgRepo() {
+  const db = import_utils58.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const collection = db.collection("organizations");
+  async function createIndex() {
+    try {
+      await collection.createIndex([
+        { name: 1 },
+        { description: 1 },
+        { status: 1 }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index.");
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({
+        name: "text",
+        description: "text"
+      });
+    } catch (error) {
+      throw new Error("Failed to create text index on name and description.");
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        {
+          name: 1
+        },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new Error("Failed to create unique index on name.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MOrg(value);
+      const res = await collection.insertOne(value, session);
+      return res.insertedId;
+    } catch (error) {
+      import_utils58.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_utils58.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_utils58.BadRequestError("Organization already exist.");
+        }
+        throw new Error("Failed to create organization.");
+      }
+    }
+  }
+  async function getOrgs({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { status };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    if (search) {
+      query.$text = { $search: search };
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit },
+        {
+          $project: {
+            _id: 1,
+            name: 1,
+            description: 1,
+            status: 1,
+            createdAt: 1
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      return (0, import_utils58.paginate)(items, page, limit, length);
+    } catch (error) {
+      import_utils58.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb24.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils58.BadRequestError("Invalid ID.");
+    }
+    try {
+      const result = await collection.findOne({ _id });
+      if (!result) {
+        throw new import_utils58.BadRequestError("Organization not found.");
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils58.AppError) {
+        throw error;
+      } else {
+        throw new import_utils58.InternalServerError("Failed to get organization.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["name", "description"];
+    if (!allowedFields.includes(field)) {
+      throw new import_utils58.BadRequestError(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new import_mongodb24.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils58.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { [field]: value } },
+        // Dynamically set the field
+        { session }
+      );
+      return `Successfully updated user ${field}.`;
+    } catch (error) {
+      throw new import_utils58.InternalServerError(`Failed to update organization ${field}.`);
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new import_mongodb24.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils58.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+      );
+      return "Successfully deleted organization.";
+    } catch (error) {
+      throw new import_utils58.InternalServerError("Failed to delete organization.");
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createUniqueIndex,
+    add,
+    getOrgs,
+    getById,
+    updateFieldById,
+    deleteById
+  };
+}
+
+// src/repositories/address.repository.ts
+var import_utils60 = require("@goweekdays/utils");
+
+// src/models/address.model.ts
+var import_utils59 = require("@goweekdays/utils");
+var import_mongodb25 = require("mongodb");
+function MAddress(value) {
+  if (value.user) {
+    try {
+      value.user = new import_mongodb25.ObjectId(value.user);
+    } catch (error) {
+      throw new import_utils59.BadRequestError("Invalid user ID.");
+    }
+  }
+  if (value.org) {
+    try {
+      value.org = new import_mongodb25.ObjectId(value.org);
+    } catch (error) {
+      throw new import_utils59.BadRequestError("Invalid org ID.");
+    }
+  }
+  return {
+    type: value.type ?? "billing",
+    user: value.user ?? "",
+    org: value.org ?? "",
+    country: value.country ?? "",
+    address: value.address ?? "",
+    continuedAddress: value.continuedAddress ?? "",
+    city: value.city ?? "",
+    province: value.province ?? "",
+    postalCode: value.postalCode ?? "",
+    taxId: value.taxId ?? ""
+  };
+}
+
+// src/repositories/address.repository.ts
+var import_mongodb26 = require("mongodb");
+function useAddressRepo() {
+  const db = import_utils60.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils60.BadRequestError("Unable to connect to server.");
+  }
+  const collection = db.collection("addresses");
+  async function createIndex() {
+    try {
+      await collection.createIndex([{ user: 1 }, { type: 1 }]);
+    } catch (error) {
+      throw new import_utils60.BadRequestError("Failed to create index on address.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MAddress(value);
+      const res = await collection.insertOne(value, { session });
+      return res.insertedId;
+    } catch (error) {
+      throw new import_utils60.BadRequestError("Failed to create address.");
+    }
+  }
+  async function getByUserId(user) {
+    try {
+      user = new import_mongodb26.ObjectId(user);
+    } catch (error) {
+      throw new import_utils60.BadRequestError("Invalid user ID.");
+    }
+    try {
+      return await collection.findOne({ user });
+    } catch (error) {
+      throw new import_utils60.BadRequestError("Failed to get address by ID.");
+    }
+  }
+  return {
+    createIndex,
+    add,
+    getByUserId
+  };
+}
+
+// src/services/subscription.service.ts
+function useSubscriptionService() {
+  const { getByUserId: _getByUserId, add } = useSubscriptionRepo();
+  const { getUserById: _getUserByUserId } = useUserRepo();
+  const { initSubscription, checkSubscriptionStatus, cancelSubscription } = useXenditService();
+  const { add: addPaymentMethod, getByPaymentMethodId } = usePaymentMethodRepo();
+  const { add: addOrg } = useOrgRepo();
+  const { add: addAddress } = useAddressRepo();
+  async function createOrgSubscription(value) {
+    const session = import_utils61.useAtlas.getClient()?.startSession();
+    session?.startTransaction();
+    try {
+      const _user = await _getUserByUserId(value.user);
+      if (!_user) {
+        throw new import_utils61.BadRequestError("User not found.");
+      }
+      const payment = await getByPaymentMethodId(value.payment_method_id);
+      if (!payment) {
+        throw new import_utils61.BadRequestError("Payment method not found.");
+      }
+      const org = await addOrg(value.organization, session);
+      payment.user = "";
+      payment.org = org;
+      delete payment._id;
+      console.log(payment);
+      await addPaymentMethod(payment, session);
+      value.billingAddress.org = org;
+      await addAddress(value.billingAddress, session);
+      const subscription = await initSubscription({
+        customer: value.customer_id,
+        paymentMethod: value.payment_method_id,
+        amount: value.amount,
+        description: "GoWeekdays Organization Monthly Subscription."
+      });
+      await add(
+        {
+          org,
+          subscriptionId: subscription.id
+        },
+        session
+      );
+      await session?.commitTransaction();
+      return "Subscription created successfully.";
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  async function createAffiliateSubscription({
+    user = "",
+    amount = 0,
+    payment_method_id = "",
+    customer_id = ""
+  } = {}) {
+    const session = import_utils61.useAtlas.getClient()?.startSession();
+    session?.startTransaction();
+    try {
+      const _user = await _getUserByUserId(user);
+      if (!_user) {
+        throw new import_utils61.BadRequestError("User not found.");
+      }
+      const subscription = await initSubscription({
+        customer: customer_id,
+        paymentMethod: payment_method_id,
+        amount,
+        description: "GoWeekdays Affiliate Annual Subscription.",
+        interval: "YEAR"
+      });
+      await add(
+        {
+          user,
+          subscriptionId: subscription.id
+        },
+        session
+      );
+      await session?.commitTransaction();
+      return "Subscription created successfully.";
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  async function getByUserId(id) {
+    try {
+      const subscription = await _getByUserId(id);
+      if (!subscription) {
+        throw new import_utils61.BadRequestError("Subscription not found.");
+      }
+      return subscription;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getStatusByUser(user) {
+    try {
+      const userSubscription = await getByUserId(user);
+      const status = await checkSubscriptionStatus(
+        userSubscription.subscriptionId
+      );
+      return status;
+    } catch (error) {
+      throw new import_utils61.BadRequestError("Failed to fetch subscription status");
+    }
+  }
+  return {
+    getByUserId,
+    getStatusByUser,
+    createAffiliateSubscription,
+    createOrgSubscription
+  };
+}
+
+// src/controllers/subscription.controller.ts
+var import_joi11 = __toESM(require("joi"));
+var import_utils62 = require("@goweekdays/utils");
+function useSubscriptionController() {
+  const { add: _add, getSubscriptions: _getSubscriptions } = useSubscriptionRepo();
+  const {
+    getByUserId: _getByUserId,
+    getStatusByUser: _getStatusByUser,
+    createAffiliateSubscription: _createAffiliateSubscription,
+    createOrgSubscription: _createOrgSubscription
+  } = useSubscriptionService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const validation = import_joi11.default.object({
+      user: import_joi11.default.string().required(),
+      subscriptionId: import_joi11.default.string().required()
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_utils62.BadRequestError(error.message));
+    }
+    try {
+      const value2 = req.body;
+      const id = await _add(value2);
+      res.json({ message: "Successfully added subscription.", id });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByUserId(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi11.default.string().required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_utils62.BadRequestError(error.message));
+    }
+    try {
+      const subscription = await _getByUserId(id);
+      res.json(subscription);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getSubscriptions(req, res, next) {
+    const status = req.query.status ?? "";
+    const search = req.query.search ?? "";
+    const page = Number(req.query.page) ?? 1;
+    const validation = import_joi11.default.object({
+      status: import_joi11.default.string().required(),
+      search: import_joi11.default.string().optional().allow("", null),
+      page: import_joi11.default.number().required()
+    });
+    const { error } = validation.validate({ status, search, page });
+    if (error) {
+      next(new import_utils62.BadRequestError(error.message));
+    }
+    try {
+      const subscriptions = await _getSubscriptions({ status, search, page });
+      res.json(subscriptions);
+      return;
+    } catch (error2) {
+      next(error2);
     }
   }
   async function getSubscriptionStatus(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi10.default.string().required();
+    const validation = import_joi11.default.string().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils54.BadRequestError(error.message));
+      next(new import_utils62.BadRequestError(error.message));
+    }
+    try {
+      const status = await _getStatusByUser(id);
+      res.json({ status });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function createAffiliateSubscription(req, res, next) {
+    const amount = req.body.amount ?? 0;
+    const payment_method_id = req.body.payment_method_id ?? "";
+    const customer_id = req.body.customer_id ?? "";
+    const currency = req.body.currency ?? "PHP";
+    const user = req.headers["user"];
+    const validation = import_joi11.default.object({
+      user: import_joi11.default.string().required(),
+      amount: import_joi11.default.number().required(),
+      customer_id: import_joi11.default.string().required(),
+      payment_method_id: import_joi11.default.string().required(),
+      currency: import_joi11.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({
+      user,
+      amount,
+      customer_id,
+      payment_method_id,
+      currency
+    });
+    if (error) {
+      next(new import_utils62.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createAffiliateSubscription({
+        user,
+        amount,
+        customer_id,
+        payment_method_id
+      });
+      res.json({ message: "Successfully added subscription.", id });
+      return;
+    } catch (error2) {
+      console.log(error2);
+      next(error2);
+      return;
+    }
+  }
+  async function createOrgSubscription(req, res, next) {
+    const value = req.body;
+    value.user = req.headers["user"];
+    const validation = import_joi11.default.object({
+      user: import_joi11.default.string().required(),
+      amount: import_joi11.default.number().required(),
+      customer_id: import_joi11.default.string().required(),
+      payment_method_id: import_joi11.default.string().required(),
+      currency: import_joi11.default.string().optional().allow("", null),
+      organization: import_joi11.default.object({
+        name: import_joi11.default.string().required(),
+        description: import_joi11.default.string().optional().allow("", null),
+        type: import_joi11.default.string().allow("personal", "business").required(),
+        email: import_joi11.default.string().email().required(),
+        contact: import_joi11.default.string().required(),
+        busInst: import_joi11.default.string().optional().allow(null, "")
+      }).required(),
+      billingAddress: import_joi11.default.object({
+        type: import_joi11.default.string().required(),
+        country: import_joi11.default.string().required(),
+        address: import_joi11.default.string().required(),
+        continuedAddress: import_joi11.default.string().optional().allow(null, ""),
+        city: import_joi11.default.string().required(),
+        province: import_joi11.default.string().required(),
+        postalCode: import_joi11.default.string().required(),
+        taxId: import_joi11.default.string().optional().allow(null, "")
+      }).required()
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_utils62.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createOrgSubscription(value);
+      res.json({ message: "Successfully added subscription.", id });
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
+  return {
+    add,
+    getByUserId,
+    getSubscriptions,
+    getSubscriptionStatus,
+    createAffiliateSubscription,
+    createOrgSubscription
+  };
+}
+
+// src/services/payment-method.service.ts
+var import_utils63 = require("@goweekdays/utils");
+function usePaymentMethodService() {
+  const { createCustomer, linkPaymentMethodEWallet, linkPaymentMethodCard } = useXenditService();
+  const { getUserById } = useUserRepo();
+  const { add } = usePaymentMethodRepo();
+  const cardRules = {
+    Visa: { length: 16, visibleDigits: 4 },
+    MasterCard: { length: 16, visibleDigits: 4 },
+    "American Express": { length: 15, visibleDigits: 5 },
+    Discover: { length: 16, visibleDigits: 4 },
+    "Diners Club": { length: 14, visibleDigits: 4 },
+    JCB: { length: 16, visibleDigits: 4 },
+    UnionPay: { length: 19, visibleDigits: 4 },
+    Maestro: { length: 19, visibleDigits: 4 }
+  };
+  const detectCardType = (cardNumber) => {
+    const patterns = {
+      Visa: /^4/,
+      MasterCard: /^(5[1-5]|222[1-9]|22[3-9]\d|2[3-6]\d{2}|27[01]\d|2720)/,
+      "American Express": /^3[47]/,
+      Discover: /^(6011|622(12[6-9]|1[3-9]\d|[2-8]\d\d|92[0-5])|64[4-9]|65)/,
+      "Diners Club": /^3(0[0-5]|[68])/,
+      JCB: /^35/,
+      UnionPay: /^62/,
+      Maestro: /^(50|5[6-9]|6\d)/
+    };
+    for (const [type, regex] of Object.entries(patterns)) {
+      if (regex.test(cardNumber))
+        return type;
+    }
+    return "Unknown";
+  };
+  const maskCardNumber = (cardNumber) => {
+    const cardType = detectCardType(cardNumber);
+    const rule = cardRules[cardType] || { visibleDigits: 4 };
+    const visibleDigits = rule.visibleDigits;
+    const maskLength = cardNumber.length - visibleDigits;
+    if (maskLength <= 0)
+      return cardNumber;
+    const maskedPart = "*".repeat(maskLength);
+    const visiblePart = cardNumber.slice(maskLength);
+    return `${maskedPart}${visiblePart}`;
+  };
+  async function linkEWallet({
+    user = "",
+    mobile_number = "",
+    type = "GCASH",
+    success_return_url = "",
+    failure_return_url = "",
+    cancel_return_url = ""
+  } = {}) {
+    const session = import_utils63.useAtlas.getClient()?.startSession();
+    session?.startTransaction();
+    try {
+      const _user = await getUserById(user);
+      if (!_user) {
+        throw new import_utils63.BadRequestError("User not found.");
+      }
+      if (!_user._id) {
+        throw new import_utils63.BadRequestError("Invalid user ID.");
+      }
+      const customer = await createCustomer({
+        mobile_number,
+        email: _user.email,
+        given_names: _user.firstName,
+        surname: _user.lastName
+      });
+      const result = await linkPaymentMethodEWallet({
+        customerId: customer.id,
+        type,
+        success_return_url,
+        failure_return_url,
+        cancel_return_url
+      });
+      await add(
+        {
+          user: _user._id,
+          type,
+          status: "active",
+          paymentId: result.id,
+          customerId: customer.id,
+          name: result.type,
+          number: mobile_number
+        },
+        session
+      );
+      await session?.commitTransaction();
+      return result;
+    } catch (error) {
+      console.log(error);
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  async function linkCard({
+    user = "",
+    type = "",
+    success_return_url = "",
+    failure_return_url = "",
+    card_number = "",
+    expiry_month = "",
+    expiry_year = "",
+    cvv = "",
+    cardholder_name = "",
+    currency = "PHP"
+  } = {}) {
+    const session = import_utils63.useAtlas.getClient()?.startSession();
+    session?.startTransaction();
+    try {
+      const _user = await getUserById(user);
+      if (!_user) {
+        throw new import_utils63.BadRequestError("User not found.");
+      }
+      if (!_user._id) {
+        throw new import_utils63.BadRequestError("Invalid user ID.");
+      }
+      const result = await linkPaymentMethodCard({
+        card_number,
+        expiry_month,
+        expiry_year,
+        cvv,
+        cardholder_name,
+        currency,
+        success_return_url,
+        failure_return_url
+      });
+      await add(
+        {
+          user: _user._id,
+          type,
+          status: "active",
+          paymentId: result.id,
+          name: result.type,
+          number: maskCardNumber(card_number)
+        },
+        session
+      );
+      await session?.commitTransaction();
+      return result;
+    } catch (error) {
+      console.log(error);
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return {
+    linkEWallet,
+    linkCard
+  };
+}
+
+// src/controllers/payment-method.controller.ts
+var import_joi12 = __toESM(require("joi"));
+var import_utils64 = require("@goweekdays/utils");
+function usePaymentMethodController() {
+  const { linkEWallet } = usePaymentMethodService();
+  async function linkEWalletController(req, res, next) {
+    const mobile_number = req.body.mobile_number ?? "";
+    const type = req.body.type ?? "";
+    const user = req.headers["user"] ?? "";
+    const success_return_url = req.body.success_return_url ?? "";
+    const failure_return_url = req.body.failure_return_url ?? "";
+    const cancel_return_url = req.body.cancel_return_url ?? "";
+    const validation = import_joi12.default.object({
+      user: import_joi12.default.string().hex().required(),
+      mobile_number: import_joi12.default.string().required(),
+      type: import_joi12.default.string().valid("GCASH", "PAYMAYA").required(),
+      success_return_url: import_joi12.default.string().uri().required(),
+      failure_return_url: import_joi12.default.string().uri().required(),
+      cancel_return_url: import_joi12.default.string().uri().required()
+    });
+    const { error } = validation.validate({
+      user,
+      mobile_number,
+      type,
+      success_return_url,
+      failure_return_url,
+      cancel_return_url
+    });
+    if (error) {
+      next(new import_utils64.BadRequestError(error.message));
     }
     try {
-      const status = await _getSubscriptionStatus(id);
-      res.json({ status });
+      const result = await linkEWallet({
+        user,
+        mobile_number,
+        type,
+        success_return_url,
+        failure_return_url,
+        cancel_return_url
+      });
+      res.json(result);
       return;
     } catch (error2) {
       next(error2);
     }
   }
-  async function cancelSubscription(req, res, next) {
-    const id = req.params.id;
-    const validation = import_joi10.default.string().required();
-    const { error } = validation.validate(id);
+  const { getByUser: _getByUser } = usePaymentMethodRepo();
+  async function getByUser(req, res, next) {
+    const user = req.headers["user"] ?? "";
+    try {
+      const result = await _getByUser(user);
+      res.json(result);
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    linkEWalletController,
+    getByUser
+  };
+}
+
+// src/controllers/address.controller.ts
+var import_utils65 = require("@goweekdays/utils");
+var import_joi13 = __toESM(require("joi"));
+function useAddressController() {
+  const { add: _add, getByUserId: _getByUserId } = useAddressRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const validation = import_joi13.default.object({
+      type: import_joi13.default.string().required(),
+      user: import_joi13.default.string().hex().optional().allow("", null),
+      org: import_joi13.default.string().hex().optional().allow("", null),
+      country: import_joi13.default.string().required(),
+      address: import_joi13.default.string().required(),
+      continuedAddress: import_joi13.default.string().optional().allow("", null),
+      city: import_joi13.default.string().required(),
+      province: import_joi13.default.string().required(),
+      postalCode: import_joi13.default.string().required(),
+      taxId: import_joi13.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_utils65.BadRequestError(error.message));
+    }
+    try {
+      const value2 = req.body;
+      const id = await _add(value2);
+      res.json({ message: "Successfully added subscription.", id });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByUserId(req, res, next) {
+    const user = req.params.user;
+    const validation = import_joi13.default.string().hex().required();
+    const { error } = validation.validate(user);
     if (error) {
-      next(new import_utils54.BadRequestError(error.message));
+      next(new import_utils65.BadRequestError(error.message));
     }
     try {
-      await _cancelSubscription(id);
-      res.json({ message: "Subscription cancelled." });
+      const address = await _getByUserId(user);
+      if (!address) {
+        next(new import_utils65.NotFoundError("Address not found."));
+        return;
+      }
+      res.json(address);
       return;
     } catch (error2) {
       next(error2);
@@ -18836,10 +19977,339 @@ function useSubscriptionController() {
   }
   return {
     add,
-    getByUserId,
-    getSubscriptions,
-    getSubscriptionStatus,
-    cancelSubscription
+    getByUserId
+  };
+}
+
+// src/services/organization.service.ts
+var import_utils68 = require("@goweekdays/utils");
+
+// src/repositories/member.repository.ts
+var import_utils67 = require("@goweekdays/utils");
+
+// src/models/member.model.ts
+var import_utils66 = require("@goweekdays/utils");
+var import_joi14 = __toESM(require("joi"));
+var import_mongodb27 = require("mongodb");
+function MMember(value) {
+  const schema = import_joi14.default.object({
+    _id: import_joi14.default.string().hex().optional().allow("", null),
+    org: import_joi14.default.string().hex().required(),
+    name: import_joi14.default.string().required(),
+    user: import_joi14.default.string().hex().required(),
+    role: import_joi14.default.string().hex().required(),
+    status: import_joi14.default.string().optional().allow("", null),
+    createdAt: import_joi14.default.string().optional().allow("", null),
+    updatedAt: import_joi14.default.string().optional().allow("", null),
+    deletedAt: import_joi14.default.string().optional().allow("", null)
+  });
+  const { error } = schema.validate(value);
+  if (error) {
+    throw new import_utils66.BadRequestError(error.message);
+  }
+  if (value.org) {
+    try {
+      value.org = new import_mongodb27.ObjectId(value.org);
+    } catch (error2) {
+      throw new import_utils66.BadRequestError("Invalid org ID.");
+    }
+  }
+  if (value.user) {
+    try {
+      value.user = new import_mongodb27.ObjectId(value.user);
+    } catch (error2) {
+      throw new import_utils66.BadRequestError("Invalid user ID.");
+    }
+  }
+  if (value.role) {
+    try {
+      value.role = new import_mongodb27.ObjectId(value.role);
+    } catch (error2) {
+      throw new import_utils66.BadRequestError("Invalid role ID.");
+    }
+  }
+  return {
+    _id: value._id,
+    org: value.org,
+    name: value.name,
+    user: value.user,
+    role: value.role,
+    status: value.status || "active",
+    createdAt: value.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
+
+// src/repositories/member.repository.ts
+var import_mongodb28 = require("mongodb");
+function useMemberRepo() {
+  const db = import_utils67.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const collection = db.collection("members");
+  async function createIndex() {
+    try {
+      await collection.createIndex([
+        {
+          name: 1
+        },
+        {
+          status: 1
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index.");
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        {
+          org: 1,
+          user: 1
+        },
+        { partialFilterExpression: { deletedAt: "" }, unique: true }
+      );
+    } catch (error) {
+      throw new Error("Failed to create unique index.");
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({
+        name: "text"
+      });
+    } catch (error) {
+      throw new Error("Failed to create text index.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MMember(value);
+      await collection.insertOne(value, { session });
+      return "Successfully added member.";
+    } catch (error) {
+      throw new import_utils67.InternalServerError("Failed to create member.");
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb28.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils67.BadRequestError("Invalid ID.");
+    }
+    try {
+      return await collection.findOne({ _id });
+    } catch (error) {
+      throw new import_utils67.InternalServerError(
+        "Internal server error, failed to retrieve member."
+      );
+    }
+  }
+  async function getByOrgId(org) {
+    try {
+      org = new import_mongodb28.ObjectId(org);
+    } catch (error) {
+      throw new import_utils67.BadRequestError("Invalid org ID.");
+    }
+    try {
+      return await collection.find({ org }).toArray();
+    } catch (error) {
+      throw new import_utils67.InternalServerError(
+        "Internal server error, failed to retrieve members."
+      );
+    }
+  }
+  async function getOrgsByUserId({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    user = "",
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    try {
+      user = new import_mongodb28.ObjectId(user);
+    } catch (error) {
+      throw new import_utils67.BadRequestError("Invalid user ID.");
+    }
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    const query = { user, status };
+    if (search) {
+      query.$text = { $search: search };
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        {
+          $lookup: {
+            from: "orgs",
+            localField: "org",
+            foreignField: "_id",
+            as: "organization"
+          }
+        },
+        { $unwind: "$organization" },
+        // Flatten the array
+        {
+          $project: { _id: "$organization._id", name: "$organization.name" }
+        }
+        // Extract required fields
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      return (0, import_utils67.paginate)(items, page, limit, length);
+    } catch (error) {
+      throw new import_utils67.InternalServerError(
+        "Internal server error, failed to retrieve organizations."
+      );
+    }
+  }
+  async function updateStatusByUserId(user, status) {
+    try {
+      user = new import_mongodb28.ObjectId(user);
+    } catch (error) {
+      throw new import_utils67.BadRequestError("Invalid user ID.");
+    }
+    try {
+      await collection.updateMany(
+        { user },
+        {
+          $set: {
+            status
+          }
+        }
+      );
+      return "Successfully updated member status.";
+    } catch (error) {
+      throw new import_utils67.InternalServerError("Failed to update member status.");
+    }
+  }
+  return {
+    createIndex,
+    createUniqueIndex,
+    createTextIndex,
+    add,
+    getById,
+    getByOrgId,
+    getOrgsByUserId,
+    updateStatusByUserId
+  };
+}
+
+// src/services/organization.service.ts
+function useOrgService() {
+  const { add: addOrg } = useOrgRepo();
+  const { addRole } = useRoleRepo();
+  const { add: addMember } = useMemberRepo();
+  const { getUserById } = useUserRepo();
+  async function createOrg({ user = "", name = "", description = "" } = {}) {
+    const session = import_utils68.useAtlas.getClient()?.startSession();
+    session?.startTransaction();
+    try {
+      const _user = await getUserById(user);
+      if (!_user) {
+        throw new import_utils68.NotFoundError("User not found.");
+      }
+      const org = await addOrg(
+        {
+          name,
+          description
+        },
+        session
+      );
+      const role = await addRole(
+        {
+          org,
+          name: "Owner",
+          description: "Owner of the organization",
+          permissions: ["all"]
+        },
+        session
+      );
+      await addMember(
+        {
+          name: `${_user.firstName} ${_user.lastName}`,
+          org,
+          user,
+          role
+        },
+        session
+      );
+      session?.commitTransaction();
+      return "Organization created successfully.";
+    } catch (error) {
+      session?.abortTransaction();
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return {
+    createOrg
+  };
+}
+
+// src/controllers/organization.controller.ts
+var import_utils69 = require("@goweekdays/utils");
+var import_joi15 = __toESM(require("joi"));
+function useOrgController() {
+  const { createOrg: _createOrg } = useOrgService();
+  const { getOrgsByUserId: _getOrgsByUserId } = useMemberRepo();
+  async function createOrg(req, res, next) {
+    const value = req.body;
+    const validation = import_joi15.default.object({
+      name: import_joi15.default.string().required(),
+      type: import_joi15.default.string().required(),
+      email: import_joi15.default.string().email().required(),
+      contact: import_joi15.default.string().required(),
+      description: import_joi15.default.string().required(),
+      user: import_joi15.default.string().hex().required()
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_utils69.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _createOrg(value);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getOrgsByUserId(req, res, next) {
+    const page = Number(req.query.page) ?? 0;
+    const limit = Number(req.query.limit) ?? 10;
+    const search = req.query.search ?? "";
+    const user = req.headers["user"];
+    const validation = import_joi15.default.object({
+      user: import_joi15.default.string().hex().required(),
+      page: import_joi15.default.number().min(1).optional().allow("", null),
+      limit: import_joi15.default.number().min(1).optional().allow("", null),
+      search: import_joi15.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({ user, page, limit, search });
+    if (error) {
+      next(new import_utils69.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const orgs = await _getOrgsByUserId({ user, page, limit, search });
+      res.json(orgs);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    createOrg,
+    getOrgsByUserId
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -18857,12 +20327,16 @@ function useSubscriptionController() {
   MAILER_TRANSPORT_HOST,
   MAILER_TRANSPORT_PORT,
   MAILER_TRANSPORT_SECURE,
+  MAddress,
   MCapBldgAct,
   MComment,
   MEntity,
   MFile,
+  MMember,
   MONGO_DB,
   MONGO_URI,
+  MOrg,
+  MPaymentMethod,
   MRole,
   MSubscription,
   MToken,
@@ -18887,7 +20361,11 @@ function useSubscriptionController() {
   SPACES_SECRET_KEY,
   VERIFICATION_FORGET_PASSWORD_DURATION,
   VERIFICATION_USER_INVITE_DURATION,
+  XENDIT_BASE_URL,
+  XENDIT_SECRET_KEY,
   isDev,
+  useAddressController,
+  useAddressRepo,
   useAuthController,
   useAuthService,
   useCapBldgActController,
@@ -18902,6 +20380,13 @@ function useSubscriptionController() {
   useFileController,
   useFileRepo,
   useFileService,
+  useMemberRepo,
+  useOrgController,
+  useOrgRepo,
+  useOrgService,
+  usePaymentMethodController,
+  usePaymentMethodRepo,
+  usePaymentMethodService,
   useRoleController,
   useRoleRepo,
   useRoleService,
@@ -18917,7 +20402,8 @@ function useSubscriptionController() {
   useVerificationService,
   useWorkflowController,
   useWorkflowRepo,
-  useWorkflowService
+  useWorkflowService,
+  useXenditService
 });
 /*! Bundled license information: