@goweekdays/core 2.3.1 → 2.4.0

package/dist/index.js

@@ -70,6 +70,7 @@ __export(src_exports, {
   XENDIT_BASE_URL: () => XENDIT_BASE_URL,
   XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
   addressSchema: () => addressSchema,
+  currencies: () => currencies,
   isDev: () => isDev,
   modelApp: () => modelApp,
   modelMember: () => modelMember,
@@ -77,7 +78,10 @@ __export(src_exports, {
   modelPSGC: () => modelPSGC,
   modelPermission: () => modelPermission,
   modelPermissionGroup: () => modelPermissionGroup,
+  modelPlan: () => modelPlan,
   modelRole: () => modelRole,
+  modelSubscription: () => modelSubscription,
+  modelSubscriptionTransaction: () => modelSubscriptionTransaction,
   modelUser: () => modelUser,
   modelVerification: () => modelVerification,
   schemaApp: () => schemaApp,
@@ -89,13 +93,20 @@ __export(src_exports, {
   schemaMemberRole: () => schemaMemberRole,
   schemaMemberStatus: () => schemaMemberStatus,
   schemaOrg: () => schemaOrg,
+  schemaOrgAdd: () => schemaOrgAdd,
+  schemaOrgUpdate: () => schemaOrgUpdate,
   schemaPSGC: () => schemaPSGC,
   schemaPermission: () => schemaPermission,
   schemaPermissionGroup: () => schemaPermissionGroup,
   schemaPermissionGroupUpdate: () => schemaPermissionGroupUpdate,
   schemaPermissionUpdate: () => schemaPermissionUpdate,
+  schemaPlan: () => schemaPlan,
   schemaRole: () => schemaRole,
   schemaRoleUpdate: () => schemaRoleUpdate,
+  schemaSubscription: () => schemaSubscription,
+  schemaSubscriptionSeats: () => schemaSubscriptionSeats,
+  schemaSubscriptionTransaction: () => schemaSubscriptionTransaction,
+  schemaSubscriptionUpdate: () => schemaSubscriptionUpdate,
   schemaUpdateOptions: () => schemaUpdateOptions,
   schemaUser: () => schemaUser,
   schemaVerification: () => schemaVerification,
@@ -132,9 +143,16 @@ __export(src_exports, {
   usePermissionGroupService: () => usePermissionGroupService,
   usePermissionRepo: () => usePermissionRepo,
   usePermissionService: () => usePermissionService,
+  usePlanController: () => usePlanController,
+  usePlanRepo: () => usePlanRepo,
+  usePlanService: () => usePlanService,
   useRoleController: () => useRoleController,
   useRoleRepo: () => useRoleRepo,
   useRoleService: () => useRoleService,
+  useSubscriptionController: () => useSubscriptionController,
+  useSubscriptionRepo: () => useSubscriptionRepo,
+  useSubscriptionTransactionController: () => useSubscriptionTransactionController,
+  useSubscriptionTransactionRepo: () => useSubscriptionTransactionRepo,
   useUserController: () => useUserController,
   useUserRepo: () => useUserRepo,
   useUserService: () => useUserService,
@@ -933,11 +951,11 @@ function useAuthService() {
 }
 
 // src/resources/auth/auth.controller.ts
-var import_joi24 = __toESM(require("joi"));
-var import_utils35 = require("@goweekdays/utils");
+var import_joi32 = __toESM(require("joi"));
+var import_utils44 = require("@goweekdays/utils");
 
 // src/resources/verification/verification.service.ts
-var import_utils34 = require("@goweekdays/utils");
+var import_utils43 = require("@goweekdays/utils");
 
 // src/resources/verification/verification.model.ts
 var import_utils6 = require("@goweekdays/utils");
@@ -1330,7 +1348,7 @@ var XENDIT_BASE_URL = process.env.XENDIT_BASE_URL ?? "https://api.xendit.co";
 var DOMAIN = process.env.DOMAIN || "localhost";
 
 // src/resources/user/user.service.ts
-var import_utils32 = require("@goweekdays/utils");
+var import_utils41 = require("@goweekdays/utils");
 
 // src/resources/file/file.repository.ts
 var import_utils8 = require("@goweekdays/utils");
@@ -4188,6 +4206,33 @@ function usePermissionGroupService() {
                 description: "Allow user to revoke invitations"
               }
             ]
+          },
+          {
+            key: "billing",
+            label: "Billing",
+            permissions: [
+              {
+                key: "billing.view",
+                name: "View Billing",
+                description: "Allow user to view billing"
+              }
+            ]
+          },
+          {
+            key: "setting",
+            label: "Setting",
+            permissions: [
+              {
+                key: "setting.view",
+                name: "View Setting",
+                description: "Allow user to view setting"
+              },
+              {
+                key: "setting.edit.details",
+                name: "Edit Setting Details",
+                description: "Allow user to edit setting details"
+              }
+            ]
           }
         ];
         for (const app of apps.items) {
@@ -4622,13 +4667,25 @@ function usePermissionGroupController() {
 var import_utils24 = require("@goweekdays/utils");
 var import_joi17 = __toESM(require("joi"));
 var import_mongodb15 = require("mongodb");
-var schemaOrg = import_joi17.default.object({
+var schema = {
   name: import_joi17.default.string().max(255).required(),
   description: import_joi17.default.string().max(1024).optional().allow("", null),
-  email: import_joi17.default.string().email().max(255).optional().allow("", null),
-  contact: import_joi17.default.string().max(50).optional().allow("", null),
+  email: import_joi17.default.string().email().max(255).required(),
+  contact: import_joi17.default.string().max(50).optional().allow("", null)
+};
+var schemaOrg = import_joi17.default.object({
+  ...schema,
   createdBy: import_joi17.default.string().hex().required()
 });
+var schemaOrgAdd = import_joi17.default.object({
+  ...schema,
+  createdBy: import_joi17.default.string().hex().required(),
+  seats: import_joi17.default.number().required()
+});
+var schemaOrgUpdate = import_joi17.default.object({
+  ...schema,
+  _id: import_joi17.default.string().hex().required()
+});
 function modelOrg(value) {
   const { error } = schemaOrg.validate(value);
   if (error) {
@@ -4902,6 +4959,30 @@ function useOrgRepo() {
       throw new import_utils25.InternalServerError("Failed to delete organization.");
     }
   }
+  async function updateById(_id, options) {
+    const { error } = schemaOrgUpdate.validate({ ...options, _id });
+    if (error) {
+      throw new import_utils25.BadRequestError(error.message);
+    }
+    try {
+      _id = new import_mongodb16.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils25.BadRequestError("Invalid org ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+    } catch (error2) {
+      const isDuplicated = error2.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_utils25.BadRequestError("Organization name already exist.");
+      }
+      throw new import_utils25.InternalServerError("Failed to update org info.");
+    }
+  }
   return {
     createIndexes,
     add,
@@ -4909,12 +4990,13 @@ function useOrgRepo() {
     getById,
     updateFieldById,
     deleteById,
-    getByName
+    getByName,
+    updateById
   };
 }
 
 // src/resources/organization/organization.service.ts
-var import_utils30 = require("@goweekdays/utils");
+var import_utils39 = require("@goweekdays/utils");
 
 // src/resources/member/member.controller.ts
 var import_joi20 = __toESM(require("joi"));
@@ -5431,180 +5513,1345 @@ function useMemberController() {
   };
 }
 
-// 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();
-  async function add(value) {
-    const session = import_utils30.useAtlas.getClient()?.startSession();
-    if (!session) {
-      throw new import_utils30.BadRequestError("Unable to start database session.");
-    }
+// src/resources/subscription/subscription.model.ts
+var import_utils30 = require("@goweekdays/utils");
+var import_joi21 = __toESM(require("joi"));
+var import_mongodb17 = require("mongodb");
+var schema2 = {
+  seats: import_joi21.default.number().integer().min(1).required(),
+  paidSeats: import_joi21.default.number().integer().min(0).required(),
+  amount: import_joi21.default.number().positive().required(),
+  promoCode: import_joi21.default.string().optional().allow("", null),
+  nextBillingDate: import_joi21.default.date().optional().allow("", null)
+};
+var schemaSubscription = import_joi21.default.object({
+  ...schema2,
+  org: import_joi21.default.string().hex().length(24).required(),
+  currency: import_joi21.default.string().length(3).required(),
+  billingCycle: import_joi21.default.string().valid("monthly", "yearly").required()
+});
+var schemaSubscriptionUpdate = import_joi21.default.object({
+  ...schema2,
+  status: import_joi21.default.string().optional().allow("", null)
+});
+var schemaSubscriptionSeats = import_joi21.default.object({
+  id: import_joi21.default.string().hex().length(24).required(),
+  seats: import_joi21.default.number().integer().min(1).required(),
+  amount: import_joi21.default.number().positive().optional().allow(null, 0),
+  user: import_joi21.default.string().hex().length(24).required()
+});
+function modelSubscription(data) {
+  const { error } = schemaSubscription.validate(data);
+  if (error) {
+    throw new import_utils30.BadRequestError(`Invalid subscription data: ${error.message}`);
+  }
+  if (data._id && typeof data._id === "string") {
     try {
-      session?.startTransaction();
-      const org = await addOrg(value, 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 createdBy = String(value.createdBy);
-      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_utils30.BadRequestError("Role is required to create org member.");
-      }
-      const user = await getUserById(createdBy);
-      if (!user) {
-        throw new import_utils30.BadRequestError("User is required to create org member.");
-      }
-      await addMember(
-        {
-          role: String(role),
-          roleName: roleData.name,
-          org: String(org),
-          name: `${user.firstName} ${user.lastName}`,
-          user: createdBy,
-          app: "org"
-        },
-        session
-      );
-      await session?.commitTransaction();
-      return String(org);
-    } catch (error) {
-      await session?.abortTransaction();
-      throw error;
-    } finally {
-      await session?.endSession();
+      data._id = new import_mongodb17.ObjectId(data._id);
+    } catch (error2) {
+      throw new import_utils30.BadRequestError("Invalid subscription ID.");
     }
   }
+  try {
+    data.org = new import_mongodb17.ObjectId(data.org);
+  } catch (error2) {
+    throw new import_utils30.BadRequestError("Invalid organization ID.");
+  }
   return {
-    add
+    _id: data._id,
+    org: data.org,
+    seats: data.seats,
+    paidSeats: data.paidSeats,
+    amount: data.amount,
+    currency: data.currency,
+    billingCycle: data.billingCycle,
+    promoCode: data.promoCode,
+    status: data.status ?? "active",
+    nextBillingDate: data.nextBillingDate,
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? ""
   };
 }
 
-// src/resources/organization/organization.controller.ts
+// src/resources/subscription/subscription.repository.ts
 var import_utils31 = require("@goweekdays/utils");
-var import_joi21 = __toESM(require("joi"));
-function useOrgController() {
-  const { add: _add } = useOrgService();
-  const { getOrgsByMembership } = useMemberRepo();
-  const {
-    getByName: _getByName,
-    getAll: getAllOrg,
-    getById: _getById
-  } = useOrgRepo();
-  async function add(req, res, next) {
-    const value = req.body;
-    const { error } = schemaOrg.validate(value);
-    if (error) {
-      next(new import_utils31.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const org = await _add(value);
-      res.json({
-        message: "Organization created successfully.",
-        data: { org }
+var import_joi22 = __toESM(require("joi"));
+var import_mongodb18 = require("mongodb");
+function useSubscriptionRepo() {
+  const db = import_utils31.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils31.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "subscriptions";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils31.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils31.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
       });
-      return;
-    } catch (error2) {
-      next(error2);
-    }
+    }).catch((err) => {
+      import_utils31.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
   }
-  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_utils31.BadRequestError("Invalid page number."));
-      return;
-    }
-    const isLimitNumber = isFinite(limit);
-    if (!isLimitNumber) {
-      next(new import_utils31.BadRequestError("Invalid limit number."));
-      return;
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        {
+          key: {
+            org: 1
+          },
+          name: "org_index"
+        },
+        {
+          key: { org: 1, status: 1 },
+          name: "org_status_index"
+        }
+      ]);
+    } catch (error) {
     }
-    const validation = import_joi21.default.object({
-      user: import_joi21.default.string().hex().required(),
-      page: import_joi21.default.number().min(1).optional().allow("", null),
-      limit: import_joi21.default.number().min(1).optional().allow("", null),
-      search: import_joi21.default.string().optional().allow("", null)
+  }
+  createIndexes().catch((error) => {
+    import_utils31.logger.log({
+      level: "error",
+      message: `Failed to create indexes for subscriptions collection: ${error.message}`
     });
-    const { error } = validation.validate({ user, page, limit, search });
-    if (error) {
-      next(new import_utils31.BadRequestError(error.message));
-      return;
-    }
+  });
+  async function add(value, session) {
     try {
-      const orgs = await getOrgsByMembership({ user, page, limit, search });
-      res.json(orgs);
-      return;
-    } catch (error2) {
-      next(error2);
+      value = modelSubscription(value);
+      const result = await collection.insertOne(value, { session });
+      delCachedData();
+      return result.insertedId.toString();
+    } catch (error) {
+      import_utils31.logger.log({
+        level: "error",
+        message: `${error}`
+      });
+      if (error instanceof import_utils31.AppError) {
+        throw error;
+      }
+      throw new import_utils31.InternalServerError("Failed to add subscription.");
     }
   }
-  async function getAll(req, res, next) {
-    const query = req.query;
-    const validation = import_joi21.default.object({
-      page: import_joi21.default.number().min(1).optional().allow("", null),
-      limit: import_joi21.default.number().min(1).optional().allow("", null),
-      search: import_joi21.default.string().optional().allow("", null),
-      status: import_joi21.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;
-    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
-    const search = req.query.search ?? "";
-    const status = req.query.status ?? "active";
-    const isPageNumber = isFinite(page);
-    if (!isPageNumber) {
-      next(new import_utils31.BadRequestError("Invalid page number."));
-      return;
+  async function getAll({
+    page = 1,
+    limit = 10,
+    search = "",
+    status = "active"
+  } = {}) {
+    page = page < 1 ? page - 1 : page;
+    const query = { status };
+    const cacheKeyOptions = {
+      page,
+      limit,
+      search,
+      status,
+      tag: "getAll"
+    };
+    if (search) {
+      query.$text = { $search: search };
     }
-    const isLimitNumber = isFinite(limit);
-    if (!isLimitNumber) {
-      next(new import_utils31.BadRequestError("Invalid limit number."));
-      return;
+    const cacheKey = (0, import_utils31.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils31.paginate)(
+        items,
+        page,
+        limit,
+        length
+      );
+      setCache(cacheKey, data).then(() => {
+        import_utils31.logger.log({
+          level: "info",
+          message: `Cache set for getAll subscription: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils31.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll subscription: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new import_utils31.InternalServerError("Failed to get subscriptions.");
     }
+  }
+  async function getByOrg(org) {
+    const { error } = import_joi22.default.string().hex().length(24).required().validate(org);
     if (error) {
-      next(new import_utils31.BadRequestError(error.message));
-      return;
+      throw new Error(`Invalid org ID: ${error.message}`);
     }
     try {
-      const orgs = await getAllOrg({ page, limit, search, status });
-      res.json(orgs);
-      return;
+      org = new import_mongodb18.ObjectId(org);
     } catch (error2) {
-      next(error2);
+      throw new import_utils31.BadRequestError("Invalid org ID.");
     }
-  }
+    try {
+      const cacheKey = (0, import_utils31.makeCacheKey)(namespace_collection, {
+        org: String(org),
+        tag: "getByOrg"
+      });
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
+      }
+      const data = await collection.findOne({
+        org,
+        status: { $ne: "deleted" }
+      });
+      setCache(cacheKey, data).then(() => {
+        import_utils31.logger.log({
+          level: "info",
+          message: `Cache set for getByOrg subscription: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils31.logger.log({
+          level: "error",
+          message: `Failed to set cache for getByOrg subscription: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      throw new import_utils31.InternalServerError("Failed to get subscription.");
+    }
+  }
+  async function getById(_id) {
+    const { error } = import_joi22.default.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid subscription ID: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb18.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils31.BadRequestError("Invalid subscription ID.");
+    }
+    try {
+      const cacheKey = (0, import_utils31.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_utils31.logger.log({
+          level: "info",
+          message: `Cache set for getById subscription: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils31.logger.log({
+          level: "error",
+          message: `Failed to set cache for getById subscription: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      throw new import_utils31.InternalServerError("Failed to get subscription.");
+    }
+  }
+  async function deleteById(_id) {
+    const { error } = import_joi22.default.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid subscription ID: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb18.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils31.BadRequestError("Invalid subscription ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted" } }
+      );
+      if (result.modifiedCount === 0) {
+        throw new import_utils31.InternalServerError("Failed to delete subscription.");
+      }
+      delCachedData();
+      return "Successfully deleted subscription.";
+    } catch (error2) {
+      if (error2 instanceof import_utils31.AppError) {
+        throw error2;
+      }
+      throw new import_utils31.InternalServerError("Failed to delete subscription.");
+    }
+  }
+  async function updateById(_id, options, session) {
+    const { error: errorId } = import_joi22.default.string().hex().length(24).required().validate(_id);
+    if (errorId) {
+      throw new Error(`Invalid subscription ID: ${errorId.message}`);
+    }
+    const { error } = schemaSubscriptionUpdate.validate(options);
+    if (error) {
+      throw new import_utils31.BadRequestError(
+        `Invalid subscription update data: ${error.message}`
+      );
+    }
+    try {
+      _id = new import_mongodb18.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils31.BadRequestError("Invalid subscription ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      if (result.modifiedCount === 0) {
+        throw new import_utils31.InternalServerError("Failed to update subscription.");
+      }
+      delCachedData();
+      return "Successfully updated subscription.";
+    } catch (error2) {
+      if (error2 instanceof import_utils31.AppError) {
+        throw error2;
+      }
+      throw new import_utils31.InternalServerError("Failed to update subscription.");
+    }
+  }
+  return {
+    add,
+    getAll,
+    getByOrg,
+    getById,
+    deleteById,
+    updateById
+  };
+}
+
+// src/resources/subscription/subscription.controller.ts
+var import_joi24 = __toESM(require("joi"));
+var import_utils35 = require("@goweekdays/utils");
+
+// src/resources/subscription/subscription.service.ts
+var import_utils34 = require("@goweekdays/utils");
+
+// src/resources/subscription/subscription.transaction.repository.ts
+var import_utils33 = require("@goweekdays/utils");
+
+// src/resources/subscription/subscription.transaction.model.ts
+var import_utils32 = require("@goweekdays/utils");
+var import_joi23 = __toESM(require("joi"));
+var import_mongodb19 = require("mongodb");
+var schemaSubscriptionTransaction = import_joi23.default.object({
+  subscription: import_joi23.default.string().hex().length(24).required(),
+  amount: import_joi23.default.number().positive().required(),
+  currency: import_joi23.default.string().length(3).required(),
+  type: import_joi23.default.string().valid("initiate", "add-seat", "remove-seat", "renewal").required(),
+  description: import_joi23.default.string().max(255).optional().allow("", null),
+  createdBy: import_joi23.default.string().hex().length(24).required(),
+  createdByName: import_joi23.default.string().optional().allow("", null)
+});
+function modelSubscriptionTransaction(data) {
+  const { error } = schemaSubscriptionTransaction.validate(data);
+  if (error) {
+    throw new import_utils32.BadRequestError(
+      `Invalid subscription transaction data: ${error.message}`
+    );
+  }
+  if (data._id && typeof data._id === "string") {
+    try {
+      data._id = new import_mongodb19.ObjectId(data._id);
+    } catch (error2) {
+      throw new import_utils32.BadRequestError("Invalid subscription transaction ID.");
+    }
+  }
+  if (data.subscription && typeof data.subscription === "string") {
+    try {
+      data.subscription = new import_mongodb19.ObjectId(data.subscription);
+    } catch (error2) {
+      throw new import_utils32.BadRequestError("Invalid subscription ID.");
+    }
+  }
+  if (data.createdBy && typeof data.createdBy === "string") {
+    try {
+      data.createdBy = new import_mongodb19.ObjectId(data.createdBy);
+    } catch (error2) {
+      throw new import_utils32.BadRequestError("Invalid createdBy ID.");
+    }
+  }
+  return {
+    _id: data._id,
+    subscription: data.subscription,
+    amount: data.amount,
+    currency: data.currency,
+    type: data.type,
+    description: data.description ?? "",
+    createdBy: data.createdBy,
+    createdByName: data.createdByName,
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/subscription/subscription.transaction.repository.ts
+var import_mongodb20 = require("mongodb");
+function useSubscriptionTransactionRepo() {
+  const db = import_utils33.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils33.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "subscription.transactions";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils33.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils33.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils33.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        {
+          key: {
+            subscription: 1
+          },
+          name: "subscription_index"
+        },
+        {
+          key: { subscription: 1, type: 1 },
+          name: "subscription_type_index"
+        },
+        {
+          key: { createdAt: -1 },
+          name: "createdAt_index"
+        }
+      ]);
+    } catch (error) {
+    }
+  }
+  createIndexes().catch((error) => {
+    import_utils33.logger.log({
+      level: "error",
+      message: `Failed to create indexes for subscription_transactions collection: ${error.message}`
+    });
+  });
+  async function add(value, session) {
+    try {
+      value = modelSubscriptionTransaction(value);
+      await collection.insertOne(value, { session });
+      delCachedData();
+      return "Successfully added subscription transaction.";
+    } catch (error) {
+      import_utils33.logger.log({
+        level: "error",
+        message: `${error}`
+      });
+      if (error instanceof import_utils33.AppError) {
+        throw error;
+      }
+      throw new import_utils33.InternalServerError("Failed to add subscription transaction.");
+    }
+  }
+  async function getAll({ page = 1, limit = 10, search = "", id = "" } = {}) {
+    page = page > 0 ? page - 1 : page;
+    const query = {};
+    const cacheKeyOptions = {
+      page,
+      limit,
+      search,
+      tag: "getAll"
+    };
+    try {
+      query.subscription = new import_mongodb20.ObjectId(id);
+      cacheKeyOptions.subscription = id;
+    } catch (error) {
+      throw new import_utils33.InternalServerError("Invalid organization ID.");
+    }
+    if (search) {
+      query.$text = { $search: search };
+    }
+    const cacheKey = (0, import_utils33.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cachedData = await getCache(
+        cacheKey
+      );
+      if (cachedData) {
+        import_utils33.logger.log({
+          level: "info",
+          message: `Cache hit for getAll subscription transaction: ${cacheKey}`
+        });
+        return cachedData;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils33.paginate)(
+        items,
+        page,
+        limit,
+        length
+      );
+      setCache(cacheKey, data).then(() => {
+        import_utils33.logger.log({
+          level: "info",
+          message: `Cache set for getAll subscription transaction: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils33.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll subscription transaction: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new import_utils33.InternalServerError("Failed to get subscription transactions.");
+    }
+  }
+  return {
+    add,
+    getAll
+  };
+}
+
+// src/resources/subscription/subscription.service.ts
+function useSubscriptionService() {
+  const { getById, updateById } = useSubscriptionRepo();
+  const { add: addTransaction } = useSubscriptionTransactionRepo();
+  const { getUserById } = useUserRepo();
+  async function updateSeats({
+    id = "",
+    user = "",
+    amount = 0,
+    seats = 0
+  } = {}) {
+    const { error } = schemaSubscriptionSeats.validate({
+      id,
+      seats,
+      amount,
+      user
+    });
+    if (error) {
+      throw new import_utils34.BadRequestError(error.message);
+    }
+    const subscription = await getById(id);
+    if (!subscription) {
+      throw new Error("Subscription not found");
+    }
+    if (subscription.seats === seats) {
+      throw new Error("Failed to update subscription, no changes detected.");
+    }
+    const userData = await getUserById(user);
+    if (!userData) {
+      throw new Error("User not found.");
+    }
+    const session = import_utils34.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Unable to start database session.");
+    }
+    let subscriptionAmount = subscription.amount;
+    const seatIncreased = seats > subscription.paidSeats;
+    let paidSeats = subscription.paidSeats;
+    if (seatIncreased) {
+      subscriptionAmount += amount ?? 0;
+      paidSeats = seats;
+    }
+    try {
+      session.startTransaction();
+      await updateById(
+        id,
+        { seats, amount: subscriptionAmount, paidSeats },
+        session
+      );
+      if (seatIncreased) {
+        await addTransaction(
+          {
+            type: "add-seat",
+            description: `Added ${seats - subscription.paidSeats} seats.`,
+            amount: amount ?? 0,
+            currency: subscription.currency,
+            subscription: id,
+            createdBy: user,
+            createdByName: `${userData.firstName} ${userData.lastName}`
+          },
+          session
+        );
+      }
+      await session.commitTransaction();
+      return "Successfully updated subscription seats.";
+    } catch (error2) {
+      await session.abortTransaction();
+      throw error2;
+    } finally {
+      session.endSession();
+    }
+  }
+  return {
+    updateSeats
+  };
+}
+
+// src/resources/subscription/subscription.controller.ts
+function useSubscriptionController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    getByOrg: _getByOrg
+  } = useSubscriptionRepo();
+  const { updateSeats: _updateSeats } = useSubscriptionService();
+  async function getAll(req, res, next) {
+    const validation = import_joi24.default.object({
+      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),
+      status: import_joi24.default.string().valid("active", "suspended").optional().default("active")
+    });
+    const query = req.query;
+    const { error, value } = validation.validate(query);
+    if (error) {
+      next(new import_utils35.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAll(value);
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id ?? "";
+    const validation = import_joi24.default.object({
+      id: import_joi24.default.string().hex().length(24).required()
+    });
+    const { error, value } = validation.validate({ id });
+    if (error) {
+      next(new import_utils35.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(value.id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByOrg(req, res, next) {
+    const org = req.params.org ?? "";
+    const validation = import_joi24.default.object({
+      org: import_joi24.default.string().hex().length(24).required()
+    });
+    const { error, value } = validation.validate({ org });
+    if (error) {
+      next(new import_utils35.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getByOrg(value.org);
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateSeats(req, res, next) {
+    const id = req.params.id ?? "";
+    const payload = req.body;
+    const { error } = schemaSubscriptionSeats.validate({ ...payload, id });
+    if (error) {
+      next(new import_utils35.BadRequestError(error.message));
+      return;
+    }
+    const user = payload.user ?? "";
+    const seats = payload.seats ?? 0;
+    const amount = payload.amount ?? 0;
+    try {
+      const message = await _updateSeats({ id, seats, amount, user });
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    getAll,
+    getById,
+    getByOrg,
+    updateSeats
+  };
+}
+
+// src/resources/subscription/subscription.transaction.controller.ts
+var import_joi25 = __toESM(require("joi"));
+var import_utils36 = require("@goweekdays/utils");
+function useSubscriptionTransactionController() {
+  const { getAll: _getAll } = useSubscriptionTransactionRepo();
+  async function getAll(req, res, next) {
+    const validation = import_joi25.default.object({
+      id: import_joi25.default.string().hex().length(24).required(),
+      page: import_joi25.default.number().min(1).max(100).optional().allow(null, "").default(1),
+      limit: import_joi25.default.number().min(1).max(100).optional().allow(null, "").default(10)
+    });
+    const query = req.query;
+    const id = req.params.id ?? "";
+    const { error, value } = validation.validate({ ...query, id });
+    if (error) {
+      next(new import_utils36.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAll(value);
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    getAll
+  };
+}
+
+// src/resources/plan/plan.model.ts
+var import_joi26 = __toESM(require("joi"));
+var currencies = ["USD", "PHP"];
+var schemaPlan = 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).allow(...currencies).required(),
+  default: import_joi26.default.boolean().optional().allow(null, ""),
+  billingCycle: import_joi26.default.string().valid("monthly", "yearly").required()
+});
+function modelPlan(data) {
+  const { error } = schemaPlan.validate(data);
+  if (error) {
+    throw new Error(`Invalid plan data: ${error.message}`);
+  }
+  return {
+    _id: data._id,
+    name: data.name,
+    description: data.description,
+    features: data.features,
+    price: data.price,
+    currency: data.currency,
+    billingCycle: data.billingCycle,
+    status: data.status ?? "active",
+    default: data.default ?? false,
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/plan/plan.repository.ts
+var import_utils37 = require("@goweekdays/utils");
+var import_joi27 = __toESM(require("joi"));
+var import_mongodb21 = require("mongodb");
+function usePlanRepo() {
+  const db = import_utils37.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils37.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "plans";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils37.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils37.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils37.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        {
+          key: {
+            status: 1
+          }
+        },
+        {
+          key: {
+            name: 1
+          }
+        },
+        {
+          key: { billingCycle: 1 }
+        },
+        {
+          key: { name: "text", description: "text" },
+          name: "name_description_text_index"
+        },
+        {
+          key: { name: 1, status: 1 },
+          partialFilterExpression: { status: "active" },
+          unique: true,
+          name: "unique_name_index"
+        },
+        {
+          key: { default: 1 },
+          unique: true,
+          partialFilterExpression: { status: "active" }
+        }
+      ]);
+    } catch (error) {
+    }
+  }
+  createIndexes().catch((error) => {
+    import_utils37.logger.log({
+      level: "error",
+      message: `Failed to create indexes for plans collection: ${error.message}`
+    });
+  });
+  async function add(value) {
+    try {
+      value = modelPlan(value);
+      await collection.insertOne(value);
+      delCachedData();
+      return "Successfully added plan.";
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_utils37.BadRequestError("Plan name already exist.");
+      }
+      throw new import_utils37.InternalServerError("Failed to add plan.");
+    }
+  }
+  async function getAll({
+    page = 1,
+    limit = 10,
+    search = "",
+    status = "active"
+  } = {}) {
+    page = page < 1 ? page - 1 : page;
+    const query = { status };
+    const cacheKeyOptions = {
+      page,
+      limit,
+      search,
+      status,
+      tag: "getAll"
+    };
+    if (search) {
+      query.$text = { $search: search };
+    }
+    const cacheKey = (0, import_utils37.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils37.paginate)(items, page, limit, length);
+      setCache(cacheKey, data).then(() => {
+        import_utils37.logger.log({
+          level: "info",
+          message: `Cache set for getAll plan: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils37.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll plan: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new import_utils37.InternalServerError("Failed to get plans.");
+    }
+  }
+  async function getById(_id) {
+    const { error } = import_joi27.default.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid plan ID: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb21.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils37.BadRequestError("Invalid plan ID.");
+    }
+    try {
+      const cacheKey = (0, import_utils37.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_utils37.logger.log({
+          level: "info",
+          message: `Cache set for getById plan: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils37.logger.log({
+          level: "error",
+          message: `Failed to set cache for getById plan: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      throw new import_utils37.InternalServerError("Failed to get plan.");
+    }
+  }
+  async function getDefault() {
+    try {
+      const cacheKey = (0, import_utils37.makeCacheKey)(namespace_collection, {
+        default: true,
+        tag: "getDefault"
+      });
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
+      }
+      const data = await collection.findOne({
+        default: true,
+        status: "active"
+      });
+      setCache(cacheKey, data).then(() => {
+        import_utils37.logger.log({
+          level: "info",
+          message: `Cache set for default plan: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils37.logger.log({
+          level: "error",
+          message: `Failed to set cache for default plan: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new import_utils37.InternalServerError("Failed to get default plan.");
+    }
+  }
+  async function deleteById(_id) {
+    const { error } = import_joi27.default.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid plan ID: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb21.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils37.BadRequestError("Invalid plan ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted" } }
+      );
+      if (result.modifiedCount === 0) {
+        throw new import_utils37.InternalServerError("Failed to delete plan.");
+      }
+      delCachedData();
+      return "Successfully deleted plan.";
+    } catch (error2) {
+      if (error2 instanceof import_utils37.AppError) {
+        throw error2;
+      }
+      throw new import_utils37.InternalServerError("Failed to delete plan.");
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    getDefault,
+    deleteById
+  };
+}
+
+// src/resources/plan/plan.service.ts
+function usePlanService() {
+  const { add } = usePlanRepo();
+  async function addDefaultPlan() {
+    try {
+      await add({
+        name: "Standard",
+        description: "Default standard plan",
+        price: 1e3,
+        currency: "PHP",
+        billingCycle: "monthly",
+        default: true
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    addDefaultPlan
+  };
+}
+
+// src/resources/plan/plan.controller.ts
+var import_joi28 = __toESM(require("joi"));
+var import_utils38 = require("@goweekdays/utils");
+function usePlanController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById,
+    deleteById: _deleteById,
+    getDefault: _getDefault
+  } = usePlanRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const validation = import_joi28.default.object({
+      name: import_joi28.default.string().min(3).max(100).required(),
+      description: import_joi28.default.string().max(255).optional().allow("", null),
+      features: import_joi28.default.array().items(import_joi28.default.string().max(100)).optional(),
+      price: import_joi28.default.number().positive().required(),
+      currency: import_joi28.default.string().length(3).required(),
+      billingCycle: import_joi28.default.string().valid("monthly", "yearly").required()
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_utils38.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _add(value);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const status = req.query.status ?? "active";
+    const search = req.query.search ?? "";
+    const page = Number(req.query.page) ?? 1;
+    const limit = Number(req.query.limit) ?? 10;
+    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(),
+      limit: import_joi28.default.number().required()
+    });
+    const { error } = validation.validate({ status, search, page, limit });
+    if (error) {
+      next(new import_utils38.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const plans = await _getAll({ status, search, page, limit });
+      res.json(plans);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi28.default.string().hex().length(24).required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_utils38.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const plan = await _getById(id);
+      res.json(plan);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi28.default.string().hex().length(24).required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_utils38.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getDefault(req, res, next) {
+    try {
+      const plan = await _getDefault();
+      res.json(plan);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    deleteById,
+    getDefault
+  };
+}
+
+// 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();
+  async function add(value) {
+    const { error } = schemaOrgAdd.validate(value);
+    if (error) {
+      throw new import_utils39.BadRequestError(error.message);
+    }
+    const session = import_utils39.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new import_utils39.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_utils39.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_utils39.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_utils39.BadRequestError("Role is required to create org member.");
+      }
+      await addMember(
+        {
+          role: String(role),
+          roleName: roleData.name,
+          org: String(org),
+          name: `${user.firstName} ${user.lastName}`,
+          user: createdBy,
+          app: "org"
+        },
+        session
+      );
+      await session?.commitTransaction();
+      return String(org);
+    } catch (error2) {
+      await session?.abortTransaction();
+      throw error2;
+    } finally {
+      await session?.endSession();
+    }
+  }
+  return {
+    add
+  };
+}
+
+// src/resources/organization/organization.controller.ts
+var import_utils40 = require("@goweekdays/utils");
+var import_joi29 = __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_utils40.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const org = await _add(value);
+      res.json({
+        message: "Organization created successfully.",
+        data: { org }
+      });
+      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_utils40.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_utils40.BadRequestError("Invalid limit number."));
+      return;
+    }
+    const validation = import_joi29.default.object({
+      user: import_joi29.default.string().hex().required(),
+      page: import_joi29.default.number().min(1).optional().allow("", null),
+      limit: import_joi29.default.number().min(1).optional().allow("", null),
+      search: import_joi29.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({ user, page, limit, search });
+    if (error) {
+      next(new import_utils40.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const orgs = await getOrgsByMembership({ user, page, limit, search });
+      res.json(orgs);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi29.default.object({
+      page: import_joi29.default.number().min(1).optional().allow("", null),
+      limit: import_joi29.default.number().min(1).optional().allow("", null),
+      search: import_joi29.default.string().optional().allow("", null),
+      status: import_joi29.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;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "active";
+    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 getAllOrg({ page, limit, search, status });
+      res.json(orgs);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
   async function getByName(req, res, next) {
     const name = req.params.name;
-    const validation = import_joi21.default.object({
-      name: import_joi21.default.string().required()
+    const validation = import_joi29.default.object({
+      name: import_joi29.default.string().required()
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new import_utils31.BadRequestError(error.message));
+      next(new import_utils40.BadRequestError(error.message));
       return;
     }
     try {
@@ -5617,12 +6864,12 @@ function useOrgController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi21.default.object({
-      id: import_joi21.default.string().hex().required()
+    const validation = import_joi29.default.object({
+      id: import_joi29.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils31.BadRequestError(error.message));
+      next(new import_utils40.BadRequestError(error.message));
       return;
     }
     try {
@@ -5633,12 +6880,29 @@ function useOrgController() {
       next(error2);
     }
   }
+  async function updateById(req, res, next) {
+    const _id = req.params.id ?? "";
+    const payload = req.body;
+    const { error } = schemaOrgUpdate.validate({ _id, ...payload });
+    if (error) {
+      next(new import_utils40.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateById(_id, payload);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
   return {
     add,
     getOrgsByUserId,
     getByName,
     getAll,
-    getById
+    getById,
+    updateById
   };
 }
 
@@ -5657,16 +6921,16 @@ function useUserService() {
   const { getAll: getAllPermission } = usePermissionRepo();
   const { getById: getOrgById } = useOrgRepo();
   async function createDefaultUser() {
-    const session = import_utils32.useAtlas.getClient()?.startSession();
+    const session = import_utils41.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       const _user = await getUserByEmail(DEFAULT_USER_EMAIL);
       if (_user) {
-        throw new import_utils32.BadRequestError(
+        throw new import_utils41.BadRequestError(
           `User already exists: ${DEFAULT_USER_EMAIL}.`
         );
       }
-      const hashedPassword = await (0, import_utils32.hashPassword)(DEFAULT_USER_PASSWORD);
+      const hashedPassword = await (0, import_utils41.hashPassword)(DEFAULT_USER_PASSWORD);
       const userId = await addUser(
         {
           email: DEFAULT_USER_EMAIL,
@@ -5712,9 +6976,9 @@ function useUserService() {
     try {
       const _user = await getUserByEmail(value.email);
       if (_user) {
-        throw new import_utils32.BadRequestError(`User already exists: ${value.email}.`);
+        throw new import_utils41.BadRequestError(`User already exists: ${value.email}.`);
       }
-      const hashedPassword = await (0, import_utils32.hashPassword)(value.password);
+      const hashedPassword = await (0, import_utils41.hashPassword)(value.password);
       const insertedId = await addUser({
         email: value.email,
         password: hashedPassword,
@@ -5724,10 +6988,10 @@ function useUserService() {
       });
       return insertedId;
     } catch (error) {
-      if (error instanceof import_utils32.AppError) {
+      if (error instanceof import_utils41.AppError) {
         throw error;
       } else {
-        throw new import_utils32.InternalServerError(`Error creating user: ${error}`);
+        throw new import_utils41.InternalServerError(`Error creating user: ${error}`);
       }
     }
   }
@@ -5738,28 +7002,28 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = import_utils32.useAtlas.getClient()?.startSession();
+    const session = import_utils41.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const invitation = await _getVerificationById(id);
       if (!invitation || !invitation.metadata?.app || !invitation.metadata?.role) {
-        throw new import_utils32.BadRequestError("Invalid invitation.");
+        throw new import_utils41.BadRequestError("Invalid invitation.");
       }
       if (invitation.status === "complete") {
-        throw new import_utils32.BadRequestError("Invitation already used.");
+        throw new import_utils41.BadRequestError("Invitation already used.");
       }
       if (!invitation.expireAt) {
-        throw new import_utils32.BadRequestError("Expiration date is required.");
+        throw new import_utils41.BadRequestError("Expiration date is required.");
       }
       const expired = new Date(invitation.expireAt) < /* @__PURE__ */ new Date();
       if (invitation.status === "expired" || expired) {
-        throw new import_utils32.BadRequestError("Invitation expired.");
+        throw new import_utils41.BadRequestError("Invitation expired.");
       }
       const email = invitation.email;
       const user = await getUserByEmail(invitation.email);
       let userId = user?._id ?? "";
       if (!user) {
-        const hashedPassword = await (0, import_utils32.hashPassword)(password);
+        const hashedPassword = await (0, import_utils41.hashPassword)(password);
         userId = await addUser(
           {
             email,
@@ -5776,7 +7040,7 @@ function useUserService() {
       if (invitation.metadata?.org) {
         const org = await getOrgById(String(invitation.metadata.org));
         if (!org) {
-          throw new import_utils32.NotFoundError("Organization not found.");
+          throw new import_utils41.NotFoundError("Organization not found.");
         }
         orgName = org.name;
       }
@@ -5784,7 +7048,7 @@ function useUserService() {
       if (invitation.metadata.role) {
         const role = await getRoleById(String(invitation.metadata.role));
         if (!role) {
-          throw new import_utils32.NotFoundError("Role not found.");
+          throw new import_utils41.NotFoundError("Role not found.");
         }
         roleName = role.name;
       }
@@ -5804,10 +7068,10 @@ function useUserService() {
       return userId;
     } catch (error) {
       await session?.abortTransaction();
-      if (error instanceof import_utils32.AppError) {
+      if (error instanceof import_utils41.AppError) {
         throw error;
       } else {
-        throw new import_utils32.InternalServerError("Failed to create user by invite.");
+        throw new import_utils41.InternalServerError("Failed to create user by invite.");
       }
     } finally {
       session?.endSession();
@@ -5819,31 +7083,31 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = import_utils32.useAtlas.getClient()?.startSession();
+    const session = import_utils41.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const signUp = await _getVerificationById(id);
       if (!signUp) {
-        throw new import_utils32.BadRequestError("Invalid sign up link.");
+        throw new import_utils41.BadRequestError("Invalid sign up link.");
       }
       if (signUp.status === "complete") {
-        throw new import_utils32.BadRequestError(
+        throw new import_utils41.BadRequestError(
           "You have already an account created using this link."
         );
       }
       if (!signUp.expireAt) {
-        throw new import_utils32.BadRequestError("Expiration date is required.");
+        throw new import_utils41.BadRequestError("Expiration date is required.");
       }
       const expired = new Date(signUp.expireAt) < /* @__PURE__ */ new Date();
       if (signUp.status === "expired" || expired) {
-        throw new import_utils32.BadRequestError("Sign up link expired.");
+        throw new import_utils41.BadRequestError("Sign up link expired.");
       }
       const email = signUp.email;
       const _user = await getUserByEmail(signUp.email);
       if (_user) {
-        throw new import_utils32.BadRequestError(`User already exists: ${email}.`);
+        throw new import_utils41.BadRequestError(`User already exists: ${email}.`);
       }
-      const hashedPassword = await (0, import_utils32.hashPassword)(password);
+      const hashedPassword = await (0, import_utils41.hashPassword)(password);
       const userId = await addUser(
         {
           email,
@@ -5867,33 +7131,33 @@ function useUserService() {
   const { updateStatusById: updateVerificationStatusById } = useVerificationRepo();
   async function resetPassword(value) {
     if (value.newPassword !== value.confirmPassword) {
-      throw new import_utils32.BadRequestError("Passwords do not match.");
+      throw new import_utils41.BadRequestError("Passwords do not match.");
     }
     let hashedPassword = "";
     try {
-      hashedPassword = await (0, import_utils32.hashPassword)(value.newPassword);
+      hashedPassword = await (0, import_utils41.hashPassword)(value.newPassword);
     } catch (error) {
-      throw new import_utils32.InternalServerError(`Error hashing password: ${error}`);
+      throw new import_utils41.InternalServerError(`Error hashing password: ${error}`);
     }
-    const session = import_utils32.useAtlas.getClient()?.startSession();
+    const session = import_utils41.useAtlas.getClient()?.startSession();
     if (!session) {
-      throw new import_utils32.InternalServerError("Failed to start database session.");
+      throw new import_utils41.InternalServerError("Failed to start database session.");
     }
     try {
       session.startTransaction();
       const otpDoc = await getById(value.id);
       if (!otpDoc) {
-        throw new import_utils32.NotFoundError("You are using an invalid reset link.");
+        throw new import_utils41.NotFoundError("You are using an invalid reset link.");
       }
       const user = await getUserByEmail(otpDoc.email);
       if (!user) {
-        throw new import_utils32.NotFoundError("User not found.");
+        throw new import_utils41.NotFoundError("User not found.");
       }
       if (!user._id) {
-        throw new import_utils32.NotFoundError("User ID is invalid.");
+        throw new import_utils41.NotFoundError("User ID is invalid.");
       }
       if (otpDoc.status === "used") {
-        throw new import_utils32.BadRequestError("This link has already been invalidated.");
+        throw new import_utils41.BadRequestError("This link has already been invalidated.");
       }
       await updateVerificationStatusById(value.id, "used", session);
       await _updateUserFieldById(
@@ -5904,31 +7168,31 @@ function useUserService() {
       return "Successfully reset password.";
     } catch (error) {
       await session.abortTransaction();
-      if (error instanceof import_utils32.AppError) {
+      if (error instanceof import_utils41.AppError) {
         throw error;
       }
-      throw new import_utils32.InternalServerError("Failed to reset password.");
+      throw new import_utils41.InternalServerError("Failed to reset password.");
     }
   }
   const { updateName: updateMemberName } = useMemberRepo();
   async function updateName(_id, firstName, lastName) {
     if (!_id) {
-      throw new import_utils32.BadRequestError("Invalid user ID");
+      throw new import_utils41.BadRequestError("Invalid user ID");
     }
     if (!firstName) {
-      throw new import_utils32.BadRequestError("Invalid firstName");
+      throw new import_utils41.BadRequestError("Invalid firstName");
     }
     if (!lastName) {
-      throw new import_utils32.BadRequestError("Invalid lastName");
+      throw new import_utils41.BadRequestError("Invalid lastName");
     }
-    const session = import_utils32.useAtlas.getClient()?.startSession();
+    const session = import_utils41.useAtlas.getClient()?.startSession();
     session?.startTransaction();
-    const cacheKey = (0, import_utils32.makeCacheKey)("users", { user: _id });
+    const cacheKey = (0, import_utils41.makeCacheKey)("users", { user: _id });
     try {
-      (0, import_utils32.useCache)().delCache(cacheKey).then(() => {
-        import_utils32.logger.info(`Cache cleared for user: ${_id}`);
+      (0, import_utils41.useCache)().delCache(cacheKey).then(() => {
+        import_utils41.logger.info(`Cache cleared for user: ${_id}`);
       }).catch((error) => {
-        import_utils32.logger.error(`Failed to clear cache for user: ${_id}`, error);
+        import_utils41.logger.error(`Failed to clear cache for user: ${_id}`, error);
       });
       await _updateName({ _id, firstName, lastName }, session);
       await updateMemberName(
@@ -5946,16 +7210,16 @@ function useUserService() {
   }
   async function updateBirthday(_id, month, day, year) {
     if (!_id) {
-      throw new import_utils32.BadRequestError("Invalid user ID");
+      throw new import_utils41.BadRequestError("Invalid user ID");
     }
     if (!month) {
-      throw new import_utils32.BadRequestError("Invalid birth month.");
+      throw new import_utils41.BadRequestError("Invalid birth month.");
     }
     if (!day) {
-      throw new import_utils32.BadRequestError("Invalid birthday.");
+      throw new import_utils41.BadRequestError("Invalid birthday.");
     }
     if (!year) {
-      throw new import_utils32.BadRequestError("Invalid birth year.");
+      throw new import_utils41.BadRequestError("Invalid birth year.");
     }
     try {
       await _updateBirthday({ _id, month, day, year });
@@ -5972,7 +7236,7 @@ function useUserService() {
     }
   }
   const { createFile: _createFile, deleteFileById } = useFileRepo();
-  const s3 = new import_utils32.useS3({
+  const s3 = new import_utils41.useS3({
     accessKeyId: SPACES_ACCESS_KEY,
     secretAccessKey: SPACES_SECRET_KEY,
     endpoint: SPACES_ENDPOINT,
@@ -5980,7 +7244,7 @@ function useUserService() {
     bucket: SPACES_BUCKET
   });
   async function updateUserProfile({ file, user, previousProfile } = {}) {
-    const session = import_utils32.useAtlas.getClient()?.startSession();
+    const session = import_utils41.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     const _file = {
       name: file.originalname,
@@ -6024,8 +7288,8 @@ function useUserService() {
 }
 
 // src/resources/user/user.controller.ts
-var import_utils33 = require("@goweekdays/utils");
-var import_joi22 = __toESM(require("joi"));
+var import_utils42 = require("@goweekdays/utils");
+var import_joi30 = __toESM(require("joi"));
 function useUserController() {
   const {
     updateName: _updateName,
@@ -6041,14 +7305,14 @@ function useUserController() {
     const status = req.query.status ?? "";
     const search = req.query.search ?? "";
     const page = Number(req.query.page) ?? 1;
-    const validation = import_joi22.default.object({
-      status: import_joi22.default.string().required(),
-      search: import_joi22.default.string().optional().allow("", null),
-      page: import_joi22.default.number().required()
+    const validation = import_joi30.default.object({
+      status: import_joi30.default.string().required(),
+      search: import_joi30.default.string().optional().allow("", null),
+      page: import_joi30.default.number().required()
     });
     const { error } = validation.validate({ status, search, page });
     if (error) {
-      next(new import_utils33.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6061,14 +7325,14 @@ function useUserController() {
   }
   async function getUserById(req, res, next) {
     const id = req.params.id || "";
-    const validation = import_joi22.default.string().hex().validate(id);
+    const validation = import_joi30.default.string().hex().validate(id);
     if (validation.error) {
-      throw new import_utils33.BadRequestError("Invalid id.");
+      throw new import_utils42.BadRequestError("Invalid id.");
     }
     try {
       const user = await _getUserById(id);
       if (!user) {
-        throw new import_utils33.BadRequestError("User not found.");
+        throw new import_utils42.BadRequestError("User not found.");
       }
       res.json(user);
     } catch (error) {
@@ -6079,13 +7343,13 @@ function useUserController() {
     const id = req.headers.user ?? "";
     const firstName = req.body.firstName ?? "";
     const lastName = req.body.lastName ?? "";
-    const validation = import_joi22.default.object({
-      firstName: import_joi22.default.string().required(),
-      lastName: import_joi22.default.string().required()
+    const validation = import_joi30.default.object({
+      firstName: import_joi30.default.string().required(),
+      lastName: import_joi30.default.string().required()
     });
     const { error } = validation.validate({ firstName, lastName });
     if (error) {
-      next(new import_utils33.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6101,14 +7365,14 @@ function useUserController() {
     const month = req.body.month ?? "";
     const day = req.body.day ?? 0;
     const year = req.body.year ?? 0;
-    const validation = import_joi22.default.object({
-      month: import_joi22.default.string().required(),
-      day: import_joi22.default.number().integer().min(1).max(31).required(),
-      year: import_joi22.default.number().integer().min(1900).max((/* @__PURE__ */ new Date()).getFullYear()).required()
+    const validation = import_joi30.default.object({
+      month: import_joi30.default.string().required(),
+      day: import_joi30.default.number().integer().min(1).max(31).required(),
+      year: import_joi30.default.number().integer().min(1900).max((/* @__PURE__ */ new Date()).getFullYear()).required()
     });
     const { error } = validation.validate({ month, day, year });
     if (error) {
-      next(new import_utils33.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6122,18 +7386,18 @@ function useUserController() {
   async function updateUserFieldById(req, res, next) {
     const _id = req.params.id;
     const { field, value } = req.body;
-    const validation = import_joi22.default.object({
-      _id: import_joi22.default.string().hex().required(),
-      field: import_joi22.default.string().valid("gender", "email", "contact", "profile").required(),
-      value: import_joi22.default.alternatives().conditional("field", {
+    const validation = import_joi30.default.object({
+      _id: import_joi30.default.string().hex().required(),
+      field: import_joi30.default.string().valid("gender", "email", "contact", "profile").required(),
+      value: import_joi30.default.alternatives().conditional("field", {
         is: "email",
-        then: import_joi22.default.string().email().required(),
-        otherwise: import_joi22.default.string().required()
+        then: import_joi30.default.string().email().required(),
+        otherwise: import_joi30.default.string().required()
       })
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new import_utils33.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6149,12 +7413,12 @@ function useUserController() {
       return;
     }
     const previousProfile = req.body.previousProfile ?? "";
-    const validation = import_joi22.default.object({
-      previousProfile: import_joi22.default.string().hex().optional().allow("", null)
+    const validation = import_joi30.default.object({
+      previousProfile: import_joi30.default.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate({ previousProfile });
     if (error) {
-      next(new import_utils33.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     const user = req.headers["user"] ?? "";
@@ -6167,10 +7431,10 @@ function useUserController() {
       res.json({ message: "Successfully updated profile picture." });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils33.AppError) {
+      if (error2 instanceof import_utils42.AppError) {
         next(error2);
       } else {
-        next(new import_utils33.InternalServerError(error2));
+        next(new import_utils42.InternalServerError(error2));
       }
     }
   }
@@ -6180,12 +7444,12 @@ function useUserController() {
     const password = req.body.password ?? "";
     const id = req.params.id ?? "";
     const type = req.body.type ?? "";
-    const validation = import_joi22.default.object({
-      firstName: import_joi22.default.string().required(),
-      lastName: import_joi22.default.string().required(),
-      password: import_joi22.default.string().required(),
-      id: import_joi22.default.string().hex().required(),
-      type: import_joi22.default.string().required()
+    const validation = import_joi30.default.object({
+      firstName: import_joi30.default.string().required(),
+      lastName: import_joi30.default.string().required(),
+      password: import_joi30.default.string().required(),
+      id: import_joi30.default.string().hex().required(),
+      type: import_joi30.default.string().required()
     });
     const { error } = validation.validate({
       firstName,
@@ -6195,7 +7459,7 @@ function useUserController() {
       type
     });
     if (error) {
-      next(new import_utils33.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6218,14 +7482,14 @@ function useUserController() {
   }
   async function resetPassword(req, res, next) {
     const payload = req.body;
-    const validation = import_joi22.default.object({
-      id: import_joi22.default.string().hex().required(),
-      newPassword: import_joi22.default.string().min(8).required(),
-      confirmPassword: import_joi22.default.string().min(8).required()
+    const validation = import_joi30.default.object({
+      id: import_joi30.default.string().hex().required(),
+      newPassword: import_joi30.default.string().min(8).required(),
+      confirmPassword: import_joi30.default.string().min(8).required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      next(new import_utils33.BadRequestError(error.message));
+      next(new import_utils42.BadRequestError(error.message));
       return;
     }
     try {
@@ -6250,7 +7514,7 @@ function useUserController() {
 }
 
 // src/resources/verification/verification.service.ts
-var import_joi23 = __toESM(require("joi"));
+var import_joi31 = __toESM(require("joi"));
 function useVerificationService() {
   const MailerConfig = {
     host: MAILER_TRANSPORT_HOST,
@@ -6259,7 +7523,7 @@ function useVerificationService() {
     email: MAILER_EMAIL,
     password: MAILER_PASSWORD
   };
-  const mailer = new import_utils34.useMailer(MailerConfig);
+  const mailer = new import_utils43.useMailer(MailerConfig);
   const {
     add,
     getById: _getById,
@@ -6285,7 +7549,7 @@ function useVerificationService() {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (!metadata.app) {
-      throw new import_utils34.BadRequestError("App metadata is required.");
+      throw new import_utils43.BadRequestError("App metadata is required.");
     }
     try {
       const user = await getUserByEmail(email);
@@ -6293,8 +7557,8 @@ function useVerificationService() {
       if (user) {
         value.type = "member-invite";
         const res2 = await add(value);
-        const filePath2 = (0, import_utils34.getDirectory)(dir, "./public/handlebars/member-invite");
-        const emailContent2 = (0, import_utils34.compileHandlebar)({
+        const filePath2 = (0, import_utils43.getDirectory)(dir, "./public/handlebars/member-invite");
+        const emailContent2 = (0, import_utils43.compileHandlebar)({
           context: {
             validity: VERIFICATION_USER_INVITE_DURATION,
             link: `${APP_MAIN}/verify/member-invite/${res2}`,
@@ -6308,7 +7572,7 @@ function useVerificationService() {
           html: emailContent2,
           from: "GoWeekdays"
         }).catch((error) => {
-          import_utils34.logger.log({
+          import_utils43.logger.log({
             level: "error",
             message: `Error sending user invite email: ${error}`
           });
@@ -6316,8 +7580,8 @@ function useVerificationService() {
         return res2;
       }
       const res = await add(value);
-      const filePath = (0, import_utils34.getDirectory)(dir, "./public/handlebars/user-invite");
-      const emailContent = (0, import_utils34.compileHandlebar)({
+      const filePath = (0, import_utils43.getDirectory)(dir, "./public/handlebars/user-invite");
+      const emailContent = (0, import_utils43.compileHandlebar)({
         context: {
           validity: VERIFICATION_USER_INVITE_DURATION,
           link: `${APP_MAIN}/verify/invitation/${res}`
@@ -6330,7 +7594,7 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error) => {
-        import_utils34.logger.log({
+        import_utils43.logger.log({
           level: "error",
           message: `Error sending user invite email: ${error}`
         });
@@ -6351,8 +7615,8 @@ function useVerificationService() {
     try {
       const res = await add(value);
       const dir = __dirname;
-      const filePath = (0, import_utils34.getDirectory)(dir, "./public/handlebars/forget-password");
-      const emailContent = (0, import_utils34.compileHandlebar)({
+      const filePath = (0, import_utils43.getDirectory)(dir, "./public/handlebars/forget-password");
+      const emailContent = (0, import_utils43.compileHandlebar)({
         context: {
           validity: VERIFICATION_FORGET_PASSWORD_DURATION,
           link: `${APP_MAIN}/reset-password/${res}`
@@ -6365,21 +7629,21 @@ function useVerificationService() {
         from: "GoWeekdays",
         html: emailContent
       }).catch((error) => {
-        import_utils34.logger.log({
+        import_utils43.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_utils34.InternalServerError("Failed to create forget password link.");
+      throw new import_utils43.InternalServerError("Failed to create forget password link.");
     }
   }
   async function getById(id) {
     try {
       const _id = await _getById(id);
       if (!_id) {
-        throw new import_utils34.NotFoundError("Verification not found.");
+        throw new import_utils43.NotFoundError("Verification not found.");
       }
       return _id;
     } catch (error) {
@@ -6411,48 +7675,48 @@ function useVerificationService() {
   }
   function errorByType(type, status) {
     if (type === "user-invite" && status === "expired") {
-      throw new import_utils34.BadRequestError(
+      throw new import_utils43.BadRequestError(
         "Invitation has already expired, please contact admin to resend the invitation."
       );
     }
     if (type === "user-sign-up" && status === "expired") {
-      throw new import_utils34.BadRequestError(
+      throw new import_utils43.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_utils34.BadRequestError(
+      throw new import_utils43.BadRequestError(
         "User already registered, please login to continue."
       );
     }
     if (type === "forget-password" && status === "complete") {
-      throw new import_utils34.BadRequestError(
+      throw new import_utils43.BadRequestError(
         "Forget password verification has already been used, please request a new one."
       );
     }
     if (type === "forget-password" && status === "expired") {
-      throw new import_utils34.BadRequestError(
+      throw new import_utils43.BadRequestError(
         "Forget password verification has expired, please request a new one."
       );
     }
-    throw new import_utils34.BadRequestError("Invalid verification.");
+    throw new import_utils43.BadRequestError("Invalid verification.");
   }
   async function verify(id) {
-    const session = import_utils34.useAtlas.getClient()?.startSession();
+    const session = import_utils43.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const _id = await _getById(id);
       if (!_id) {
-        throw new import_utils34.NotFoundError("Verification not found.");
+        throw new import_utils43.NotFoundError("Verification not found.");
       }
       if (_id.status === "expired") {
         errorByType(_id.type, "expired");
       }
       if (_id.status === "complete") {
-        throw new import_utils34.BadRequestError("Verification already completed.");
+        throw new import_utils43.BadRequestError("Verification already completed.");
       }
       if (!_id.expireAt) {
-        throw new import_utils34.BadRequestError("Expiration date is required.");
+        throw new import_utils43.BadRequestError("Expiration date is required.");
       }
       const expiration = new Date(_id.expireAt).getTime();
       const now = (/* @__PURE__ */ new Date()).getTime();
@@ -6465,15 +7729,15 @@ function useVerificationService() {
         await _updateStatusById(id, "complete", session);
         const user = await getUserByEmail(_id.email);
         if (!user) {
-          throw new import_utils34.NotFoundError("User not found for member invite.");
+          throw new import_utils43.NotFoundError("User not found for member invite.");
         }
         if (!_id.metadata?.app) {
-          throw new import_utils34.BadRequestError(
+          throw new import_utils43.BadRequestError(
             "App metadata is required for member invite."
           );
         }
         if (!_id.metadata?.role || !_id.metadata?.roleName) {
-          throw new import_utils34.BadRequestError(
+          throw new import_utils43.BadRequestError(
             "Role metadata is required for member invite."
           );
         }
@@ -6495,7 +7759,7 @@ function useVerificationService() {
       return _id;
     } catch (error) {
       await session?.abortTransaction();
-      import_utils34.logger.log({
+      import_utils43.logger.log({
         level: "info",
         message: `Error verifying user invitation: ${error}`
       });
@@ -6508,7 +7772,7 @@ function useVerificationService() {
     try {
       await updateStatusById(id, "cancelled");
     } catch (error) {
-      throw new import_utils34.InternalServerError(
+      throw new import_utils43.InternalServerError(
         `Error cancelling user invitation: ${error}`
       );
     }
@@ -6528,7 +7792,7 @@ function useVerificationService() {
     try {
       const user = await getUserByEmail(email);
       if (user) {
-        throw new import_utils34.BadRequestError(
+        throw new import_utils43.BadRequestError(
           `Email ${email} is already registered, please login to continue.`
         );
       }
@@ -6541,8 +7805,8 @@ function useVerificationService() {
       };
       const res = await add(value);
       const dir = __dirname;
-      const filePath = (0, import_utils34.getDirectory)(dir, "./public/handlebars/sign-up");
-      const emailContent = (0, import_utils34.compileHandlebar)({
+      const filePath = (0, import_utils43.getDirectory)(dir, "./public/handlebars/sign-up");
+      const emailContent = (0, import_utils43.compileHandlebar)({
         context: {
           validity: "5 minutes",
           link: `${APP_MAIN}/sign-up/${res}`
@@ -6555,7 +7819,7 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error) => {
-        import_utils34.logger.log({
+        import_utils43.logger.log({
           level: "error",
           message: `Error sending user invite email: ${error}`
         });
@@ -6568,11 +7832,11 @@ function useVerificationService() {
   async function inviteMember(value) {
     const { error } = schemaInviteMember.validate(value);
     if (error) {
-      throw new import_utils34.BadRequestError(error.message);
+      throw new import_utils43.BadRequestError(error.message);
     }
     const role = await getRoleById(value.role);
     if (!role) {
-      throw new import_utils34.NotFoundError("Role not found.");
+      throw new import_utils43.NotFoundError("Role not found.");
     }
     let verificationData = {
       type: "user-invite",
@@ -6590,15 +7854,15 @@ function useVerificationService() {
       if (user) {
         verificationData.type = "member-invite";
         const verificationId2 = await add(verificationData);
-        const filePath2 = (0, import_utils34.getDirectory)(dir, "./public/handlebars/member-invite");
+        const filePath2 = (0, import_utils43.getDirectory)(dir, "./public/handlebars/member-invite");
         let org = null;
         if (verificationData.metadata.org) {
           org = await getOrgById(verificationData.metadata.org);
           if (!org) {
-            throw new import_utils34.NotFoundError("Organization not found.");
+            throw new import_utils43.NotFoundError("Organization not found.");
           }
         }
-        const emailContent2 = (0, import_utils34.compileHandlebar)({
+        const emailContent2 = (0, import_utils43.compileHandlebar)({
           context: {
             validity: VERIFICATION_USER_INVITE_DURATION,
             link: `${APP_MAIN}/verify/member-invite/${verificationId2}`,
@@ -6612,7 +7876,7 @@ function useVerificationService() {
           html: emailContent2,
           from: "GoWeekdays"
         }).catch((error2) => {
-          import_utils34.logger.log({
+          import_utils43.logger.log({
             level: "error",
             message: `Error sending user invite email: ${error2}`
           });
@@ -6620,8 +7884,8 @@ function useVerificationService() {
         return verificationId2;
       }
       const verificationId = await add(verificationData);
-      const filePath = (0, import_utils34.getDirectory)(dir, "./public/handlebars/user-invite");
-      const emailContent = (0, import_utils34.compileHandlebar)({
+      const filePath = (0, import_utils43.getDirectory)(dir, "./public/handlebars/user-invite");
+      const emailContent = (0, import_utils43.compileHandlebar)({
         context: {
           validity: VERIFICATION_USER_INVITE_DURATION,
           link: `${APP_MAIN}/verify/invitation/${verificationId}`
@@ -6634,55 +7898,55 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error2) => {
-        import_utils34.logger.log({
+        import_utils43.logger.log({
           level: "error",
           message: `Error sending user invite email: ${error2}`
         });
       });
       return verificationId;
     } catch (error2) {
-      if (error2 instanceof import_utils34.AppError) {
+      if (error2 instanceof import_utils43.AppError) {
         throw error2;
       } else {
-        throw new import_utils34.InternalServerError("Failed to invite member.");
+        throw new import_utils43.InternalServerError("Failed to invite member.");
       }
     }
   }
   async function cancelInviteMember(id) {
-    const { error } = import_joi23.default.string().hex().required().validate(id);
+    const { error } = import_joi31.default.string().hex().required().validate(id);
     if (error) {
-      throw new import_utils34.BadRequestError("Invalid verification ID.");
+      throw new import_utils43.BadRequestError("Invalid verification ID.");
     }
     try {
       const invite = await _getById(id);
       if (!invite) {
-        throw new import_utils34.NotFoundError("Invitation not found.");
+        throw new import_utils43.NotFoundError("Invitation not found.");
       }
       if (invite.status === "cancelled") {
-        throw new import_utils34.BadRequestError("Invitation already cancelled.");
+        throw new import_utils43.BadRequestError("Invitation already cancelled.");
       }
       if (invite.status === "complete") {
-        throw new import_utils34.BadRequestError("Cannot cancel a completed invitation.");
+        throw new import_utils43.BadRequestError("Cannot cancel a completed invitation.");
       }
       await _updateStatusById(id, "cancelled");
       return "Successfully cancelled the invitation.";
     } catch (error2) {
-      if (error2 instanceof import_utils34.AppError) {
+      if (error2 instanceof import_utils43.AppError) {
         throw error2;
       } else {
-        throw new import_utils34.InternalServerError("Failed to cancel the invitation.");
+        throw new import_utils43.InternalServerError("Failed to cancel the invitation.");
       }
     }
   }
   async function forgetPassword(email) {
-    const { error } = import_joi23.default.string().email().required().validate(email);
+    const { error } = import_joi31.default.string().email().required().validate(email);
     if (error) {
-      throw new import_utils34.BadRequestError("Invalid email address.");
+      throw new import_utils43.BadRequestError("Invalid email address.");
     }
     try {
       const member = await getUserByEmail(email);
       if (!member) {
-        throw new import_utils34.NotFoundError("User not found.");
+        throw new import_utils43.NotFoundError("User not found.");
       }
       const value = {
         type: "forget-password",
@@ -6692,8 +7956,8 @@ function useVerificationService() {
       };
       const res = await add(value);
       const dir = __dirname;
-      const filePath = (0, import_utils34.getDirectory)(dir, "./public/handlebars/forget-password");
-      const emailContent = (0, import_utils34.compileHandlebar)({
+      const filePath = (0, import_utils43.getDirectory)(dir, "./public/handlebars/forget-password");
+      const emailContent = (0, import_utils43.compileHandlebar)({
         context: {
           validity: VERIFICATION_FORGET_PASSWORD_DURATION,
           link: `${APP_MAIN}/reset-password/${res}`
@@ -6706,17 +7970,17 @@ function useVerificationService() {
         from: "GoWeekdays",
         html: emailContent
       }).catch((error2) => {
-        import_utils34.logger.log({
+        import_utils43.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_utils34.AppError) {
+      if (error2 instanceof import_utils43.AppError) {
         throw error2;
       } else {
-        throw new import_utils34.InternalServerError(
+        throw new import_utils43.InternalServerError(
           "Failed to process forget password request."
         );
       }
@@ -6743,13 +8007,13 @@ function useAuthController() {
   async function login(req, res, next) {
     const email = req.body.email;
     const password = req.body.password;
-    const validation = import_joi24.default.object({
-      email: import_joi24.default.string().email().required(),
-      password: import_joi24.default.string().required()
+    const validation = import_joi32.default.object({
+      email: import_joi32.default.string().email().required(),
+      password: import_joi32.default.string().required()
     });
     const { error } = validation.validate({ email, password });
     if (error) {
-      next(new import_utils35.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -6765,14 +8029,14 @@ function useAuthController() {
       res.cookie("sid", session.sid, cookieOptions).cookie("user", session.user, cookieOptions).json({ message: "Login successful" });
       return;
     } catch (error2) {
-      import_utils35.logger.log({
+      import_utils44.logger.log({
         level: "error",
         message: `Error during login: ${error2.message}`
       });
-      if (error2 instanceof import_utils35.AppError) {
+      if (error2 instanceof import_utils44.AppError) {
         next(error2);
       } else {
-        next(new import_utils35.InternalServerError("An unexpected error occurred"));
+        next(new import_utils44.InternalServerError("An unexpected error occurred"));
       }
       return;
     }
@@ -6780,17 +8044,17 @@ function useAuthController() {
   async function logout(req, res, next) {
     const sid = req.headers["authorization"] ?? "";
     if (!sid) {
-      next(new import_utils35.BadRequestError("Session ID is required"));
+      next(new import_utils44.BadRequestError("Session ID is required"));
       return;
     }
     try {
       await useAuthService().logout(sid);
       res.json({ message: "Logged out successfully" });
     } catch (error) {
-      if (error instanceof import_utils35.AppError) {
+      if (error instanceof import_utils44.AppError) {
         next(error);
       } else {
-        next(new import_utils35.InternalServerError("An unexpected error occurred"));
+        next(new import_utils44.InternalServerError("An unexpected error occurred"));
       }
     }
   }
@@ -6801,64 +8065,64 @@ function useAuthController() {
 }
 
 // src/resources/building/building.model.ts
-var import_utils36 = require("@goweekdays/utils");
-var import_joi25 = __toESM(require("joi"));
-var import_mongodb17 = require("mongodb");
-var schemaBuilding = import_joi25.default.object({
-  _id: import_joi25.default.string().hex().optional(),
-  school: import_joi25.default.string().hex().required(),
-  serial: import_joi25.default.string().optional().allow("", null),
-  name: import_joi25.default.string().required(),
-  levels: import_joi25.default.number().integer().min(1).required(),
-  createdAt: import_joi25.default.date().optional().allow("", null),
-  updatedAt: import_joi25.default.date().optional().allow("", null),
-  deletedAt: import_joi25.default.date().optional().allow("", null),
-  status: import_joi25.default.string().optional().allow("", null)
+var import_utils45 = require("@goweekdays/utils");
+var import_joi33 = __toESM(require("joi"));
+var import_mongodb22 = require("mongodb");
+var schemaBuilding = import_joi33.default.object({
+  _id: import_joi33.default.string().hex().optional(),
+  school: import_joi33.default.string().hex().required(),
+  serial: import_joi33.default.string().optional().allow("", null),
+  name: import_joi33.default.string().required(),
+  levels: import_joi33.default.number().integer().min(1).required(),
+  createdAt: import_joi33.default.date().optional().allow("", null),
+  updatedAt: import_joi33.default.date().optional().allow("", null),
+  deletedAt: import_joi33.default.date().optional().allow("", null),
+  status: import_joi33.default.string().optional().allow("", null)
 });
-var schemaBuildingUnit = import_joi25.default.object({
-  _id: import_joi25.default.string().hex().optional(),
-  school: import_joi25.default.string().hex().required(),
-  name: import_joi25.default.string().optional().allow("", null),
-  building: import_joi25.default.string().hex().required(),
-  buildingName: import_joi25.default.string().optional().allow("", null),
-  level: import_joi25.default.number().integer().min(1).required(),
-  category: import_joi25.default.string().required(),
-  type: import_joi25.default.string().required(),
-  seating_capacity: import_joi25.default.number().integer().min(0).required(),
-  standing_capacity: import_joi25.default.number().integer().min(0).required(),
-  description: import_joi25.default.string().optional().allow("", null),
-  unit_of_measurement: import_joi25.default.string().valid("sqm").required(),
-  area: import_joi25.default.number().positive().required(),
-  status: import_joi25.default.string().optional().allow("", null)
+var schemaBuildingUnit = import_joi33.default.object({
+  _id: import_joi33.default.string().hex().optional(),
+  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)
 });
-var schemaUpdateOptions = import_joi25.default.object({
-  name: import_joi25.default.string().optional().allow("", null),
-  building: import_joi25.default.string().hex().optional().allow("", null),
-  buildingName: import_joi25.default.string().optional().allow("", null),
-  level: import_joi25.default.number().integer().min(1).optional().allow("", null),
-  category: import_joi25.default.string().optional().allow("", null),
-  type: import_joi25.default.string().optional().allow("", null),
-  seating_capacity: import_joi25.default.number().integer().min(0).optional().allow("", null),
-  standing_capacity: import_joi25.default.number().integer().min(0).optional().allow("", null),
-  area: import_joi25.default.number().positive().optional().allow("", null)
+var schemaUpdateOptions = import_joi33.default.object({
+  name: import_joi33.default.string().optional().allow("", null),
+  building: import_joi33.default.string().hex().optional().allow("", null),
+  buildingName: import_joi33.default.string().optional().allow("", null),
+  level: import_joi33.default.number().integer().min(1).optional().allow("", null),
+  category: import_joi33.default.string().optional().allow("", null),
+  type: import_joi33.default.string().optional().allow("", null),
+  seating_capacity: import_joi33.default.number().integer().min(0).optional().allow("", null),
+  standing_capacity: import_joi33.default.number().integer().min(0).optional().allow("", null),
+  area: import_joi33.default.number().positive().optional().allow("", null)
 });
 function MBuilding(value) {
   const { error } = schemaBuilding.validate(value);
   if (error) {
-    import_utils36.logger.info(`Building Model: ${error.message}`);
-    throw new import_utils36.BadRequestError(error.message);
+    import_utils45.logger.info(`Building Model: ${error.message}`);
+    throw new import_utils45.BadRequestError(error.message);
   }
   if (value._id && typeof value._id === "string") {
     try {
-      value._id = new import_mongodb17.ObjectId(value._id);
+      value._id = new import_mongodb22.ObjectId(value._id);
     } catch (error2) {
-      throw new import_utils36.BadRequestError("Invalid _id format");
+      throw new import_utils45.BadRequestError("Invalid _id format");
     }
   }
   try {
-    value.school = new import_mongodb17.ObjectId(value.school);
+    value.school = new import_mongodb22.ObjectId(value.school);
   } catch (error2) {
-    throw new import_utils36.BadRequestError("Invalid school format");
+    throw new import_utils45.BadRequestError("Invalid school format");
   }
   return {
     _id: value._id ?? void 0,
@@ -6875,25 +8139,25 @@ function MBuilding(value) {
 function MBuildingUnit(value) {
   const { error } = schemaBuildingUnit.validate(value);
   if (error) {
-    import_utils36.logger.info(`Building Unit Model: ${error.message}`);
-    throw new import_utils36.BadRequestError(error.message);
+    import_utils45.logger.info(`Building Unit Model: ${error.message}`);
+    throw new import_utils45.BadRequestError(error.message);
   }
   if (value._id && typeof value._id === "string") {
     try {
-      value._id = new import_mongodb17.ObjectId(value._id);
+      value._id = new import_mongodb22.ObjectId(value._id);
     } catch (error2) {
-      throw new import_utils36.BadRequestError("Invalid ID");
+      throw new import_utils45.BadRequestError("Invalid ID");
     }
   }
   try {
-    value.school = new import_mongodb17.ObjectId(value.school);
+    value.school = new import_mongodb22.ObjectId(value.school);
   } catch (error2) {
-    throw new import_utils36.BadRequestError("Invalid school ID");
+    throw new import_utils45.BadRequestError("Invalid school ID");
   }
   try {
-    value.building = new import_mongodb17.ObjectId(value.building);
+    value.building = new import_mongodb22.ObjectId(value.building);
   } catch (error2) {
-    throw new import_utils36.BadRequestError("Invalid building ID");
+    throw new import_utils45.BadRequestError("Invalid building ID");
   }
   return {
     _id: value._id ?? void 0,
@@ -6917,16 +8181,16 @@ function MBuildingUnit(value) {
 }
 
 // src/resources/building/building.repository.ts
-var import_utils37 = require("@goweekdays/utils");
-var import_mongodb18 = require("mongodb");
+var import_utils46 = require("@goweekdays/utils");
+var import_mongodb23 = require("mongodb");
 function useBuildingRepo() {
-  const db = import_utils37.useAtlas.getDb();
+  const db = import_utils46.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_utils37.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils46.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -6939,7 +8203,7 @@ function useBuildingRepo() {
     }
   }
   createIndexes().catch((error) => {
-    import_utils37.logger.log({ level: "error", message: `Index creation error: ${error}` });
+    import_utils46.logger.log({ level: "error", message: `Index creation error: ${error}` });
   });
   async function add(value, session) {
     try {
@@ -6948,16 +8212,16 @@ function useBuildingRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils37.logger.log({
+      import_utils46.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils37.AppError) {
+      if (error instanceof import_utils46.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils37.BadRequestError("Building already exists.");
+          throw new import_utils46.BadRequestError("Building already exists.");
         }
         throw new Error("Failed to create building.");
       }
@@ -6965,9 +8229,9 @@ function useBuildingRepo() {
   }
   async function updateById(_id, value, session) {
     try {
-      _id = new import_mongodb18.ObjectId(_id);
+      _id = new import_mongodb23.ObjectId(_id);
     } catch (error) {
-      throw new import_utils37.BadRequestError("Invalid ID.");
+      throw new import_utils46.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -6978,11 +8242,11 @@ function useBuildingRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils37.logger.log({
+      import_utils46.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils37.AppError) {
+      if (error instanceof import_utils46.AppError) {
         throw error;
       } else {
         throw new Error("Failed to update building.");
@@ -7007,9 +8271,9 @@ function useBuildingRepo() {
     }
     if (school) {
       try {
-        query.school = new import_mongodb18.ObjectId(school);
+        query.school = new import_mongodb23.ObjectId(school);
       } catch (error) {
-        throw new import_utils37.BadRequestError("Invalid school ID.");
+        throw new import_utils46.BadRequestError("Invalid school ID.");
       }
     }
     const cacheParams = {
@@ -7023,15 +8287,15 @@ function useBuildingRepo() {
       cacheParams.school = school;
     if (status !== "active")
       cacheParams.status = status;
-    const cacheKey = (0, import_utils37.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils37.logger.log({
+    const cacheKey = (0, import_utils46.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils46.logger.log({
       level: "info",
       message: `Cache key for getAll buildings: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils37.logger.log({
+        import_utils46.logger.log({
           level: "info",
           message: `Cache hit for getAll buildings: ${cacheKey}`
         });
@@ -7044,35 +8308,35 @@ function useBuildingRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils37.paginate)(items, page, limit, length);
+      const data = (0, import_utils46.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils37.logger.log({
+        import_utils46.logger.log({
           level: "info",
           message: `Cache set for getAll buildings: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils37.logger.log({
+        import_utils46.logger.log({
           level: "error",
           message: `Failed to set cache for getAll buildings: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils37.logger.log({ level: "error", message: `${error}` });
+      import_utils46.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new import_mongodb18.ObjectId(_id);
+      _id = new import_mongodb23.ObjectId(_id);
     } catch (error) {
-      throw new import_utils37.BadRequestError("Invalid ID.");
+      throw new import_utils46.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils37.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils46.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils37.logger.log({
+        import_utils46.logger.log({
           level: "info",
           message: `Cache hit for getById building: ${cacheKey}`
         });
@@ -7082,30 +8346,30 @@ function useBuildingRepo() {
         _id
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils37.logger.log({
+        import_utils46.logger.log({
           level: "info",
           message: `Cache set for building by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils37.logger.log({
+        import_utils46.logger.log({
           level: "error",
           message: `Failed to set cache for building by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils37.AppError) {
+      if (error instanceof import_utils46.AppError) {
         throw error;
       } else {
-        throw new import_utils37.InternalServerError("Failed to get building.");
+        throw new import_utils46.InternalServerError("Failed to get building.");
       }
     }
   }
   async function deleteById(_id, session) {
     try {
-      _id = new import_mongodb18.ObjectId(_id);
+      _id = new import_mongodb23.ObjectId(_id);
     } catch (error) {
-      throw new import_utils37.BadRequestError("Invalid ID.");
+      throw new import_utils46.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -7115,25 +8379,25 @@ function useBuildingRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils37.logger.log({
+      import_utils46.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils37.AppError) {
+      if (error instanceof import_utils46.AppError) {
         throw error;
       } else {
-        throw new import_utils37.InternalServerError("Failed to delete building.");
+        throw new import_utils46.InternalServerError("Failed to delete building.");
       }
     }
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils37.logger.log({
+      import_utils46.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils37.logger.log({
+      import_utils46.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -7150,19 +8414,19 @@ function useBuildingRepo() {
 }
 
 // src/resources/building/building.service.ts
-var import_utils39 = require("@goweekdays/utils");
+var import_utils48 = require("@goweekdays/utils");
 
 // src/resources/building/building-unit.repository.ts
-var import_utils38 = require("@goweekdays/utils");
-var import_mongodb19 = require("mongodb");
+var import_utils47 = require("@goweekdays/utils");
+var import_mongodb24 = require("mongodb");
 function useBuildingUnitRepo() {
-  const db = import_utils38.useAtlas.getDb();
+  const db = import_utils47.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_utils38.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils47.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -7190,12 +8454,12 @@ function useBuildingUnitRepo() {
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils38.logger.log({
+      import_utils47.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils38.logger.log({
+      import_utils47.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -7208,11 +8472,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils38.logger.log({
+      import_utils47.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils38.AppError) {
+      if (error instanceof import_utils47.AppError) {
         throw error;
       } else {
         throw new Error("Failed to create building unit.");
@@ -7222,12 +8486,12 @@ function useBuildingUnitRepo() {
   async function updateById(_id, value, session) {
     const { error } = schemaUpdateOptions.validate(value);
     if (error) {
-      throw new import_utils38.BadRequestError(error.message);
+      throw new import_utils47.BadRequestError(error.message);
     }
     try {
-      _id = new import_mongodb19.ObjectId(_id);
+      _id = new import_mongodb24.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils38.BadRequestError("Invalid ID.");
+      throw new import_utils47.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -7238,11 +8502,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils38.logger.log({
+      import_utils47.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils38.AppError) {
+      if (error2 instanceof import_utils47.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to create building unit.");
@@ -7252,12 +8516,12 @@ function useBuildingUnitRepo() {
   async function updateByBuildingId(building, value, session) {
     const { error } = schemaUpdateOptions.validate(value);
     if (error) {
-      throw new import_utils38.BadRequestError(error.message);
+      throw new import_utils47.BadRequestError(error.message);
     }
     try {
-      building = new import_mongodb19.ObjectId(building);
+      building = new import_mongodb24.ObjectId(building);
     } catch (error2) {
-      throw new import_utils38.BadRequestError("Invalid building ID.");
+      throw new import_utils47.BadRequestError("Invalid building ID.");
     }
     try {
       const res = await collection.updateMany(
@@ -7268,11 +8532,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils38.logger.log({
+      import_utils47.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils38.AppError) {
+      if (error2 instanceof import_utils47.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to update building unit.");
@@ -7299,16 +8563,16 @@ function useBuildingUnitRepo() {
     }
     if (school) {
       try {
-        query.school = new import_mongodb19.ObjectId(school);
+        query.school = new import_mongodb24.ObjectId(school);
       } catch (error) {
-        throw new import_utils38.BadRequestError("Invalid school ID.");
+        throw new import_utils47.BadRequestError("Invalid school ID.");
       }
     }
     if (building) {
       try {
-        query.building = new import_mongodb19.ObjectId(building);
+        query.building = new import_mongodb24.ObjectId(building);
       } catch (error) {
-        throw new import_utils38.BadRequestError("Invalid building ID.");
+        throw new import_utils47.BadRequestError("Invalid building ID.");
       }
     }
     const cacheParams = {
@@ -7324,15 +8588,15 @@ function useBuildingUnitRepo() {
       cacheParams.building = building;
     if (status !== "active")
       cacheParams.status = status;
-    const cacheKey = (0, import_utils38.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils38.logger.log({
+    const cacheKey = (0, import_utils47.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils47.logger.log({
       level: "info",
       message: `Cache key for getAll building units: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "info",
           message: `Cache hit for getAll building units: ${cacheKey}`
         });
@@ -7345,35 +8609,35 @@ function useBuildingUnitRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils38.paginate)(items, page, limit, length);
+      const data = (0, import_utils47.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "info",
           message: `Cache set for getAll building units: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "error",
           message: `Failed to set cache for getAll building units: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils38.logger.log({ level: "error", message: `${error}` });
+      import_utils47.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new import_mongodb19.ObjectId(_id);
+      _id = new import_mongodb24.ObjectId(_id);
     } catch (error) {
-      throw new import_utils38.BadRequestError("Invalid ID.");
+      throw new import_utils47.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils38.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils47.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -7384,42 +8648,42 @@ function useBuildingUnitRepo() {
         deletedAt: { $in: ["", null] }
       });
       if (!result) {
-        throw new import_utils38.BadRequestError("Building unit not found.");
+        throw new import_utils47.BadRequestError("Building unit not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils38.AppError) {
+      if (error instanceof import_utils47.AppError) {
         throw error;
       } else {
-        throw new import_utils38.InternalServerError("Failed to get building unit.");
+        throw new import_utils47.InternalServerError("Failed to get building unit.");
       }
     }
   }
   async function getByBuildingLevel(building, level) {
     try {
-      building = new import_mongodb19.ObjectId(building);
+      building = new import_mongodb24.ObjectId(building);
     } catch (error) {
-      throw new import_utils38.BadRequestError("Invalid building ID.");
+      throw new import_utils47.BadRequestError("Invalid building ID.");
     }
-    const cacheKey = (0, import_utils38.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils47.makeCacheKey)(namespace_collection, {
       building: String(building),
       level
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -7431,38 +8695,38 @@ function useBuildingUnitRepo() {
         status: "active"
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils38.AppError) {
+      if (error instanceof import_utils47.AppError) {
         throw error;
       } else {
-        throw new import_utils38.InternalServerError("Failed to get building unit.");
+        throw new import_utils47.InternalServerError("Failed to get building unit.");
       }
     }
   }
   async function getByBuilding(building) {
     try {
-      building = new import_mongodb19.ObjectId(building);
+      building = new import_mongodb24.ObjectId(building);
     } catch (error) {
-      throw new import_utils38.BadRequestError("Invalid building ID.");
+      throw new import_utils47.BadRequestError("Invalid building ID.");
     }
-    const cacheKey = (0, import_utils38.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils47.makeCacheKey)(namespace_collection, {
       building: String(building)
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -7473,30 +8737,30 @@ function useBuildingUnitRepo() {
         status: "active"
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils38.logger.log({
+        import_utils47.logger.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils38.AppError) {
+      if (error instanceof import_utils47.AppError) {
         throw error;
       } else {
-        throw new import_utils38.InternalServerError("Failed to get building unit.");
+        throw new import_utils47.InternalServerError("Failed to get building unit.");
       }
     }
   }
   async function deleteById(_id, session) {
     try {
-      _id = new import_mongodb19.ObjectId(_id);
+      _id = new import_mongodb24.ObjectId(_id);
     } catch (error) {
-      throw new import_utils38.BadRequestError("Invalid ID.");
+      throw new import_utils47.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -7507,11 +8771,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return "Room/Facility deleted successfully.";
     } catch (error) {
-      import_utils38.logger.log({
+      import_utils47.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils38.AppError) {
+      if (error instanceof import_utils47.AppError) {
         throw error;
       } else {
         throw new Error("Failed to deleted room/facility.");
@@ -7541,16 +8805,16 @@ function useBuildingService() {
   const { getByBuildingLevel, getByBuilding, updateByBuildingId } = useBuildingUnitRepo();
   async function updateById(id, data) {
     data.levels = Number(data.levels);
-    const session = import_utils39.useAtlas.getClient()?.startSession();
+    const session = import_utils48.useAtlas.getClient()?.startSession();
     try {
       const building = await _getById(id);
       if (!building) {
-        throw new import_utils39.NotFoundError("Building not found.");
+        throw new import_utils48.NotFoundError("Building not found.");
       }
       if (data.levels < building.levels) {
         const unit = await getByBuildingLevel(id, building.levels);
         if (unit) {
-          throw new import_utils39.BadRequestError(
+          throw new import_utils48.BadRequestError(
             "Cannot reduce floors, there are existing building units at higher floors."
           );
         }
@@ -7572,7 +8836,7 @@ function useBuildingService() {
   async function deleteById(id) {
     const building = await getByBuilding(id);
     if (building) {
-      throw new import_utils39.BadRequestError(
+      throw new import_utils48.BadRequestError(
         "Cannot delete building with existing room/facility. Please delete room/facility first."
       );
     }
@@ -7590,24 +8854,24 @@ function useBuildingService() {
 }
 
 // src/resources/building/building.controller.ts
-var import_utils40 = require("@goweekdays/utils");
-var import_joi26 = __toESM(require("joi"));
+var import_utils49 = require("@goweekdays/utils");
+var import_joi34 = __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_joi26.default.object({
-      name: import_joi26.default.string().required(),
-      school: import_joi26.default.string().hex().required(),
-      levels: import_joi26.default.number().integer().min(1).required(),
-      serial: import_joi26.default.string().optional().allow("", null),
-      status: import_joi26.default.string().optional().allow("", null)
+    const validation = import_joi34.default.object({
+      name: import_joi34.default.string().required(),
+      school: import_joi34.default.string().hex().required(),
+      levels: import_joi34.default.number().integer().min(1).required(),
+      serial: import_joi34.default.string().optional().allow("", null),
+      status: import_joi34.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
-      import_utils40.logger.info(`Controller: ${error.message}`);
+      next(new import_utils49.BadRequestError(error.message));
+      import_utils49.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -7621,18 +8885,18 @@ function useBuildingController() {
   async function updateById(req, res, next) {
     const value = req.body;
     const id = req.params.id ?? "";
-    const validation = import_joi26.default.object({
-      id: import_joi26.default.string().hex().required(),
-      value: import_joi26.default.object({
-        name: import_joi26.default.string().required(),
-        serial: import_joi26.default.string().optional().allow("", null),
-        levels: import_joi26.default.number().integer().min(1).required()
+    const validation = import_joi34.default.object({
+      id: import_joi34.default.string().hex().required(),
+      value: import_joi34.default.object({
+        name: import_joi34.default.string().required(),
+        serial: import_joi34.default.string().optional().allow("", null),
+        levels: import_joi34.default.number().integer().min(1).required()
       })
     });
     const { error } = validation.validate({ id, value });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
-      import_utils40.logger.info(`Controller: ${error.message}`);
+      next(new import_utils49.BadRequestError(error.message));
+      import_utils49.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -7645,16 +8909,16 @@ function useBuildingController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi26.default.object({
-      page: import_joi26.default.number().min(1).optional().allow("", null),
-      limit: import_joi26.default.number().min(1).optional().allow("", null),
-      search: import_joi26.default.string().optional().allow("", null),
-      school: import_joi26.default.string().hex().optional().allow("", null),
-      status: import_joi26.default.string().optional().allow("", null)
+    const validation = import_joi34.default.object({
+      page: import_joi34.default.number().min(1).optional().allow("", null),
+      limit: import_joi34.default.number().min(1).optional().allow("", null),
+      search: import_joi34.default.string().optional().allow("", null),
+      school: import_joi34.default.string().hex().optional().allow("", null),
+      status: import_joi34.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils49.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -7688,12 +8952,12 @@ function useBuildingController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi26.default.object({
-      id: import_joi26.default.string().hex().required()
+    const validation = import_joi34.default.object({
+      id: import_joi34.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils49.BadRequestError(error.message));
       return;
     }
     try {
@@ -7709,12 +8973,12 @@ function useBuildingController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi26.default.object({
-      id: import_joi26.default.string().hex().required()
+    const validation = import_joi34.default.object({
+      id: import_joi34.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils49.BadRequestError(error.message));
       return;
     }
     try {
@@ -7735,11 +8999,11 @@ function useBuildingController() {
 }
 
 // src/resources/building/building-unit.service.ts
-var import_utils41 = require("@goweekdays/utils");
+var import_utils50 = require("@goweekdays/utils");
 function useBuildingUnitService() {
   const { add: _add } = useBuildingUnitRepo();
   async function add(value) {
-    const session = import_utils41.useAtlas.getClient()?.startSession();
+    const session = import_utils50.useAtlas.getClient()?.startSession();
     if (!session) {
       throw new Error("Unable to start session for building unit service.");
     }
@@ -7766,8 +9030,8 @@ function useBuildingUnitService() {
 }
 
 // src/resources/building/building-unit.controller.ts
-var import_utils42 = require("@goweekdays/utils");
-var import_joi27 = __toESM(require("joi"));
+var import_utils51 = require("@goweekdays/utils");
+var import_joi35 = __toESM(require("joi"));
 function useBuildingUnitController() {
   const {
     getAll: _getAll,
@@ -7778,27 +9042,27 @@ function useBuildingUnitController() {
   const { add: _add } = useBuildingUnitService();
   async function add(req, res, next) {
     const data = req.body;
-    const validation = import_joi27.default.object({
-      building: import_joi27.default.object({
-        school: import_joi27.default.string().hex().required(),
-        name: import_joi27.default.string().optional().allow("", null),
-        building: import_joi27.default.string().hex().required(),
-        buildingName: import_joi27.default.string().optional().allow("", null),
-        level: import_joi27.default.number().integer().min(1).required(),
-        category: import_joi27.default.string().required(),
-        type: import_joi27.default.string().required(),
-        seating_capacity: import_joi27.default.number().integer().min(0).required(),
-        standing_capacity: import_joi27.default.number().integer().min(0).required(),
-        description: import_joi27.default.string().optional().allow("", null),
-        unit_of_measurement: import_joi27.default.string().valid("sqm").required(),
-        area: import_joi27.default.number().positive().required(),
-        status: import_joi27.default.string().optional().allow("", null)
+    const validation = import_joi35.default.object({
+      building: import_joi35.default.object({
+        school: import_joi35.default.string().hex().required(),
+        name: import_joi35.default.string().optional().allow("", null),
+        building: import_joi35.default.string().hex().required(),
+        buildingName: import_joi35.default.string().optional().allow("", null),
+        level: import_joi35.default.number().integer().min(1).required(),
+        category: import_joi35.default.string().required(),
+        type: import_joi35.default.string().required(),
+        seating_capacity: import_joi35.default.number().integer().min(0).required(),
+        standing_capacity: import_joi35.default.number().integer().min(0).required(),
+        description: import_joi35.default.string().optional().allow("", null),
+        unit_of_measurement: import_joi35.default.string().valid("sqm").required(),
+        area: import_joi35.default.number().positive().required(),
+        status: import_joi35.default.string().optional().allow("", null)
       }),
-      qty: import_joi27.default.number().integer().min(1).max(20).optional().default(1)
+      qty: import_joi35.default.number().integer().min(1).max(20).optional().default(1)
     });
     const { error } = validation.validate(data);
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils51.BadRequestError(error.message));
       return;
     }
     try {
@@ -7814,13 +9078,13 @@ function useBuildingUnitController() {
   async function updateById(req, res, next) {
     const data = req.body;
     const id = req.params.id ?? "";
-    const validation = import_joi27.default.object({
-      id: import_joi27.default.string().hex().required(),
+    const validation = import_joi35.default.object({
+      id: import_joi35.default.string().hex().required(),
       value: schemaUpdateOptions
     });
     const { error } = validation.validate({ id, value: data });
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils51.BadRequestError(error.message));
       return;
     }
     try {
@@ -7835,17 +9099,17 @@ function useBuildingUnitController() {
   }
   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),
-      school: import_joi27.default.string().hex().optional().allow("", null),
-      building: import_joi27.default.string().hex().optional().allow("", null),
-      status: import_joi27.default.string().optional().allow("", null)
+    const validation = import_joi35.default.object({
+      page: import_joi35.default.number().min(1).optional().allow("", null),
+      limit: import_joi35.default.number().min(1).optional().allow("", null),
+      search: import_joi35.default.string().optional().allow("", null),
+      school: import_joi35.default.string().hex().optional().allow("", null),
+      building: import_joi35.default.string().hex().optional().allow("", null),
+      status: import_joi35.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils51.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -7881,12 +9145,12 @@ function useBuildingUnitController() {
   }
   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_joi35.default.object({
+      id: import_joi35.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils51.BadRequestError(error.message));
       return;
     }
     try {
@@ -7902,12 +9166,12 @@ function useBuildingUnitController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi27.default.object({
-      id: import_joi27.default.string().hex().required()
+    const validation = import_joi35.default.object({
+      id: import_joi35.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils51.BadRequestError(error.message));
       return;
     }
     try {
@@ -7928,14 +9192,14 @@ function useBuildingUnitController() {
 }
 
 // src/resources/counter/counter.model.ts
-var import_utils43 = require("@goweekdays/utils");
-var import_mongodb20 = require("mongodb");
+var import_utils52 = 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_mongodb20.ObjectId)
-  ]).transform((val) => typeof val === "string" ? new import_mongodb20.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()),
@@ -7948,7 +9212,7 @@ function useCounterModel(db) {
     try {
       return TCounter.parse(value);
     } catch (error) {
-      throw new import_utils43.BadRequestError(error.issues[0].message);
+      throw new import_utils52.BadRequestError(error.issues[0].message);
     }
   }
   function validateCounter(data) {
@@ -7962,23 +9226,23 @@ function useCounterModel(db) {
 }
 
 // src/resources/counter/counter.repository.ts
-var import_utils44 = require("@goweekdays/utils");
+var import_utils53 = require("@goweekdays/utils");
 function useCounterRepo() {
-  const db = import_utils44.useAtlas.getDb();
+  const db = import_utils53.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_utils44.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils53.useCache)(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils44.logger.log({
+      import_utils53.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils44.logger.log({
+      import_utils53.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -8030,11 +9294,11 @@ function useCounterRepo() {
     }
   }
   async function getByType(type) {
-    const cacheKey = (0, import_utils44.makeCacheKey)(namespace_collection, { type });
+    const cacheKey = (0, import_utils53.makeCacheKey)(namespace_collection, { type });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils44.logger.log({
+        import_utils53.logger.log({
           level: "info",
           message: `Cache hit for getByType counter: ${cacheKey}`
         });
@@ -8043,12 +9307,12 @@ function useCounterRepo() {
       const data = await collection.findOne({ type });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          import_utils44.logger.log({
+          import_utils53.logger.log({
             level: "info",
             message: `Cache set for counter by type: ${cacheKey}`
           });
         }).catch((err) => {
-          import_utils44.logger.log({
+          import_utils53.logger.log({
             level: "error",
             message: `Failed to set cache for counter by type: ${err.message}`
           });
@@ -8069,7 +9333,7 @@ function useCounterRepo() {
 }
 
 // src/resources/file/file.service.ts
-var import_utils45 = require("@goweekdays/utils");
+var import_utils54 = require("@goweekdays/utils");
 var import_node_cron = __toESM(require("node-cron"));
 var fs = __toESM(require("fs"));
 function useFileService() {
@@ -8078,7 +9342,7 @@ function useFileService() {
     deleteFileById,
     getAllDraftedFiles
   } = useFileRepo();
-  const s3 = new import_utils45.useS3({
+  const s3 = new import_utils54.useS3({
     accessKeyId: SPACES_ACCESS_KEY,
     secretAccessKey: SPACES_SECRET_KEY,
     endpoint: SPACES_ENDPOINT,
@@ -8087,7 +9351,7 @@ function useFileService() {
     forcePathStyle: true
   });
   async function createFile(value) {
-    const session = import_utils45.useAtlas.getClient()?.startSession();
+    const session = import_utils54.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     const file = {
       name: value.originalname,
@@ -8121,7 +9385,7 @@ function useFileService() {
     }
   }
   async function deleteFile(id) {
-    const session = import_utils45.useAtlas.getClient()?.startSession();
+    const session = import_utils54.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       await deleteFileById(id, session);
@@ -8142,12 +9406,12 @@ function useFileService() {
         const file = files[index];
         try {
           await deleteFile(file._id.toString());
-          await import_utils45.logger.log({
+          await import_utils54.logger.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
         } catch (error) {
-          import_utils45.logger.log({
+          import_utils54.logger.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
@@ -8164,8 +9428,8 @@ function useFileService() {
 }
 
 // src/resources/file/file.controller.ts
-var import_utils46 = require("@goweekdays/utils");
-var import_joi28 = __toESM(require("joi"));
+var import_utils55 = require("@goweekdays/utils");
+var import_joi36 = __toESM(require("joi"));
 function useFileController() {
   const { createFile, deleteFile: _deleteFile } = useFileService();
   async function upload(req, res, next) {
@@ -8178,29 +9442,29 @@ function useFileController() {
       res.json({ message: "Successfully uploaded file", id });
       return;
     } catch (error) {
-      if (error instanceof import_utils46.AppError) {
+      if (error instanceof import_utils55.AppError) {
         next(error);
       } else {
-        next(new import_utils46.InternalServerError(error));
+        next(new import_utils55.InternalServerError(error));
       }
     }
   }
   async function deleteFile(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi28.default.string().required();
+    const validation = import_joi36.default.string().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils55.BadRequestError(error.message));
     }
     try {
       const message = await _deleteFile(id);
       res.json({ message });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils46.AppError) {
+      if (error2 instanceof import_utils55.AppError) {
         next(error2);
       } else {
-        next(new import_utils46.InternalServerError(error2));
+        next(new import_utils55.InternalServerError(error2));
       }
     }
   }
@@ -8211,11 +9475,11 @@ function useFileController() {
 }
 
 // src/resources/psgc/psgc.model.ts
-var import_joi29 = __toESM(require("joi"));
-var schemaPSGC = import_joi29.default.object({
-  code: import_joi29.default.string().length(10).required(),
-  name: import_joi29.default.string().required(),
-  type: import_joi29.default.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required()
+var import_joi37 = __toESM(require("joi"));
+var schemaPSGC = import_joi37.default.object({
+  code: import_joi37.default.string().length(10).required(),
+  name: import_joi37.default.string().required(),
+  type: import_joi37.default.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required()
 });
 function modelPSGC(data) {
   const { error } = schemaPSGC.validate(data);
@@ -8230,16 +9494,16 @@ function modelPSGC(data) {
 }
 
 // src/resources/psgc/psgc.repository.ts
-var import_utils47 = require("@goweekdays/utils");
-var import_mongodb21 = require("mongodb");
+var import_utils56 = require("@goweekdays/utils");
+var import_mongodb26 = require("mongodb");
 function usePSGCRepo() {
-  const db = import_utils47.useAtlas.getDb();
+  const db = import_utils56.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "psgc";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils47.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils56.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -8253,12 +9517,12 @@ function usePSGCRepo() {
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils47.logger.log({
+      import_utils56.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils47.logger.log({
+      import_utils56.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -8271,16 +9535,16 @@ function usePSGCRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils47.logger.log({
+      import_utils56.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils47.AppError) {
+      if (error instanceof import_utils56.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils47.BadRequestError("Region already exists.");
+          throw new import_utils56.BadRequestError("Region already exists.");
         }
         throw new Error("Failed to create PSGC.");
       }
@@ -8316,15 +9580,15 @@ function usePSGCRepo() {
       query.$text = { $search: search };
       cacheKeyOptions.search = search;
     }
-    const cacheKey = (0, import_utils47.makeCacheKey)(namespace_collection, cacheKeyOptions);
-    import_utils47.logger.log({
+    const cacheKey = (0, import_utils56.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_utils56.logger.log({
       level: "info",
       message: `Cache key for getAll PSGC: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils47.logger.log({
+        import_utils56.logger.log({
           level: "info",
           message: `Cache hit for getAll PSGC: ${cacheKey}`
         });
@@ -8337,35 +9601,35 @@ function usePSGCRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils47.paginate)(items, page, limit, length);
+      const data = (0, import_utils56.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils47.logger.log({
+        import_utils56.logger.log({
           level: "info",
           message: `Cache set for getAll PSGC: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils47.logger.log({
+        import_utils56.logger.log({
           level: "error",
           message: `Failed to set cache for getAll PSGC: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils47.logger.log({ level: "error", message: `${error}` });
+      import_utils56.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new import_mongodb21.ObjectId(_id);
+      _id = new import_mongodb26.ObjectId(_id);
     } catch (error) {
-      throw new import_utils47.BadRequestError("Invalid ID.");
+      throw new import_utils56.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils47.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils56.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils47.logger.log({
+        import_utils56.logger.log({
           level: "info",
           message: `Cache hit for getById PSGC: ${cacheKey}`
         });
@@ -8376,25 +9640,25 @@ function usePSGCRepo() {
         deletedAt: { $in: ["", null] }
       });
       if (!result) {
-        throw new import_utils47.BadRequestError("Region not found.");
+        throw new import_utils56.BadRequestError("Region not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        import_utils47.logger.log({
+        import_utils56.logger.log({
           level: "info",
           message: `Cache set for PSGC by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils47.logger.log({
+        import_utils56.logger.log({
           level: "error",
           message: `Failed to set cache for PSGC by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils47.AppError) {
+      if (error instanceof import_utils56.AppError) {
         throw error;
       } else {
-        throw new import_utils47.InternalServerError("Failed to get PSGC.");
+        throw new import_utils56.InternalServerError("Failed to get PSGC.");
       }
     }
   }
@@ -8418,15 +9682,15 @@ function usePSGCRepo() {
       query.code = { $regex: `^${prefix}` };
       cacheKeyOptions.prefix = prefix;
     }
-    const cacheKey = (0, import_utils47.makeCacheKey)(namespace_collection, { name });
-    import_utils47.logger.log({
+    const cacheKey = (0, import_utils56.makeCacheKey)(namespace_collection, { name });
+    import_utils56.logger.log({
       level: "info",
       message: `Query for getByName PSGC: ${JSON.stringify(query)}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils47.logger.log({
+        import_utils56.logger.log({
           level: "info",
           message: `Cache hit for getByName PSGC: ${cacheKey}`
         });
@@ -8434,36 +9698,36 @@ function usePSGCRepo() {
       }
       const result = await collection.findOne(query);
       setCache(cacheKey, result, 300).then(() => {
-        import_utils47.logger.log({
+        import_utils56.logger.log({
           level: "info",
           message: `Cache set for PSGC by name: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils47.logger.log({
+        import_utils56.logger.log({
           level: "error",
           message: `Failed to set cache for PSGC by name: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils47.AppError) {
+      if (error instanceof import_utils56.AppError) {
         throw error;
       } else {
-        throw new import_utils47.InternalServerError("Failed to get PSGC.");
+        throw new import_utils56.InternalServerError("Failed to get PSGC.");
       }
     }
   }
   async function updateFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["name"];
     if (!allowedFields.includes(field)) {
-      throw new import_utils47.BadRequestError(
+      throw new import_utils56.BadRequestError(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
-      _id = new import_mongodb21.ObjectId(_id);
+      _id = new import_mongodb26.ObjectId(_id);
     } catch (error) {
-      throw new import_utils47.BadRequestError("Invalid ID.");
+      throw new import_utils56.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -8474,14 +9738,14 @@ function usePSGCRepo() {
       delCachedData();
       return `Successfully updated PSGC ${field}.`;
     } catch (error) {
-      throw new import_utils47.InternalServerError(`Failed to update PSGC ${field}.`);
+      throw new import_utils56.InternalServerError(`Failed to update PSGC ${field}.`);
     }
   }
   async function deleteById(_id) {
     try {
-      _id = new import_mongodb21.ObjectId(_id);
+      _id = new import_mongodb26.ObjectId(_id);
     } catch (error) {
-      throw new import_utils47.BadRequestError("Invalid ID.");
+      throw new import_utils56.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -8491,7 +9755,7 @@ function usePSGCRepo() {
       delCachedData();
       return "Successfully deleted PSGC.";
     } catch (error) {
-      throw new import_utils47.InternalServerError("Failed to delete PSGC.");
+      throw new import_utils56.InternalServerError("Failed to delete PSGC.");
     }
   }
   return {
@@ -8506,8 +9770,8 @@ function usePSGCRepo() {
 }
 
 // src/resources/psgc/psgc.controller.ts
-var import_utils48 = require("@goweekdays/utils");
-var import_joi30 = __toESM(require("joi"));
+var import_utils57 = require("@goweekdays/utils");
+var import_joi38 = __toESM(require("joi"));
 function usePSGCController() {
   const {
     add: _add,
@@ -8521,7 +9785,7 @@ function usePSGCController() {
     const value = req.body;
     const { error } = schemaPSGC.validate(value);
     if (error) {
-      next(new import_utils48.BadRequestError(error.message));
+      next(new import_utils57.BadRequestError(error.message));
       return;
     }
     try {
@@ -8537,12 +9801,12 @@ function usePSGCController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi30.default.object({
-      page: import_joi30.default.number().min(1).optional().allow("", null),
-      limit: import_joi30.default.number().min(1).optional().allow("", null),
-      search: import_joi30.default.string().optional().allow("", null),
-      type: import_joi30.default.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required(),
-      prefix: import_joi30.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),
+      type: import_joi38.default.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required(),
+      prefix: import_joi38.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
@@ -8552,16 +9816,16 @@ function usePSGCController() {
     const prefix = req.query.prefix ? String(req.query.prefix) : "";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_utils48.BadRequestError("Invalid page number."));
+      next(new import_utils57.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_utils48.BadRequestError("Invalid limit number."));
+      next(new import_utils57.BadRequestError("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new import_utils48.BadRequestError(error.message));
+      next(new import_utils57.BadRequestError(error.message));
       return;
     }
     try {
@@ -8580,12 +9844,12 @@ function usePSGCController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi30.default.object({
-      id: import_joi30.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_utils48.BadRequestError(error.message));
+      next(new import_utils57.BadRequestError(error.message));
       return;
     }
     try {
@@ -8601,12 +9865,12 @@ function usePSGCController() {
   }
   async function getByName(req, res, next) {
     const name = req.params.name;
-    const validation = import_joi30.default.object({
-      name: import_joi30.default.string().required()
+    const validation = import_joi38.default.object({
+      name: import_joi38.default.string().required()
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new import_utils48.BadRequestError(error.message));
+      next(new import_utils57.BadRequestError(error.message));
       return;
     }
     try {
@@ -8623,14 +9887,14 @@ function usePSGCController() {
   async function updateField(req, res, next) {
     const _id = req.params.id;
     const { field, value } = req.body;
-    const validation = import_joi30.default.object({
-      _id: import_joi30.default.string().hex().required(),
-      field: import_joi30.default.string().valid("name", "director", "directorName").required(),
-      value: import_joi30.default.string().required()
+    const validation = import_joi38.default.object({
+      _id: import_joi38.default.string().hex().required(),
+      field: import_joi38.default.string().valid("name", "director", "directorName").required(),
+      value: import_joi38.default.string().required()
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new import_utils48.BadRequestError(error.message));
+      next(new import_utils57.BadRequestError(error.message));
       return;
     }
     try {
@@ -8643,12 +9907,12 @@ function usePSGCController() {
   }
   async function deleteById(req, res, next) {
     const _id = req.params.id;
-    const validation = import_joi30.default.object({
-      _id: import_joi30.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_utils48.BadRequestError(error.message));
+      next(new import_utils57.BadRequestError(error.message));
       return;
     }
     try {
@@ -8670,7 +9934,7 @@ function usePSGCController() {
 }
 
 // src/resources/utils/github.service.ts
-var import_utils49 = require("@goweekdays/utils");
+var import_utils58 = require("@goweekdays/utils");
 var import_rest = require("@octokit/rest");
 var import_libsodium_wrappers = __toESM(require("libsodium-wrappers"));
 function useGitHubService() {
@@ -8684,23 +9948,23 @@ function useGitHubService() {
     try {
       const { data: repoData } = await octokit.repos.get({ owner, repo });
       if (!repoData.permissions?.admin) {
-        throw new import_utils49.BadRequestError(
+        throw new import_utils58.BadRequestError(
           "You do not have admin access to this repository."
         );
       }
     } catch (error) {
       if (error.status === 404) {
-        throw new import_utils49.BadRequestError(
+        throw new import_utils58.BadRequestError(
           "Repository not found or you don't have access to it."
         );
       } else if (error.status === 401) {
-        throw new import_utils49.BadRequestError(
+        throw new import_utils58.BadRequestError(
           "Invalid GitHub token or insufficient permissions."
         );
       } else if (error.message.includes("admin access")) {
         throw error;
       } else {
-        throw new import_utils49.BadRequestError(
+        throw new import_utils58.BadRequestError(
           `Failed to check repository permissions: ${error.message}`
         );
       }
@@ -8749,7 +10013,7 @@ function useGitHubService() {
               key_id: publicKeyRes.key_id
             });
           } catch (encryptionError) {
-            throw new import_utils49.BadRequestError(
+            throw new import_utils58.BadRequestError(
               `Failed to encrypt secret '${key}': ${encryptionError.message}`
             );
           }
@@ -8779,22 +10043,22 @@ function useGitHubService() {
       }
       return `Successfully set ${lines.length} ${type} variables/secrets in environment '${environment}'`;
     } catch (error) {
-      if (error instanceof import_utils49.AppError)
+      if (error instanceof import_utils58.AppError)
         throw error;
       if (error.status === 422) {
-        throw new import_utils49.BadRequestError(
+        throw new import_utils58.BadRequestError(
           `GitHub API validation error: ${error.message}`
         );
       } else if (error.status === 404) {
-        throw new import_utils49.BadRequestError("Environment or repository not found.");
+        throw new import_utils58.BadRequestError("Environment or repository not found.");
       } else if (error.status === 403) {
-        throw new import_utils49.BadRequestError(
+        throw new import_utils58.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_utils49.BadRequestError(
+        throw new import_utils58.BadRequestError(
           `Failed to set GitHub variables: ${error.message}`
         );
       }
@@ -8806,8 +10070,8 @@ function useGitHubService() {
 }
 
 // src/resources/utils/util.controller.ts
-var import_joi31 = __toESM(require("joi"));
-var import_utils50 = require("@goweekdays/utils");
+var import_joi39 = __toESM(require("joi"));
+var import_utils59 = require("@goweekdays/utils");
 function useUtilController() {
   async function healthCheck(req, res, next) {
     try {
@@ -8823,32 +10087,32 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_utils50.logger.error("Health check failed", { error: error.message });
-      next(new import_utils50.InternalServerError("Health check failed"));
+      import_utils59.logger.error("Health check failed", { error: error.message });
+      next(new import_utils59.InternalServerError("Health check failed"));
     }
   }
   async function setGitHubVariables(req, res, next) {
     try {
       const { githubToken, repoUrl, environment, type, keyValues } = req.body;
-      const validation = import_joi31.default.object({
-        githubToken: import_joi31.default.string().required().messages({
+      const validation = import_joi39.default.object({
+        githubToken: import_joi39.default.string().required().messages({
           "string.empty": "GitHub token is required",
           "any.required": "GitHub token is required"
         }),
-        repoUrl: import_joi31.default.string().uri().required().messages({
+        repoUrl: import_joi39.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_joi31.default.string().required().messages({
+        environment: import_joi39.default.string().required().messages({
           "string.empty": "Environment name is required",
           "any.required": "Environment name is required"
         }),
-        type: import_joi31.default.string().valid("env", "secret").required().messages({
+        type: import_joi39.default.string().valid("env", "secret").required().messages({
           "any.only": 'Type must be either "env" or "secret"',
           "any.required": "Type is required"
         }),
-        keyValues: import_joi31.default.string().required().messages({
+        keyValues: import_joi39.default.string().required().messages({
           "string.empty": "Key-value pairs are required",
           "any.required": "Key-value pairs are required"
         })
@@ -8861,13 +10125,13 @@ function useUtilController() {
         keyValues
       });
       if (error) {
-        next(new import_utils50.BadRequestError(error.message));
+        next(new import_utils59.BadRequestError(error.message));
         return;
       }
       const repoUrlPattern = /github\.com[:\/]([^\/]+)\/(.+)\.git$/;
       if (!repoUrlPattern.test(repoUrl)) {
         next(
-          new import_utils50.BadRequestError(
+          new import_utils59.BadRequestError(
             "Invalid GitHub repository URL format. Expected format: https://github.com/owner/repo.git"
           )
         );
@@ -8879,7 +10143,7 @@ function useUtilController() {
       );
       if (invalidLines.length > 0) {
         next(
-          new import_utils50.BadRequestError(
+          new import_utils59.BadRequestError(
             "Invalid key-value format. Each pair should be in format: KEY=value. Pairs should be separated by semicolons."
           )
         );
@@ -8893,7 +10157,7 @@ function useUtilController() {
         type,
         keyValues
       });
-      import_utils50.logger.info(`GitHub variables set successfully`, {
+      import_utils59.logger.info(`GitHub variables set successfully`, {
         repoUrl,
         environment,
         type,
@@ -8910,15 +10174,15 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_utils50.logger.error("Failed to set GitHub variables", {
+      import_utils59.logger.error("Failed to set GitHub variables", {
         error: error.message,
         stack: error.stack
       });
-      if (error instanceof import_utils50.AppError) {
+      if (error instanceof import_utils59.AppError) {
         next(error);
       } else {
         next(
-          new import_utils50.InternalServerError(
+          new import_utils59.InternalServerError(
             `Failed to set GitHub variables: ${error.message}`
           )
         );
@@ -8932,31 +10196,31 @@ function useUtilController() {
 }
 
 // src/resources/utils/transaction.schema.ts
-var import_joi32 = __toESM(require("joi"));
-var transactionSchema = import_joi32.default.object({
-  _id: import_joi32.default.string().hex().optional().allow("", null),
-  payment: import_joi32.default.string().required(),
-  user: import_joi32.default.string().hex().optional().allow("", null),
-  org: import_joi32.default.string().hex().optional().allow("", null),
-  type: import_joi32.default.string().required(),
-  amount: import_joi32.default.number().positive().min(0).required(),
-  currency: import_joi32.default.string().required(),
-  description: import_joi32.default.string().optional().allow("", null),
-  metadata: import_joi32.default.object({
-    subscriptionId: import_joi32.default.string().hex().optional().allow("", null),
-    cycle: import_joi32.default.number().optional().allow("", null),
-    seats: import_joi32.default.number().optional().allow("", null),
-    promoCode: import_joi32.default.string().optional().allow("", null)
+var import_joi40 = __toESM(require("joi"));
+var transactionSchema = import_joi40.default.object({
+  _id: import_joi40.default.string().hex().optional().allow("", null),
+  payment: import_joi40.default.string().required(),
+  user: import_joi40.default.string().hex().optional().allow("", null),
+  org: import_joi40.default.string().hex().optional().allow("", null),
+  type: import_joi40.default.string().required(),
+  amount: import_joi40.default.number().positive().min(0).required(),
+  currency: import_joi40.default.string().required(),
+  description: import_joi40.default.string().optional().allow("", null),
+  metadata: import_joi40.default.object({
+    subscriptionId: import_joi40.default.string().hex().optional().allow("", null),
+    cycle: import_joi40.default.number().optional().allow("", null),
+    seats: import_joi40.default.number().optional().allow("", null),
+    promoCode: import_joi40.default.string().optional().allow("", null)
   }).optional().allow("", null),
-  status: import_joi32.default.string().optional().allow("", null),
-  createdAt: import_joi32.default.string().optional().allow("", null),
-  updatedAt: import_joi32.default.string().optional().allow("", null),
-  deletedAt: import_joi32.default.string().optional().allow("", null)
+  status: import_joi40.default.string().optional().allow("", null),
+  createdAt: import_joi40.default.string().optional().allow("", null),
+  updatedAt: import_joi40.default.string().optional().allow("", null),
+  deletedAt: import_joi40.default.string().optional().allow("", null)
 });
 
 // src/resources/verification/verification.controller.ts
-var import_utils51 = require("@goweekdays/utils");
-var import_joi33 = __toESM(require("joi"));
+var import_utils60 = require("@goweekdays/utils");
+var import_joi41 = __toESM(require("joi"));
 function useVerificationController() {
   const {
     createUserInvite: _createUserInvite,
@@ -8970,17 +10234,17 @@ function useVerificationController() {
   } = useVerificationService();
   const { getVerifications: _getVerifications } = useVerificationRepo();
   async function createUserInvite(req, res, next) {
-    const validation = import_joi33.default.object({
-      email: import_joi33.default.string().email().required(),
-      app: import_joi33.default.string().required(),
-      role: import_joi33.default.string().hex().required(),
-      roleName: import_joi33.default.string().required(),
-      org: import_joi33.default.string().hex().optional().optional().allow("", null),
-      orgName: import_joi33.default.string().optional().optional().allow("", null)
+    const validation = import_joi41.default.object({
+      email: import_joi41.default.string().email().required(),
+      app: import_joi41.default.string().required(),
+      role: import_joi41.default.string().hex().required(),
+      roleName: import_joi41.default.string().required(),
+      org: import_joi41.default.string().hex().optional().optional().allow("", null),
+      orgName: import_joi41.default.string().optional().optional().allow("", null)
     });
     const { error } = validation.validate(req.body);
     if (error) {
-      next(new import_utils51.BadRequestError(error.message));
+      next(new import_utils60.BadRequestError(error.message));
       return;
     }
     const email = req.body.email ?? "";
@@ -9008,10 +10272,10 @@ function useVerificationController() {
   }
   async function createForgetPassword(req, res, next) {
     const email = req.body.email || "";
-    const validation = import_joi33.default.string().email().required();
+    const validation = import_joi41.default.string().email().required();
     const { error } = validation.validate(email);
     if (error) {
-      next(new import_utils51.BadRequestError(error.message));
+      next(new import_utils60.BadRequestError(error.message));
       return;
     }
     try {
@@ -9021,26 +10285,26 @@ function useVerificationController() {
       });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils51.AppError) {
+      if (error2 instanceof import_utils60.AppError) {
         next(error2);
       } else {
-        next(new import_utils51.InternalServerError("An unexpected error occurred"));
+        next(new import_utils60.InternalServerError("An unexpected error occurred"));
       }
     }
   }
   async function getVerifications(req, res, next) {
-    const validation = import_joi33.default.object({
-      status: import_joi33.default.string().required(),
-      search: import_joi33.default.string().optional().allow("", null),
-      page: import_joi33.default.number().required(),
-      type: import_joi33.default.string().optional().allow("", null),
-      email: import_joi33.default.string().optional().allow("", null),
-      app: import_joi33.default.string().optional().allow("", null),
-      org: import_joi33.default.string().optional().allow("", null)
+    const validation = import_joi41.default.object({
+      status: import_joi41.default.string().required(),
+      search: import_joi41.default.string().optional().allow("", null),
+      page: import_joi41.default.number().required(),
+      type: import_joi41.default.string().optional().allow("", null),
+      email: import_joi41.default.string().optional().allow("", null),
+      app: import_joi41.default.string().optional().allow("", null),
+      org: import_joi41.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(req.query);
     if (error) {
-      next(new import_utils51.BadRequestError(error.message));
+      next(new import_utils60.BadRequestError(error.message));
       return;
     }
     const status = req.query.status ?? "";
@@ -9073,10 +10337,10 @@ function useVerificationController() {
   }
   async function verify(req, res, next) {
     const id = req.params.id || "";
-    const validation = import_joi33.default.string().hex().required();
+    const validation = import_joi41.default.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils51.BadRequestError(error.message));
+      next(new import_utils60.BadRequestError(error.message));
       return;
     }
     try {
@@ -9089,10 +10353,10 @@ function useVerificationController() {
   }
   async function cancelUserInvitation(req, res, next) {
     const otpId = req.params.id || "";
-    const validation = import_joi33.default.string().hex().required();
+    const validation = import_joi41.default.string().hex().required();
     const { error } = validation.validate(otpId);
     if (error) {
-      next(new import_utils51.BadRequestError(error.message));
+      next(new import_utils60.BadRequestError(error.message));
       return;
     }
     try {
@@ -9105,10 +10369,10 @@ function useVerificationController() {
     }
   }
   async function signUp(req, res, next) {
-    const validation = import_joi33.default.string().email().required();
+    const validation = import_joi41.default.string().email().required();
     const { error } = validation.validate(req.body.email);
     if (error) {
-      next(new import_utils51.BadRequestError(error.message));
+      next(new import_utils60.BadRequestError(error.message));
       return;
     }
     const email = req.body.email ?? "";
@@ -9123,7 +10387,7 @@ function useVerificationController() {
   async function inviteMember(req, res, next) {
     const { error } = schemaInviteMember.validate(req.body);
     if (error) {
-      next(new import_utils51.BadRequestError(error.message));
+      next(new import_utils60.BadRequestError(error.message));
       return;
     }
     try {
@@ -9136,10 +10400,10 @@ function useVerificationController() {
   }
   async function cancelInviteMember(req, res, next) {
     const id = req.params.id || "";
-    const validation = import_joi33.default.string().hex().required();
+    const validation = import_joi41.default.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils51.BadRequestError(error.message));
+      next(new import_utils60.BadRequestError(error.message));
       return;
     }
     try {
@@ -9152,10 +10416,10 @@ function useVerificationController() {
   }
   async function forgetPassword(req, res, next) {
     const email = req.body.email ?? "";
-    const validation = import_joi33.default.string().email().required();
+    const validation = import_joi41.default.string().email().required();
     const { error } = validation.validate(email);
     if (error) {
-      next(new import_utils51.BadRequestError(error.message));
+      next(new import_utils60.BadRequestError(error.message));
       return;
     }
     try {
@@ -9165,10 +10429,10 @@ function useVerificationController() {
       });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils51.AppError) {
+      if (error2 instanceof import_utils60.AppError) {
         next(error2);
       } else {
-        next(new import_utils51.InternalServerError("An unexpected error occurred"));
+        next(new import_utils60.InternalServerError("An unexpected error occurred"));
       }
     }
   }
@@ -9226,6 +10490,7 @@ function useVerificationController() {
   XENDIT_BASE_URL,
   XENDIT_SECRET_KEY,
   addressSchema,
+  currencies,
   isDev,
   modelApp,
   modelMember,
@@ -9233,7 +10498,10 @@ function useVerificationController() {
   modelPSGC,
   modelPermission,
   modelPermissionGroup,
+  modelPlan,
   modelRole,
+  modelSubscription,
+  modelSubscriptionTransaction,
   modelUser,
   modelVerification,
   schemaApp,
@@ -9245,13 +10513,20 @@ function useVerificationController() {
   schemaMemberRole,
   schemaMemberStatus,
   schemaOrg,
+  schemaOrgAdd,
+  schemaOrgUpdate,
   schemaPSGC,
   schemaPermission,
   schemaPermissionGroup,
   schemaPermissionGroupUpdate,
   schemaPermissionUpdate,
+  schemaPlan,
   schemaRole,
   schemaRoleUpdate,
+  schemaSubscription,
+  schemaSubscriptionSeats,
+  schemaSubscriptionTransaction,
+  schemaSubscriptionUpdate,
   schemaUpdateOptions,
   schemaUser,
   schemaVerification,
@@ -9288,9 +10563,16 @@ function useVerificationController() {
   usePermissionGroupService,
   usePermissionRepo,
   usePermissionService,
+  usePlanController,
+  usePlanRepo,
+  usePlanService,
   useRoleController,
   useRoleRepo,
   useRoleService,
+  useSubscriptionController,
+  useSubscriptionRepo,
+  useSubscriptionTransactionController,
+  useSubscriptionTransactionRepo,
   useUserController,
   useUserRepo,
   useUserService,