@goweekdays/core 2.6.0 → 2.7.0

package/dist/index.js

@@ -72,7 +72,11 @@ __export(src_exports, {
   XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
   currencies: () => currencies,
   isDev: () => isDev,
+  ledgerBillStatuses: () => ledgerBillStatuses,
+  ledgerBillTypes: () => ledgerBillTypes,
   modelApp: () => modelApp,
+  modelJobPost: () => modelJobPost,
+  modelLedgerBill: () => modelLedgerBill,
   modelMember: () => modelMember,
   modelOrg: () => modelOrg,
   modelPermission: () => modelPermission,
@@ -89,6 +93,8 @@ __export(src_exports, {
   schemaBuilding: () => schemaBuilding,
   schemaBuildingUnit: () => schemaBuildingUnit,
   schemaInviteMember: () => schemaInviteMember,
+  schemaJobPost: () => schemaJobPost,
+  schemaLedgerBill: () => schemaLedgerBill,
   schemaMember: () => schemaMember,
   schemaMemberRole: () => schemaMemberRole,
   schemaMemberStatus: () => schemaMemberStatus,
@@ -128,6 +134,11 @@ __export(src_exports, {
   useFileRepo: () => useFileRepo,
   useFileService: () => useFileService,
   useGitHubService: () => useGitHubService,
+  useJobPostController: () => useJobPostController,
+  useJobPostRepo: () => useJobPostRepo,
+  useJobPostService: () => useJobPostService,
+  useLedgerBillingController: () => useLedgerBillingController,
+  useLedgerBillingRepo: () => useLedgerBillingRepo,
   useMemberController: () => useMemberController,
   useMemberRepo: () => useMemberRepo,
   useOrgController: () => useOrgController,
@@ -638,11 +649,11 @@ function useAuthService() {
 }
 
 // src/resources/auth/auth.controller.ts
-var import_joi30 = __toESM(require("joi"));
-var import_utils41 = require("@goweekdays/utils");
+var import_joi36 = __toESM(require("joi"));
+var import_utils46 = require("@goweekdays/utils");
 
 // src/resources/verification/verification.service.ts
-var import_utils40 = require("@goweekdays/utils");
+var import_utils45 = require("@goweekdays/utils");
 
 // src/resources/verification/verification.model.ts
 var import_utils3 = require("@goweekdays/utils");
@@ -664,7 +675,11 @@ var schemaVerification = import_joi2.default.object({
     roleName: import_joi2.default.string().optional().allow("", null),
     referralCode: import_joi2.default.string().optional().allow("", null),
     org: import_joi2.default.string().hex().optional().allow("", null),
-    orgName: import_joi2.default.string().optional().allow("", null)
+    orgName: import_joi2.default.string().optional().allow("", null),
+    contact: import_joi2.default.string().optional().allow("", null),
+    seats: import_joi2.default.number().optional().allow("", null),
+    createdBy: import_joi2.default.string().optional().allow("", null),
+    amount: import_joi2.default.number().optional().allow("", null)
   }).optional(),
   expireAt: import_joi2.default.date().optional().allow("", null)
 });
@@ -1037,7 +1052,7 @@ var DOMAIN = process.env.DOMAIN || "localhost";
 var APP_ORG = process.env.APP_ORG || "http://localhost/organizations/create";
 
 // src/resources/user/user.service.ts
-var import_utils38 = require("@goweekdays/utils");
+var import_utils43 = require("@goweekdays/utils");
 
 // src/resources/file/file.repository.ts
 var import_utils5 = require("@goweekdays/utils");
@@ -1635,9 +1650,6 @@ function useMemberRepo() {
         {
           $match: query
         },
-        {
-          $sort: { _id: -1 }
-        },
         {
           $limit: limit
         },
@@ -4425,6 +4437,7 @@ function modelOrg(value) {
 // src/resources/organization/organization.repository.ts
 var import_utils22 = require("@goweekdays/utils");
 var import_mongodb14 = require("mongodb");
+var import_joi16 = __toESM(require("joi"));
 function useOrgRepo() {
   const db = import_utils22.useAtlas.getDb();
   if (!db) {
@@ -4600,10 +4613,9 @@ function useOrgRepo() {
         });
         return cached;
       }
-      const result = await collection.findOne({ name });
-      if (!result) {
-        throw new import_utils22.BadRequestError("Organization not found.");
-      }
+      const result = await collection.findOne({
+        name: { $regex: name, $options: "i" }
+      });
       setCache(cacheKey, result, 300).then(() => {
         import_utils22.logger.log({
           level: "info",
@@ -4624,6 +4636,42 @@ function useOrgRepo() {
       }
     }
   }
+  async function getByEmail(email) {
+    const { error } = import_joi16.default.string().email().required().validate(email);
+    if (error) {
+      throw new import_utils22.BadRequestError(error.message);
+    }
+    const cacheKey = (0, import_utils22.makeCacheKey)(namespace_collection, { email });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils22.logger.log({
+          level: "info",
+          message: `Cache hit for getByEmail organization: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({ email });
+      setCache(cacheKey, result, 300).then(() => {
+        import_utils22.logger.log({
+          level: "info",
+          message: `Cache set for organization by email: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils22.logger.log({
+          level: "error",
+          message: `Failed to set cache for organization by email: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof import_utils22.AppError) {
+        throw error2;
+      } else {
+        throw new import_utils22.InternalServerError("Failed to get organization.");
+      }
+    }
+  }
   async function updateFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["name", "description"];
     if (!allowedFields.includes(field)) {
@@ -4698,15 +4746,16 @@ function useOrgRepo() {
     updateFieldById,
     deleteById,
     getByName,
+    getByEmail,
     updateById
   };
 }
 
 // src/resources/organization/organization.service.ts
-var import_utils36 = require("@goweekdays/utils");
+var import_utils41 = require("@goweekdays/utils");
 
 // src/resources/member/member.controller.ts
-var import_joi18 = __toESM(require("joi"));
+var import_joi19 = __toESM(require("joi"));
 var import_utils26 = require("@goweekdays/utils");
 
 // src/resources/member/member.service.ts
@@ -4738,7 +4787,7 @@ function useRoleService() {
 }
 
 // src/resources/role/role.controller.ts
-var import_joi16 = __toESM(require("joi"));
+var import_joi17 = __toESM(require("joi"));
 var import_utils24 = require("@goweekdays/utils");
 function useRoleController() {
   const {
@@ -4771,12 +4820,12 @@ function useRoleController() {
     const limit = parseInt(req.query.limit ?? "10");
     const app = req.query.app ?? "";
     const org = req.query.org ?? "";
-    const validation = import_joi16.default.object({
-      search: import_joi16.default.string().optional().allow("", null),
-      page: import_joi16.default.number().required(),
-      limit: import_joi16.default.number().required(),
-      app: import_joi16.default.string().optional().allow("", null),
-      org: import_joi16.default.string().hex().optional().allow("", null)
+    const validation = import_joi17.default.object({
+      search: import_joi17.default.string().optional().allow("", null),
+      page: import_joi17.default.number().required(),
+      limit: import_joi17.default.number().required(),
+      app: import_joi17.default.string().optional().allow("", null),
+      org: import_joi17.default.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate({ search, page, limit, app, org });
     if (error) {
@@ -4793,8 +4842,8 @@ function useRoleController() {
   }
   async function getRoleByUserId(req, res, next) {
     const userId = req.params.userId;
-    const validation = import_joi16.default.object({
-      userId: import_joi16.default.string().required()
+    const validation = import_joi17.default.object({
+      userId: import_joi17.default.string().required()
     });
     const { error } = validation.validate({ userId });
     if (error) {
@@ -4811,8 +4860,8 @@ function useRoleController() {
   }
   async function getRoleById(req, res, next) {
     const _id = req.params.id;
-    const validation = import_joi16.default.object({
-      _id: import_joi16.default.string().hex().required()
+    const validation = import_joi17.default.object({
+      _id: import_joi17.default.string().hex().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
@@ -4831,10 +4880,10 @@ function useRoleController() {
     const _id = req.params.id;
     const name = req.body.name ?? "";
     const permissions = req.body.permissions ?? [];
-    const validation = import_joi16.default.object({
-      _id: import_joi16.default.string().required(),
-      name: import_joi16.default.string().required(),
-      permissions: import_joi16.default.array().items(import_joi16.default.string()).required()
+    const validation = import_joi17.default.object({
+      _id: import_joi17.default.string().required(),
+      name: import_joi17.default.string().required(),
+      permissions: import_joi17.default.array().items(import_joi17.default.string()).required()
     });
     const { error } = validation.validate({ _id, name, permissions });
     if (error) {
@@ -4852,9 +4901,9 @@ function useRoleController() {
   async function updatePermissionsById(req, res, next) {
     const _id = req.params.id;
     const permissions = req.body.permissions ?? [];
-    const validation = import_joi16.default.object({
-      _id: import_joi16.default.string().required(),
-      permissions: import_joi16.default.array().items(import_joi16.default.string()).required()
+    const validation = import_joi17.default.object({
+      _id: import_joi17.default.string().required(),
+      permissions: import_joi17.default.array().items(import_joi17.default.string()).required()
     });
     const { error } = validation.validate({ _id, permissions });
     if (error) {
@@ -4871,8 +4920,8 @@ function useRoleController() {
   }
   async function deleteRole(req, res, next) {
     const _id = req.params.id;
-    const validation = import_joi16.default.object({
-      _id: import_joi16.default.string().required()
+    const validation = import_joi17.default.object({
+      _id: import_joi17.default.string().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
@@ -4899,7 +4948,7 @@ function useRoleController() {
 }
 
 // src/resources/member/member.service.ts
-var import_joi17 = __toESM(require("joi"));
+var import_joi18 = __toESM(require("joi"));
 function useMemberService() {
   const { getById: getRoleById } = useRoleRepo();
   const {
@@ -4952,7 +5001,7 @@ function useMemberService() {
     }
   }
   async function deleteById(id) {
-    const { error } = import_joi17.default.string().hex().required().validate(id);
+    const { error } = import_joi18.default.string().hex().required().validate(id);
     if (error) {
       throw new import_utils25.BadRequestError(error.message);
     }
@@ -4995,8 +5044,8 @@ function useMemberController() {
   } = useMemberService();
   async function getByUserId(req, res, next) {
     const userId = req.params.id;
-    const validation = import_joi18.default.object({
-      id: import_joi18.default.string().hex().required()
+    const validation = import_joi19.default.object({
+      id: import_joi19.default.string().hex().required()
     });
     const { error } = validation.validate({ id: userId });
     if (error) {
@@ -5015,10 +5064,10 @@ function useMemberController() {
     }
   }
   async function getByUserType(req, res, next) {
-    const validation = import_joi18.default.object({
-      org: import_joi18.default.string().hex().optional().allow("", null),
-      user: import_joi18.default.string().hex().required(),
-      app: import_joi18.default.string().required()
+    const validation = import_joi19.default.object({
+      org: import_joi19.default.string().hex().optional().allow("", null),
+      user: import_joi19.default.string().hex().required(),
+      app: import_joi19.default.string().required()
     });
     const { error } = validation.validate({ ...req.params, ...req.query });
     if (error) {
@@ -5040,10 +5089,10 @@ function useMemberController() {
     }
   }
   async function getByApp(req, res, next) {
-    const validation = import_joi18.default.object({
-      org: import_joi18.default.string().hex().optional().allow("", null),
-      user: import_joi18.default.string().hex().required(),
-      app: import_joi18.default.string().required()
+    const validation = import_joi19.default.object({
+      org: import_joi19.default.string().hex().optional().allow("", null),
+      user: import_joi19.default.string().hex().required(),
+      app: import_joi19.default.string().required()
     });
     const app = req.params.app ?? "";
     const org = req.query.org;
@@ -5072,14 +5121,14 @@ function useMemberController() {
     const org = req.query.org ?? "";
     const app = req.params.app ?? "";
     const status = req.query.status ?? "active";
-    const validation = import_joi18.default.object({
-      limit: import_joi18.default.number().min(10).max(50).required(),
-      search: import_joi18.default.string().optional().allow("", null),
-      page: import_joi18.default.number().required(),
-      user: import_joi18.default.string().hex().optional().allow("", null),
-      org: import_joi18.default.string().hex().optional().allow("", null),
-      app: import_joi18.default.string().required(),
-      status: import_joi18.default.string().required()
+    const validation = import_joi19.default.object({
+      limit: import_joi19.default.number().min(10).max(50).required(),
+      search: import_joi19.default.string().optional().allow("", null),
+      page: import_joi19.default.number().required(),
+      user: import_joi19.default.string().hex().optional().allow("", null),
+      org: import_joi19.default.string().hex().optional().allow("", null),
+      app: import_joi19.default.string().required(),
+      status: import_joi19.default.string().required()
     });
     const { error } = validation.validate({
       search,
@@ -5116,12 +5165,12 @@ function useMemberController() {
     const page = Number(req.query.page) ?? 1;
     const user = req.params.user ?? "";
     const app = req.params.app ?? "";
-    const validation = import_joi18.default.object({
-      limit: import_joi18.default.number().min(10).max(50).allow(null, ""),
-      search: import_joi18.default.string().optional().allow("", null),
-      page: import_joi18.default.number().optional().allow(null, ""),
-      app: import_joi18.default.string().required(),
-      user: import_joi18.default.string().hex().required()
+    const validation = import_joi19.default.object({
+      limit: import_joi19.default.number().min(10).max(200).allow(null, ""),
+      search: import_joi19.default.string().optional().allow("", null),
+      page: import_joi19.default.number().optional().allow(null, ""),
+      app: import_joi19.default.string().required(),
+      user: import_joi19.default.string().hex().required()
     });
     const { error } = validation.validate({
       search,
@@ -5153,11 +5202,11 @@ function useMemberController() {
     const search = req.query.search ?? "";
     const page = Number(req.query.page) ?? 1;
     const user = req.query.user ?? "";
-    const validation = import_joi18.default.object({
-      limit: import_joi18.default.number().min(10).max(50).required(),
-      search: import_joi18.default.string().optional().allow("", null),
-      page: import_joi18.default.number().required(),
-      user: import_joi18.default.string().hex().optional().allow("", null)
+    const validation = import_joi19.default.object({
+      limit: import_joi19.default.number().min(10).max(50).required(),
+      search: import_joi19.default.string().optional().allow("", null),
+      page: import_joi19.default.number().required(),
+      user: import_joi19.default.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate({
       search,
@@ -5182,9 +5231,9 @@ function useMemberController() {
     }
   }
   async function updateStatusByUserId(req, res, next) {
-    const validation = import_joi18.default.object({
-      id: import_joi18.default.string().hex().required(),
-      status: import_joi18.default.string().valid("active", "suspended", "deleted").required()
+    const validation = import_joi19.default.object({
+      id: import_joi19.default.string().hex().required(),
+      status: import_joi19.default.string().valid("active", "suspended", "deleted").required()
     });
     const { error } = validation.validate(req.params);
     if (error) {
@@ -5233,7 +5282,7 @@ function useMemberController() {
   async function deleteById(req, res, next) {
     const payload = req.body;
     const _id = req.params.id ?? "";
-    const { error } = import_joi18.default.string().hex().required().validate(_id);
+    const { error } = import_joi19.default.string().hex().required().validate(_id);
     if (error) {
       next(new import_utils26.BadRequestError(error.message));
       return;
@@ -5261,30 +5310,30 @@ function useMemberController() {
 
 // src/resources/subscription/subscription.model.ts
 var import_utils27 = require("@goweekdays/utils");
-var import_joi19 = __toESM(require("joi"));
+var import_joi20 = __toESM(require("joi"));
 var import_mongodb15 = require("mongodb");
 var schema2 = {
-  seats: import_joi19.default.number().integer().min(1).required(),
-  paidSeats: import_joi19.default.number().integer().min(0).required(),
-  amount: import_joi19.default.number().positive().required(),
-  promoCode: import_joi19.default.string().optional().allow("", null),
-  nextBillingDate: import_joi19.default.date().optional().allow("", null)
+  seats: import_joi20.default.number().integer().min(1).required(),
+  paidSeats: import_joi20.default.number().integer().min(0).required(),
+  amount: import_joi20.default.number().positive().required(),
+  promoCode: import_joi20.default.string().optional().allow("", null),
+  nextBillingDate: import_joi20.default.date().optional().allow("", null)
 };
-var schemaSubscription = import_joi19.default.object({
+var schemaSubscription = import_joi20.default.object({
   ...schema2,
-  org: import_joi19.default.string().hex().length(24).required(),
-  currency: import_joi19.default.string().length(3).required(),
-  billingCycle: import_joi19.default.string().valid("monthly", "yearly").required()
+  org: import_joi20.default.string().hex().length(24).required(),
+  currency: import_joi20.default.string().length(3).required(),
+  billingCycle: import_joi20.default.string().valid("monthly", "yearly").required()
 });
-var schemaSubscriptionUpdate = import_joi19.default.object({
+var schemaSubscriptionUpdate = import_joi20.default.object({
   ...schema2,
-  status: import_joi19.default.string().optional().allow("", null)
+  status: import_joi20.default.string().optional().allow("", null)
 });
-var schemaSubscriptionSeats = import_joi19.default.object({
-  id: import_joi19.default.string().hex().length(24).required(),
-  seats: import_joi19.default.number().integer().min(1).required(),
-  amount: import_joi19.default.number().positive().optional().allow(null, 0),
-  user: import_joi19.default.string().hex().length(24).required()
+var schemaSubscriptionSeats = import_joi20.default.object({
+  id: import_joi20.default.string().hex().length(24).required(),
+  seats: import_joi20.default.number().integer().min(1).required(),
+  amount: import_joi20.default.number().positive().optional().allow(null, 0),
+  user: import_joi20.default.string().hex().length(24).required()
 });
 function modelSubscription(data) {
   const { error } = schemaSubscription.validate(data);
@@ -5321,7 +5370,7 @@ function modelSubscription(data) {
 
 // src/resources/subscription/subscription.repository.ts
 var import_utils28 = require("@goweekdays/utils");
-var import_joi20 = __toESM(require("joi"));
+var import_joi21 = __toESM(require("joi"));
 var import_mongodb16 = require("mongodb");
 function useSubscriptionRepo() {
   const db = import_utils28.useAtlas.getDb();
@@ -5431,7 +5480,7 @@ function useSubscriptionRepo() {
     }
   }
   async function getByOrg(org) {
-    const { error } = import_joi20.default.string().hex().length(24).required().validate(org);
+    const { error } = import_joi21.default.string().hex().length(24).required().validate(org);
     if (error) {
       throw new Error(`Invalid org ID: ${error.message}`);
     }
@@ -5470,7 +5519,7 @@ function useSubscriptionRepo() {
     }
   }
   async function getById(_id) {
-    const { error } = import_joi20.default.string().hex().length(24).required().validate(_id);
+    const { error } = import_joi21.default.string().hex().length(24).required().validate(_id);
     if (error) {
       throw new Error(`Invalid subscription ID: ${error.message}`);
     }
@@ -5509,7 +5558,7 @@ function useSubscriptionRepo() {
     }
   }
   async function deleteById(_id) {
-    const { error } = import_joi20.default.string().hex().length(24).required().validate(_id);
+    const { error } = import_joi21.default.string().hex().length(24).required().validate(_id);
     if (error) {
       throw new Error(`Invalid subscription ID: ${error.message}`);
     }
@@ -5536,7 +5585,7 @@ function useSubscriptionRepo() {
     }
   }
   async function updateById(_id, options, session) {
-    const { error: errorId } = import_joi20.default.string().hex().length(24).required().validate(_id);
+    const { error: errorId } = import_joi21.default.string().hex().length(24).required().validate(_id);
     if (errorId) {
       throw new Error(`Invalid subscription ID: ${errorId.message}`);
     }
@@ -5581,7 +5630,7 @@ function useSubscriptionRepo() {
 }
 
 // src/resources/subscription/subscription.controller.ts
-var import_joi22 = __toESM(require("joi"));
+var import_joi23 = __toESM(require("joi"));
 var import_utils32 = require("@goweekdays/utils");
 
 // src/resources/subscription/subscription.service.ts
@@ -5592,16 +5641,16 @@ var import_utils30 = require("@goweekdays/utils");
 
 // src/resources/subscription/subscription.transaction.model.ts
 var import_utils29 = require("@goweekdays/utils");
-var import_joi21 = __toESM(require("joi"));
+var import_joi22 = __toESM(require("joi"));
 var import_mongodb17 = require("mongodb");
-var schemaSubscriptionTransaction = import_joi21.default.object({
-  subscription: import_joi21.default.string().hex().length(24).required(),
-  amount: import_joi21.default.number().positive().required(),
-  currency: import_joi21.default.string().length(3).required(),
-  type: import_joi21.default.string().valid("initiate", "add-seat", "remove-seat", "renewal").required(),
-  description: import_joi21.default.string().max(255).optional().allow("", null),
-  createdBy: import_joi21.default.string().hex().length(24).required(),
-  createdByName: import_joi21.default.string().optional().allow("", null)
+var schemaSubscriptionTransaction = import_joi22.default.object({
+  subscription: import_joi22.default.string().hex().length(24).required(),
+  amount: import_joi22.default.number().positive().required(),
+  currency: import_joi22.default.string().length(3).required(),
+  type: import_joi22.default.string().valid("initiate", "add-seat", "remove-seat", "renewal").required(),
+  description: import_joi22.default.string().max(255).optional().allow("", null),
+  createdBy: import_joi22.default.string().hex().length(24).required(),
+  createdByName: import_joi22.default.string().optional().allow("", null)
 });
 function modelSubscriptionTransaction(data) {
   const { error } = schemaSubscriptionTransaction.validate(data);
@@ -5857,10 +5906,10 @@ function useSubscriptionController() {
   } = useSubscriptionRepo();
   const { updateSeats: _updateSeats } = useSubscriptionService();
   async function getAll(req, res, next) {
-    const validation = import_joi22.default.object({
-      page: import_joi22.default.number().min(1).max(100).optional().allow(null, "").default(1),
-      limit: import_joi22.default.number().min(1).max(100).optional().allow(null, "").default(10),
-      status: import_joi22.default.string().valid("active", "suspended").optional().default("active")
+    const validation = import_joi23.default.object({
+      page: import_joi23.default.number().min(1).max(100).optional().allow(null, "").default(1),
+      limit: import_joi23.default.number().min(1).max(100).optional().allow(null, "").default(10),
+      status: import_joi23.default.string().valid("active", "suspended").optional().default("active")
     });
     const query = req.query;
     const { error, value } = validation.validate(query);
@@ -5878,8 +5927,8 @@ function useSubscriptionController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id ?? "";
-    const validation = import_joi22.default.object({
-      id: import_joi22.default.string().hex().length(24).required()
+    const validation = import_joi23.default.object({
+      id: import_joi23.default.string().hex().length(24).required()
     });
     const { error, value } = validation.validate({ id });
     if (error) {
@@ -5896,8 +5945,8 @@ function useSubscriptionController() {
   }
   async function getByOrg(req, res, next) {
     const org = req.params.org ?? "";
-    const validation = import_joi22.default.object({
-      org: import_joi22.default.string().hex().length(24).required()
+    const validation = import_joi23.default.object({
+      org: import_joi23.default.string().hex().length(24).required()
     });
     const { error, value } = validation.validate({ org });
     if (error) {
@@ -5940,15 +5989,15 @@ function useSubscriptionController() {
 }
 
 // src/resources/subscription/subscription.transaction.controller.ts
-var import_joi23 = __toESM(require("joi"));
+var import_joi24 = __toESM(require("joi"));
 var import_utils33 = require("@goweekdays/utils");
 function useSubscriptionTransactionController() {
   const { getAll: _getAll } = useSubscriptionTransactionRepo();
   async function getAll(req, res, next) {
-    const validation = import_joi23.default.object({
-      id: import_joi23.default.string().hex().length(24).required(),
-      page: import_joi23.default.number().min(1).max(100).optional().allow(null, "").default(1),
-      limit: import_joi23.default.number().min(1).max(100).optional().allow(null, "").default(10)
+    const validation = import_joi24.default.object({
+      id: import_joi24.default.string().hex().length(24).required(),
+      page: import_joi24.default.number().min(1).max(100).optional().allow(null, "").default(1),
+      limit: import_joi24.default.number().min(1).max(100).optional().allow(null, "").default(10)
     });
     const query = req.query;
     const id = req.params.id ?? "";
@@ -5971,16 +6020,16 @@ function useSubscriptionTransactionController() {
 }
 
 // src/resources/plan/plan.model.ts
-var import_joi24 = __toESM(require("joi"));
+var import_joi25 = __toESM(require("joi"));
 var currencies = ["USD", "PHP"];
-var schemaPlan = import_joi24.default.object({
-  name: import_joi24.default.string().min(3).max(100).required(),
-  description: import_joi24.default.string().max(255).optional().allow("", null),
-  features: import_joi24.default.array().items(import_joi24.default.string().max(100)).optional(),
-  price: import_joi24.default.number().positive().required(),
-  currency: import_joi24.default.string().length(3).allow(...currencies).required(),
-  default: import_joi24.default.boolean().optional().allow(null, ""),
-  billingCycle: import_joi24.default.string().valid("monthly", "yearly").required()
+var schemaPlan = import_joi25.default.object({
+  name: import_joi25.default.string().min(3).max(100).required(),
+  description: import_joi25.default.string().max(255).optional().allow("", null),
+  features: import_joi25.default.array().items(import_joi25.default.string().max(100)).optional(),
+  price: import_joi25.default.number().positive().required(),
+  currency: import_joi25.default.string().length(3).allow(...currencies).required(),
+  default: import_joi25.default.boolean().optional().allow(null, ""),
+  billingCycle: import_joi25.default.string().valid("monthly", "yearly").required()
 });
 function modelPlan(data) {
   const { error } = schemaPlan.validate(data);
@@ -6004,7 +6053,7 @@ function modelPlan(data) {
 
 // src/resources/plan/plan.repository.ts
 var import_utils34 = require("@goweekdays/utils");
-var import_joi25 = __toESM(require("joi"));
+var import_joi26 = __toESM(require("joi"));
 var import_mongodb19 = require("mongodb");
 function usePlanRepo() {
   const db = import_utils34.useAtlas.getDb();
@@ -6124,7 +6173,7 @@ function usePlanRepo() {
     }
   }
   async function getById(_id) {
-    const { error } = import_joi25.default.string().hex().length(24).required().validate(_id);
+    const { error } = import_joi26.default.string().hex().length(24).required().validate(_id);
     if (error) {
       throw new Error(`Invalid plan ID: ${error.message}`);
     }
@@ -6193,7 +6242,7 @@ function usePlanRepo() {
     }
   }
   async function deleteById(_id) {
-    const { error } = import_joi25.default.string().hex().length(24).required().validate(_id);
+    const { error } = import_joi26.default.string().hex().length(24).required().validate(_id);
     if (error) {
       throw new Error(`Invalid plan ID: ${error.message}`);
     }
@@ -6252,7 +6301,7 @@ function usePlanService() {
 }
 
 // src/resources/plan/plan.controller.ts
-var import_joi26 = __toESM(require("joi"));
+var import_joi27 = __toESM(require("joi"));
 var import_utils35 = require("@goweekdays/utils");
 function usePlanController() {
   const {
@@ -6264,13 +6313,13 @@ function usePlanController() {
   } = usePlanRepo();
   async function add(req, res, next) {
     const value = req.body;
-    const validation = import_joi26.default.object({
-      name: import_joi26.default.string().min(3).max(100).required(),
-      description: import_joi26.default.string().max(255).optional().allow("", null),
-      features: import_joi26.default.array().items(import_joi26.default.string().max(100)).optional(),
-      price: import_joi26.default.number().positive().required(),
-      currency: import_joi26.default.string().length(3).required(),
-      billingCycle: import_joi26.default.string().valid("monthly", "yearly").required()
+    const validation = import_joi27.default.object({
+      name: import_joi27.default.string().min(3).max(100).required(),
+      description: import_joi27.default.string().max(255).optional().allow("", null),
+      features: import_joi27.default.array().items(import_joi27.default.string().max(100)).optional(),
+      price: import_joi27.default.number().positive().required(),
+      currency: import_joi27.default.string().length(3).required(),
+      billingCycle: import_joi27.default.string().valid("monthly", "yearly").required()
     });
     const { error } = validation.validate(value);
     if (error) {
@@ -6290,11 +6339,11 @@ function usePlanController() {
     const search = req.query.search ?? "";
     const page = Number(req.query.page) ?? 1;
     const limit = Number(req.query.limit) ?? 10;
-    const validation = import_joi26.default.object({
-      status: import_joi26.default.string().required(),
-      search: import_joi26.default.string().optional().allow("", null),
-      page: import_joi26.default.number().required(),
-      limit: import_joi26.default.number().required()
+    const validation = import_joi27.default.object({
+      status: import_joi27.default.string().required(),
+      search: import_joi27.default.string().optional().allow("", null),
+      page: import_joi27.default.number().required(),
+      limit: import_joi27.default.number().required()
     });
     const { error } = validation.validate({ status, search, page, limit });
     if (error) {
@@ -6311,7 +6360,7 @@ function usePlanController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi26.default.string().hex().length(24).required();
+    const validation = import_joi27.default.string().hex().length(24).required();
     const { error } = validation.validate(id);
     if (error) {
       next(new import_utils35.BadRequestError(error.message));
@@ -6327,7 +6376,7 @@ function usePlanController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi26.default.string().hex().length(24).required();
+    const validation = import_joi27.default.string().hex().length(24).required();
     const { error } = validation.validate(id);
     if (error) {
       next(new import_utils35.BadRequestError(error.message));
@@ -6363,6 +6412,7 @@ function usePlanController() {
 var import_paypal_server_sdk = require("@paypal/paypal-server-sdk");
 var import_crypto3 = __toESM(require("crypto"));
 var import_buffer_crc32 = __toESM(require("buffer-crc32"));
+var import_utils36 = require("@goweekdays/utils");
 var certCache = /* @__PURE__ */ new Map();
 function usePaypalService() {
   const paypalClient = new import_paypal_server_sdk.Client({
@@ -6420,17 +6470,20 @@ function usePaypalService() {
     certCache.set(url, certPem);
     return certPem;
   }
-  async function verifyWebhook(rawBody, headers, webhookId = PAYPAL_WEBHOOK_ID) {
+  async function verifySignature(rawBody, headers, webhookId = PAYPAL_WEBHOOK_ID) {
     const transmissionId = headers["paypal-transmission-id"];
     const timeStamp = headers["paypal-transmission-time"];
     const certUrl = headers["paypal-cert-url"];
     const transmissionSig = headers["paypal-transmission-sig"];
     if (!transmissionId || !timeStamp || !certUrl || !transmissionSig) {
+      import_utils36.logger.log({
+        level: "error",
+        message: "Missing required PayPal webhook headers"
+      });
       return false;
     }
-    const eventBuffer = Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(rawBody);
-    const crcValue = parseInt("0x" + (0, import_buffer_crc32.default)(eventBuffer).toString("hex"));
-    const message = `${transmissionId}|${timeStamp}|${webhookId}|${crcValue}`;
+    const crc = parseInt("0x" + (0, import_buffer_crc32.default)(rawBody).toString("hex"));
+    const message = `${transmissionId}|${timeStamp}|${webhookId}|${crc}`;
     try {
       const certPem = await downloadAndCacheCert(certUrl);
       const signatureBuffer = Buffer.from(transmissionSig, "base64");
@@ -6438,204 +6491,868 @@ function usePaypalService() {
       verifier.update(message);
       return verifier.verify(certPem, signatureBuffer);
     } catch (error) {
-      console.error("PayPal webhook verification error:", error);
+      import_utils36.logger.log({
+        level: "error",
+        message: `PayPal webhook verification error: ${error}`
+      });
       throw new Error("Failed to verify PayPal webhook signature.");
     }
   }
   return {
     addOrder,
     captureOrder,
-    verifyWebhook
+    verifySignature
   };
 }
 
 // src/resources/organization/organization.service.ts
-function useOrgService() {
-  const { add: addOrg } = useOrgRepo();
-  const { addRole } = useRoleRepo();
-  const { getAll: getAllPermission } = usePermissionRepo();
-  const { add: addMember, updateRoleById: _updateRoleById } = useMemberRepo();
-  const { getUserById } = useUserRepo();
-  const { getDefault } = usePlanRepo();
-  const { add: addSubscription } = useSubscriptionRepo();
-  const { add: addSubscriptionTransaction } = useSubscriptionTransactionRepo();
-  const { addOrder: addPaypalOrder } = usePaypalService();
-  async function add(value) {
-    const { error } = schemaOrgAdd.validate(value);
-    if (error) {
-      throw new import_utils36.BadRequestError(error.message);
-    }
-    const session = import_utils36.useAtlas.getClient()?.startSession();
-    if (!session) {
-      throw new import_utils36.BadRequestError("Unable to start database session.");
-    }
-    try {
-      session?.startTransaction();
-      const org = await addOrg(
-        {
-          email: value.email,
-          name: value.name,
-          contact: value.contact,
-          createdBy: value.createdBy
-        },
-        session
-      );
-      const plan = await getDefault();
-      if (!plan) {
-        throw new import_utils36.BadRequestError(
-          "Failed to create organization, plan not found."
-        );
-      }
-      const currentDate = /* @__PURE__ */ new Date();
-      const nextBillingDate = new Date(currentDate);
-      nextBillingDate.setMonth(currentDate.getMonth() + 1);
-      const amount = plan.price * value.seats;
-      const subscriptionId = await addSubscription(
-        {
-          amount,
-          org: String(org),
-          seats: value.seats,
-          paidSeats: value.seats,
-          currency: plan.currency,
-          billingCycle: plan.billingCycle,
-          nextBillingDate
-        },
-        session
-      );
-      const createdBy = String(value.createdBy);
-      const user = await getUserById(createdBy);
-      if (!user) {
-        throw new import_utils36.BadRequestError("User is required to create org member.");
-      }
-      await addSubscriptionTransaction(
-        {
-          subscription: subscriptionId,
-          type: "initiate",
-          amount,
-          currency: plan.currency,
-          description: "Initial subscription transaction",
-          createdBy: value.createdBy,
-          createdByName: `${user.firstName} ${user.lastName}`
-        },
-        session
-      );
-      const allPermissions = await getAllPermission({
-        app: "org",
-        limit: 100
-      });
-      let permissions = [];
-      if (allPermissions && allPermissions.items && allPermissions.items.length) {
-        permissions = allPermissions.items.map((perm) => perm.key);
-      }
-      if (permissions.length === 0) {
-        throw new Error("No permissions found for the organization type.");
-      }
-      const roleData = {
-        org: String(org),
-        name: "Owner",
-        description: "Owner of the organization",
-        permissions,
-        createdBy,
-        app: "org"
-      };
-      const role = await addRole(roleData, session);
-      if (!role) {
-        throw new import_utils36.BadRequestError("Role is required to create org member.");
-      }
-      await addMember(
-        {
-          role: String(role),
-          roleName: roleData.name,
-          org: String(org),
-          orgName: value.name,
-          name: `${user.firstName} ${user.lastName}`,
-          user: createdBy,
-          app: "org"
-        },
-        session
-      );
-      const order = await addPaypalOrder({
-        amount,
-        currency: plan.currency,
-        customId: subscriptionId,
-        returnUrl: `${APP_ORG}/organizations/success`,
-        cancelUrl: `${APP_ORG}/organizations/cancel`,
-        action: "pay"
-      });
-      await session?.commitTransaction();
-      const paypalOrderLink = JSON.parse(order.body.toString()).links.find(
-        (link) => link.rel === "approve"
-      );
-      return {
-        org: String(org),
-        paypalOrderLink: paypalOrderLink ? paypalOrderLink.href : ""
-      };
-    } catch (error2) {
-      await session?.abortTransaction();
-      throw error2;
-    } finally {
-      await session?.endSession();
-    }
-  }
-  return {
-    add
-  };
-}
+var import_joi32 = __toESM(require("joi"));
 
-// src/resources/organization/organization.controller.ts
+// src/resources/verification/verification.controller.ts
 var import_utils37 = require("@goweekdays/utils");
-var import_joi27 = __toESM(require("joi"));
-function useOrgController() {
-  const { add: _add } = useOrgService();
-  const { getOrgsByMembership } = useMemberRepo();
+var import_joi28 = __toESM(require("joi"));
+function useVerificationController() {
   const {
-    getByName: _getByName,
-    getAll: getAllOrg,
-    getById: _getById,
-    updateById: _updateById
-  } = useOrgRepo();
-  async function add(req, res, next) {
-    const value = req.body;
-    const { error } = schemaOrgAdd.validate(value);
+    createUserInvite: _createUserInvite,
+    createForgetPassword: _createForgetPassword,
+    cancelUserInvitation: _cancelUserInvitation,
+    verify: _verify,
+    inviteMember: _inviteMember,
+    signUp: _signUp,
+    cancelInviteMember: _cancelInviteMember,
+    forgetPassword: _forgetPassword,
+    orgSetupFee: _orgSetupFee
+  } = useVerificationService();
+  const { getVerifications: _getVerifications } = useVerificationRepo();
+  async function createUserInvite(req, res, next) {
+    const validation = import_joi28.default.object({
+      email: import_joi28.default.string().email().required(),
+      app: import_joi28.default.string().required(),
+      role: import_joi28.default.string().hex().required(),
+      roleName: import_joi28.default.string().required(),
+      org: import_joi28.default.string().hex().optional().optional().allow("", null),
+      orgName: import_joi28.default.string().optional().optional().allow("", null)
+    });
+    const { error } = validation.validate(req.body);
     if (error) {
       next(new import_utils37.BadRequestError(error.message));
       return;
     }
+    const email = req.body.email ?? "";
+    const app = req.body.app ?? "";
+    const role = req.body.role ?? "";
+    const roleName = req.body.roleName ?? "";
+    const org = req.body.org ?? "";
+    const orgName = req.body.orgName ?? "";
     try {
-      const data = await _add(value);
-      res.json({
-        message: "Organization created successfully.",
-        data
-      });
-      return;
-    } catch (error2) {
-      next(error2);
-    }
-  }
-  async function getOrgsByUserId(req, res, next) {
+      await _createUserInvite({
+        email,
+        metadata: {
+          app,
+          role,
+          roleName,
+          org,
+          orgName
+        }
+      });
+      res.json({ message: "Successfully invited user." });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function createForgetPassword(req, res, next) {
+    const email = req.body.email || "";
+    const validation = import_joi28.default.string().email().required();
+    const { error } = validation.validate(email);
+    if (error) {
+      next(new import_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _createForgetPassword(email);
+      res.json({
+        message: "Check your email to verify it before resetting your password."
+      });
+      return;
+    } catch (error2) {
+      if (error2 instanceof import_utils37.AppError) {
+        next(error2);
+      } else {
+        next(new import_utils37.InternalServerError("An unexpected error occurred"));
+      }
+    }
+  }
+  async function getVerifications(req, res, next) {
+    const validation = import_joi28.default.object({
+      status: import_joi28.default.string().required(),
+      search: import_joi28.default.string().optional().allow("", null),
+      page: import_joi28.default.number().required(),
+      type: import_joi28.default.string().optional().allow("", null),
+      email: import_joi28.default.string().optional().allow("", null),
+      app: import_joi28.default.string().optional().allow("", null),
+      org: import_joi28.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(req.query);
+    if (error) {
+      next(new import_utils37.BadRequestError(error.message));
+      return;
+    }
+    const status = req.query.status ?? "";
+    const search = req.query.search ?? "";
+    const page = Number(req.query.page) ?? 1;
+    let type = req.query.type ?? "";
+    const email = req.query.email ?? "";
+    const app = req.query.app ?? "";
+    const org = req.query.org ?? "";
+    const hasMultipleTypes = type.includes(",");
+    let splitType = [];
+    if (hasMultipleTypes) {
+      splitType = type.split(",");
+    }
+    try {
+      const items = await _getVerifications({
+        status,
+        search,
+        page,
+        type: hasMultipleTypes ? splitType : type,
+        email,
+        app,
+        org
+      });
+      res.json(items);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function verify(req, res, next) {
+    const id = req.params.id || "";
+    const validation = import_joi28.default.string().hex().required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _verify(id);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function cancelUserInvitation(req, res, next) {
+    const otpId = req.params.id || "";
+    const validation = import_joi28.default.string().hex().required();
+    const { error } = validation.validate(otpId);
+    if (error) {
+      next(new import_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _cancelUserInvitation(otpId);
+      return res.json({
+        message: "User invite has been cancelled."
+      });
+    } catch (error2) {
+      throw error2;
+    }
+  }
+  async function signUp(req, res, next) {
+    const validation = import_joi28.default.string().email().required();
+    const { error } = validation.validate(req.body.email);
+    if (error) {
+      next(new import_utils37.BadRequestError(error.message));
+      return;
+    }
+    const email = req.body.email ?? "";
+    try {
+      await _signUp({ email });
+      res.json({ message: "Successfully signed up user." });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function inviteMember(req, res, next) {
+    const { error } = schemaInviteMember.validate(req.body);
+    if (error) {
+      next(new import_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _inviteMember(req.body);
+      res.json({ message: "Successfully invited member." });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function cancelInviteMember(req, res, next) {
+    const id = req.params.id || "";
+    const validation = import_joi28.default.string().hex().required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _cancelInviteMember(id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function forgetPassword(req, res, next) {
+    const email = req.body.email ?? "";
+    const validation = import_joi28.default.string().email().required();
+    const { error } = validation.validate(email);
+    if (error) {
+      next(new import_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _forgetPassword(email);
+      res.json({
+        message
+      });
+      return;
+    } catch (error2) {
+      if (error2 instanceof import_utils37.AppError) {
+        next(error2);
+      } else {
+        next(new import_utils37.InternalServerError("An unexpected error occurred"));
+      }
+    }
+  }
+  async function orgSetupFee(req, res, next) {
+    const value = req.body;
+    const { error } = schemaOrgAdd.validate(value);
+    if (error) {
+      next(new import_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _orgSetupFee(value);
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    getVerifications,
+    createUserInvite,
+    createForgetPassword,
+    verify,
+    cancelUserInvitation,
+    inviteMember,
+    signUp,
+    cancelInviteMember,
+    forgetPassword,
+    orgSetupFee
+  };
+}
+
+// src/resources/ledger/ledger.billing.model.ts
+var import_utils38 = require("@goweekdays/utils");
+var import_joi29 = __toESM(require("joi"));
+var import_mongodb20 = require("mongodb");
+var ledgerBillTypes = ["setup-fee", "subscription"];
+var ledgerBillStatuses = ["pending", "completed", "overdue"];
+var schemaLedgerBill = import_joi29.default.object({
+  org: import_joi29.default.string().hex().length(24).required(),
+  type: import_joi29.default.string().valid(...ledgerBillTypes).required(),
+  description: import_joi29.default.string().max(255).required(),
+  amount: import_joi29.default.number().positive().required(),
+  currency: import_joi29.default.string().length(3).required(),
+  status: import_joi29.default.string().valid(...ledgerBillStatuses).required(),
+  billingFrom: import_joi29.default.date().optional().allow("", null),
+  billingTo: import_joi29.default.date().optional().allow("", null),
+  paidAt: import_joi29.default.date().optional().allow("", null),
+  dueDate: import_joi29.default.date().optional().allow("", null)
+});
+function modelLedgerBill(value) {
+  const { error } = schemaLedgerBill.validate(value);
+  if (error) {
+    throw new Error(`Ledger bill model validation error: ${error.message}`);
+  }
+  try {
+    value.org = new import_mongodb20.ObjectId(value.org);
+  } catch (error2) {
+    throw new import_utils38.BadRequestError("Invalid org ID.");
+  }
+  return {
+    _id: value._id,
+    org: value.org,
+    type: value.type,
+    description: value.description,
+    amount: value.amount,
+    currency: value.currency,
+    status: value.status,
+    billingFrom: value.billingFrom ?? "",
+    billingTo: value.billingTo ?? "",
+    paidAt: value.paidAt ?? "",
+    dueDate: value.dueDate ?? "",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date()
+  };
+}
+
+// src/resources/ledger/ledger.billing.repository.ts
+var import_utils39 = require("@goweekdays/utils");
+var import_mongodb21 = require("mongodb");
+var import_joi30 = __toESM(require("joi"));
+function useLedgerBillingRepo() {
+  const db = import_utils39.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "ledger.billings";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils39.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils39.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils39.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { org: 1 } },
+        { key: { status: 1 } },
+        { key: { description: "text" }, name: "text_index" }
+      ]);
+      return "Successfully created ledger billing indexes.";
+    } catch (error) {
+      throw new import_utils39.BadRequestError("Failed to create ledger billing indexes.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelLedgerBill(value);
+      const result = await collection.insertOne(value, { session });
+      delCachedData();
+      return result.insertedId;
+    } catch (error) {
+      if (error instanceof import_utils39.AppError) {
+        throw error;
+      }
+      throw new import_utils39.BadRequestError(
+        `Failed to add ledger billing: ${error.message}`
+      );
+    }
+  }
+  async function getAll({
+    org = "",
+    search = "",
+    page = 1,
+    limit = 10,
+    status = ""
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { status: { $ne: "deleted" } };
+    const cacheKeyOptions = {
+      search,
+      page,
+      limit,
+      tag: "getAll"
+    };
+    try {
+      query.org = new import_mongodb21.ObjectId(org);
+      cacheKeyOptions.org = org;
+    } catch (error) {
+      throw new import_utils39.BadRequestError("Invalid organization ID.");
+    }
+    if (status) {
+      query.status = status;
+      cacheKeyOptions.status = status;
+    }
+    if (search) {
+      query.$text = { $search: search };
+    }
+    const cacheKey = (0, import_utils39.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_utils39.logger.log({
+      level: "info",
+      message: `Cache key for getAll ledger billings: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils39.logger.log({
+          level: "info",
+          message: `Cache hit for getAll ledger billings: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils39.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_utils39.logger.log({
+          level: "info",
+          message: `Cache set for getAll ledger billings: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils39.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll ledger billings: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_utils39.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    const { error } = import_joi30.default.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid ledger billing ID: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb21.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils39.BadRequestError("Invalid ledger billing ID.");
+    }
+    try {
+      const cacheKey = (0, import_utils39.makeCacheKey)(namespace_collection, {
+        _id: String(_id),
+        tag: "getById"
+      });
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
+      }
+      const data = await collection.findOne({
+        _id,
+        status: { $ne: "deleted" }
+      });
+      setCache(cacheKey, data).then(() => {
+        import_utils39.logger.log({
+          level: "info",
+          message: `Cache set for getById ledger billing: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils39.logger.log({
+          level: "error",
+          message: `Failed to set cache for getById ledger billing: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      throw new import_utils39.InternalServerError("Failed to get ledger billing.");
+    }
+  }
+  return {
+    delCachedData,
+    createIndexes,
+    add,
+    getAll,
+    getById
+  };
+}
+
+// src/resources/ledger/ledger.billing.controller.ts
+var import_joi31 = __toESM(require("joi"));
+var import_utils40 = require("@goweekdays/utils");
+function useLedgerBillingController() {
+  const { getAll: _getAll, getById: _getById } = useLedgerBillingRepo();
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi31.default.object({
+      org: import_joi31.default.string().hex().optional().allow("", null),
+      page: import_joi31.default.number().min(1).optional().allow("", null),
+      limit: import_joi31.default.number().min(1).optional().allow("", null),
+      search: import_joi31.default.string().optional().allow("", null),
+      status: import_joi31.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    const search = req.query.search ?? "";
+    const org = req.query.org ?? "";
+    const status = req.query.status ?? "";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_utils40.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_utils40.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_utils40.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const orgs = await _getAll({ org, page, limit, search, status });
+      res.json(orgs);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi31.default.object({
+      id: import_joi31.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_utils40.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const org = await _getById(id);
+      res.json(org);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    getAll,
+    getById
+  };
+}
+
+// src/resources/organization/organization.service.ts
+function useOrgService() {
+  const { add: addOrg } = useOrgRepo();
+  const { addRole } = useRoleRepo();
+  const { getAll: getAllPermission } = usePermissionRepo();
+  const { add: addMember, updateRoleById: _updateRoleById } = useMemberRepo();
+  const { getUserById } = useUserRepo();
+  const { getDefault } = usePlanRepo();
+  const { add: addSubscription } = useSubscriptionRepo();
+  const { add: addSubscriptionTransaction } = useSubscriptionTransactionRepo();
+  const { addOrder: addPaypalOrder } = usePaypalService();
+  async function add(value) {
+    const { error } = schemaOrgAdd.validate(value);
+    if (error) {
+      throw new import_utils41.BadRequestError(error.message);
+    }
+    const session = import_utils41.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new import_utils41.BadRequestError("Unable to start database session.");
+    }
+    try {
+      session?.startTransaction();
+      const org = await addOrg(
+        {
+          email: value.email,
+          name: value.name,
+          contact: value.contact,
+          createdBy: value.createdBy
+        },
+        session
+      );
+      const plan = await getDefault();
+      if (!plan) {
+        throw new import_utils41.BadRequestError(
+          "Failed to create organization, plan not found."
+        );
+      }
+      const currentDate = /* @__PURE__ */ new Date();
+      const nextBillingDate = new Date(currentDate);
+      nextBillingDate.setMonth(currentDate.getMonth() + 1);
+      const amount = plan.price * value.seats;
+      const subscriptionId = await addSubscription(
+        {
+          amount,
+          org: String(org),
+          seats: value.seats,
+          paidSeats: value.seats,
+          currency: plan.currency,
+          billingCycle: plan.billingCycle,
+          nextBillingDate
+        },
+        session
+      );
+      const createdBy = String(value.createdBy);
+      const user = await getUserById(createdBy);
+      if (!user) {
+        throw new import_utils41.BadRequestError("User is required to create org member.");
+      }
+      await addSubscriptionTransaction(
+        {
+          subscription: subscriptionId,
+          type: "initiate",
+          amount,
+          currency: plan.currency,
+          description: "Initial subscription transaction",
+          createdBy: value.createdBy,
+          createdByName: `${user.firstName} ${user.lastName}`
+        },
+        session
+      );
+      const allPermissions = await getAllPermission({
+        app: "org",
+        limit: 100
+      });
+      let permissions = [];
+      if (allPermissions && allPermissions.items && allPermissions.items.length) {
+        permissions = allPermissions.items.map((perm) => perm.key);
+      }
+      if (permissions.length === 0) {
+        throw new Error("No permissions found for the organization type.");
+      }
+      const roleData = {
+        org: String(org),
+        name: "Owner",
+        description: "Owner of the organization",
+        permissions,
+        createdBy,
+        app: "org"
+      };
+      const role = await addRole(roleData, session);
+      if (!role) {
+        throw new import_utils41.BadRequestError("Role is required to create org member.");
+      }
+      await addMember(
+        {
+          role: String(role),
+          roleName: roleData.name,
+          org: String(org),
+          orgName: value.name,
+          name: `${user.firstName} ${user.lastName}`,
+          user: createdBy,
+          app: "org"
+        },
+        session
+      );
+      const order = await addPaypalOrder({
+        amount,
+        currency: plan.currency,
+        customId: subscriptionId,
+        returnUrl: `${APP_ORG}/organizations/success`,
+        cancelUrl: `${APP_ORG}/organizations/cancel`,
+        action: "pay"
+      });
+      await session?.commitTransaction();
+      const paypalOrderLink = JSON.parse(order.body.toString()).links.find(
+        (link) => link.rel === "approve"
+      );
+      return {
+        org: String(org),
+        paypalOrderLink: paypalOrderLink ? paypalOrderLink.href : ""
+      };
+    } catch (error2) {
+      await session?.abortTransaction();
+      throw error2;
+    } finally {
+      await session?.endSession();
+    }
+  }
+  const { getById, updateStatusById: updateVerificationStatus } = useVerificationRepo();
+  const { add: addLedgerBilling } = useLedgerBillingRepo();
+  async function addWithVerification(id) {
+    const { error } = import_joi32.default.string().hex().required().validate(id);
+    if (error) {
+      throw new import_utils41.BadRequestError(error.message);
+    }
+    const session = import_utils41.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new import_utils41.BadRequestError("Unable to start database session.");
+    }
+    try {
+      session?.startTransaction();
+      const verification = await getById(id);
+      await updateVerificationStatus(id, "complete", session);
+      if (!verification) {
+        throw new import_utils41.BadRequestError("Verification not found.");
+      }
+      if (!verification.metadata?.orgName) {
+        throw new import_utils41.BadRequestError("Organization name is required.");
+      }
+      if (!verification.metadata?.seats) {
+        throw new import_utils41.BadRequestError("Number of seats is required.");
+      }
+      if (!verification.metadata?.createdBy) {
+        throw new import_utils41.BadRequestError("CreatedBy is required.");
+      }
+      if (!verification.metadata?.contact) {
+        throw new import_utils41.BadRequestError("Contact is required.");
+      }
+      const org = await addOrg(
+        {
+          email: verification.email,
+          name: verification.metadata.orgName,
+          contact: verification.metadata.contact,
+          createdBy: verification.metadata.createdBy
+        },
+        session
+      );
+      const plan = await getDefault();
+      if (!plan) {
+        throw new import_utils41.BadRequestError(
+          "Failed to create organization, plan not found."
+        );
+      }
+      const currentDate = /* @__PURE__ */ new Date();
+      const nextBillingDate = new Date(currentDate);
+      nextBillingDate.setMonth(currentDate.getMonth() + 1);
+      const amount = plan.price * verification.metadata.seats;
+      const subscriptionId = await addSubscription(
+        {
+          amount,
+          org: String(org),
+          seats: verification.metadata.seats,
+          paidSeats: verification.metadata.seats,
+          currency: plan.currency,
+          billingCycle: plan.billingCycle,
+          nextBillingDate
+        },
+        session
+      );
+      const createdBy = String(verification.metadata.createdBy);
+      const user = await getUserById(createdBy);
+      if (!user) {
+        throw new import_utils41.BadRequestError("User is required to create org member.");
+      }
+      await addSubscriptionTransaction(
+        {
+          subscription: subscriptionId,
+          type: "initiate",
+          amount,
+          currency: plan.currency,
+          description: "Initial subscription transaction",
+          createdBy,
+          createdByName: `${user.firstName} ${user.lastName}`
+        },
+        session
+      );
+      await addLedgerBilling(
+        {
+          org: String(org),
+          amount: verification.metadata?.amount ?? 0,
+          description: "Setup payment during organization creation",
+          currency: plan.currency,
+          type: "setup-fee",
+          status: "completed"
+        },
+        session
+      );
+      const allPermissions = await getAllPermission({
+        app: "org",
+        limit: 100
+      });
+      let permissions = [];
+      if (allPermissions && allPermissions.items && allPermissions.items.length) {
+        permissions = allPermissions.items.map((perm) => perm.key);
+      }
+      if (permissions.length === 0) {
+        throw new Error("No permissions found for the organization type.");
+      }
+      const roleData = {
+        org: String(org),
+        name: "Owner",
+        description: "Owner of the organization",
+        permissions,
+        createdBy,
+        app: "org"
+      };
+      const role = await addRole(roleData, session);
+      if (!role) {
+        throw new import_utils41.BadRequestError("Role is required to create org member.");
+      }
+      await addMember(
+        {
+          role: String(role),
+          roleName: roleData.name,
+          org: String(org),
+          orgName: verification.metadata.orgName,
+          name: `${user.firstName} ${user.lastName}`,
+          user: createdBy,
+          app: "org"
+        },
+        session
+      );
+      await session?.commitTransaction();
+      return "Successfully created organization with verification.";
+    } catch (error2) {
+      await session?.abortTransaction();
+      throw error2;
+    } finally {
+      await session?.endSession();
+    }
+  }
+  return {
+    add,
+    addWithVerification
+  };
+}
+
+// src/resources/organization/organization.controller.ts
+var import_utils42 = require("@goweekdays/utils");
+var import_joi33 = __toESM(require("joi"));
+function useOrgController() {
+  const { add: _add } = useOrgService();
+  const { getOrgsByMembership } = useMemberRepo();
+  const {
+    getByName: _getByName,
+    getAll: getAllOrg,
+    getById: _getById,
+    updateById: _updateById
+  } = useOrgRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaOrgAdd.validate(value);
+    if (error) {
+      next(new import_utils42.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _add(value);
+      res.json({
+        message: "Organization created successfully.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getOrgsByUserId(req, res, next) {
     const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
     const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
     const search = req.query.search ?? "";
     const user = req.params.user ?? "";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_utils37.BadRequestError("Invalid page number."));
+      next(new import_utils42.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_utils37.BadRequestError("Invalid limit number."));
+      next(new import_utils42.BadRequestError("Invalid limit number."));
       return;
     }
-    const validation = import_joi27.default.object({
-      user: import_joi27.default.string().hex().required(),
-      page: import_joi27.default.number().min(1).optional().allow("", null),
-      limit: import_joi27.default.number().min(1).optional().allow("", null),
-      search: import_joi27.default.string().optional().allow("", null)
+    const validation = import_joi33.default.object({
+      user: import_joi33.default.string().hex().required(),
+      page: import_joi33.default.number().min(1).optional().allow("", null),
+      limit: import_joi33.default.number().min(1).optional().allow("", null),
+      search: import_joi33.default.string().optional().allow("", null)
     });
     const { error } = validation.validate({ user, page, limit, search });
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6648,11 +7365,11 @@ function useOrgController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi27.default.object({
-      page: import_joi27.default.number().min(1).optional().allow("", null),
-      limit: import_joi27.default.number().min(1).optional().allow("", null),
-      search: import_joi27.default.string().optional().allow("", null),
-      status: import_joi27.default.string().valid("active", "suspended", "inactive", "deleted").optional()
+    const validation = import_joi33.default.object({
+      page: import_joi33.default.number().min(1).optional().allow("", null),
+      limit: import_joi33.default.number().min(1).optional().allow("", null),
+      search: import_joi33.default.string().optional().allow("", null),
+      status: import_joi33.default.string().valid("active", "suspended", "inactive", "deleted").optional()
     });
     const { error } = validation.validate(query);
     const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
@@ -6661,16 +7378,16 @@ function useOrgController() {
     const status = req.query.status ?? "active";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_utils37.BadRequestError("Invalid page number."));
+      next(new import_utils42.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_utils37.BadRequestError("Invalid limit number."));
+      next(new import_utils42.BadRequestError("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6683,12 +7400,12 @@ function useOrgController() {
   }
   async function getByName(req, res, next) {
     const name = req.params.name;
-    const validation = import_joi27.default.object({
-      name: import_joi27.default.string().required()
+    const validation = import_joi33.default.object({
+      name: import_joi33.default.string().required()
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6701,12 +7418,12 @@ function useOrgController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi27.default.object({
-      id: import_joi27.default.string().hex().required()
+    const validation = import_joi33.default.object({
+      id: import_joi33.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6722,7 +7439,7 @@ function useOrgController() {
     const payload = req.body;
     const { error } = schemaOrgUpdate.validate({ _id, ...payload });
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6758,16 +7475,16 @@ function useUserService() {
   const { getAll: getAllPermission } = usePermissionRepo();
   const { getById: getOrgById } = useOrgRepo();
   async function createDefaultUser() {
-    const session = import_utils38.useAtlas.getClient()?.startSession();
+    const session = import_utils43.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       const _user = await getUserByEmail(DEFAULT_USER_EMAIL);
       if (_user) {
-        throw new import_utils38.BadRequestError(
+        throw new import_utils43.BadRequestError(
           `User already exists: ${DEFAULT_USER_EMAIL}.`
         );
       }
-      const hashedPassword = await (0, import_utils38.hashPassword)(DEFAULT_USER_PASSWORD);
+      const hashedPassword = await (0, import_utils43.hashPassword)(DEFAULT_USER_PASSWORD);
       const userId = await addUser(
         {
           email: DEFAULT_USER_EMAIL,
@@ -6813,9 +7530,9 @@ function useUserService() {
     try {
       const _user = await getUserByEmail(value.email);
       if (_user) {
-        throw new import_utils38.BadRequestError(`User already exists: ${value.email}.`);
+        throw new import_utils43.BadRequestError(`User already exists: ${value.email}.`);
       }
-      const hashedPassword = await (0, import_utils38.hashPassword)(value.password);
+      const hashedPassword = await (0, import_utils43.hashPassword)(value.password);
       const insertedId = await addUser({
         email: value.email,
         password: hashedPassword,
@@ -6825,10 +7542,10 @@ function useUserService() {
       });
       return insertedId;
     } catch (error) {
-      if (error instanceof import_utils38.AppError) {
+      if (error instanceof import_utils43.AppError) {
         throw error;
       } else {
-        throw new import_utils38.InternalServerError(`Error creating user: ${error}`);
+        throw new import_utils43.InternalServerError(`Error creating user: ${error}`);
       }
     }
   }
@@ -6839,28 +7556,28 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = import_utils38.useAtlas.getClient()?.startSession();
+    const session = import_utils43.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const invitation = await _getVerificationById(id);
       if (!invitation || !invitation.metadata?.app || !invitation.metadata?.role) {
-        throw new import_utils38.BadRequestError("Invalid invitation.");
+        throw new import_utils43.BadRequestError("Invalid invitation.");
       }
       if (invitation.status === "complete") {
-        throw new import_utils38.BadRequestError("Invitation already used.");
+        throw new import_utils43.BadRequestError("Invitation already used.");
       }
       if (!invitation.expireAt) {
-        throw new import_utils38.BadRequestError("Expiration date is required.");
+        throw new import_utils43.BadRequestError("Expiration date is required.");
       }
       const expired = new Date(invitation.expireAt) < /* @__PURE__ */ new Date();
       if (invitation.status === "expired" || expired) {
-        throw new import_utils38.BadRequestError("Invitation expired.");
+        throw new import_utils43.BadRequestError("Invitation expired.");
       }
       const email = invitation.email;
       const user = await getUserByEmail(invitation.email);
       let userId = user?._id ?? "";
       if (!user) {
-        const hashedPassword = await (0, import_utils38.hashPassword)(password);
+        const hashedPassword = await (0, import_utils43.hashPassword)(password);
         userId = await addUser(
           {
             email,
@@ -6877,7 +7594,7 @@ function useUserService() {
       if (invitation.metadata?.org) {
         const org = await getOrgById(String(invitation.metadata.org));
         if (!org) {
-          throw new import_utils38.NotFoundError("Organization not found.");
+          throw new import_utils43.NotFoundError("Organization not found.");
         }
         orgName = org.name;
       }
@@ -6885,7 +7602,7 @@ function useUserService() {
       if (invitation.metadata.role) {
         const role = await getRoleById(String(invitation.metadata.role));
         if (!role) {
-          throw new import_utils38.NotFoundError("Role not found.");
+          throw new import_utils43.NotFoundError("Role not found.");
         }
         roleName = role.name;
       }
@@ -6905,10 +7622,10 @@ function useUserService() {
       return userId;
     } catch (error) {
       await session?.abortTransaction();
-      if (error instanceof import_utils38.AppError) {
+      if (error instanceof import_utils43.AppError) {
         throw error;
       } else {
-        throw new import_utils38.InternalServerError("Failed to create user by invite.");
+        throw new import_utils43.InternalServerError("Failed to create user by invite.");
       }
     } finally {
       session?.endSession();
@@ -6920,31 +7637,31 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = import_utils38.useAtlas.getClient()?.startSession();
+    const session = import_utils43.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const signUp = await _getVerificationById(id);
       if (!signUp) {
-        throw new import_utils38.BadRequestError("Invalid sign up link.");
+        throw new import_utils43.BadRequestError("Invalid sign up link.");
       }
       if (signUp.status === "complete") {
-        throw new import_utils38.BadRequestError(
+        throw new import_utils43.BadRequestError(
           "You have already an account created using this link."
         );
       }
       if (!signUp.expireAt) {
-        throw new import_utils38.BadRequestError("Expiration date is required.");
+        throw new import_utils43.BadRequestError("Expiration date is required.");
       }
       const expired = new Date(signUp.expireAt) < /* @__PURE__ */ new Date();
       if (signUp.status === "expired" || expired) {
-        throw new import_utils38.BadRequestError("Sign up link expired.");
+        throw new import_utils43.BadRequestError("Sign up link expired.");
       }
       const email = signUp.email;
       const _user = await getUserByEmail(signUp.email);
       if (_user) {
-        throw new import_utils38.BadRequestError(`User already exists: ${email}.`);
+        throw new import_utils43.BadRequestError(`User already exists: ${email}.`);
       }
-      const hashedPassword = await (0, import_utils38.hashPassword)(password);
+      const hashedPassword = await (0, import_utils43.hashPassword)(password);
       const userId = await addUser(
         {
           email,
@@ -6968,33 +7685,33 @@ function useUserService() {
   const { updateStatusById: updateVerificationStatusById } = useVerificationRepo();
   async function resetPassword(value) {
     if (value.newPassword !== value.confirmPassword) {
-      throw new import_utils38.BadRequestError("Passwords do not match.");
+      throw new import_utils43.BadRequestError("Passwords do not match.");
     }
     let hashedPassword = "";
     try {
-      hashedPassword = await (0, import_utils38.hashPassword)(value.newPassword);
+      hashedPassword = await (0, import_utils43.hashPassword)(value.newPassword);
     } catch (error) {
-      throw new import_utils38.InternalServerError(`Error hashing password: ${error}`);
+      throw new import_utils43.InternalServerError(`Error hashing password: ${error}`);
     }
-    const session = import_utils38.useAtlas.getClient()?.startSession();
+    const session = import_utils43.useAtlas.getClient()?.startSession();
     if (!session) {
-      throw new import_utils38.InternalServerError("Failed to start database session.");
+      throw new import_utils43.InternalServerError("Failed to start database session.");
     }
     try {
       session.startTransaction();
       const otpDoc = await getById(value.id);
       if (!otpDoc) {
-        throw new import_utils38.NotFoundError("You are using an invalid reset link.");
+        throw new import_utils43.NotFoundError("You are using an invalid reset link.");
       }
       const user = await getUserByEmail(otpDoc.email);
       if (!user) {
-        throw new import_utils38.NotFoundError("User not found.");
+        throw new import_utils43.NotFoundError("User not found.");
       }
       if (!user._id) {
-        throw new import_utils38.NotFoundError("User ID is invalid.");
+        throw new import_utils43.NotFoundError("User ID is invalid.");
       }
       if (otpDoc.status === "used") {
-        throw new import_utils38.BadRequestError("This link has already been invalidated.");
+        throw new import_utils43.BadRequestError("This link has already been invalidated.");
       }
       await updateVerificationStatusById(value.id, "used", session);
       await _updateUserFieldById(
@@ -7005,31 +7722,31 @@ function useUserService() {
       return "Successfully reset password.";
     } catch (error) {
       await session.abortTransaction();
-      if (error instanceof import_utils38.AppError) {
+      if (error instanceof import_utils43.AppError) {
         throw error;
       }
-      throw new import_utils38.InternalServerError("Failed to reset password.");
+      throw new import_utils43.InternalServerError("Failed to reset password.");
     }
   }
   const { updateName: updateMemberName } = useMemberRepo();
   async function updateName(_id, firstName, lastName) {
     if (!_id) {
-      throw new import_utils38.BadRequestError("Invalid user ID");
+      throw new import_utils43.BadRequestError("Invalid user ID");
     }
     if (!firstName) {
-      throw new import_utils38.BadRequestError("Invalid firstName");
+      throw new import_utils43.BadRequestError("Invalid firstName");
     }
     if (!lastName) {
-      throw new import_utils38.BadRequestError("Invalid lastName");
+      throw new import_utils43.BadRequestError("Invalid lastName");
     }
-    const session = import_utils38.useAtlas.getClient()?.startSession();
+    const session = import_utils43.useAtlas.getClient()?.startSession();
     session?.startTransaction();
-    const cacheKey = (0, import_utils38.makeCacheKey)("users", { user: _id });
+    const cacheKey = (0, import_utils43.makeCacheKey)("users", { user: _id });
     try {
-      (0, import_utils38.useCache)().delCache(cacheKey).then(() => {
-        import_utils38.logger.info(`Cache cleared for user: ${_id}`);
+      (0, import_utils43.useCache)().delCache(cacheKey).then(() => {
+        import_utils43.logger.info(`Cache cleared for user: ${_id}`);
       }).catch((error) => {
-        import_utils38.logger.error(`Failed to clear cache for user: ${_id}`, error);
+        import_utils43.logger.error(`Failed to clear cache for user: ${_id}`, error);
       });
       await _updateName({ _id, firstName, lastName }, session);
       await updateMemberName(
@@ -7047,16 +7764,16 @@ function useUserService() {
   }
   async function updateBirthday(_id, month, day, year) {
     if (!_id) {
-      throw new import_utils38.BadRequestError("Invalid user ID");
+      throw new import_utils43.BadRequestError("Invalid user ID");
     }
     if (!month) {
-      throw new import_utils38.BadRequestError("Invalid birth month.");
+      throw new import_utils43.BadRequestError("Invalid birth month.");
     }
     if (!day) {
-      throw new import_utils38.BadRequestError("Invalid birthday.");
+      throw new import_utils43.BadRequestError("Invalid birthday.");
     }
     if (!year) {
-      throw new import_utils38.BadRequestError("Invalid birth year.");
+      throw new import_utils43.BadRequestError("Invalid birth year.");
     }
     try {
       await _updateBirthday({ _id, month, day, year });
@@ -7073,7 +7790,7 @@ function useUserService() {
     }
   }
   const { createFile: _createFile, deleteFileById } = useFileRepo();
-  const s3 = new import_utils38.useS3({
+  const s3 = new import_utils43.useS3({
     accessKeyId: SPACES_ACCESS_KEY,
     secretAccessKey: SPACES_SECRET_KEY,
     endpoint: SPACES_ENDPOINT,
@@ -7081,7 +7798,7 @@ function useUserService() {
     bucket: SPACES_BUCKET
   });
   async function updateUserProfile({ file, user, previousProfile } = {}) {
-    const session = import_utils38.useAtlas.getClient()?.startSession();
+    const session = import_utils43.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     const _file = {
       name: file.originalname,
@@ -7125,8 +7842,8 @@ function useUserService() {
 }
 
 // src/resources/user/user.controller.ts
-var import_utils39 = require("@goweekdays/utils");
-var import_joi28 = __toESM(require("joi"));
+var import_utils44 = require("@goweekdays/utils");
+var import_joi34 = __toESM(require("joi"));
 function useUserController() {
   const {
     updateName: _updateName,
@@ -7142,14 +7859,14 @@ function useUserController() {
     const status = req.query.status ?? "";
     const search = req.query.search ?? "";
     const page = Number(req.query.page) ?? 1;
-    const validation = import_joi28.default.object({
-      status: import_joi28.default.string().required(),
-      search: import_joi28.default.string().optional().allow("", null),
-      page: import_joi28.default.number().required()
+    const validation = import_joi34.default.object({
+      status: import_joi34.default.string().required(),
+      search: import_joi34.default.string().optional().allow("", null),
+      page: import_joi34.default.number().required()
     });
     const { error } = validation.validate({ status, search, page });
     if (error) {
-      next(new import_utils39.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -7162,14 +7879,14 @@ function useUserController() {
   }
   async function getUserById(req, res, next) {
     const id = req.params.id || "";
-    const validation = import_joi28.default.string().hex().validate(id);
+    const validation = import_joi34.default.string().hex().validate(id);
     if (validation.error) {
-      throw new import_utils39.BadRequestError("Invalid id.");
+      throw new import_utils44.BadRequestError("Invalid id.");
     }
     try {
       const user = await _getUserById(id);
       if (!user) {
-        throw new import_utils39.BadRequestError("User not found.");
+        throw new import_utils44.BadRequestError("User not found.");
       }
       res.json(user);
     } catch (error) {
@@ -7180,13 +7897,13 @@ function useUserController() {
     const id = req.headers.user ?? "";
     const firstName = req.body.firstName ?? "";
     const lastName = req.body.lastName ?? "";
-    const validation = import_joi28.default.object({
-      firstName: import_joi28.default.string().required(),
-      lastName: import_joi28.default.string().required()
+    const validation = import_joi34.default.object({
+      firstName: import_joi34.default.string().required(),
+      lastName: import_joi34.default.string().required()
     });
     const { error } = validation.validate({ firstName, lastName });
     if (error) {
-      next(new import_utils39.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -7202,14 +7919,14 @@ function useUserController() {
     const month = req.body.month ?? "";
     const day = req.body.day ?? 0;
     const year = req.body.year ?? 0;
-    const validation = import_joi28.default.object({
-      month: import_joi28.default.string().required(),
-      day: import_joi28.default.number().integer().min(1).max(31).required(),
-      year: import_joi28.default.number().integer().min(1900).max((/* @__PURE__ */ new Date()).getFullYear()).required()
+    const validation = import_joi34.default.object({
+      month: import_joi34.default.string().required(),
+      day: import_joi34.default.number().integer().min(1).max(31).required(),
+      year: import_joi34.default.number().integer().min(1900).max((/* @__PURE__ */ new Date()).getFullYear()).required()
     });
     const { error } = validation.validate({ month, day, year });
     if (error) {
-      next(new import_utils39.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -7223,18 +7940,18 @@ function useUserController() {
   async function updateUserFieldById(req, res, next) {
     const _id = req.params.id;
     const { field, value } = req.body;
-    const validation = import_joi28.default.object({
-      _id: import_joi28.default.string().hex().required(),
-      field: import_joi28.default.string().valid("gender", "email", "contact", "profile").required(),
-      value: import_joi28.default.alternatives().conditional("field", {
+    const validation = import_joi34.default.object({
+      _id: import_joi34.default.string().hex().required(),
+      field: import_joi34.default.string().valid("gender", "email", "contact", "profile").required(),
+      value: import_joi34.default.alternatives().conditional("field", {
         is: "email",
-        then: import_joi28.default.string().email().required(),
-        otherwise: import_joi28.default.string().required()
+        then: import_joi34.default.string().email().required(),
+        otherwise: import_joi34.default.string().required()
       })
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new import_utils39.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -7250,12 +7967,12 @@ function useUserController() {
       return;
     }
     const previousProfile = req.body.previousProfile ?? "";
-    const validation = import_joi28.default.object({
-      previousProfile: import_joi28.default.string().hex().optional().allow("", null)
+    const validation = import_joi34.default.object({
+      previousProfile: import_joi34.default.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate({ previousProfile });
     if (error) {
-      next(new import_utils39.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     const user = req.headers["user"] ?? "";
@@ -7268,10 +7985,10 @@ function useUserController() {
       res.json({ message: "Successfully updated profile picture." });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils39.AppError) {
+      if (error2 instanceof import_utils44.AppError) {
         next(error2);
       } else {
-        next(new import_utils39.InternalServerError(error2));
+        next(new import_utils44.InternalServerError(error2));
       }
     }
   }
@@ -7281,12 +7998,12 @@ function useUserController() {
     const password = req.body.password ?? "";
     const id = req.params.id ?? "";
     const type = req.body.type ?? "";
-    const validation = import_joi28.default.object({
-      firstName: import_joi28.default.string().required(),
-      lastName: import_joi28.default.string().required(),
-      password: import_joi28.default.string().required(),
-      id: import_joi28.default.string().hex().required(),
-      type: import_joi28.default.string().required()
+    const validation = import_joi34.default.object({
+      firstName: import_joi34.default.string().required(),
+      lastName: import_joi34.default.string().required(),
+      password: import_joi34.default.string().required(),
+      id: import_joi34.default.string().hex().required(),
+      type: import_joi34.default.string().required()
     });
     const { error } = validation.validate({
       firstName,
@@ -7296,7 +8013,7 @@ function useUserController() {
       type
     });
     if (error) {
-      next(new import_utils39.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -7319,14 +8036,14 @@ function useUserController() {
   }
   async function resetPassword(req, res, next) {
     const payload = req.body;
-    const validation = import_joi28.default.object({
-      id: import_joi28.default.string().hex().required(),
-      newPassword: import_joi28.default.string().min(8).required(),
-      confirmPassword: import_joi28.default.string().min(8).required()
+    const validation = import_joi34.default.object({
+      id: import_joi34.default.string().hex().required(),
+      newPassword: import_joi34.default.string().min(8).required(),
+      confirmPassword: import_joi34.default.string().min(8).required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      next(new import_utils39.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -7351,7 +8068,7 @@ function useUserController() {
 }
 
 // src/resources/verification/verification.service.ts
-var import_joi29 = __toESM(require("joi"));
+var import_joi35 = __toESM(require("joi"));
 function useVerificationService() {
   const MailerConfig = {
     host: MAILER_TRANSPORT_HOST,
@@ -7360,7 +8077,7 @@ function useVerificationService() {
     email: MAILER_EMAIL,
     password: MAILER_PASSWORD
   };
-  const mailer = new import_utils40.useMailer(MailerConfig);
+  const mailer = new import_utils45.useMailer(MailerConfig);
   const {
     add,
     getById: _getById,
@@ -7386,7 +8103,7 @@ function useVerificationService() {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (!metadata.app) {
-      throw new import_utils40.BadRequestError("App metadata is required.");
+      throw new import_utils45.BadRequestError("App metadata is required.");
     }
     try {
       const user = await getUserByEmail(email);
@@ -7394,8 +8111,8 @@ function useVerificationService() {
       if (user) {
         value.type = "member-invite";
         const res2 = await add(value);
-        const filePath2 = (0, import_utils40.getDirectory)(dir, "./public/handlebars/member-invite");
-        const emailContent2 = (0, import_utils40.compileHandlebar)({
+        const filePath2 = (0, import_utils45.getDirectory)(dir, "./public/handlebars/member-invite");
+        const emailContent2 = (0, import_utils45.compileHandlebar)({
           context: {
             validity: VERIFICATION_USER_INVITE_DURATION,
             link: `${APP_MAIN}/verify/member-invite/${res2}`,
@@ -7409,7 +8126,7 @@ function useVerificationService() {
           html: emailContent2,
           from: "GoWeekdays"
         }).catch((error) => {
-          import_utils40.logger.log({
+          import_utils45.logger.log({
             level: "error",
             message: `Error sending user invite email: ${error}`
           });
@@ -7417,8 +8134,8 @@ function useVerificationService() {
         return res2;
       }
       const res = await add(value);
-      const filePath = (0, import_utils40.getDirectory)(dir, "./public/handlebars/user-invite");
-      const emailContent = (0, import_utils40.compileHandlebar)({
+      const filePath = (0, import_utils45.getDirectory)(dir, "./public/handlebars/user-invite");
+      const emailContent = (0, import_utils45.compileHandlebar)({
         context: {
           validity: VERIFICATION_USER_INVITE_DURATION,
           link: `${APP_MAIN}/verify/invitation/${res}`
@@ -7431,7 +8148,7 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error) => {
-        import_utils40.logger.log({
+        import_utils45.logger.log({
           level: "error",
           message: `Error sending user invite email: ${error}`
         });
@@ -7452,8 +8169,8 @@ function useVerificationService() {
     try {
       const res = await add(value);
       const dir = __dirname;
-      const filePath = (0, import_utils40.getDirectory)(dir, "./public/handlebars/forget-password");
-      const emailContent = (0, import_utils40.compileHandlebar)({
+      const filePath = (0, import_utils45.getDirectory)(dir, "./public/handlebars/forget-password");
+      const emailContent = (0, import_utils45.compileHandlebar)({
         context: {
           validity: VERIFICATION_FORGET_PASSWORD_DURATION,
           link: `${APP_MAIN}/reset-password/${res}`
@@ -7466,21 +8183,21 @@ function useVerificationService() {
         from: "GoWeekdays",
         html: emailContent
       }).catch((error) => {
-        import_utils40.logger.log({
+        import_utils45.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_utils40.InternalServerError("Failed to create forget password link.");
+      throw new import_utils45.InternalServerError("Failed to create forget password link.");
     }
   }
   async function getById(id) {
     try {
       const _id = await _getById(id);
       if (!_id) {
-        throw new import_utils40.NotFoundError("Verification not found.");
+        throw new import_utils45.NotFoundError("Verification not found.");
       }
       return _id;
     } catch (error) {
@@ -7512,48 +8229,48 @@ function useVerificationService() {
   }
   function errorByType(type, status) {
     if (type === "user-invite" && status === "expired") {
-      throw new import_utils40.BadRequestError(
+      throw new import_utils45.BadRequestError(
         "Invitation has already expired, please contact admin to resend the invitation."
       );
     }
     if (type === "user-sign-up" && status === "expired") {
-      throw new import_utils40.BadRequestError(
+      throw new import_utils45.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_utils40.BadRequestError(
+      throw new import_utils45.BadRequestError(
         "User already registered, please login to continue."
       );
     }
     if (type === "forget-password" && status === "complete") {
-      throw new import_utils40.BadRequestError(
+      throw new import_utils45.BadRequestError(
         "Forget password verification has already been used, please request a new one."
       );
     }
     if (type === "forget-password" && status === "expired") {
-      throw new import_utils40.BadRequestError(
+      throw new import_utils45.BadRequestError(
         "Forget password verification has expired, please request a new one."
       );
     }
-    throw new import_utils40.BadRequestError("Invalid verification.");
+    throw new import_utils45.BadRequestError("Invalid verification.");
   }
   async function verify(id) {
-    const session = import_utils40.useAtlas.getClient()?.startSession();
+    const session = import_utils45.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const _id = await _getById(id);
       if (!_id) {
-        throw new import_utils40.NotFoundError("Verification not found.");
+        throw new import_utils45.NotFoundError("Verification not found.");
       }
       if (_id.status === "expired") {
         errorByType(_id.type, "expired");
       }
       if (_id.status === "complete") {
-        throw new import_utils40.BadRequestError("Verification already completed.");
+        throw new import_utils45.BadRequestError("Verification already completed.");
       }
       if (!_id.expireAt) {
-        throw new import_utils40.BadRequestError("Expiration date is required.");
+        throw new import_utils45.BadRequestError("Expiration date is required.");
       }
       const expiration = new Date(_id.expireAt).getTime();
       const now = (/* @__PURE__ */ new Date()).getTime();
@@ -7566,15 +8283,15 @@ function useVerificationService() {
         await _updateStatusById(id, "complete", session);
         const user = await getUserByEmail(_id.email);
         if (!user) {
-          throw new import_utils40.NotFoundError("User not found for member invite.");
+          throw new import_utils45.NotFoundError("User not found for member invite.");
         }
         if (!_id.metadata?.app) {
-          throw new import_utils40.BadRequestError(
+          throw new import_utils45.BadRequestError(
             "App metadata is required for member invite."
           );
         }
         if (!_id.metadata?.role || !_id.metadata?.roleName) {
-          throw new import_utils40.BadRequestError(
+          throw new import_utils45.BadRequestError(
             "Role metadata is required for member invite."
           );
         }
@@ -7596,7 +8313,7 @@ function useVerificationService() {
       return _id;
     } catch (error) {
       await session?.abortTransaction();
-      import_utils40.logger.log({
+      import_utils45.logger.log({
         level: "info",
         message: `Error verifying user invitation: ${error}`
       });
@@ -7609,7 +8326,7 @@ function useVerificationService() {
     try {
       await updateStatusById(id, "cancelled");
     } catch (error) {
-      throw new import_utils40.InternalServerError(
+      throw new import_utils45.InternalServerError(
         `Error cancelling user invitation: ${error}`
       );
     }
@@ -7629,7 +8346,7 @@ function useVerificationService() {
     try {
       const user = await getUserByEmail(email);
       if (user) {
-        throw new import_utils40.BadRequestError(
+        throw new import_utils45.BadRequestError(
           `Email ${email} is already registered, please login to continue.`
         );
       }
@@ -7642,8 +8359,8 @@ function useVerificationService() {
       };
       const res = await add(value);
       const dir = __dirname;
-      const filePath = (0, import_utils40.getDirectory)(dir, "./public/handlebars/sign-up");
-      const emailContent = (0, import_utils40.compileHandlebar)({
+      const filePath = (0, import_utils45.getDirectory)(dir, "./public/handlebars/sign-up");
+      const emailContent = (0, import_utils45.compileHandlebar)({
         context: {
           validity: "5 minutes",
           link: `${APP_MAIN}/sign-up/${res}`
@@ -7656,7 +8373,7 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error) => {
-        import_utils40.logger.log({
+        import_utils45.logger.log({
           level: "error",
           message: `Error sending user invite email: ${error}`
         });
@@ -7669,17 +8386,17 @@ function useVerificationService() {
   async function inviteMember(value) {
     const { error } = schemaInviteMember.validate(value);
     if (error) {
-      throw new import_utils40.BadRequestError(error.message);
+      throw new import_utils45.BadRequestError(error.message);
     }
     const role = await getRoleById(value.role);
     if (!role) {
-      throw new import_utils40.NotFoundError("Role not found.");
+      throw new import_utils45.NotFoundError("Role not found.");
     }
     let org = null;
     if (value.org) {
       org = await getOrgById(String(value.org));
       if (!org) {
-        throw new import_utils40.NotFoundError("Organization not found.");
+        throw new import_utils45.NotFoundError("Organization not found.");
       }
     }
     let verificationData = {
@@ -7699,8 +8416,8 @@ function useVerificationService() {
       if (user) {
         verificationData.type = "member-invite";
         const verificationId2 = await add(verificationData);
-        const filePath2 = (0, import_utils40.getDirectory)(dir, "./public/handlebars/member-invite");
-        const emailContent2 = (0, import_utils40.compileHandlebar)({
+        const filePath2 = (0, import_utils45.getDirectory)(dir, "./public/handlebars/member-invite");
+        const emailContent2 = (0, import_utils45.compileHandlebar)({
           context: {
             validity: VERIFICATION_USER_INVITE_DURATION,
             link: `${APP_MAIN}/verify/member-invite/${verificationId2}`,
@@ -7714,7 +8431,7 @@ function useVerificationService() {
           html: emailContent2,
           from: "GoWeekdays"
         }).catch((error2) => {
-          import_utils40.logger.log({
+          import_utils45.logger.log({
             level: "error",
             message: `Error sending user invite email: ${error2}`
           });
@@ -7722,8 +8439,8 @@ function useVerificationService() {
         return verificationId2;
       }
       const verificationId = await add(verificationData);
-      const filePath = (0, import_utils40.getDirectory)(dir, "./public/handlebars/user-invite");
-      const emailContent = (0, import_utils40.compileHandlebar)({
+      const filePath = (0, import_utils45.getDirectory)(dir, "./public/handlebars/user-invite");
+      const emailContent = (0, import_utils45.compileHandlebar)({
         context: {
           validity: VERIFICATION_USER_INVITE_DURATION,
           link: `${APP_MAIN}/verify/invitation/${verificationId}`
@@ -7736,55 +8453,55 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error2) => {
-        import_utils40.logger.log({
+        import_utils45.logger.log({
           level: "error",
           message: `Error sending user invite email: ${error2}`
         });
       });
       return verificationId;
     } catch (error2) {
-      if (error2 instanceof import_utils40.AppError) {
+      if (error2 instanceof import_utils45.AppError) {
         throw error2;
       } else {
-        throw new import_utils40.InternalServerError("Failed to invite member.");
+        throw new import_utils45.InternalServerError("Failed to invite member.");
       }
     }
   }
   async function cancelInviteMember(id) {
-    const { error } = import_joi29.default.string().hex().required().validate(id);
+    const { error } = import_joi35.default.string().hex().required().validate(id);
     if (error) {
-      throw new import_utils40.BadRequestError("Invalid verification ID.");
+      throw new import_utils45.BadRequestError("Invalid verification ID.");
     }
     try {
       const invite = await _getById(id);
       if (!invite) {
-        throw new import_utils40.NotFoundError("Invitation not found.");
+        throw new import_utils45.NotFoundError("Invitation not found.");
       }
       if (invite.status === "cancelled") {
-        throw new import_utils40.BadRequestError("Invitation already cancelled.");
+        throw new import_utils45.BadRequestError("Invitation already cancelled.");
       }
       if (invite.status === "complete") {
-        throw new import_utils40.BadRequestError("Cannot cancel a completed invitation.");
+        throw new import_utils45.BadRequestError("Cannot cancel a completed invitation.");
       }
       await _updateStatusById(id, "cancelled");
       return "Successfully cancelled the invitation.";
     } catch (error2) {
-      if (error2 instanceof import_utils40.AppError) {
+      if (error2 instanceof import_utils45.AppError) {
         throw error2;
       } else {
-        throw new import_utils40.InternalServerError("Failed to cancel the invitation.");
+        throw new import_utils45.InternalServerError("Failed to cancel the invitation.");
       }
     }
   }
   async function forgetPassword(email) {
-    const { error } = import_joi29.default.string().email().required().validate(email);
+    const { error } = import_joi35.default.string().email().required().validate(email);
     if (error) {
-      throw new import_utils40.BadRequestError("Invalid email address.");
+      throw new import_utils45.BadRequestError("Invalid email address.");
     }
     try {
       const member = await getUserByEmail(email);
       if (!member) {
-        throw new import_utils40.NotFoundError("User not found.");
+        throw new import_utils45.NotFoundError("User not found.");
       }
       const value = {
         type: "forget-password",
@@ -7794,8 +8511,8 @@ function useVerificationService() {
       };
       const res = await add(value);
       const dir = __dirname;
-      const filePath = (0, import_utils40.getDirectory)(dir, "./public/handlebars/forget-password");
-      const emailContent = (0, import_utils40.compileHandlebar)({
+      const filePath = (0, import_utils45.getDirectory)(dir, "./public/handlebars/forget-password");
+      const emailContent = (0, import_utils45.compileHandlebar)({
         context: {
           validity: VERIFICATION_FORGET_PASSWORD_DURATION,
           link: `${APP_MAIN}/reset-password/${res}`
@@ -7808,22 +8525,78 @@ function useVerificationService() {
         from: "GoWeekdays",
         html: emailContent
       }).catch((error2) => {
-        import_utils40.logger.log({
+        import_utils45.logger.log({
           level: "error",
           message: `Error sending forget password email: ${error2}`
         });
       });
       return "Successfully created a link to reset password. Please check your email.";
     } catch (error2) {
-      if (error2 instanceof import_utils40.AppError) {
+      if (error2 instanceof import_utils45.AppError) {
         throw error2;
       } else {
-        throw new import_utils40.InternalServerError(
+        throw new import_utils45.InternalServerError(
           "Failed to process forget password request."
         );
       }
     }
   }
+  const { addOrder: addPaypalOrder } = usePaypalService();
+  const { getByEmail: getOrgByEmail, getByName: getOrgByName } = useOrgRepo();
+  async function orgSetupFee(value) {
+    const session = import_utils45.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new import_utils45.BadRequestError("Unable to start database session.");
+    }
+    try {
+      session.startTransaction();
+      const orgExistingByName = await getOrgByName(value.name);
+      if (orgExistingByName) {
+        throw new import_utils45.BadRequestError(`Name ${value.name} is already taken.`);
+      }
+      const orgExistingByEmail = await getOrgByEmail(value.email);
+      if (orgExistingByEmail) {
+        throw new import_utils45.BadRequestError(`Email ${value.email} is already taken.`);
+      }
+      const amount = 100;
+      const verificationId = await add(
+        {
+          type: "org-setup-fee",
+          email: value.email,
+          metadata: {
+            seats: value.seats,
+            contact: value.contact,
+            orgName: value.name,
+            createdBy: value.createdBy,
+            amount
+          }
+        },
+        session
+      );
+      const order = await addPaypalOrder({
+        amount,
+        currency: "PHP",
+        customId: String(verificationId),
+        returnUrl: `${APP_ORG}/organizations/success`,
+        cancelUrl: `${APP_ORG}/organizations/cancel`,
+        action: "pay"
+      });
+      await session?.commitTransaction();
+      const paypalOrderLink = JSON.parse(order.body.toString()).links.find(
+        (link) => link.rel === "approve"
+      );
+      return {
+        paypalOrderLink: paypalOrderLink ? paypalOrderLink.href : ""
+      };
+    } catch (error) {
+      if (error instanceof import_utils45.AppError) {
+        throw error;
+      }
+      throw new import_utils45.InternalServerError(
+        "Failed to process organization setup fee."
+      );
+    }
+  }
   return {
     createForgetPassword,
     createUserInvite,
@@ -7835,7 +8608,8 @@ function useVerificationService() {
     signUp,
     inviteMember,
     cancelInviteMember,
-    forgetPassword
+    forgetPassword,
+    orgSetupFee
   };
 }
 
@@ -7845,13 +8619,13 @@ function useAuthController() {
   async function login(req, res, next) {
     const email = req.body.email;
     const password = req.body.password;
-    const validation = import_joi30.default.object({
-      email: import_joi30.default.string().email().required(),
-      password: import_joi30.default.string().required()
+    const validation = import_joi36.default.object({
+      email: import_joi36.default.string().email().required(),
+      password: import_joi36.default.string().required()
     });
     const { error } = validation.validate({ email, password });
     if (error) {
-      next(new import_utils41.BadRequestError(error.message));
+      next(new import_utils46.BadRequestError(error.message));
       return;
     }
     try {
@@ -7867,14 +8641,14 @@ function useAuthController() {
       res.cookie("sid", session.sid, cookieOptions).cookie("user", session.user, cookieOptions).json({ message: "Login successful" });
       return;
     } catch (error2) {
-      import_utils41.logger.log({
+      import_utils46.logger.log({
         level: "error",
         message: `Error during login: ${error2.message}`
       });
-      if (error2 instanceof import_utils41.AppError) {
+      if (error2 instanceof import_utils46.AppError) {
         next(error2);
       } else {
-        next(new import_utils41.InternalServerError("An unexpected error occurred"));
+        next(new import_utils46.InternalServerError("An unexpected error occurred"));
       }
       return;
     }
@@ -7882,17 +8656,17 @@ function useAuthController() {
   async function logout(req, res, next) {
     const sid = req.headers["authorization"] ?? "";
     if (!sid) {
-      next(new import_utils41.BadRequestError("Session ID is required"));
+      next(new import_utils46.BadRequestError("Session ID is required"));
       return;
     }
     try {
       await useAuthService().logout(sid);
       res.json({ message: "Logged out successfully" });
     } catch (error) {
-      if (error instanceof import_utils41.AppError) {
+      if (error instanceof import_utils46.AppError) {
         next(error);
       } else {
-        next(new import_utils41.InternalServerError("An unexpected error occurred"));
+        next(new import_utils46.InternalServerError("An unexpected error occurred"));
       }
     }
   }
@@ -7903,64 +8677,64 @@ function useAuthController() {
 }
 
 // src/resources/building/building.model.ts
-var import_utils42 = require("@goweekdays/utils");
-var import_joi31 = __toESM(require("joi"));
-var import_mongodb20 = require("mongodb");
-var schemaBuilding = import_joi31.default.object({
-  _id: import_joi31.default.string().hex().optional(),
-  school: import_joi31.default.string().hex().required(),
-  serial: import_joi31.default.string().optional().allow("", null),
-  name: import_joi31.default.string().required(),
-  levels: import_joi31.default.number().integer().min(1).required(),
-  createdAt: import_joi31.default.date().optional().allow("", null),
-  updatedAt: import_joi31.default.date().optional().allow("", null),
-  deletedAt: import_joi31.default.date().optional().allow("", null),
-  status: import_joi31.default.string().optional().allow("", null)
+var import_utils47 = require("@goweekdays/utils");
+var import_joi37 = __toESM(require("joi"));
+var import_mongodb22 = require("mongodb");
+var schemaBuilding = import_joi37.default.object({
+  _id: import_joi37.default.string().hex().optional(),
+  school: import_joi37.default.string().hex().required(),
+  serial: import_joi37.default.string().optional().allow("", null),
+  name: import_joi37.default.string().required(),
+  levels: import_joi37.default.number().integer().min(1).required(),
+  createdAt: import_joi37.default.date().optional().allow("", null),
+  updatedAt: import_joi37.default.date().optional().allow("", null),
+  deletedAt: import_joi37.default.date().optional().allow("", null),
+  status: import_joi37.default.string().optional().allow("", null)
 });
-var schemaBuildingUnit = import_joi31.default.object({
-  _id: import_joi31.default.string().hex().optional(),
-  school: import_joi31.default.string().hex().required(),
-  name: import_joi31.default.string().optional().allow("", null),
-  building: import_joi31.default.string().hex().required(),
-  buildingName: import_joi31.default.string().optional().allow("", null),
-  level: import_joi31.default.number().integer().min(1).required(),
-  category: import_joi31.default.string().required(),
-  type: import_joi31.default.string().required(),
-  seating_capacity: import_joi31.default.number().integer().min(0).required(),
-  standing_capacity: import_joi31.default.number().integer().min(0).required(),
-  description: import_joi31.default.string().optional().allow("", null),
-  unit_of_measurement: import_joi31.default.string().valid("sqm").required(),
-  area: import_joi31.default.number().positive().required(),
-  status: import_joi31.default.string().optional().allow("", null)
+var schemaBuildingUnit = import_joi37.default.object({
+  _id: import_joi37.default.string().hex().optional(),
+  school: import_joi37.default.string().hex().required(),
+  name: import_joi37.default.string().optional().allow("", null),
+  building: import_joi37.default.string().hex().required(),
+  buildingName: import_joi37.default.string().optional().allow("", null),
+  level: import_joi37.default.number().integer().min(1).required(),
+  category: import_joi37.default.string().required(),
+  type: import_joi37.default.string().required(),
+  seating_capacity: import_joi37.default.number().integer().min(0).required(),
+  standing_capacity: import_joi37.default.number().integer().min(0).required(),
+  description: import_joi37.default.string().optional().allow("", null),
+  unit_of_measurement: import_joi37.default.string().valid("sqm").required(),
+  area: import_joi37.default.number().positive().required(),
+  status: import_joi37.default.string().optional().allow("", null)
 });
-var schemaUpdateOptions = import_joi31.default.object({
-  name: import_joi31.default.string().optional().allow("", null),
-  building: import_joi31.default.string().hex().optional().allow("", null),
-  buildingName: import_joi31.default.string().optional().allow("", null),
-  level: import_joi31.default.number().integer().min(1).optional().allow("", null),
-  category: import_joi31.default.string().optional().allow("", null),
-  type: import_joi31.default.string().optional().allow("", null),
-  seating_capacity: import_joi31.default.number().integer().min(0).optional().allow("", null),
-  standing_capacity: import_joi31.default.number().integer().min(0).optional().allow("", null),
-  area: import_joi31.default.number().positive().optional().allow("", null)
+var schemaUpdateOptions = import_joi37.default.object({
+  name: import_joi37.default.string().optional().allow("", null),
+  building: import_joi37.default.string().hex().optional().allow("", null),
+  buildingName: import_joi37.default.string().optional().allow("", null),
+  level: import_joi37.default.number().integer().min(1).optional().allow("", null),
+  category: import_joi37.default.string().optional().allow("", null),
+  type: import_joi37.default.string().optional().allow("", null),
+  seating_capacity: import_joi37.default.number().integer().min(0).optional().allow("", null),
+  standing_capacity: import_joi37.default.number().integer().min(0).optional().allow("", null),
+  area: import_joi37.default.number().positive().optional().allow("", null)
 });
 function MBuilding(value) {
   const { error } = schemaBuilding.validate(value);
   if (error) {
-    import_utils42.logger.info(`Building Model: ${error.message}`);
-    throw new import_utils42.BadRequestError(error.message);
+    import_utils47.logger.info(`Building Model: ${error.message}`);
+    throw new import_utils47.BadRequestError(error.message);
   }
   if (value._id && typeof value._id === "string") {
     try {
-      value._id = new import_mongodb20.ObjectId(value._id);
+      value._id = new import_mongodb22.ObjectId(value._id);
     } catch (error2) {
-      throw new import_utils42.BadRequestError("Invalid _id format");
+      throw new import_utils47.BadRequestError("Invalid _id format");
     }
   }
   try {
-    value.school = new import_mongodb20.ObjectId(value.school);
+    value.school = new import_mongodb22.ObjectId(value.school);
   } catch (error2) {
-    throw new import_utils42.BadRequestError("Invalid school format");
+    throw new import_utils47.BadRequestError("Invalid school format");
   }
   return {
     _id: value._id ?? void 0,
@@ -7977,25 +8751,25 @@ function MBuilding(value) {
 function MBuildingUnit(value) {
   const { error } = schemaBuildingUnit.validate(value);
   if (error) {
-    import_utils42.logger.info(`Building Unit Model: ${error.message}`);
-    throw new import_utils42.BadRequestError(error.message);
+    import_utils47.logger.info(`Building Unit Model: ${error.message}`);
+    throw new import_utils47.BadRequestError(error.message);
   }
   if (value._id && typeof value._id === "string") {
     try {
-      value._id = new import_mongodb20.ObjectId(value._id);
+      value._id = new import_mongodb22.ObjectId(value._id);
     } catch (error2) {
-      throw new import_utils42.BadRequestError("Invalid ID");
+      throw new import_utils47.BadRequestError("Invalid ID");
     }
   }
   try {
-    value.school = new import_mongodb20.ObjectId(value.school);
+    value.school = new import_mongodb22.ObjectId(value.school);
   } catch (error2) {
-    throw new import_utils42.BadRequestError("Invalid school ID");
+    throw new import_utils47.BadRequestError("Invalid school ID");
   }
   try {
-    value.building = new import_mongodb20.ObjectId(value.building);
+    value.building = new import_mongodb22.ObjectId(value.building);
   } catch (error2) {
-    throw new import_utils42.BadRequestError("Invalid building ID");
+    throw new import_utils47.BadRequestError("Invalid building ID");
   }
   return {
     _id: value._id ?? void 0,
@@ -8019,16 +8793,16 @@ function MBuildingUnit(value) {
 }
 
 // src/resources/building/building.repository.ts
-var import_utils43 = require("@goweekdays/utils");
-var import_mongodb21 = require("mongodb");
+var import_utils48 = require("@goweekdays/utils");
+var import_mongodb23 = require("mongodb");
 function useBuildingRepo() {
-  const db = import_utils43.useAtlas.getDb();
+  const db = import_utils48.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "school.buildings";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils43.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils48.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -8047,16 +8821,16 @@ function useBuildingRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils43.logger.log({
+      import_utils48.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils43.AppError) {
+      if (error instanceof import_utils48.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils43.BadRequestError("Building already exists.");
+          throw new import_utils48.BadRequestError("Building already exists.");
         }
         throw new Error("Failed to create building.");
       }
@@ -8064,9 +8838,9 @@ function useBuildingRepo() {
   }
   async function updateById(_id, value, session) {
     try {
-      _id = new import_mongodb21.ObjectId(_id);
+      _id = new import_mongodb23.ObjectId(_id);
     } catch (error) {
-      throw new import_utils43.BadRequestError("Invalid ID.");
+      throw new import_utils48.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -8077,11 +8851,11 @@ function useBuildingRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils43.logger.log({
+      import_utils48.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils43.AppError) {
+      if (error instanceof import_utils48.AppError) {
         throw error;
       } else {
         throw new Error("Failed to update building.");
@@ -8106,9 +8880,9 @@ function useBuildingRepo() {
     }
     if (school) {
       try {
-        query.school = new import_mongodb21.ObjectId(school);
+        query.school = new import_mongodb23.ObjectId(school);
       } catch (error) {
-        throw new import_utils43.BadRequestError("Invalid school ID.");
+        throw new import_utils48.BadRequestError("Invalid school ID.");
       }
     }
     const cacheParams = {
@@ -8122,15 +8896,15 @@ function useBuildingRepo() {
       cacheParams.school = school;
     if (status !== "active")
       cacheParams.status = status;
-    const cacheKey = (0, import_utils43.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils43.logger.log({
+    const cacheKey = (0, import_utils48.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils48.logger.log({
       level: "info",
       message: `Cache key for getAll buildings: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils43.logger.log({
+        import_utils48.logger.log({
           level: "info",
           message: `Cache hit for getAll buildings: ${cacheKey}`
         });
@@ -8143,35 +8917,35 @@ function useBuildingRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils43.paginate)(items, page, limit, length);
+      const data = (0, import_utils48.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils43.logger.log({
+        import_utils48.logger.log({
           level: "info",
           message: `Cache set for getAll buildings: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils43.logger.log({
+        import_utils48.logger.log({
           level: "error",
           message: `Failed to set cache for getAll buildings: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils43.logger.log({ level: "error", message: `${error}` });
+      import_utils48.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new import_mongodb21.ObjectId(_id);
+      _id = new import_mongodb23.ObjectId(_id);
     } catch (error) {
-      throw new import_utils43.BadRequestError("Invalid ID.");
+      throw new import_utils48.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils43.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils48.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils43.logger.log({
+        import_utils48.logger.log({
           level: "info",
           message: `Cache hit for getById building: ${cacheKey}`
         });
@@ -8181,30 +8955,30 @@ function useBuildingRepo() {
         _id
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils43.logger.log({
+        import_utils48.logger.log({
           level: "info",
           message: `Cache set for building by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils43.logger.log({
+        import_utils48.logger.log({
           level: "error",
           message: `Failed to set cache for building by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils43.AppError) {
+      if (error instanceof import_utils48.AppError) {
         throw error;
       } else {
-        throw new import_utils43.InternalServerError("Failed to get building.");
+        throw new import_utils48.InternalServerError("Failed to get building.");
       }
     }
   }
   async function deleteById(_id, session) {
     try {
-      _id = new import_mongodb21.ObjectId(_id);
+      _id = new import_mongodb23.ObjectId(_id);
     } catch (error) {
-      throw new import_utils43.BadRequestError("Invalid ID.");
+      throw new import_utils48.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -8214,25 +8988,25 @@ function useBuildingRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils43.logger.log({
+      import_utils48.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils43.AppError) {
+      if (error instanceof import_utils48.AppError) {
         throw error;
       } else {
-        throw new import_utils43.InternalServerError("Failed to delete building.");
+        throw new import_utils48.InternalServerError("Failed to delete building.");
       }
     }
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils43.logger.log({
+      import_utils48.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils43.logger.log({
+      import_utils48.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -8249,19 +9023,19 @@ function useBuildingRepo() {
 }
 
 // src/resources/building/building.service.ts
-var import_utils45 = require("@goweekdays/utils");
+var import_utils50 = require("@goweekdays/utils");
 
 // src/resources/building/building-unit.repository.ts
-var import_utils44 = require("@goweekdays/utils");
-var import_mongodb22 = require("mongodb");
+var import_utils49 = require("@goweekdays/utils");
+var import_mongodb24 = require("mongodb");
 function useBuildingUnitRepo() {
-  const db = import_utils44.useAtlas.getDb();
+  const db = import_utils49.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "school.building-units";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils44.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils49.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -8289,12 +9063,12 @@ function useBuildingUnitRepo() {
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils44.logger.log({
+      import_utils49.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils44.logger.log({
+      import_utils49.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -8307,11 +9081,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils44.logger.log({
+      import_utils49.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils44.AppError) {
+      if (error instanceof import_utils49.AppError) {
         throw error;
       } else {
         throw new Error("Failed to create building unit.");
@@ -8321,12 +9095,12 @@ function useBuildingUnitRepo() {
   async function updateById(_id, value, session) {
     const { error } = schemaUpdateOptions.validate(value);
     if (error) {
-      throw new import_utils44.BadRequestError(error.message);
+      throw new import_utils49.BadRequestError(error.message);
     }
     try {
-      _id = new import_mongodb22.ObjectId(_id);
+      _id = new import_mongodb24.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils44.BadRequestError("Invalid ID.");
+      throw new import_utils49.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -8337,11 +9111,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils44.logger.log({
+      import_utils49.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils44.AppError) {
+      if (error2 instanceof import_utils49.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to create building unit.");
@@ -8351,12 +9125,12 @@ function useBuildingUnitRepo() {
   async function updateByBuildingId(building, value, session) {
     const { error } = schemaUpdateOptions.validate(value);
     if (error) {
-      throw new import_utils44.BadRequestError(error.message);
+      throw new import_utils49.BadRequestError(error.message);
     }
     try {
-      building = new import_mongodb22.ObjectId(building);
+      building = new import_mongodb24.ObjectId(building);
     } catch (error2) {
-      throw new import_utils44.BadRequestError("Invalid building ID.");
+      throw new import_utils49.BadRequestError("Invalid building ID.");
     }
     try {
       const res = await collection.updateMany(
@@ -8367,11 +9141,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils44.logger.log({
+      import_utils49.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils44.AppError) {
+      if (error2 instanceof import_utils49.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to update building unit.");
@@ -8398,16 +9172,16 @@ function useBuildingUnitRepo() {
     }
     if (school) {
       try {
-        query.school = new import_mongodb22.ObjectId(school);
+        query.school = new import_mongodb24.ObjectId(school);
       } catch (error) {
-        throw new import_utils44.BadRequestError("Invalid school ID.");
+        throw new import_utils49.BadRequestError("Invalid school ID.");
       }
     }
     if (building) {
       try {
-        query.building = new import_mongodb22.ObjectId(building);
+        query.building = new import_mongodb24.ObjectId(building);
       } catch (error) {
-        throw new import_utils44.BadRequestError("Invalid building ID.");
+        throw new import_utils49.BadRequestError("Invalid building ID.");
       }
     }
     const cacheParams = {
@@ -8423,15 +9197,15 @@ function useBuildingUnitRepo() {
       cacheParams.building = building;
     if (status !== "active")
       cacheParams.status = status;
-    const cacheKey = (0, import_utils44.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils44.logger.log({
+    const cacheKey = (0, import_utils49.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils49.logger.log({
       level: "info",
       message: `Cache key for getAll building units: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "info",
           message: `Cache hit for getAll building units: ${cacheKey}`
         });
@@ -8444,35 +9218,35 @@ function useBuildingUnitRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils44.paginate)(items, page, limit, length);
+      const data = (0, import_utils49.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "info",
           message: `Cache set for getAll building units: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "error",
           message: `Failed to set cache for getAll building units: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils44.logger.log({ level: "error", message: `${error}` });
+      import_utils49.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new import_mongodb22.ObjectId(_id);
+      _id = new import_mongodb24.ObjectId(_id);
     } catch (error) {
-      throw new import_utils44.BadRequestError("Invalid ID.");
+      throw new import_utils49.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils44.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils49.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -8483,42 +9257,42 @@ function useBuildingUnitRepo() {
         deletedAt: { $in: ["", null] }
       });
       if (!result) {
-        throw new import_utils44.BadRequestError("Building unit not found.");
+        throw new import_utils49.BadRequestError("Building unit not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils44.AppError) {
+      if (error instanceof import_utils49.AppError) {
         throw error;
       } else {
-        throw new import_utils44.InternalServerError("Failed to get building unit.");
+        throw new import_utils49.InternalServerError("Failed to get building unit.");
       }
     }
   }
   async function getByBuildingLevel(building, level) {
     try {
-      building = new import_mongodb22.ObjectId(building);
+      building = new import_mongodb24.ObjectId(building);
     } catch (error) {
-      throw new import_utils44.BadRequestError("Invalid building ID.");
+      throw new import_utils49.BadRequestError("Invalid building ID.");
     }
-    const cacheKey = (0, import_utils44.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils49.makeCacheKey)(namespace_collection, {
       building: String(building),
       level
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -8530,38 +9304,38 @@ function useBuildingUnitRepo() {
         status: "active"
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils44.AppError) {
+      if (error instanceof import_utils49.AppError) {
         throw error;
       } else {
-        throw new import_utils44.InternalServerError("Failed to get building unit.");
+        throw new import_utils49.InternalServerError("Failed to get building unit.");
       }
     }
   }
   async function getByBuilding(building) {
     try {
-      building = new import_mongodb22.ObjectId(building);
+      building = new import_mongodb24.ObjectId(building);
     } catch (error) {
-      throw new import_utils44.BadRequestError("Invalid building ID.");
+      throw new import_utils49.BadRequestError("Invalid building ID.");
     }
-    const cacheKey = (0, import_utils44.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils49.makeCacheKey)(namespace_collection, {
       building: String(building)
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -8572,30 +9346,30 @@ function useBuildingUnitRepo() {
         status: "active"
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils44.logger.log({
+        import_utils49.logger.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils44.AppError) {
+      if (error instanceof import_utils49.AppError) {
         throw error;
       } else {
-        throw new import_utils44.InternalServerError("Failed to get building unit.");
+        throw new import_utils49.InternalServerError("Failed to get building unit.");
       }
     }
   }
   async function deleteById(_id, session) {
     try {
-      _id = new import_mongodb22.ObjectId(_id);
+      _id = new import_mongodb24.ObjectId(_id);
     } catch (error) {
-      throw new import_utils44.BadRequestError("Invalid ID.");
+      throw new import_utils49.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -8606,11 +9380,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return "Room/Facility deleted successfully.";
     } catch (error) {
-      import_utils44.logger.log({
+      import_utils49.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils44.AppError) {
+      if (error instanceof import_utils49.AppError) {
         throw error;
       } else {
         throw new Error("Failed to deleted room/facility.");
@@ -8640,16 +9414,16 @@ function useBuildingService() {
   const { getByBuildingLevel, getByBuilding, updateByBuildingId } = useBuildingUnitRepo();
   async function updateById(id, data) {
     data.levels = Number(data.levels);
-    const session = import_utils45.useAtlas.getClient()?.startSession();
+    const session = import_utils50.useAtlas.getClient()?.startSession();
     try {
       const building = await _getById(id);
       if (!building) {
-        throw new import_utils45.NotFoundError("Building not found.");
+        throw new import_utils50.NotFoundError("Building not found.");
       }
       if (data.levels < building.levels) {
         const unit = await getByBuildingLevel(id, building.levels);
         if (unit) {
-          throw new import_utils45.BadRequestError(
+          throw new import_utils50.BadRequestError(
             "Cannot reduce floors, there are existing building units at higher floors."
           );
         }
@@ -8671,7 +9445,7 @@ function useBuildingService() {
   async function deleteById(id) {
     const building = await getByBuilding(id);
     if (building) {
-      throw new import_utils45.BadRequestError(
+      throw new import_utils50.BadRequestError(
         "Cannot delete building with existing room/facility. Please delete room/facility first."
       );
     }
@@ -8689,24 +9463,24 @@ function useBuildingService() {
 }
 
 // src/resources/building/building.controller.ts
-var import_utils46 = require("@goweekdays/utils");
-var import_joi32 = __toESM(require("joi"));
+var import_utils51 = require("@goweekdays/utils");
+var import_joi38 = __toESM(require("joi"));
 function useBuildingController() {
   const { getAll: _getAll, getById: _getById, add: _add } = useBuildingRepo();
   const { updateById: _updateById, deleteById: _deleteById } = useBuildingService();
   async function createBuilding(req, res, next) {
     const value = req.body;
-    const validation = import_joi32.default.object({
-      name: import_joi32.default.string().required(),
-      school: import_joi32.default.string().hex().required(),
-      levels: import_joi32.default.number().integer().min(1).required(),
-      serial: import_joi32.default.string().optional().allow("", null),
-      status: import_joi32.default.string().optional().allow("", null)
+    const validation = import_joi38.default.object({
+      name: import_joi38.default.string().required(),
+      school: import_joi38.default.string().hex().required(),
+      levels: import_joi38.default.number().integer().min(1).required(),
+      serial: import_joi38.default.string().optional().allow("", null),
+      status: import_joi38.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
-      import_utils46.logger.info(`Controller: ${error.message}`);
+      next(new import_utils51.BadRequestError(error.message));
+      import_utils51.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -8720,18 +9494,18 @@ function useBuildingController() {
   async function updateById(req, res, next) {
     const value = req.body;
     const id = req.params.id ?? "";
-    const validation = import_joi32.default.object({
-      id: import_joi32.default.string().hex().required(),
-      value: import_joi32.default.object({
-        name: import_joi32.default.string().required(),
-        serial: import_joi32.default.string().optional().allow("", null),
-        levels: import_joi32.default.number().integer().min(1).required()
+    const validation = import_joi38.default.object({
+      id: import_joi38.default.string().hex().required(),
+      value: import_joi38.default.object({
+        name: import_joi38.default.string().required(),
+        serial: import_joi38.default.string().optional().allow("", null),
+        levels: import_joi38.default.number().integer().min(1).required()
       })
     });
     const { error } = validation.validate({ id, value });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
-      import_utils46.logger.info(`Controller: ${error.message}`);
+      next(new import_utils51.BadRequestError(error.message));
+      import_utils51.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -8744,16 +9518,16 @@ function useBuildingController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi32.default.object({
-      page: import_joi32.default.number().min(1).optional().allow("", null),
-      limit: import_joi32.default.number().min(1).optional().allow("", null),
-      search: import_joi32.default.string().optional().allow("", null),
-      school: import_joi32.default.string().hex().optional().allow("", null),
-      status: import_joi32.default.string().optional().allow("", null)
+    const validation = import_joi38.default.object({
+      page: import_joi38.default.number().min(1).optional().allow("", null),
+      limit: import_joi38.default.number().min(1).optional().allow("", null),
+      search: import_joi38.default.string().optional().allow("", null),
+      school: import_joi38.default.string().hex().optional().allow("", null),
+      status: import_joi38.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils51.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -8787,12 +9561,12 @@ function useBuildingController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi32.default.object({
-      id: import_joi32.default.string().hex().required()
+    const validation = import_joi38.default.object({
+      id: import_joi38.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils51.BadRequestError(error.message));
       return;
     }
     try {
@@ -8808,12 +9582,12 @@ function useBuildingController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi32.default.object({
-      id: import_joi32.default.string().hex().required()
+    const validation = import_joi38.default.object({
+      id: import_joi38.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils51.BadRequestError(error.message));
       return;
     }
     try {
@@ -8834,11 +9608,11 @@ function useBuildingController() {
 }
 
 // src/resources/building/building-unit.service.ts
-var import_utils47 = require("@goweekdays/utils");
+var import_utils52 = require("@goweekdays/utils");
 function useBuildingUnitService() {
   const { add: _add } = useBuildingUnitRepo();
   async function add(value) {
-    const session = import_utils47.useAtlas.getClient()?.startSession();
+    const session = import_utils52.useAtlas.getClient()?.startSession();
     if (!session) {
       throw new Error("Unable to start session for building unit service.");
     }
@@ -8865,8 +9639,8 @@ function useBuildingUnitService() {
 }
 
 // src/resources/building/building-unit.controller.ts
-var import_utils48 = require("@goweekdays/utils");
-var import_joi33 = __toESM(require("joi"));
+var import_utils53 = require("@goweekdays/utils");
+var import_joi39 = __toESM(require("joi"));
 function useBuildingUnitController() {
   const {
     getAll: _getAll,
@@ -8877,27 +9651,27 @@ function useBuildingUnitController() {
   const { add: _add } = useBuildingUnitService();
   async function add(req, res, next) {
     const data = req.body;
-    const validation = import_joi33.default.object({
-      building: import_joi33.default.object({
-        school: import_joi33.default.string().hex().required(),
-        name: import_joi33.default.string().optional().allow("", null),
-        building: import_joi33.default.string().hex().required(),
-        buildingName: import_joi33.default.string().optional().allow("", null),
-        level: import_joi33.default.number().integer().min(1).required(),
-        category: import_joi33.default.string().required(),
-        type: import_joi33.default.string().required(),
-        seating_capacity: import_joi33.default.number().integer().min(0).required(),
-        standing_capacity: import_joi33.default.number().integer().min(0).required(),
-        description: import_joi33.default.string().optional().allow("", null),
-        unit_of_measurement: import_joi33.default.string().valid("sqm").required(),
-        area: import_joi33.default.number().positive().required(),
-        status: import_joi33.default.string().optional().allow("", null)
+    const validation = import_joi39.default.object({
+      building: import_joi39.default.object({
+        school: import_joi39.default.string().hex().required(),
+        name: import_joi39.default.string().optional().allow("", null),
+        building: import_joi39.default.string().hex().required(),
+        buildingName: import_joi39.default.string().optional().allow("", null),
+        level: import_joi39.default.number().integer().min(1).required(),
+        category: import_joi39.default.string().required(),
+        type: import_joi39.default.string().required(),
+        seating_capacity: import_joi39.default.number().integer().min(0).required(),
+        standing_capacity: import_joi39.default.number().integer().min(0).required(),
+        description: import_joi39.default.string().optional().allow("", null),
+        unit_of_measurement: import_joi39.default.string().valid("sqm").required(),
+        area: import_joi39.default.number().positive().required(),
+        status: import_joi39.default.string().optional().allow("", null)
       }),
-      qty: import_joi33.default.number().integer().min(1).max(20).optional().default(1)
+      qty: import_joi39.default.number().integer().min(1).max(20).optional().default(1)
     });
     const { error } = validation.validate(data);
     if (error) {
-      next(new import_utils48.BadRequestError(error.message));
+      next(new import_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -8913,13 +9687,13 @@ function useBuildingUnitController() {
   async function updateById(req, res, next) {
     const data = req.body;
     const id = req.params.id ?? "";
-    const validation = import_joi33.default.object({
-      id: import_joi33.default.string().hex().required(),
+    const validation = import_joi39.default.object({
+      id: import_joi39.default.string().hex().required(),
       value: schemaUpdateOptions
     });
     const { error } = validation.validate({ id, value: data });
     if (error) {
-      next(new import_utils48.BadRequestError(error.message));
+      next(new import_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -8934,17 +9708,17 @@ function useBuildingUnitController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi33.default.object({
-      page: import_joi33.default.number().min(1).optional().allow("", null),
-      limit: import_joi33.default.number().min(1).optional().allow("", null),
-      search: import_joi33.default.string().optional().allow("", null),
-      school: import_joi33.default.string().hex().optional().allow("", null),
-      building: import_joi33.default.string().hex().optional().allow("", null),
-      status: import_joi33.default.string().optional().allow("", null)
+    const validation = import_joi39.default.object({
+      page: import_joi39.default.number().min(1).optional().allow("", null),
+      limit: import_joi39.default.number().min(1).optional().allow("", null),
+      search: import_joi39.default.string().optional().allow("", null),
+      school: import_joi39.default.string().hex().optional().allow("", null),
+      building: import_joi39.default.string().hex().optional().allow("", null),
+      status: import_joi39.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils48.BadRequestError(error.message));
+      next(new import_utils53.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -8980,12 +9754,12 @@ function useBuildingUnitController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi33.default.object({
-      id: import_joi33.default.string().hex().required()
+    const validation = import_joi39.default.object({
+      id: import_joi39.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils48.BadRequestError(error.message));
+      next(new import_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -9001,12 +9775,12 @@ function useBuildingUnitController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi33.default.object({
-      id: import_joi33.default.string().hex().required()
+    const validation = import_joi39.default.object({
+      id: import_joi39.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils48.BadRequestError(error.message));
+      next(new import_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -9027,14 +9801,14 @@ function useBuildingUnitController() {
 }
 
 // src/resources/counter/counter.model.ts
-var import_utils49 = require("@goweekdays/utils");
-var import_mongodb23 = require("mongodb");
+var import_utils54 = require("@goweekdays/utils");
+var import_mongodb25 = require("mongodb");
 var import_zod = require("zod");
 var TCounter = import_zod.z.object({
   _id: import_zod.z.union([
     import_zod.z.string().length(24, "Invalid ObjectId hex string"),
-    import_zod.z.instanceof(import_mongodb23.ObjectId)
-  ]).transform((val) => typeof val === "string" ? new import_mongodb23.ObjectId(val) : val).optional(),
+    import_zod.z.instanceof(import_mongodb25.ObjectId)
+  ]).transform((val) => typeof val === "string" ? new import_mongodb25.ObjectId(val) : val).optional(),
   count: import_zod.z.number().int().min(0).default(0),
   type: import_zod.z.string(),
   createdAt: import_zod.z.date().optional().default(() => /* @__PURE__ */ new Date()),
@@ -9047,7 +9821,7 @@ function useCounterModel(db) {
     try {
       return TCounter.parse(value);
     } catch (error) {
-      throw new import_utils49.BadRequestError(error.issues[0].message);
+      throw new import_utils54.BadRequestError(error.issues[0].message);
     }
   }
   function validateCounter(data) {
@@ -9061,23 +9835,23 @@ function useCounterModel(db) {
 }
 
 // src/resources/counter/counter.repository.ts
-var import_utils50 = require("@goweekdays/utils");
+var import_utils55 = require("@goweekdays/utils");
 function useCounterRepo() {
-  const db = import_utils50.useAtlas.getDb();
+  const db = import_utils55.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "counters";
   const { collection, createCounter } = useCounterModel(db);
-  const { getCache, setCache, delNamespace } = (0, import_utils50.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils55.useCache)(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils50.logger.log({
+      import_utils55.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils50.logger.log({
+      import_utils55.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -9121,11 +9895,11 @@ function useCounterRepo() {
     }
   }
   async function getByType(type) {
-    const cacheKey = (0, import_utils50.makeCacheKey)(namespace_collection, { type });
+    const cacheKey = (0, import_utils55.makeCacheKey)(namespace_collection, { type });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils50.logger.log({
+        import_utils55.logger.log({
           level: "info",
           message: `Cache hit for getByType counter: ${cacheKey}`
         });
@@ -9134,12 +9908,12 @@ function useCounterRepo() {
       const data = await collection.findOne({ type });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          import_utils50.logger.log({
+          import_utils55.logger.log({
             level: "info",
             message: `Cache set for counter by type: ${cacheKey}`
           });
         }).catch((err) => {
-          import_utils50.logger.log({
+          import_utils55.logger.log({
             level: "error",
             message: `Failed to set cache for counter by type: ${err.message}`
           });
@@ -9159,7 +9933,7 @@ function useCounterRepo() {
 }
 
 // src/resources/file/file.service.ts
-var import_utils51 = require("@goweekdays/utils");
+var import_utils56 = require("@goweekdays/utils");
 var import_node_cron = __toESM(require("node-cron"));
 var fs = __toESM(require("fs"));
 function useFileService() {
@@ -9168,7 +9942,7 @@ function useFileService() {
     deleteFileById,
     getAllDraftedFiles
   } = useFileRepo();
-  const s3 = new import_utils51.useS3({
+  const s3 = new import_utils56.useS3({
     accessKeyId: SPACES_ACCESS_KEY,
     secretAccessKey: SPACES_SECRET_KEY,
     endpoint: SPACES_ENDPOINT,
@@ -9177,7 +9951,7 @@ function useFileService() {
     forcePathStyle: true
   });
   async function createFile(value) {
-    const session = import_utils51.useAtlas.getClient()?.startSession();
+    const session = import_utils56.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     const file = {
       name: value.originalname,
@@ -9211,7 +9985,7 @@ function useFileService() {
     }
   }
   async function deleteFile(id) {
-    const session = import_utils51.useAtlas.getClient()?.startSession();
+    const session = import_utils56.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       await deleteFileById(id, session);
@@ -9232,12 +10006,12 @@ function useFileService() {
         const file = files[index];
         try {
           await deleteFile(file._id.toString());
-          await import_utils51.logger.log({
+          await import_utils56.logger.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
         } catch (error) {
-          import_utils51.logger.log({
+          import_utils56.logger.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
@@ -9254,8 +10028,8 @@ function useFileService() {
 }
 
 // src/resources/file/file.controller.ts
-var import_utils52 = require("@goweekdays/utils");
-var import_joi34 = __toESM(require("joi"));
+var import_utils57 = require("@goweekdays/utils");
+var import_joi40 = __toESM(require("joi"));
 function useFileController() {
   const { createFile, deleteFile: _deleteFile } = useFileService();
   async function upload(req, res, next) {
@@ -9268,29 +10042,29 @@ function useFileController() {
       res.json({ message: "Successfully uploaded file", id });
       return;
     } catch (error) {
-      if (error instanceof import_utils52.AppError) {
+      if (error instanceof import_utils57.AppError) {
         next(error);
       } else {
-        next(new import_utils52.InternalServerError(error));
+        next(new import_utils57.InternalServerError(error));
       }
     }
   }
   async function deleteFile(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi34.default.string().required();
+    const validation = import_joi40.default.string().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils52.BadRequestError(error.message));
+      next(new import_utils57.BadRequestError(error.message));
     }
     try {
       const message = await _deleteFile(id);
       res.json({ message });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils52.AppError) {
+      if (error2 instanceof import_utils57.AppError) {
         next(error2);
       } else {
-        next(new import_utils52.InternalServerError(error2));
+        next(new import_utils57.InternalServerError(error2));
       }
     }
   }
@@ -9301,35 +10075,35 @@ function useFileController() {
 }
 
 // src/resources/promo/promo.model.ts
-var import_joi35 = __toESM(require("joi"));
-var schemaPromo = import_joi35.default.object({
-  code: import_joi35.default.string().min(3).max(50).required(),
-  description: import_joi35.default.string().max(255).optional().allow("", null),
-  type: import_joi35.default.string().valid("flat", "fixed", "tiered").required(),
-  flatRate: import_joi35.default.number().positive().when("type", {
+var import_joi41 = __toESM(require("joi"));
+var schemaPromo = import_joi41.default.object({
+  code: import_joi41.default.string().min(3).max(50).required(),
+  description: import_joi41.default.string().max(255).optional().allow("", null),
+  type: import_joi41.default.string().valid("flat", "fixed", "tiered").required(),
+  flatRate: import_joi41.default.number().positive().when("type", {
     is: "flat",
-    then: import_joi35.default.required(),
-    otherwise: import_joi35.default.forbidden()
+    then: import_joi41.default.required(),
+    otherwise: import_joi41.default.forbidden()
   }).optional().allow(null, 0),
-  fixedRate: import_joi35.default.number().positive().when("type", {
+  fixedRate: import_joi41.default.number().positive().when("type", {
     is: "fixed",
-    then: import_joi35.default.required(),
-    otherwise: import_joi35.default.forbidden()
+    then: import_joi41.default.required(),
+    otherwise: import_joi41.default.forbidden()
   }).optional().allow(null, 0),
-  tiers: import_joi35.default.array().items(
-    import_joi35.default.object({
-      minSeats: import_joi35.default.number().integer().min(1).required(),
-      maxSeats: import_joi35.default.number().integer().min(import_joi35.default.ref("minSeats")).required(),
-      rate: import_joi35.default.number().positive().required()
+  tiers: import_joi41.default.array().items(
+    import_joi41.default.object({
+      minSeats: import_joi41.default.number().integer().min(1).required(),
+      maxSeats: import_joi41.default.number().integer().min(import_joi41.default.ref("minSeats")).required(),
+      rate: import_joi41.default.number().positive().required()
     })
   ).when("type", {
     is: "tiered",
-    then: import_joi35.default.required(),
-    otherwise: import_joi35.default.forbidden()
+    then: import_joi41.default.required(),
+    otherwise: import_joi41.default.forbidden()
   }),
-  currency: import_joi35.default.string().length(3).required(),
-  startDate: import_joi35.default.date().required(),
-  endDate: import_joi35.default.date().greater(import_joi35.default.ref("startDate")).optional().allow(null, "")
+  currency: import_joi41.default.string().length(3).required(),
+  startDate: import_joi41.default.date().required(),
+  endDate: import_joi41.default.date().greater(import_joi41.default.ref("startDate")).optional().allow(null, "")
 });
 function modelPromo(data) {
   const { error } = schemaPromo.validate(data);
@@ -9357,25 +10131,25 @@ function modelPromo(data) {
 }
 
 // src/resources/promo/promo.repository.ts
-var import_utils53 = require("@goweekdays/utils");
-var import_joi36 = __toESM(require("joi"));
-var import_mongodb24 = require("mongodb");
+var import_utils58 = require("@goweekdays/utils");
+var import_joi42 = __toESM(require("joi"));
+var import_mongodb26 = require("mongodb");
 function usePromoRepo() {
-  const db = import_utils53.useAtlas.getDb();
+  const db = import_utils58.useAtlas.getDb();
   if (!db) {
-    throw new import_utils53.InternalServerError("Unable to connect to server.");
+    throw new import_utils58.InternalServerError("Unable to connect to server.");
   }
   const namespace_collection = "users";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils53.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils58.useCache)(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils53.logger.log({
+      import_utils58.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils53.logger.log({
+      import_utils58.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -9407,7 +10181,7 @@ function usePromoRepo() {
       delCachedData();
       return "Successfully added promo.";
     } catch (error) {
-      throw new import_utils53.InternalServerError("Failed to add promo.");
+      throw new import_utils58.InternalServerError("Failed to add promo.");
     }
   }
   async function getAll({
@@ -9428,7 +10202,7 @@ function usePromoRepo() {
     if (search) {
       query.$text = { $search: search };
     }
-    const cacheKey = (0, import_utils53.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    const cacheKey = (0, import_utils58.makeCacheKey)(namespace_collection, cacheKeyOptions);
     try {
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
@@ -9440,30 +10214,30 @@ function usePromoRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils53.paginate)(items, page, limit, length);
+      const data = (0, import_utils58.paginate)(items, page, limit, length);
       setCache(cacheKey, data).then(() => {
-        import_utils53.logger.log({
+        import_utils58.logger.log({
           level: "info",
           message: `Cache set for getAll promo: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils53.logger.log({
+        import_utils58.logger.log({
           level: "error",
           message: `Failed to set cache for getAll promo: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      throw new import_utils53.InternalServerError("Failed to get promos.");
+      throw new import_utils58.InternalServerError("Failed to get promos.");
     }
   }
   async function getByCode(code) {
-    const { error } = import_joi36.default.string().min(3).max(50).required().validate(code);
+    const { error } = import_joi42.default.string().min(3).max(50).required().validate(code);
     if (error) {
       throw new Error(`Invalid promo code: ${error.message}`);
     }
     try {
-      const cacheKey = (0, import_utils53.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_utils58.makeCacheKey)(namespace_collection, {
         code,
         tag: "getByCode"
       });
@@ -9476,33 +10250,33 @@ function usePromoRepo() {
         status: { $ne: "deleted" }
       });
       setCache(cacheKey, data).then(() => {
-        import_utils53.logger.log({
+        import_utils58.logger.log({
           level: "info",
           message: `Cache set for getByCode promo: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils53.logger.log({
+        import_utils58.logger.log({
           level: "error",
           message: `Failed to set cache for getByCode promo: ${err.message}`
         });
       });
       return data;
     } catch (error2) {
-      throw new import_utils53.InternalServerError("Failed to get promo.");
+      throw new import_utils58.InternalServerError("Failed to get promo.");
     }
   }
   async function getById(_id) {
-    const { error } = import_joi36.default.string().hex().length(24).required().validate(_id);
+    const { error } = import_joi42.default.string().hex().length(24).required().validate(_id);
     if (error) {
       throw new Error(`Invalid promo ID: ${error.message}`);
     }
     try {
-      _id = new import_mongodb24.ObjectId(_id);
+      _id = new import_mongodb26.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils53.BadRequestError("Invalid promo ID.");
+      throw new import_utils58.BadRequestError("Invalid promo ID.");
     }
     try {
-      const cacheKey = (0, import_utils53.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_utils58.makeCacheKey)(namespace_collection, {
         _id: String(_id),
         tag: "getById"
       });
@@ -9515,30 +10289,30 @@ function usePromoRepo() {
         status: { $ne: "deleted" }
       });
       setCache(cacheKey, data).then(() => {
-        import_utils53.logger.log({
+        import_utils58.logger.log({
           level: "info",
           message: `Cache set for getById promo: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils53.logger.log({
+        import_utils58.logger.log({
           level: "error",
           message: `Failed to set cache for getById promo: ${err.message}`
         });
       });
       return data;
     } catch (error2) {
-      throw new import_utils53.InternalServerError("Failed to get promo.");
+      throw new import_utils58.InternalServerError("Failed to get promo.");
     }
   }
   async function deleteById(_id) {
-    const { error } = import_joi36.default.string().hex().length(24).required().validate(_id);
+    const { error } = import_joi42.default.string().hex().length(24).required().validate(_id);
     if (error) {
       throw new Error(`Invalid promo ID: ${error.message}`);
     }
     try {
-      _id = new import_mongodb24.ObjectId(_id);
+      _id = new import_mongodb26.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils53.BadRequestError("Invalid promo ID.");
+      throw new import_utils58.BadRequestError("Invalid promo ID.");
     }
     try {
       const result = await collection.updateOne(
@@ -9546,15 +10320,15 @@ function usePromoRepo() {
         { $set: { status: "deleted" } }
       );
       if (result.modifiedCount === 0) {
-        throw new import_utils53.InternalServerError("Failed to delete promo.");
+        throw new import_utils58.InternalServerError("Failed to delete promo.");
       }
       delCachedData();
       return "Successfully deleted promo.";
     } catch (error2) {
-      if (error2 instanceof import_utils53.AppError) {
+      if (error2 instanceof import_utils58.AppError) {
         throw error2;
       }
-      throw new import_utils53.InternalServerError("Failed to delete promo.");
+      throw new import_utils58.InternalServerError("Failed to delete promo.");
     }
   }
   return {
@@ -9568,7 +10342,7 @@ function usePromoRepo() {
 }
 
 // src/resources/utils/github.service.ts
-var import_utils54 = require("@goweekdays/utils");
+var import_utils59 = require("@goweekdays/utils");
 var import_rest = require("@octokit/rest");
 var import_libsodium_wrappers = __toESM(require("libsodium-wrappers"));
 function useGitHubService() {
@@ -9582,23 +10356,23 @@ function useGitHubService() {
     try {
       const { data: repoData } = await octokit.repos.get({ owner, repo });
       if (!repoData.permissions?.admin) {
-        throw new import_utils54.BadRequestError(
+        throw new import_utils59.BadRequestError(
           "You do not have admin access to this repository."
         );
       }
     } catch (error) {
       if (error.status === 404) {
-        throw new import_utils54.BadRequestError(
+        throw new import_utils59.BadRequestError(
           "Repository not found or you don't have access to it."
         );
       } else if (error.status === 401) {
-        throw new import_utils54.BadRequestError(
+        throw new import_utils59.BadRequestError(
           "Invalid GitHub token or insufficient permissions."
         );
       } else if (error.message.includes("admin access")) {
         throw error;
       } else {
-        throw new import_utils54.BadRequestError(
+        throw new import_utils59.BadRequestError(
           `Failed to check repository permissions: ${error.message}`
         );
       }
@@ -9647,7 +10421,7 @@ function useGitHubService() {
               key_id: publicKeyRes.key_id
             });
           } catch (encryptionError) {
-            throw new import_utils54.BadRequestError(
+            throw new import_utils59.BadRequestError(
               `Failed to encrypt secret '${key}': ${encryptionError.message}`
             );
           }
@@ -9677,22 +10451,22 @@ function useGitHubService() {
       }
       return `Successfully set ${lines.length} ${type} variables/secrets in environment '${environment}'`;
     } catch (error) {
-      if (error instanceof import_utils54.AppError)
+      if (error instanceof import_utils59.AppError)
         throw error;
       if (error.status === 422) {
-        throw new import_utils54.BadRequestError(
+        throw new import_utils59.BadRequestError(
           `GitHub API validation error: ${error.message}`
         );
       } else if (error.status === 404) {
-        throw new import_utils54.BadRequestError("Environment or repository not found.");
+        throw new import_utils59.BadRequestError("Environment or repository not found.");
       } else if (error.status === 403) {
-        throw new import_utils54.BadRequestError(
+        throw new import_utils59.BadRequestError(
           "Forbidden: Insufficient permissions or rate limit exceeded."
         );
       } else if (error.message.includes("admin access") || error.message.includes("permissions")) {
         throw error;
       } else {
-        throw new import_utils54.BadRequestError(
+        throw new import_utils59.BadRequestError(
           `Failed to set GitHub variables: ${error.message}`
         );
       }
@@ -9704,8 +10478,8 @@ function useGitHubService() {
 }
 
 // src/resources/utils/util.controller.ts
-var import_joi37 = __toESM(require("joi"));
-var import_utils55 = require("@goweekdays/utils");
+var import_joi43 = __toESM(require("joi"));
+var import_utils60 = require("@goweekdays/utils");
 function useUtilController() {
   async function healthCheck(req, res, next) {
     try {
@@ -9721,32 +10495,32 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_utils55.logger.error("Health check failed", { error: error.message });
-      next(new import_utils55.InternalServerError("Health check failed"));
+      import_utils60.logger.error("Health check failed", { error: error.message });
+      next(new import_utils60.InternalServerError("Health check failed"));
     }
   }
   async function setGitHubVariables(req, res, next) {
     try {
       const { githubToken, repoUrl, environment, type, keyValues } = req.body;
-      const validation = import_joi37.default.object({
-        githubToken: import_joi37.default.string().required().messages({
+      const validation = import_joi43.default.object({
+        githubToken: import_joi43.default.string().required().messages({
           "string.empty": "GitHub token is required",
           "any.required": "GitHub token is required"
         }),
-        repoUrl: import_joi37.default.string().uri().required().messages({
+        repoUrl: import_joi43.default.string().uri().required().messages({
           "string.empty": "Repository URL is required",
           "string.uri": "Repository URL must be a valid URL",
           "any.required": "Repository URL is required"
         }),
-        environment: import_joi37.default.string().required().messages({
+        environment: import_joi43.default.string().required().messages({
           "string.empty": "Environment name is required",
           "any.required": "Environment name is required"
         }),
-        type: import_joi37.default.string().valid("env", "secret").required().messages({
+        type: import_joi43.default.string().valid("env", "secret").required().messages({
           "any.only": 'Type must be either "env" or "secret"',
           "any.required": "Type is required"
         }),
-        keyValues: import_joi37.default.string().required().messages({
+        keyValues: import_joi43.default.string().required().messages({
           "string.empty": "Key-value pairs are required",
           "any.required": "Key-value pairs are required"
         })
@@ -9759,13 +10533,13 @@ function useUtilController() {
         keyValues
       });
       if (error) {
-        next(new import_utils55.BadRequestError(error.message));
+        next(new import_utils60.BadRequestError(error.message));
         return;
       }
       const repoUrlPattern = /github\.com[:\/]([^\/]+)\/(.+)\.git$/;
       if (!repoUrlPattern.test(repoUrl)) {
         next(
-          new import_utils55.BadRequestError(
+          new import_utils60.BadRequestError(
             "Invalid GitHub repository URL format. Expected format: https://github.com/owner/repo.git"
           )
         );
@@ -9777,7 +10551,7 @@ function useUtilController() {
       );
       if (invalidLines.length > 0) {
         next(
-          new import_utils55.BadRequestError(
+          new import_utils60.BadRequestError(
             "Invalid key-value format. Each pair should be in format: KEY=value. Pairs should be separated by semicolons."
           )
         );
@@ -9791,7 +10565,7 @@ function useUtilController() {
         type,
         keyValues
       });
-      import_utils55.logger.info(`GitHub variables set successfully`, {
+      import_utils60.logger.info(`GitHub variables set successfully`, {
         repoUrl,
         environment,
         type,
@@ -9808,35 +10582,63 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_utils55.logger.error("Failed to set GitHub variables", {
+      import_utils60.logger.error("Failed to set GitHub variables", {
         error: error.message,
         stack: error.stack
       });
-      if (error instanceof import_utils55.AppError) {
+      if (error instanceof import_utils60.AppError) {
         next(error);
       } else {
         next(
-          new import_utils55.InternalServerError(
+          new import_utils60.InternalServerError(
             `Failed to set GitHub variables: ${error.message}`
           )
         );
       }
     }
   }
-  const { verifyWebhook } = usePaypalService();
+  const { verifySignature, captureOrder } = usePaypalService();
+  const { addWithVerification } = useOrgService();
   async function paypalWebhook(req, res, next) {
-    console.log(req);
     try {
-      await verifyWebhook(req.body, req.headers, PAYPAL_WEBHOOK_ID);
-      res.status(200).send("OK");
+      const isSignatureValid = await verifySignature(
+        req.body,
+        req.headers,
+        PAYPAL_WEBHOOK_ID
+      );
+      if (isSignatureValid) {
+        const payload = JSON.parse(req.body);
+        const eventType = payload.event_type;
+        const resource = payload.resource;
+        switch (eventType) {
+          case "CHECKOUT.ORDER.APPROVED": {
+            const orderId = resource.id;
+            await captureOrder(orderId);
+            break;
+          }
+          case "PAYMENT.CAPTURE.COMPLETED": {
+            const customId = resource?.custom_id || resource?.purchase_units?.[0]?.custom_id;
+            if (!customId) {
+              throw new Error("Missing PayPal customId");
+            }
+            await addWithVerification(customId);
+            break;
+          }
+          default:
+            break;
+        }
+      } else {
+        next(new import_utils60.BadRequestError("Invalid PayPal webhook signature."));
+        return;
+      }
+      res.sendStatus(200);
       return;
     } catch (error) {
-      import_utils55.logger.log({
+      import_utils60.logger.log({
         level: "error",
-        message: "PayPal webhook verification failed"
+        message: `${error}`
       });
-      res.status(400).send("Invalid webhook");
-      return;
+      next(new import_utils60.InternalServerError(`PayPal webhook error: ${error.message}`));
     }
   }
   return {
@@ -9847,256 +10649,234 @@ function useUtilController() {
 }
 
 // src/resources/utils/transaction.schema.ts
-var import_joi38 = __toESM(require("joi"));
-var transactionSchema = import_joi38.default.object({
-  _id: import_joi38.default.string().hex().optional().allow("", null),
-  payment: import_joi38.default.string().required(),
-  user: import_joi38.default.string().hex().optional().allow("", null),
-  org: import_joi38.default.string().hex().optional().allow("", null),
-  type: import_joi38.default.string().required(),
-  amount: import_joi38.default.number().positive().min(0).required(),
-  currency: import_joi38.default.string().required(),
-  description: import_joi38.default.string().optional().allow("", null),
-  metadata: import_joi38.default.object({
-    subscriptionId: import_joi38.default.string().hex().optional().allow("", null),
-    cycle: import_joi38.default.number().optional().allow("", null),
-    seats: import_joi38.default.number().optional().allow("", null),
-    promoCode: import_joi38.default.string().optional().allow("", null)
+var import_joi44 = __toESM(require("joi"));
+var transactionSchema = import_joi44.default.object({
+  _id: import_joi44.default.string().hex().optional().allow("", null),
+  payment: import_joi44.default.string().required(),
+  user: import_joi44.default.string().hex().optional().allow("", null),
+  org: import_joi44.default.string().hex().optional().allow("", null),
+  type: import_joi44.default.string().required(),
+  amount: import_joi44.default.number().positive().min(0).required(),
+  currency: import_joi44.default.string().required(),
+  description: import_joi44.default.string().optional().allow("", null),
+  metadata: import_joi44.default.object({
+    subscriptionId: import_joi44.default.string().hex().optional().allow("", null),
+    cycle: import_joi44.default.number().optional().allow("", null),
+    seats: import_joi44.default.number().optional().allow("", null),
+    promoCode: import_joi44.default.string().optional().allow("", null)
   }).optional().allow("", null),
-  status: import_joi38.default.string().optional().allow("", null),
-  createdAt: import_joi38.default.string().optional().allow("", null),
-  updatedAt: import_joi38.default.string().optional().allow("", null),
-  deletedAt: import_joi38.default.string().optional().allow("", null)
+  status: import_joi44.default.string().optional().allow("", null),
+  createdAt: import_joi44.default.string().optional().allow("", null),
+  updatedAt: import_joi44.default.string().optional().allow("", null),
+  deletedAt: import_joi44.default.string().optional().allow("", null)
 });
 
-// src/resources/verification/verification.controller.ts
-var import_utils56 = require("@goweekdays/utils");
-var import_joi39 = __toESM(require("joi"));
-function useVerificationController() {
-  const {
-    createUserInvite: _createUserInvite,
-    createForgetPassword: _createForgetPassword,
-    cancelUserInvitation: _cancelUserInvitation,
-    verify: _verify,
-    inviteMember: _inviteMember,
-    signUp: _signUp,
-    cancelInviteMember: _cancelInviteMember,
-    forgetPassword: _forgetPassword
-  } = useVerificationService();
-  const { getVerifications: _getVerifications } = useVerificationRepo();
-  async function createUserInvite(req, res, next) {
-    const validation = import_joi39.default.object({
-      email: import_joi39.default.string().email().required(),
-      app: import_joi39.default.string().required(),
-      role: import_joi39.default.string().hex().required(),
-      roleName: import_joi39.default.string().required(),
-      org: import_joi39.default.string().hex().optional().optional().allow("", null),
-      orgName: import_joi39.default.string().optional().optional().allow("", null)
-    });
-    const { error } = validation.validate(req.body);
-    if (error) {
-      next(new import_utils56.BadRequestError(error.message));
-      return;
-    }
-    const email = req.body.email ?? "";
-    const app = req.body.app ?? "";
-    const role = req.body.role ?? "";
-    const roleName = req.body.roleName ?? "";
-    const org = req.body.org ?? "";
-    const orgName = req.body.orgName ?? "";
-    try {
-      await _createUserInvite({
-        email,
-        metadata: {
-          app,
-          role,
-          roleName,
-          org,
-          orgName
-        }
-      });
-      res.json({ message: "Successfully invited user." });
-      return;
-    } catch (error2) {
-      next(error2);
-    }
+// src/resources/job-post/job.post.model.ts
+var import_utils61 = require("@goweekdays/utils");
+var import_joi45 = __toESM(require("joi"));
+var import_mongodb27 = require("mongodb");
+var schemaJobPost = import_joi45.default.object({
+  _id: import_joi45.default.string().hex().optional(),
+  org: import_joi45.default.string().hex().optional(),
+  title: import_joi45.default.string().trim().required(),
+  setup: import_joi45.default.string().trim().required(),
+  location: import_joi45.default.string().trim().required(),
+  type: import_joi45.default.string().trim().required(),
+  description: import_joi45.default.string().trim().required(),
+  status: import_joi45.default.string().trim().required(),
+  createdAt: import_joi45.default.date().optional(),
+  updatedAt: import_joi45.default.date().optional(),
+  deletedAt: import_joi45.default.date().optional()
+});
+function modelJobPost(value) {
+  const { error } = schemaJobPost.validate(value);
+  if (error) {
+    throw new import_utils61.BadRequestError(`Invalid job post: ${error.message}`);
   }
-  async function createForgetPassword(req, res, next) {
-    const email = req.body.email || "";
-    const validation = import_joi39.default.string().email().required();
-    const { error } = validation.validate(email);
-    if (error) {
-      next(new import_utils56.BadRequestError(error.message));
-      return;
-    }
+  if (!value._id) {
     try {
-      await _createForgetPassword(email);
-      res.json({
-        message: "Check your email to verify it before resetting your password."
-      });
-      return;
+      value._id = new import_mongodb27.ObjectId();
     } catch (error2) {
-      if (error2 instanceof import_utils56.AppError) {
-        next(error2);
-      } else {
-        next(new import_utils56.InternalServerError("An unexpected error occurred"));
-      }
+      throw new import_utils61.BadRequestError("Invalid job post ID.");
     }
   }
-  async function getVerifications(req, res, next) {
-    const validation = import_joi39.default.object({
-      status: import_joi39.default.string().required(),
-      search: import_joi39.default.string().optional().allow("", null),
-      page: import_joi39.default.number().required(),
-      type: import_joi39.default.string().optional().allow("", null),
-      email: import_joi39.default.string().optional().allow("", null),
-      app: import_joi39.default.string().optional().allow("", null),
-      org: import_joi39.default.string().optional().allow("", null)
-    });
-    const { error } = validation.validate(req.query);
-    if (error) {
-      next(new import_utils56.BadRequestError(error.message));
-      return;
-    }
-    const status = req.query.status ?? "";
-    const search = req.query.search ?? "";
-    const page = Number(req.query.page) ?? 1;
-    let type = req.query.type ?? "";
-    const email = req.query.email ?? "";
-    const app = req.query.app ?? "";
-    const org = req.query.org ?? "";
-    const hasMultipleTypes = type.includes(",");
-    let splitType = [];
-    if (hasMultipleTypes) {
-      splitType = type.split(",");
-    }
-    try {
-      const items = await _getVerifications({
-        status,
-        search,
-        page,
-        type: hasMultipleTypes ? splitType : type,
-        email,
-        app,
-        org
+  try {
+    value.org = new import_mongodb27.ObjectId(value.org);
+  } catch (error2) {
+    throw new import_utils61.BadRequestError("Invalid Org ID");
+  }
+  return {
+    _id: value._id,
+    org: value.org,
+    title: value.title,
+    setup: value.setup,
+    location: value.location,
+    type: value.type,
+    description: value.description,
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt,
+    deletedAt: value.deletedAt
+  };
+}
+
+// src/resources/job-post/job.post.controller.ts
+var import_utils64 = require("@goweekdays/utils");
+
+// src/resources/job-post/job.post.repository.ts
+var import_utils62 = require("@goweekdays/utils");
+var import_mongodb28 = require("mongodb");
+function useJobPostRepo() {
+  const db = import_utils62.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils62.BadRequestError("Unable to connect to server.");
+  }
+  const namespace_collection = "job.posts";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace } = (0, import_utils62.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils62.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
       });
-      res.json(items);
-      return;
-    } catch (error2) {
-      next(error2);
-    }
+    }).catch((err) => {
+      import_utils62.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
   }
-  async function verify(req, res, next) {
-    const id = req.params.id || "";
-    const validation = import_joi39.default.string().hex().required();
-    const { error } = validation.validate(id);
-    if (error) {
-      next(new import_utils56.BadRequestError(error.message));
-      return;
-    }
+  async function createIndexes() {
     try {
-      const message = await _verify(id);
-      res.json(message);
-      return;
-    } catch (error2) {
-      next(error2);
+      await collection.createIndexes([
+        { key: { title: 1 } },
+        { key: { setup: 1 } },
+        { key: { location: 1 } },
+        { key: { type: 1 } },
+        {
+          key: {
+            title: "text",
+            setup: "text",
+            location: "text",
+            type: "text"
+          },
+          name: "jobpost_text_search"
+        }
+      ]);
+      return "Successfully created job post indexes.";
+    } catch (error) {
+      throw new import_utils62.BadRequestError("Failed to create job post indexes.");
     }
   }
-  async function cancelUserInvitation(req, res, next) {
-    const otpId = req.params.id || "";
-    const validation = import_joi39.default.string().hex().required();
-    const { error } = validation.validate(otpId);
-    if (error) {
-      next(new import_utils56.BadRequestError(error.message));
-      return;
-    }
+  async function add(value, session) {
     try {
-      await _cancelUserInvitation(otpId);
-      return res.json({
-        message: "User invite has been cancelled."
+      value = modelJobPost(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_utils62.logger.log({
+        level: "error",
+        message: error.message
       });
-    } catch (error2) {
-      throw error2;
+      throw new import_utils62.BadRequestError(`Failed to create job post: ${error.message}`);
     }
   }
-  async function signUp(req, res, next) {
-    const validation = import_joi39.default.string().email().required();
-    const { error } = validation.validate(req.body.email);
-    if (error) {
-      next(new import_utils56.BadRequestError(error.message));
-      return;
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb28.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils62.BadRequestError("Invalid ID.");
     }
-    const email = req.body.email ?? "";
     try {
-      await _signUp({ email });
-      res.json({ message: "Successfully signed up user." });
-      return;
-    } catch (error2) {
-      next(error2);
+      await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: "deleted",
+            updatedAt: /* @__PURE__ */ new Date(),
+            deletedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { session }
+      );
+      delCachedData();
+      return "Successfully deleted job post.";
+    } catch (error) {
+      throw new import_utils62.InternalServerError("Failed to delete job post.");
     }
   }
-  async function inviteMember(req, res, next) {
-    const { error } = schemaInviteMember.validate(req.body);
+  return {
+    createIndexes,
+    add,
+    deleteById
+  };
+}
+
+// src/resources/job-post/job.post.service.ts
+var import_utils63 = require("@goweekdays/utils");
+var import_joi46 = __toESM(require("joi"));
+function useJobPostService() {
+  const { deleteById: _deleteById } = useJobPostRepo();
+  async function deleteById(id) {
+    const { error } = import_joi46.default.string().hex().required().validate(id);
     if (error) {
-      next(new import_utils56.BadRequestError(error.message));
-      return;
+      throw new import_utils63.BadRequestError(error.message);
     }
     try {
-      await _inviteMember(req.body);
-      res.json({ message: "Successfully invited member." });
-      return;
+      await _deleteById(id);
+      return "Successfully deleted job post.";
     } catch (error2) {
-      next(error2);
+      if (error2 instanceof import_utils63.AppError) {
+        throw error2;
+      } else {
+        throw new import_utils63.InternalServerError("Failed to delete job post.");
+      }
     }
   }
-  async function cancelInviteMember(req, res, next) {
-    const id = req.params.id || "";
-    const validation = import_joi39.default.string().hex().required();
-    const { error } = validation.validate(id);
+  return {
+    deleteById
+  };
+}
+
+// src/resources/job-post/job.post.controller.ts
+function useJobPostController() {
+  const { add: _add } = useJobPostRepo();
+  const { deleteById: _deleteById } = useJobPostService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaJobPost.validate(value);
     if (error) {
-      next(new import_utils56.BadRequestError(error.message));
+      next(new import_utils64.BadRequestError(error.message));
+      import_utils64.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
-      const message = await _cancelInviteMember(id);
-      res.json({ message });
+      const result = await _add(value);
+      res.json({ message: "Successfully created job post.", data: { result } });
       return;
     } catch (error2) {
       next(error2);
     }
   }
-  async function forgetPassword(req, res, next) {
-    const email = req.body.email ?? "";
-    const validation = import_joi39.default.string().email().required();
-    const { error } = validation.validate(email);
-    if (error) {
-      next(new import_utils56.BadRequestError(error.message));
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    if (!id) {
+      next(new import_utils64.BadRequestError("Job Post ID is required."));
       return;
     }
     try {
-      const message = await _forgetPassword(email);
-      res.json({
-        message
-      });
+      const message = await _deleteById(id);
+      res.json(message);
       return;
-    } catch (error2) {
-      if (error2 instanceof import_utils56.AppError) {
-        next(error2);
-      } else {
-        next(new import_utils56.InternalServerError("An unexpected error occurred"));
-      }
+    } catch (error) {
+      next(error);
     }
   }
   return {
-    getVerifications,
-    createUserInvite,
-    createForgetPassword,
-    verify,
-    cancelUserInvitation,
-    inviteMember,
-    signUp,
-    cancelInviteMember,
-    forgetPassword
+    add,
+    deleteById
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -10143,7 +10923,11 @@ function useVerificationController() {
   XENDIT_SECRET_KEY,
   currencies,
   isDev,
+  ledgerBillStatuses,
+  ledgerBillTypes,
   modelApp,
+  modelJobPost,
+  modelLedgerBill,
   modelMember,
   modelOrg,
   modelPermission,
@@ -10160,6 +10944,8 @@ function useVerificationController() {
   schemaBuilding,
   schemaBuildingUnit,
   schemaInviteMember,
+  schemaJobPost,
+  schemaLedgerBill,
   schemaMember,
   schemaMemberRole,
   schemaMemberStatus,
@@ -10199,6 +10985,11 @@ function useVerificationController() {
   useFileRepo,
   useFileService,
   useGitHubService,
+  useJobPostController,
+  useJobPostRepo,
+  useJobPostService,
+  useLedgerBillingController,
+  useLedgerBillingRepo,
   useMemberController,
   useMemberRepo,
   useOrgController,