@goweekdays/core 2.3.1 → 2.4.0

package/dist/index.mjs

@@ -807,25 +807,25 @@ function useAuthService() {
 }
 
 // src/resources/auth/auth.controller.ts
-import Joi24 from "joi";
+import Joi32 from "joi";
 import {
-  AppError as AppError14,
-  BadRequestError as BadRequestError34,
-  InternalServerError as InternalServerError18,
-  logger as logger18
+  AppError as AppError17,
+  BadRequestError as BadRequestError42,
+  InternalServerError as InternalServerError21,
+  logger as logger21
 } from "@goweekdays/utils";
 
 // src/resources/verification/verification.service.ts
 import {
   useMailer,
   compileHandlebar,
-  logger as logger17,
+  logger as logger20,
   getDirectory,
-  BadRequestError as BadRequestError33,
+  BadRequestError as BadRequestError41,
   NotFoundError as NotFoundError4,
-  InternalServerError as InternalServerError17,
-  useAtlas as useAtlas15,
-  AppError as AppError13
+  InternalServerError as InternalServerError20,
+  useAtlas as useAtlas19,
+  AppError as AppError16
 } from "@goweekdays/utils";
 
 // src/resources/verification/verification.model.ts
@@ -1228,15 +1228,15 @@ var DOMAIN = process.env.DOMAIN || "localhost";
 
 // src/resources/user/user.service.ts
 import {
-  AppError as AppError11,
-  BadRequestError as BadRequestError31,
-  InternalServerError as InternalServerError15,
+  AppError as AppError14,
+  BadRequestError as BadRequestError39,
+  InternalServerError as InternalServerError18,
   NotFoundError as NotFoundError3,
   hashPassword,
-  logger as logger16,
-  makeCacheKey as makeCacheKey11,
-  useAtlas as useAtlas14,
-  useCache as useCache12,
+  logger as logger19,
+  makeCacheKey as makeCacheKey14,
+  useAtlas as useAtlas18,
+  useCache as useCache15,
   useS3
 } from "@goweekdays/utils";
 
@@ -4154,6 +4154,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) {
@@ -4588,13 +4615,25 @@ function usePermissionGroupController() {
 import { BadRequestError as BadRequestError23 } from "@goweekdays/utils";
 import Joi17 from "joi";
 import { ObjectId as ObjectId15 } from "mongodb";
-var schemaOrg = Joi17.object({
+var schema = {
   name: Joi17.string().max(255).required(),
   description: Joi17.string().max(1024).optional().allow("", null),
-  email: Joi17.string().email().max(255).optional().allow("", null),
-  contact: Joi17.string().max(50).optional().allow("", null),
+  email: Joi17.string().email().max(255).required(),
+  contact: Joi17.string().max(50).optional().allow("", null)
+};
+var schemaOrg = Joi17.object({
+  ...schema,
   createdBy: Joi17.string().hex().required()
 });
+var schemaOrgAdd = Joi17.object({
+  ...schema,
+  createdBy: Joi17.string().hex().required(),
+  seats: Joi17.number().required()
+});
+var schemaOrgUpdate = Joi17.object({
+  ...schema,
+  _id: Joi17.string().hex().required()
+});
 function modelOrg(value) {
   const { error } = schemaOrg.validate(value);
   if (error) {
@@ -4877,6 +4916,30 @@ function useOrgRepo() {
       throw new InternalServerError11("Failed to delete organization.");
     }
   }
+  async function updateById(_id, options) {
+    const { error } = schemaOrgUpdate.validate({ ...options, _id });
+    if (error) {
+      throw new BadRequestError24(error.message);
+    }
+    try {
+      _id = new ObjectId16(_id);
+    } catch (error2) {
+      throw new BadRequestError24("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 BadRequestError24("Organization name already exist.");
+      }
+      throw new InternalServerError11("Failed to update org info.");
+    }
+  }
   return {
     createIndexes,
     add,
@@ -4884,12 +4947,13 @@ function useOrgRepo() {
     getById,
     updateFieldById,
     deleteById,
-    getByName
+    getByName,
+    updateById
   };
 }
 
 // src/resources/organization/organization.service.ts
-import { BadRequestError as BadRequestError29, useAtlas as useAtlas13 } from "@goweekdays/utils";
+import { BadRequestError as BadRequestError37, useAtlas as useAtlas17 } from "@goweekdays/utils";
 
 // src/resources/member/member.controller.ts
 import Joi20 from "joi";
@@ -5414,162 +5478,1353 @@ 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 = useAtlas13.getClient()?.startSession();
-    if (!session) {
-      throw new BadRequestError29("Unable to start database session.");
-    }
+// src/resources/subscription/subscription.model.ts
+import { BadRequestError as BadRequestError29 } from "@goweekdays/utils";
+import Joi21 from "joi";
+import { ObjectId as ObjectId17 } from "mongodb";
+var schema2 = {
+  seats: Joi21.number().integer().min(1).required(),
+  paidSeats: Joi21.number().integer().min(0).required(),
+  amount: Joi21.number().positive().required(),
+  promoCode: Joi21.string().optional().allow("", null),
+  nextBillingDate: Joi21.date().optional().allow("", null)
+};
+var schemaSubscription = Joi21.object({
+  ...schema2,
+  org: Joi21.string().hex().length(24).required(),
+  currency: Joi21.string().length(3).required(),
+  billingCycle: Joi21.string().valid("monthly", "yearly").required()
+});
+var schemaSubscriptionUpdate = Joi21.object({
+  ...schema2,
+  status: Joi21.string().optional().allow("", null)
+});
+var schemaSubscriptionSeats = Joi21.object({
+  id: Joi21.string().hex().length(24).required(),
+  seats: Joi21.number().integer().min(1).required(),
+  amount: Joi21.number().positive().optional().allow(null, 0),
+  user: Joi21.string().hex().length(24).required()
+});
+function modelSubscription(data) {
+  const { error } = schemaSubscription.validate(data);
+  if (error) {
+    throw new BadRequestError29(`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 BadRequestError29("Role is required to create org member.");
-      }
-      const user = await getUserById(createdBy);
-      if (!user) {
-        throw new BadRequestError29("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 ObjectId17(data._id);
+    } catch (error2) {
+      throw new BadRequestError29("Invalid subscription ID.");
     }
   }
+  try {
+    data.org = new ObjectId17(data.org);
+  } catch (error2) {
+    throw new BadRequestError29("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
-import { BadRequestError as BadRequestError30 } from "@goweekdays/utils";
-import Joi21 from "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 BadRequestError30(error.message));
-      return;
+// src/resources/subscription/subscription.repository.ts
+import {
+  AppError as AppError11,
+  BadRequestError as BadRequestError30,
+  InternalServerError as InternalServerError15,
+  logger as logger16,
+  makeCacheKey as makeCacheKey11,
+  paginate as paginate9,
+  useAtlas as useAtlas13,
+  useCache as useCache12
+} from "@goweekdays/utils";
+import Joi22 from "joi";
+import { ObjectId as ObjectId18 } from "mongodb";
+function useSubscriptionRepo() {
+  const db = useAtlas13.getDb();
+  if (!db) {
+    throw new InternalServerError15("Unable to connect to server.");
+  }
+  const namespace_collection = "subscriptions";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache12(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      logger16.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger16.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        {
+          key: {
+            org: 1
+          },
+          name: "org_index"
+        },
+        {
+          key: { org: 1, status: 1 },
+          name: "org_status_index"
+        }
+      ]);
+    } catch (error) {
     }
+  }
+  createIndexes().catch((error) => {
+    logger16.log({
+      level: "error",
+      message: `Failed to create indexes for subscriptions collection: ${error.message}`
+    });
+  });
+  async function add(value, session) {
     try {
-      const org = await _add(value);
-      res.json({
-        message: "Organization created successfully.",
-        data: { org }
+      value = modelSubscription(value);
+      const result = await collection.insertOne(value, { session });
+      delCachedData();
+      return result.insertedId.toString();
+    } catch (error) {
+      logger16.log({
+        level: "error",
+        message: `${error}`
       });
-      return;
-    } catch (error2) {
-      next(error2);
+      if (error instanceof AppError11) {
+        throw error;
+      }
+      throw new InternalServerError15("Failed to add subscription.");
     }
   }
-  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 BadRequestError30("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 BadRequestError30("Invalid limit number."));
-      return;
+    const cacheKey = makeCacheKey11(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 = paginate9(
+        items,
+        page,
+        limit,
+        length
+      );
+      setCache(cacheKey, data).then(() => {
+        logger16.log({
+          level: "info",
+          message: `Cache set for getAll subscription: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger16.log({
+          level: "error",
+          message: `Failed to set cache for getAll subscription: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new InternalServerError15("Failed to get subscriptions.");
     }
-    const validation = Joi21.object({
-      user: Joi21.string().hex().required(),
-      page: Joi21.number().min(1).optional().allow("", null),
-      limit: Joi21.number().min(1).optional().allow("", null),
-      search: Joi21.string().optional().allow("", null)
-    });
-    const { error } = validation.validate({ user, page, limit, search });
+  }
+  async function getByOrg(org) {
+    const { error } = Joi22.string().hex().length(24).required().validate(org);
     if (error) {
-      next(new BadRequestError30(error.message));
-      return;
+      throw new Error(`Invalid org ID: ${error.message}`);
     }
     try {
-      const orgs = await getOrgsByMembership({ user, page, limit, search });
-      res.json(orgs);
-      return;
+      org = new ObjectId18(org);
     } catch (error2) {
-      next(error2);
+      throw new BadRequestError30("Invalid org ID.");
     }
-  }
-  async function getAll(req, res, next) {
-    const query = req.query;
-    const validation = Joi21.object({
-      page: Joi21.number().min(1).optional().allow("", null),
-      limit: Joi21.number().min(1).optional().allow("", null),
-      search: Joi21.string().optional().allow("", null),
-      status: Joi21.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);
+    try {
+      const cacheKey = makeCacheKey11(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(() => {
+        logger16.log({
+          level: "info",
+          message: `Cache set for getByOrg subscription: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger16.log({
+          level: "error",
+          message: `Failed to set cache for getByOrg subscription: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      throw new InternalServerError15("Failed to get subscription.");
+    }
+  }
+  async function getById(_id) {
+    const { error } = Joi22.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid subscription ID: ${error.message}`);
+    }
+    try {
+      _id = new ObjectId18(_id);
+    } catch (error2) {
+      throw new BadRequestError30("Invalid subscription ID.");
+    }
+    try {
+      const cacheKey = makeCacheKey11(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(() => {
+        logger16.log({
+          level: "info",
+          message: `Cache set for getById subscription: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger16.log({
+          level: "error",
+          message: `Failed to set cache for getById subscription: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      throw new InternalServerError15("Failed to get subscription.");
+    }
+  }
+  async function deleteById(_id) {
+    const { error } = Joi22.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid subscription ID: ${error.message}`);
+    }
+    try {
+      _id = new ObjectId18(_id);
+    } catch (error2) {
+      throw new BadRequestError30("Invalid subscription ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted" } }
+      );
+      if (result.modifiedCount === 0) {
+        throw new InternalServerError15("Failed to delete subscription.");
+      }
+      delCachedData();
+      return "Successfully deleted subscription.";
+    } catch (error2) {
+      if (error2 instanceof AppError11) {
+        throw error2;
+      }
+      throw new InternalServerError15("Failed to delete subscription.");
+    }
+  }
+  async function updateById(_id, options, session) {
+    const { error: errorId } = Joi22.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 BadRequestError30(
+        `Invalid subscription update data: ${error.message}`
+      );
+    }
+    try {
+      _id = new ObjectId18(_id);
+    } catch (error2) {
+      throw new BadRequestError30("Invalid subscription ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      if (result.modifiedCount === 0) {
+        throw new InternalServerError15("Failed to update subscription.");
+      }
+      delCachedData();
+      return "Successfully updated subscription.";
+    } catch (error2) {
+      if (error2 instanceof AppError11) {
+        throw error2;
+      }
+      throw new InternalServerError15("Failed to update subscription.");
+    }
+  }
+  return {
+    add,
+    getAll,
+    getByOrg,
+    getById,
+    deleteById,
+    updateById
+  };
+}
+
+// src/resources/subscription/subscription.controller.ts
+import Joi24 from "joi";
+import { BadRequestError as BadRequestError33 } from "@goweekdays/utils";
+
+// src/resources/subscription/subscription.service.ts
+import { BadRequestError as BadRequestError32, useAtlas as useAtlas15 } from "@goweekdays/utils";
+
+// src/resources/subscription/subscription.transaction.repository.ts
+import {
+  AppError as AppError12,
+  InternalServerError as InternalServerError16,
+  logger as logger17,
+  makeCacheKey as makeCacheKey12,
+  paginate as paginate10,
+  useAtlas as useAtlas14,
+  useCache as useCache13
+} from "@goweekdays/utils";
+
+// src/resources/subscription/subscription.transaction.model.ts
+import { BadRequestError as BadRequestError31 } from "@goweekdays/utils";
+import Joi23 from "joi";
+import { ObjectId as ObjectId19 } from "mongodb";
+var schemaSubscriptionTransaction = Joi23.object({
+  subscription: Joi23.string().hex().length(24).required(),
+  amount: Joi23.number().positive().required(),
+  currency: Joi23.string().length(3).required(),
+  type: Joi23.string().valid("initiate", "add-seat", "remove-seat", "renewal").required(),
+  description: Joi23.string().max(255).optional().allow("", null),
+  createdBy: Joi23.string().hex().length(24).required(),
+  createdByName: Joi23.string().optional().allow("", null)
+});
+function modelSubscriptionTransaction(data) {
+  const { error } = schemaSubscriptionTransaction.validate(data);
+  if (error) {
+    throw new BadRequestError31(
+      `Invalid subscription transaction data: ${error.message}`
+    );
+  }
+  if (data._id && typeof data._id === "string") {
+    try {
+      data._id = new ObjectId19(data._id);
+    } catch (error2) {
+      throw new BadRequestError31("Invalid subscription transaction ID.");
+    }
+  }
+  if (data.subscription && typeof data.subscription === "string") {
+    try {
+      data.subscription = new ObjectId19(data.subscription);
+    } catch (error2) {
+      throw new BadRequestError31("Invalid subscription ID.");
+    }
+  }
+  if (data.createdBy && typeof data.createdBy === "string") {
+    try {
+      data.createdBy = new ObjectId19(data.createdBy);
+    } catch (error2) {
+      throw new BadRequestError31("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
+import { ObjectId as ObjectId20 } from "mongodb";
+function useSubscriptionTransactionRepo() {
+  const db = useAtlas14.getDb();
+  if (!db) {
+    throw new InternalServerError16("Unable to connect to server.");
+  }
+  const namespace_collection = "subscription.transactions";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache13(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      logger17.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger17.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) => {
+    logger17.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) {
+      logger17.log({
+        level: "error",
+        message: `${error}`
+      });
+      if (error instanceof AppError12) {
+        throw error;
+      }
+      throw new InternalServerError16("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 ObjectId20(id);
+      cacheKeyOptions.subscription = id;
+    } catch (error) {
+      throw new InternalServerError16("Invalid organization ID.");
+    }
+    if (search) {
+      query.$text = { $search: search };
+    }
+    const cacheKey = makeCacheKey12(namespace_collection, cacheKeyOptions);
+    try {
+      const cachedData = await getCache(
+        cacheKey
+      );
+      if (cachedData) {
+        logger17.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 = paginate10(
+        items,
+        page,
+        limit,
+        length
+      );
+      setCache(cacheKey, data).then(() => {
+        logger17.log({
+          level: "info",
+          message: `Cache set for getAll subscription transaction: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger17.log({
+          level: "error",
+          message: `Failed to set cache for getAll subscription transaction: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new InternalServerError16("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 BadRequestError32(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 = useAtlas15.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 = Joi24.object({
+      page: Joi24.number().min(1).max(100).optional().allow(null, "").default(1),
+      limit: Joi24.number().min(1).max(100).optional().allow(null, "").default(10),
+      status: Joi24.string().valid("active", "suspended").optional().default("active")
+    });
+    const query = req.query;
+    const { error, value } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError33(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 = Joi24.object({
+      id: Joi24.string().hex().length(24).required()
+    });
+    const { error, value } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError33(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 = Joi24.object({
+      org: Joi24.string().hex().length(24).required()
+    });
+    const { error, value } = validation.validate({ org });
+    if (error) {
+      next(new BadRequestError33(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 BadRequestError33(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
+import Joi25 from "joi";
+import { BadRequestError as BadRequestError34 } from "@goweekdays/utils";
+function useSubscriptionTransactionController() {
+  const { getAll: _getAll } = useSubscriptionTransactionRepo();
+  async function getAll(req, res, next) {
+    const validation = Joi25.object({
+      id: Joi25.string().hex().length(24).required(),
+      page: Joi25.number().min(1).max(100).optional().allow(null, "").default(1),
+      limit: Joi25.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 BadRequestError34(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
+import Joi26 from "joi";
+var currencies = ["USD", "PHP"];
+var schemaPlan = Joi26.object({
+  name: Joi26.string().min(3).max(100).required(),
+  description: Joi26.string().max(255).optional().allow("", null),
+  features: Joi26.array().items(Joi26.string().max(100)).optional(),
+  price: Joi26.number().positive().required(),
+  currency: Joi26.string().length(3).allow(...currencies).required(),
+  default: Joi26.boolean().optional().allow(null, ""),
+  billingCycle: Joi26.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
+import {
+  AppError as AppError13,
+  BadRequestError as BadRequestError35,
+  InternalServerError as InternalServerError17,
+  logger as logger18,
+  makeCacheKey as makeCacheKey13,
+  paginate as paginate11,
+  useAtlas as useAtlas16,
+  useCache as useCache14
+} from "@goweekdays/utils";
+import Joi27 from "joi";
+import { ObjectId as ObjectId21 } from "mongodb";
+function usePlanRepo() {
+  const db = useAtlas16.getDb();
+  if (!db) {
+    throw new InternalServerError17("Unable to connect to server.");
+  }
+  const namespace_collection = "plans";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache14(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      logger18.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger18.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) => {
+    logger18.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 BadRequestError35("Plan name already exist.");
+      }
+      throw new InternalServerError17("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 = makeCacheKey13(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 = paginate11(items, page, limit, length);
+      setCache(cacheKey, data).then(() => {
+        logger18.log({
+          level: "info",
+          message: `Cache set for getAll plan: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger18.log({
+          level: "error",
+          message: `Failed to set cache for getAll plan: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new InternalServerError17("Failed to get plans.");
+    }
+  }
+  async function getById(_id) {
+    const { error } = Joi27.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid plan ID: ${error.message}`);
+    }
+    try {
+      _id = new ObjectId21(_id);
+    } catch (error2) {
+      throw new BadRequestError35("Invalid plan ID.");
+    }
+    try {
+      const cacheKey = makeCacheKey13(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(() => {
+        logger18.log({
+          level: "info",
+          message: `Cache set for getById plan: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger18.log({
+          level: "error",
+          message: `Failed to set cache for getById plan: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      throw new InternalServerError17("Failed to get plan.");
+    }
+  }
+  async function getDefault() {
+    try {
+      const cacheKey = makeCacheKey13(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(() => {
+        logger18.log({
+          level: "info",
+          message: `Cache set for default plan: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger18.log({
+          level: "error",
+          message: `Failed to set cache for default plan: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new InternalServerError17("Failed to get default plan.");
+    }
+  }
+  async function deleteById(_id) {
+    const { error } = Joi27.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid plan ID: ${error.message}`);
+    }
+    try {
+      _id = new ObjectId21(_id);
+    } catch (error2) {
+      throw new BadRequestError35("Invalid plan ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted" } }
+      );
+      if (result.modifiedCount === 0) {
+        throw new InternalServerError17("Failed to delete plan.");
+      }
+      delCachedData();
+      return "Successfully deleted plan.";
+    } catch (error2) {
+      if (error2 instanceof AppError13) {
+        throw error2;
+      }
+      throw new InternalServerError17("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
+import Joi28 from "joi";
+import { BadRequestError as BadRequestError36 } from "@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 = Joi28.object({
+      name: Joi28.string().min(3).max(100).required(),
+      description: Joi28.string().max(255).optional().allow("", null),
+      features: Joi28.array().items(Joi28.string().max(100)).optional(),
+      price: Joi28.number().positive().required(),
+      currency: Joi28.string().length(3).required(),
+      billingCycle: Joi28.string().valid("monthly", "yearly").required()
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new BadRequestError36(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 = Joi28.object({
+      status: Joi28.string().required(),
+      search: Joi28.string().optional().allow("", null),
+      page: Joi28.number().required(),
+      limit: Joi28.number().required()
+    });
+    const { error } = validation.validate({ status, search, page, limit });
+    if (error) {
+      next(new BadRequestError36(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 = Joi28.string().hex().length(24).required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new BadRequestError36(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 = Joi28.string().hex().length(24).required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new BadRequestError36(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 BadRequestError37(error.message);
+    }
+    const session = useAtlas17.getClient()?.startSession();
+    if (!session) {
+      throw new BadRequestError37("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 BadRequestError37(
+          "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 BadRequestError37("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 BadRequestError37("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
+import { BadRequestError as BadRequestError38 } from "@goweekdays/utils";
+import Joi29 from "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 BadRequestError38(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 BadRequestError38("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new BadRequestError38("Invalid limit number."));
+      return;
+    }
+    const validation = Joi29.object({
+      user: Joi29.string().hex().required(),
+      page: Joi29.number().min(1).optional().allow("", null),
+      limit: Joi29.number().min(1).optional().allow("", null),
+      search: Joi29.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({ user, page, limit, search });
+    if (error) {
+      next(new BadRequestError38(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 = Joi29.object({
+      page: Joi29.number().min(1).optional().allow("", null),
+      limit: Joi29.number().min(1).optional().allow("", null),
+      search: Joi29.string().optional().allow("", null),
+      status: Joi29.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 BadRequestError30("Invalid page number."));
+      next(new BadRequestError38("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new BadRequestError30("Invalid limit number."));
+      next(new BadRequestError38("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new BadRequestError30(error.message));
+      next(new BadRequestError38(error.message));
       return;
     }
     try {
@@ -5582,12 +6837,12 @@ function useOrgController() {
   }
   async function getByName(req, res, next) {
     const name = req.params.name;
-    const validation = Joi21.object({
-      name: Joi21.string().required()
+    const validation = Joi29.object({
+      name: Joi29.string().required()
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new BadRequestError30(error.message));
+      next(new BadRequestError38(error.message));
       return;
     }
     try {
@@ -5600,12 +6855,12 @@ function useOrgController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = Joi21.object({
-      id: Joi21.string().hex().required()
+    const validation = Joi29.object({
+      id: Joi29.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new BadRequestError30(error.message));
+      next(new BadRequestError38(error.message));
       return;
     }
     try {
@@ -5616,12 +6871,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 BadRequestError38(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
   };
 }
 
@@ -5640,12 +6912,12 @@ function useUserService() {
   const { getAll: getAllPermission } = usePermissionRepo();
   const { getById: getOrgById } = useOrgRepo();
   async function createDefaultUser() {
-    const session = useAtlas14.getClient()?.startSession();
+    const session = useAtlas18.getClient()?.startSession();
     try {
       session?.startTransaction();
       const _user = await getUserByEmail(DEFAULT_USER_EMAIL);
       if (_user) {
-        throw new BadRequestError31(
+        throw new BadRequestError39(
           `User already exists: ${DEFAULT_USER_EMAIL}.`
         );
       }
@@ -5695,7 +6967,7 @@ function useUserService() {
     try {
       const _user = await getUserByEmail(value.email);
       if (_user) {
-        throw new BadRequestError31(`User already exists: ${value.email}.`);
+        throw new BadRequestError39(`User already exists: ${value.email}.`);
       }
       const hashedPassword = await hashPassword(value.password);
       const insertedId = await addUser({
@@ -5707,10 +6979,10 @@ function useUserService() {
       });
       return insertedId;
     } catch (error) {
-      if (error instanceof AppError11) {
+      if (error instanceof AppError14) {
         throw error;
       } else {
-        throw new InternalServerError15(`Error creating user: ${error}`);
+        throw new InternalServerError18(`Error creating user: ${error}`);
       }
     }
   }
@@ -5721,22 +6993,22 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = useAtlas14.getClient()?.startSession();
+    const session = useAtlas18.getClient()?.startSession();
     session?.startTransaction();
     try {
       const invitation = await _getVerificationById(id);
       if (!invitation || !invitation.metadata?.app || !invitation.metadata?.role) {
-        throw new BadRequestError31("Invalid invitation.");
+        throw new BadRequestError39("Invalid invitation.");
       }
       if (invitation.status === "complete") {
-        throw new BadRequestError31("Invitation already used.");
+        throw new BadRequestError39("Invitation already used.");
       }
       if (!invitation.expireAt) {
-        throw new BadRequestError31("Expiration date is required.");
+        throw new BadRequestError39("Expiration date is required.");
       }
       const expired = new Date(invitation.expireAt) < /* @__PURE__ */ new Date();
       if (invitation.status === "expired" || expired) {
-        throw new BadRequestError31("Invitation expired.");
+        throw new BadRequestError39("Invitation expired.");
       }
       const email = invitation.email;
       const user = await getUserByEmail(invitation.email);
@@ -5787,10 +7059,10 @@ function useUserService() {
       return userId;
     } catch (error) {
       await session?.abortTransaction();
-      if (error instanceof AppError11) {
+      if (error instanceof AppError14) {
         throw error;
       } else {
-        throw new InternalServerError15("Failed to create user by invite.");
+        throw new InternalServerError18("Failed to create user by invite.");
       }
     } finally {
       session?.endSession();
@@ -5802,29 +7074,29 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = useAtlas14.getClient()?.startSession();
+    const session = useAtlas18.getClient()?.startSession();
     session?.startTransaction();
     try {
       const signUp = await _getVerificationById(id);
       if (!signUp) {
-        throw new BadRequestError31("Invalid sign up link.");
+        throw new BadRequestError39("Invalid sign up link.");
       }
       if (signUp.status === "complete") {
-        throw new BadRequestError31(
+        throw new BadRequestError39(
           "You have already an account created using this link."
         );
       }
       if (!signUp.expireAt) {
-        throw new BadRequestError31("Expiration date is required.");
+        throw new BadRequestError39("Expiration date is required.");
       }
       const expired = new Date(signUp.expireAt) < /* @__PURE__ */ new Date();
       if (signUp.status === "expired" || expired) {
-        throw new BadRequestError31("Sign up link expired.");
+        throw new BadRequestError39("Sign up link expired.");
       }
       const email = signUp.email;
       const _user = await getUserByEmail(signUp.email);
       if (_user) {
-        throw new BadRequestError31(`User already exists: ${email}.`);
+        throw new BadRequestError39(`User already exists: ${email}.`);
       }
       const hashedPassword = await hashPassword(password);
       const userId = await addUser(
@@ -5850,17 +7122,17 @@ function useUserService() {
   const { updateStatusById: updateVerificationStatusById } = useVerificationRepo();
   async function resetPassword(value) {
     if (value.newPassword !== value.confirmPassword) {
-      throw new BadRequestError31("Passwords do not match.");
+      throw new BadRequestError39("Passwords do not match.");
     }
     let hashedPassword = "";
     try {
       hashedPassword = await hashPassword(value.newPassword);
     } catch (error) {
-      throw new InternalServerError15(`Error hashing password: ${error}`);
+      throw new InternalServerError18(`Error hashing password: ${error}`);
     }
-    const session = useAtlas14.getClient()?.startSession();
+    const session = useAtlas18.getClient()?.startSession();
     if (!session) {
-      throw new InternalServerError15("Failed to start database session.");
+      throw new InternalServerError18("Failed to start database session.");
     }
     try {
       session.startTransaction();
@@ -5876,7 +7148,7 @@ function useUserService() {
         throw new NotFoundError3("User ID is invalid.");
       }
       if (otpDoc.status === "used") {
-        throw new BadRequestError31("This link has already been invalidated.");
+        throw new BadRequestError39("This link has already been invalidated.");
       }
       await updateVerificationStatusById(value.id, "used", session);
       await _updateUserFieldById(
@@ -5887,31 +7159,31 @@ function useUserService() {
       return "Successfully reset password.";
     } catch (error) {
       await session.abortTransaction();
-      if (error instanceof AppError11) {
+      if (error instanceof AppError14) {
         throw error;
       }
-      throw new InternalServerError15("Failed to reset password.");
+      throw new InternalServerError18("Failed to reset password.");
     }
   }
   const { updateName: updateMemberName } = useMemberRepo();
   async function updateName(_id, firstName, lastName) {
     if (!_id) {
-      throw new BadRequestError31("Invalid user ID");
+      throw new BadRequestError39("Invalid user ID");
     }
     if (!firstName) {
-      throw new BadRequestError31("Invalid firstName");
+      throw new BadRequestError39("Invalid firstName");
     }
     if (!lastName) {
-      throw new BadRequestError31("Invalid lastName");
+      throw new BadRequestError39("Invalid lastName");
     }
-    const session = useAtlas14.getClient()?.startSession();
+    const session = useAtlas18.getClient()?.startSession();
     session?.startTransaction();
-    const cacheKey = makeCacheKey11("users", { user: _id });
+    const cacheKey = makeCacheKey14("users", { user: _id });
     try {
-      useCache12().delCache(cacheKey).then(() => {
-        logger16.info(`Cache cleared for user: ${_id}`);
+      useCache15().delCache(cacheKey).then(() => {
+        logger19.info(`Cache cleared for user: ${_id}`);
       }).catch((error) => {
-        logger16.error(`Failed to clear cache for user: ${_id}`, error);
+        logger19.error(`Failed to clear cache for user: ${_id}`, error);
       });
       await _updateName({ _id, firstName, lastName }, session);
       await updateMemberName(
@@ -5929,16 +7201,16 @@ function useUserService() {
   }
   async function updateBirthday(_id, month, day, year) {
     if (!_id) {
-      throw new BadRequestError31("Invalid user ID");
+      throw new BadRequestError39("Invalid user ID");
     }
     if (!month) {
-      throw new BadRequestError31("Invalid birth month.");
+      throw new BadRequestError39("Invalid birth month.");
     }
     if (!day) {
-      throw new BadRequestError31("Invalid birthday.");
+      throw new BadRequestError39("Invalid birthday.");
     }
     if (!year) {
-      throw new BadRequestError31("Invalid birth year.");
+      throw new BadRequestError39("Invalid birth year.");
     }
     try {
       await _updateBirthday({ _id, month, day, year });
@@ -5963,7 +7235,7 @@ function useUserService() {
     bucket: SPACES_BUCKET
   });
   async function updateUserProfile({ file, user, previousProfile } = {}) {
-    const session = useAtlas14.getClient()?.startSession();
+    const session = useAtlas18.getClient()?.startSession();
     session?.startTransaction();
     const _file = {
       name: file.originalname,
@@ -6008,11 +7280,11 @@ function useUserService() {
 
 // src/resources/user/user.controller.ts
 import {
-  AppError as AppError12,
-  BadRequestError as BadRequestError32,
-  InternalServerError as InternalServerError16
+  AppError as AppError15,
+  BadRequestError as BadRequestError40,
+  InternalServerError as InternalServerError19
 } from "@goweekdays/utils";
-import Joi22 from "joi";
+import Joi30 from "joi";
 function useUserController() {
   const {
     updateName: _updateName,
@@ -6028,14 +7300,14 @@ function useUserController() {
     const status = req.query.status ?? "";
     const search = req.query.search ?? "";
     const page = Number(req.query.page) ?? 1;
-    const validation = Joi22.object({
-      status: Joi22.string().required(),
-      search: Joi22.string().optional().allow("", null),
-      page: Joi22.number().required()
+    const validation = Joi30.object({
+      status: Joi30.string().required(),
+      search: Joi30.string().optional().allow("", null),
+      page: Joi30.number().required()
     });
     const { error } = validation.validate({ status, search, page });
     if (error) {
-      next(new BadRequestError32(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6048,14 +7320,14 @@ function useUserController() {
   }
   async function getUserById(req, res, next) {
     const id = req.params.id || "";
-    const validation = Joi22.string().hex().validate(id);
+    const validation = Joi30.string().hex().validate(id);
     if (validation.error) {
-      throw new BadRequestError32("Invalid id.");
+      throw new BadRequestError40("Invalid id.");
     }
     try {
       const user = await _getUserById(id);
       if (!user) {
-        throw new BadRequestError32("User not found.");
+        throw new BadRequestError40("User not found.");
       }
       res.json(user);
     } catch (error) {
@@ -6066,13 +7338,13 @@ function useUserController() {
     const id = req.headers.user ?? "";
     const firstName = req.body.firstName ?? "";
     const lastName = req.body.lastName ?? "";
-    const validation = Joi22.object({
-      firstName: Joi22.string().required(),
-      lastName: Joi22.string().required()
+    const validation = Joi30.object({
+      firstName: Joi30.string().required(),
+      lastName: Joi30.string().required()
     });
     const { error } = validation.validate({ firstName, lastName });
     if (error) {
-      next(new BadRequestError32(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6088,14 +7360,14 @@ function useUserController() {
     const month = req.body.month ?? "";
     const day = req.body.day ?? 0;
     const year = req.body.year ?? 0;
-    const validation = Joi22.object({
-      month: Joi22.string().required(),
-      day: Joi22.number().integer().min(1).max(31).required(),
-      year: Joi22.number().integer().min(1900).max((/* @__PURE__ */ new Date()).getFullYear()).required()
+    const validation = Joi30.object({
+      month: Joi30.string().required(),
+      day: Joi30.number().integer().min(1).max(31).required(),
+      year: Joi30.number().integer().min(1900).max((/* @__PURE__ */ new Date()).getFullYear()).required()
     });
     const { error } = validation.validate({ month, day, year });
     if (error) {
-      next(new BadRequestError32(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6109,18 +7381,18 @@ function useUserController() {
   async function updateUserFieldById(req, res, next) {
     const _id = req.params.id;
     const { field, value } = req.body;
-    const validation = Joi22.object({
-      _id: Joi22.string().hex().required(),
-      field: Joi22.string().valid("gender", "email", "contact", "profile").required(),
-      value: Joi22.alternatives().conditional("field", {
+    const validation = Joi30.object({
+      _id: Joi30.string().hex().required(),
+      field: Joi30.string().valid("gender", "email", "contact", "profile").required(),
+      value: Joi30.alternatives().conditional("field", {
         is: "email",
-        then: Joi22.string().email().required(),
-        otherwise: Joi22.string().required()
+        then: Joi30.string().email().required(),
+        otherwise: Joi30.string().required()
       })
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new BadRequestError32(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6136,12 +7408,12 @@ function useUserController() {
       return;
     }
     const previousProfile = req.body.previousProfile ?? "";
-    const validation = Joi22.object({
-      previousProfile: Joi22.string().hex().optional().allow("", null)
+    const validation = Joi30.object({
+      previousProfile: Joi30.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate({ previousProfile });
     if (error) {
-      next(new BadRequestError32(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     const user = req.headers["user"] ?? "";
@@ -6154,10 +7426,10 @@ function useUserController() {
       res.json({ message: "Successfully updated profile picture." });
       return;
     } catch (error2) {
-      if (error2 instanceof AppError12) {
+      if (error2 instanceof AppError15) {
         next(error2);
       } else {
-        next(new InternalServerError16(error2));
+        next(new InternalServerError19(error2));
       }
     }
   }
@@ -6167,12 +7439,12 @@ function useUserController() {
     const password = req.body.password ?? "";
     const id = req.params.id ?? "";
     const type = req.body.type ?? "";
-    const validation = Joi22.object({
-      firstName: Joi22.string().required(),
-      lastName: Joi22.string().required(),
-      password: Joi22.string().required(),
-      id: Joi22.string().hex().required(),
-      type: Joi22.string().required()
+    const validation = Joi30.object({
+      firstName: Joi30.string().required(),
+      lastName: Joi30.string().required(),
+      password: Joi30.string().required(),
+      id: Joi30.string().hex().required(),
+      type: Joi30.string().required()
     });
     const { error } = validation.validate({
       firstName,
@@ -6182,7 +7454,7 @@ function useUserController() {
       type
     });
     if (error) {
-      next(new BadRequestError32(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6205,14 +7477,14 @@ function useUserController() {
   }
   async function resetPassword(req, res, next) {
     const payload = req.body;
-    const validation = Joi22.object({
-      id: Joi22.string().hex().required(),
-      newPassword: Joi22.string().min(8).required(),
-      confirmPassword: Joi22.string().min(8).required()
+    const validation = Joi30.object({
+      id: Joi30.string().hex().required(),
+      newPassword: Joi30.string().min(8).required(),
+      confirmPassword: Joi30.string().min(8).required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      next(new BadRequestError32(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6237,7 +7509,7 @@ function useUserController() {
 }
 
 // src/resources/verification/verification.service.ts
-import Joi23 from "joi";
+import Joi31 from "joi";
 function useVerificationService() {
   const MailerConfig = {
     host: MAILER_TRANSPORT_HOST,
@@ -6272,7 +7544,7 @@ function useVerificationService() {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (!metadata.app) {
-      throw new BadRequestError33("App metadata is required.");
+      throw new BadRequestError41("App metadata is required.");
     }
     try {
       const user = await getUserByEmail(email);
@@ -6295,7 +7567,7 @@ function useVerificationService() {
           html: emailContent2,
           from: "GoWeekdays"
         }).catch((error) => {
-          logger17.log({
+          logger20.log({
             level: "error",
             message: `Error sending user invite email: ${error}`
           });
@@ -6317,7 +7589,7 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error) => {
-        logger17.log({
+        logger20.log({
           level: "error",
           message: `Error sending user invite email: ${error}`
         });
@@ -6352,14 +7624,14 @@ function useVerificationService() {
         from: "GoWeekdays",
         html: emailContent
       }).catch((error) => {
-        logger17.log({
+        logger20.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 InternalServerError17("Failed to create forget password link.");
+      throw new InternalServerError20("Failed to create forget password link.");
     }
   }
   async function getById(id) {
@@ -6398,34 +7670,34 @@ function useVerificationService() {
   }
   function errorByType(type, status) {
     if (type === "user-invite" && status === "expired") {
-      throw new BadRequestError33(
+      throw new BadRequestError41(
         "Invitation has already expired, please contact admin to resend the invitation."
       );
     }
     if (type === "user-sign-up" && status === "expired") {
-      throw new BadRequestError33(
+      throw new BadRequestError41(
         "Sign up verification has expired, please sign up again to get a new verification link."
       );
     }
     if (type === "user-invite" && status === "complete") {
-      throw new BadRequestError33(
+      throw new BadRequestError41(
         "User already registered, please login to continue."
       );
     }
     if (type === "forget-password" && status === "complete") {
-      throw new BadRequestError33(
+      throw new BadRequestError41(
         "Forget password verification has already been used, please request a new one."
       );
     }
     if (type === "forget-password" && status === "expired") {
-      throw new BadRequestError33(
+      throw new BadRequestError41(
         "Forget password verification has expired, please request a new one."
       );
     }
-    throw new BadRequestError33("Invalid verification.");
+    throw new BadRequestError41("Invalid verification.");
   }
   async function verify(id) {
-    const session = useAtlas15.getClient()?.startSession();
+    const session = useAtlas19.getClient()?.startSession();
     session?.startTransaction();
     try {
       const _id = await _getById(id);
@@ -6436,10 +7708,10 @@ function useVerificationService() {
         errorByType(_id.type, "expired");
       }
       if (_id.status === "complete") {
-        throw new BadRequestError33("Verification already completed.");
+        throw new BadRequestError41("Verification already completed.");
       }
       if (!_id.expireAt) {
-        throw new BadRequestError33("Expiration date is required.");
+        throw new BadRequestError41("Expiration date is required.");
       }
       const expiration = new Date(_id.expireAt).getTime();
       const now = (/* @__PURE__ */ new Date()).getTime();
@@ -6455,12 +7727,12 @@ function useVerificationService() {
           throw new NotFoundError4("User not found for member invite.");
         }
         if (!_id.metadata?.app) {
-          throw new BadRequestError33(
+          throw new BadRequestError41(
             "App metadata is required for member invite."
           );
         }
         if (!_id.metadata?.role || !_id.metadata?.roleName) {
-          throw new BadRequestError33(
+          throw new BadRequestError41(
             "Role metadata is required for member invite."
           );
         }
@@ -6482,7 +7754,7 @@ function useVerificationService() {
       return _id;
     } catch (error) {
       await session?.abortTransaction();
-      logger17.log({
+      logger20.log({
         level: "info",
         message: `Error verifying user invitation: ${error}`
       });
@@ -6495,7 +7767,7 @@ function useVerificationService() {
     try {
       await updateStatusById(id, "cancelled");
     } catch (error) {
-      throw new InternalServerError17(
+      throw new InternalServerError20(
         `Error cancelling user invitation: ${error}`
       );
     }
@@ -6515,7 +7787,7 @@ function useVerificationService() {
     try {
       const user = await getUserByEmail(email);
       if (user) {
-        throw new BadRequestError33(
+        throw new BadRequestError41(
           `Email ${email} is already registered, please login to continue.`
         );
       }
@@ -6542,7 +7814,7 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error) => {
-        logger17.log({
+        logger20.log({
           level: "error",
           message: `Error sending user invite email: ${error}`
         });
@@ -6555,7 +7827,7 @@ function useVerificationService() {
   async function inviteMember(value) {
     const { error } = schemaInviteMember.validate(value);
     if (error) {
-      throw new BadRequestError33(error.message);
+      throw new BadRequestError41(error.message);
     }
     const role = await getRoleById(value.role);
     if (!role) {
@@ -6599,7 +7871,7 @@ function useVerificationService() {
           html: emailContent2,
           from: "GoWeekdays"
         }).catch((error2) => {
-          logger17.log({
+          logger20.log({
             level: "error",
             message: `Error sending user invite email: ${error2}`
           });
@@ -6621,24 +7893,24 @@ function useVerificationService() {
         html: emailContent,
         from: "GoWeekdays"
       }).catch((error2) => {
-        logger17.log({
+        logger20.log({
           level: "error",
           message: `Error sending user invite email: ${error2}`
         });
       });
       return verificationId;
     } catch (error2) {
-      if (error2 instanceof AppError13) {
+      if (error2 instanceof AppError16) {
         throw error2;
       } else {
-        throw new InternalServerError17("Failed to invite member.");
+        throw new InternalServerError20("Failed to invite member.");
       }
     }
   }
   async function cancelInviteMember(id) {
-    const { error } = Joi23.string().hex().required().validate(id);
+    const { error } = Joi31.string().hex().required().validate(id);
     if (error) {
-      throw new BadRequestError33("Invalid verification ID.");
+      throw new BadRequestError41("Invalid verification ID.");
     }
     try {
       const invite = await _getById(id);
@@ -6646,25 +7918,25 @@ function useVerificationService() {
         throw new NotFoundError4("Invitation not found.");
       }
       if (invite.status === "cancelled") {
-        throw new BadRequestError33("Invitation already cancelled.");
+        throw new BadRequestError41("Invitation already cancelled.");
       }
       if (invite.status === "complete") {
-        throw new BadRequestError33("Cannot cancel a completed invitation.");
+        throw new BadRequestError41("Cannot cancel a completed invitation.");
       }
       await _updateStatusById(id, "cancelled");
       return "Successfully cancelled the invitation.";
     } catch (error2) {
-      if (error2 instanceof AppError13) {
+      if (error2 instanceof AppError16) {
         throw error2;
       } else {
-        throw new InternalServerError17("Failed to cancel the invitation.");
+        throw new InternalServerError20("Failed to cancel the invitation.");
       }
     }
   }
   async function forgetPassword(email) {
-    const { error } = Joi23.string().email().required().validate(email);
+    const { error } = Joi31.string().email().required().validate(email);
     if (error) {
-      throw new BadRequestError33("Invalid email address.");
+      throw new BadRequestError41("Invalid email address.");
     }
     try {
       const member = await getUserByEmail(email);
@@ -6693,17 +7965,17 @@ function useVerificationService() {
         from: "GoWeekdays",
         html: emailContent
       }).catch((error2) => {
-        logger17.log({
+        logger20.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 AppError13) {
+      if (error2 instanceof AppError16) {
         throw error2;
       } else {
-        throw new InternalServerError17(
+        throw new InternalServerError20(
           "Failed to process forget password request."
         );
       }
@@ -6730,13 +8002,13 @@ function useAuthController() {
   async function login(req, res, next) {
     const email = req.body.email;
     const password = req.body.password;
-    const validation = Joi24.object({
-      email: Joi24.string().email().required(),
-      password: Joi24.string().required()
+    const validation = Joi32.object({
+      email: Joi32.string().email().required(),
+      password: Joi32.string().required()
     });
     const { error } = validation.validate({ email, password });
     if (error) {
-      next(new BadRequestError34(error.message));
+      next(new BadRequestError42(error.message));
       return;
     }
     try {
@@ -6752,14 +8024,14 @@ function useAuthController() {
       res.cookie("sid", session.sid, cookieOptions).cookie("user", session.user, cookieOptions).json({ message: "Login successful" });
       return;
     } catch (error2) {
-      logger18.log({
+      logger21.log({
         level: "error",
         message: `Error during login: ${error2.message}`
       });
-      if (error2 instanceof AppError14) {
+      if (error2 instanceof AppError17) {
         next(error2);
       } else {
-        next(new InternalServerError18("An unexpected error occurred"));
+        next(new InternalServerError21("An unexpected error occurred"));
       }
       return;
     }
@@ -6767,17 +8039,17 @@ function useAuthController() {
   async function logout(req, res, next) {
     const sid = req.headers["authorization"] ?? "";
     if (!sid) {
-      next(new BadRequestError34("Session ID is required"));
+      next(new BadRequestError42("Session ID is required"));
       return;
     }
     try {
       await useAuthService().logout(sid);
       res.json({ message: "Logged out successfully" });
     } catch (error) {
-      if (error instanceof AppError14) {
+      if (error instanceof AppError17) {
         next(error);
       } else {
-        next(new InternalServerError18("An unexpected error occurred"));
+        next(new InternalServerError21("An unexpected error occurred"));
       }
     }
   }
@@ -6788,64 +8060,64 @@ function useAuthController() {
 }
 
 // src/resources/building/building.model.ts
-import { BadRequestError as BadRequestError35, logger as logger19 } from "@goweekdays/utils";
-import Joi25 from "joi";
-import { ObjectId as ObjectId17 } from "mongodb";
-var schemaBuilding = Joi25.object({
-  _id: Joi25.string().hex().optional(),
-  school: Joi25.string().hex().required(),
-  serial: Joi25.string().optional().allow("", null),
-  name: Joi25.string().required(),
-  levels: Joi25.number().integer().min(1).required(),
-  createdAt: Joi25.date().optional().allow("", null),
-  updatedAt: Joi25.date().optional().allow("", null),
-  deletedAt: Joi25.date().optional().allow("", null),
-  status: Joi25.string().optional().allow("", null)
+import { BadRequestError as BadRequestError43, logger as logger22 } from "@goweekdays/utils";
+import Joi33 from "joi";
+import { ObjectId as ObjectId22 } from "mongodb";
+var schemaBuilding = Joi33.object({
+  _id: Joi33.string().hex().optional(),
+  school: Joi33.string().hex().required(),
+  serial: Joi33.string().optional().allow("", null),
+  name: Joi33.string().required(),
+  levels: Joi33.number().integer().min(1).required(),
+  createdAt: Joi33.date().optional().allow("", null),
+  updatedAt: Joi33.date().optional().allow("", null),
+  deletedAt: Joi33.date().optional().allow("", null),
+  status: Joi33.string().optional().allow("", null)
 });
-var schemaBuildingUnit = Joi25.object({
-  _id: Joi25.string().hex().optional(),
-  school: Joi25.string().hex().required(),
-  name: Joi25.string().optional().allow("", null),
-  building: Joi25.string().hex().required(),
-  buildingName: Joi25.string().optional().allow("", null),
-  level: Joi25.number().integer().min(1).required(),
-  category: Joi25.string().required(),
-  type: Joi25.string().required(),
-  seating_capacity: Joi25.number().integer().min(0).required(),
-  standing_capacity: Joi25.number().integer().min(0).required(),
-  description: Joi25.string().optional().allow("", null),
-  unit_of_measurement: Joi25.string().valid("sqm").required(),
-  area: Joi25.number().positive().required(),
-  status: Joi25.string().optional().allow("", null)
+var schemaBuildingUnit = Joi33.object({
+  _id: Joi33.string().hex().optional(),
+  school: Joi33.string().hex().required(),
+  name: Joi33.string().optional().allow("", null),
+  building: Joi33.string().hex().required(),
+  buildingName: Joi33.string().optional().allow("", null),
+  level: Joi33.number().integer().min(1).required(),
+  category: Joi33.string().required(),
+  type: Joi33.string().required(),
+  seating_capacity: Joi33.number().integer().min(0).required(),
+  standing_capacity: Joi33.number().integer().min(0).required(),
+  description: Joi33.string().optional().allow("", null),
+  unit_of_measurement: Joi33.string().valid("sqm").required(),
+  area: Joi33.number().positive().required(),
+  status: Joi33.string().optional().allow("", null)
 });
-var schemaUpdateOptions = Joi25.object({
-  name: Joi25.string().optional().allow("", null),
-  building: Joi25.string().hex().optional().allow("", null),
-  buildingName: Joi25.string().optional().allow("", null),
-  level: Joi25.number().integer().min(1).optional().allow("", null),
-  category: Joi25.string().optional().allow("", null),
-  type: Joi25.string().optional().allow("", null),
-  seating_capacity: Joi25.number().integer().min(0).optional().allow("", null),
-  standing_capacity: Joi25.number().integer().min(0).optional().allow("", null),
-  area: Joi25.number().positive().optional().allow("", null)
+var schemaUpdateOptions = Joi33.object({
+  name: Joi33.string().optional().allow("", null),
+  building: Joi33.string().hex().optional().allow("", null),
+  buildingName: Joi33.string().optional().allow("", null),
+  level: Joi33.number().integer().min(1).optional().allow("", null),
+  category: Joi33.string().optional().allow("", null),
+  type: Joi33.string().optional().allow("", null),
+  seating_capacity: Joi33.number().integer().min(0).optional().allow("", null),
+  standing_capacity: Joi33.number().integer().min(0).optional().allow("", null),
+  area: Joi33.number().positive().optional().allow("", null)
 });
 function MBuilding(value) {
   const { error } = schemaBuilding.validate(value);
   if (error) {
-    logger19.info(`Building Model: ${error.message}`);
-    throw new BadRequestError35(error.message);
+    logger22.info(`Building Model: ${error.message}`);
+    throw new BadRequestError43(error.message);
   }
   if (value._id && typeof value._id === "string") {
     try {
-      value._id = new ObjectId17(value._id);
+      value._id = new ObjectId22(value._id);
     } catch (error2) {
-      throw new BadRequestError35("Invalid _id format");
+      throw new BadRequestError43("Invalid _id format");
     }
   }
   try {
-    value.school = new ObjectId17(value.school);
+    value.school = new ObjectId22(value.school);
   } catch (error2) {
-    throw new BadRequestError35("Invalid school format");
+    throw new BadRequestError43("Invalid school format");
   }
   return {
     _id: value._id ?? void 0,
@@ -6862,25 +8134,25 @@ function MBuilding(value) {
 function MBuildingUnit(value) {
   const { error } = schemaBuildingUnit.validate(value);
   if (error) {
-    logger19.info(`Building Unit Model: ${error.message}`);
-    throw new BadRequestError35(error.message);
+    logger22.info(`Building Unit Model: ${error.message}`);
+    throw new BadRequestError43(error.message);
   }
   if (value._id && typeof value._id === "string") {
     try {
-      value._id = new ObjectId17(value._id);
+      value._id = new ObjectId22(value._id);
     } catch (error2) {
-      throw new BadRequestError35("Invalid ID");
+      throw new BadRequestError43("Invalid ID");
     }
   }
   try {
-    value.school = new ObjectId17(value.school);
+    value.school = new ObjectId22(value.school);
   } catch (error2) {
-    throw new BadRequestError35("Invalid school ID");
+    throw new BadRequestError43("Invalid school ID");
   }
   try {
-    value.building = new ObjectId17(value.building);
+    value.building = new ObjectId22(value.building);
   } catch (error2) {
-    throw new BadRequestError35("Invalid building ID");
+    throw new BadRequestError43("Invalid building ID");
   }
   return {
     _id: value._id ?? void 0,
@@ -6905,24 +8177,24 @@ function MBuildingUnit(value) {
 
 // src/resources/building/building.repository.ts
 import {
-  AppError as AppError15,
-  BadRequestError as BadRequestError36,
-  InternalServerError as InternalServerError19,
-  logger as logger20,
-  makeCacheKey as makeCacheKey12,
-  paginate as paginate9,
-  useAtlas as useAtlas16,
-  useCache as useCache13
+  AppError as AppError18,
+  BadRequestError as BadRequestError44,
+  InternalServerError as InternalServerError22,
+  logger as logger23,
+  makeCacheKey as makeCacheKey15,
+  paginate as paginate12,
+  useAtlas as useAtlas20,
+  useCache as useCache16
 } from "@goweekdays/utils";
-import { ObjectId as ObjectId18 } from "mongodb";
+import { ObjectId as ObjectId23 } from "mongodb";
 function useBuildingRepo() {
-  const db = useAtlas16.getDb();
+  const db = useAtlas20.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 } = useCache13(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache16(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -6935,7 +8207,7 @@ function useBuildingRepo() {
     }
   }
   createIndexes().catch((error) => {
-    logger20.log({ level: "error", message: `Index creation error: ${error}` });
+    logger23.log({ level: "error", message: `Index creation error: ${error}` });
   });
   async function add(value, session) {
     try {
@@ -6944,16 +8216,16 @@ function useBuildingRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      logger20.log({
+      logger23.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof AppError15) {
+      if (error instanceof AppError18) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new BadRequestError36("Building already exists.");
+          throw new BadRequestError44("Building already exists.");
         }
         throw new Error("Failed to create building.");
       }
@@ -6961,9 +8233,9 @@ function useBuildingRepo() {
   }
   async function updateById(_id, value, session) {
     try {
-      _id = new ObjectId18(_id);
+      _id = new ObjectId23(_id);
     } catch (error) {
-      throw new BadRequestError36("Invalid ID.");
+      throw new BadRequestError44("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -6974,11 +8246,11 @@ function useBuildingRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      logger20.log({
+      logger23.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof AppError15) {
+      if (error instanceof AppError18) {
         throw error;
       } else {
         throw new Error("Failed to update building.");
@@ -7003,9 +8275,9 @@ function useBuildingRepo() {
     }
     if (school) {
       try {
-        query.school = new ObjectId18(school);
+        query.school = new ObjectId23(school);
       } catch (error) {
-        throw new BadRequestError36("Invalid school ID.");
+        throw new BadRequestError44("Invalid school ID.");
       }
     }
     const cacheParams = {
@@ -7019,15 +8291,15 @@ function useBuildingRepo() {
       cacheParams.school = school;
     if (status !== "active")
       cacheParams.status = status;
-    const cacheKey = makeCacheKey12(namespace_collection, cacheParams);
-    logger20.log({
+    const cacheKey = makeCacheKey15(namespace_collection, cacheParams);
+    logger23.log({
       level: "info",
       message: `Cache key for getAll buildings: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger20.log({
+        logger23.log({
           level: "info",
           message: `Cache hit for getAll buildings: ${cacheKey}`
         });
@@ -7040,35 +8312,35 @@ function useBuildingRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate9(items, page, limit, length);
+      const data = paginate12(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        logger20.log({
+        logger23.log({
           level: "info",
           message: `Cache set for getAll buildings: ${cacheKey}`
         });
       }).catch((err) => {
-        logger20.log({
+        logger23.log({
           level: "error",
           message: `Failed to set cache for getAll buildings: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      logger20.log({ level: "error", message: `${error}` });
+      logger23.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new ObjectId18(_id);
+      _id = new ObjectId23(_id);
     } catch (error) {
-      throw new BadRequestError36("Invalid ID.");
+      throw new BadRequestError44("Invalid ID.");
     }
-    const cacheKey = makeCacheKey12(namespace_collection, { _id: String(_id) });
+    const cacheKey = makeCacheKey15(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger20.log({
+        logger23.log({
           level: "info",
           message: `Cache hit for getById building: ${cacheKey}`
         });
@@ -7078,30 +8350,30 @@ function useBuildingRepo() {
         _id
       });
       setCache(cacheKey, result, 300).then(() => {
-        logger20.log({
+        logger23.log({
           level: "info",
           message: `Cache set for building by id: ${cacheKey}`
         });
       }).catch((err) => {
-        logger20.log({
+        logger23.log({
           level: "error",
           message: `Failed to set cache for building by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof AppError15) {
+      if (error instanceof AppError18) {
         throw error;
       } else {
-        throw new InternalServerError19("Failed to get building.");
+        throw new InternalServerError22("Failed to get building.");
       }
     }
   }
   async function deleteById(_id, session) {
     try {
-      _id = new ObjectId18(_id);
+      _id = new ObjectId23(_id);
     } catch (error) {
-      throw new BadRequestError36("Invalid ID.");
+      throw new BadRequestError44("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -7111,25 +8383,25 @@ function useBuildingRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      logger20.log({
+      logger23.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof AppError15) {
+      if (error instanceof AppError18) {
         throw error;
       } else {
-        throw new InternalServerError19("Failed to delete building.");
+        throw new InternalServerError22("Failed to delete building.");
       }
     }
   }
   function delCachedData() {
     delNamespace().then(() => {
-      logger20.log({
+      logger23.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      logger20.log({
+      logger23.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -7146,28 +8418,28 @@ function useBuildingRepo() {
 }
 
 // src/resources/building/building.service.ts
-import { BadRequestError as BadRequestError38, NotFoundError as NotFoundError5, useAtlas as useAtlas18 } from "@goweekdays/utils";
+import { BadRequestError as BadRequestError46, NotFoundError as NotFoundError5, useAtlas as useAtlas22 } from "@goweekdays/utils";
 
 // src/resources/building/building-unit.repository.ts
 import {
-  AppError as AppError16,
-  BadRequestError as BadRequestError37,
-  InternalServerError as InternalServerError20,
-  logger as logger21,
-  makeCacheKey as makeCacheKey13,
-  paginate as paginate10,
-  useAtlas as useAtlas17,
-  useCache as useCache14
+  AppError as AppError19,
+  BadRequestError as BadRequestError45,
+  InternalServerError as InternalServerError23,
+  logger as logger24,
+  makeCacheKey as makeCacheKey16,
+  paginate as paginate13,
+  useAtlas as useAtlas21,
+  useCache as useCache17
 } from "@goweekdays/utils";
-import { ObjectId as ObjectId19 } from "mongodb";
+import { ObjectId as ObjectId24 } from "mongodb";
 function useBuildingUnitRepo() {
-  const db = useAtlas17.getDb();
+  const db = useAtlas21.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 } = useCache14(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache17(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -7195,12 +8467,12 @@ function useBuildingUnitRepo() {
   }
   function delCachedData() {
     delNamespace().then(() => {
-      logger21.log({
+      logger24.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      logger21.log({
+      logger24.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -7213,11 +8485,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      logger21.log({
+      logger24.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof AppError16) {
+      if (error instanceof AppError19) {
         throw error;
       } else {
         throw new Error("Failed to create building unit.");
@@ -7227,12 +8499,12 @@ function useBuildingUnitRepo() {
   async function updateById(_id, value, session) {
     const { error } = schemaUpdateOptions.validate(value);
     if (error) {
-      throw new BadRequestError37(error.message);
+      throw new BadRequestError45(error.message);
     }
     try {
-      _id = new ObjectId19(_id);
+      _id = new ObjectId24(_id);
     } catch (error2) {
-      throw new BadRequestError37("Invalid ID.");
+      throw new BadRequestError45("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -7243,11 +8515,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      logger21.log({
+      logger24.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof AppError16) {
+      if (error2 instanceof AppError19) {
         throw error2;
       } else {
         throw new Error("Failed to create building unit.");
@@ -7257,12 +8529,12 @@ function useBuildingUnitRepo() {
   async function updateByBuildingId(building, value, session) {
     const { error } = schemaUpdateOptions.validate(value);
     if (error) {
-      throw new BadRequestError37(error.message);
+      throw new BadRequestError45(error.message);
     }
     try {
-      building = new ObjectId19(building);
+      building = new ObjectId24(building);
     } catch (error2) {
-      throw new BadRequestError37("Invalid building ID.");
+      throw new BadRequestError45("Invalid building ID.");
     }
     try {
       const res = await collection.updateMany(
@@ -7273,11 +8545,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      logger21.log({
+      logger24.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof AppError16) {
+      if (error2 instanceof AppError19) {
         throw error2;
       } else {
         throw new Error("Failed to update building unit.");
@@ -7304,16 +8576,16 @@ function useBuildingUnitRepo() {
     }
     if (school) {
       try {
-        query.school = new ObjectId19(school);
+        query.school = new ObjectId24(school);
       } catch (error) {
-        throw new BadRequestError37("Invalid school ID.");
+        throw new BadRequestError45("Invalid school ID.");
       }
     }
     if (building) {
       try {
-        query.building = new ObjectId19(building);
+        query.building = new ObjectId24(building);
       } catch (error) {
-        throw new BadRequestError37("Invalid building ID.");
+        throw new BadRequestError45("Invalid building ID.");
       }
     }
     const cacheParams = {
@@ -7329,15 +8601,15 @@ function useBuildingUnitRepo() {
       cacheParams.building = building;
     if (status !== "active")
       cacheParams.status = status;
-    const cacheKey = makeCacheKey13(namespace_collection, cacheParams);
-    logger21.log({
+    const cacheKey = makeCacheKey16(namespace_collection, cacheParams);
+    logger24.log({
       level: "info",
       message: `Cache key for getAll building units: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger21.log({
+        logger24.log({
           level: "info",
           message: `Cache hit for getAll building units: ${cacheKey}`
         });
@@ -7350,35 +8622,35 @@ function useBuildingUnitRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate10(items, page, limit, length);
+      const data = paginate13(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        logger21.log({
+        logger24.log({
           level: "info",
           message: `Cache set for getAll building units: ${cacheKey}`
         });
       }).catch((err) => {
-        logger21.log({
+        logger24.log({
           level: "error",
           message: `Failed to set cache for getAll building units: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      logger21.log({ level: "error", message: `${error}` });
+      logger24.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new ObjectId19(_id);
+      _id = new ObjectId24(_id);
     } catch (error) {
-      throw new BadRequestError37("Invalid ID.");
+      throw new BadRequestError45("Invalid ID.");
     }
-    const cacheKey = makeCacheKey13(namespace_collection, { _id: String(_id) });
+    const cacheKey = makeCacheKey16(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger21.log({
+        logger24.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -7389,42 +8661,42 @@ function useBuildingUnitRepo() {
         deletedAt: { $in: ["", null] }
       });
       if (!result) {
-        throw new BadRequestError37("Building unit not found.");
+        throw new BadRequestError45("Building unit not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        logger21.log({
+        logger24.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        logger21.log({
+        logger24.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof AppError16) {
+      if (error instanceof AppError19) {
         throw error;
       } else {
-        throw new InternalServerError20("Failed to get building unit.");
+        throw new InternalServerError23("Failed to get building unit.");
       }
     }
   }
   async function getByBuildingLevel(building, level) {
     try {
-      building = new ObjectId19(building);
+      building = new ObjectId24(building);
     } catch (error) {
-      throw new BadRequestError37("Invalid building ID.");
+      throw new BadRequestError45("Invalid building ID.");
     }
-    const cacheKey = makeCacheKey13(namespace_collection, {
+    const cacheKey = makeCacheKey16(namespace_collection, {
       building: String(building),
       level
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger21.log({
+        logger24.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -7436,38 +8708,38 @@ function useBuildingUnitRepo() {
         status: "active"
       });
       setCache(cacheKey, result, 300).then(() => {
-        logger21.log({
+        logger24.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        logger21.log({
+        logger24.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof AppError16) {
+      if (error instanceof AppError19) {
         throw error;
       } else {
-        throw new InternalServerError20("Failed to get building unit.");
+        throw new InternalServerError23("Failed to get building unit.");
       }
     }
   }
   async function getByBuilding(building) {
     try {
-      building = new ObjectId19(building);
+      building = new ObjectId24(building);
     } catch (error) {
-      throw new BadRequestError37("Invalid building ID.");
+      throw new BadRequestError45("Invalid building ID.");
     }
-    const cacheKey = makeCacheKey13(namespace_collection, {
+    const cacheKey = makeCacheKey16(namespace_collection, {
       building: String(building)
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger21.log({
+        logger24.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -7478,30 +8750,30 @@ function useBuildingUnitRepo() {
         status: "active"
       });
       setCache(cacheKey, result, 300).then(() => {
-        logger21.log({
+        logger24.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        logger21.log({
+        logger24.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof AppError16) {
+      if (error instanceof AppError19) {
         throw error;
       } else {
-        throw new InternalServerError20("Failed to get building unit.");
+        throw new InternalServerError23("Failed to get building unit.");
       }
     }
   }
   async function deleteById(_id, session) {
     try {
-      _id = new ObjectId19(_id);
+      _id = new ObjectId24(_id);
     } catch (error) {
-      throw new BadRequestError37("Invalid ID.");
+      throw new BadRequestError45("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -7512,11 +8784,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return "Room/Facility deleted successfully.";
     } catch (error) {
-      logger21.log({
+      logger24.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof AppError16) {
+      if (error instanceof AppError19) {
         throw error;
       } else {
         throw new Error("Failed to deleted room/facility.");
@@ -7546,7 +8818,7 @@ function useBuildingService() {
   const { getByBuildingLevel, getByBuilding, updateByBuildingId } = useBuildingUnitRepo();
   async function updateById(id, data) {
     data.levels = Number(data.levels);
-    const session = useAtlas18.getClient()?.startSession();
+    const session = useAtlas22.getClient()?.startSession();
     try {
       const building = await _getById(id);
       if (!building) {
@@ -7555,7 +8827,7 @@ function useBuildingService() {
       if (data.levels < building.levels) {
         const unit = await getByBuildingLevel(id, building.levels);
         if (unit) {
-          throw new BadRequestError38(
+          throw new BadRequestError46(
             "Cannot reduce floors, there are existing building units at higher floors."
           );
         }
@@ -7577,7 +8849,7 @@ function useBuildingService() {
   async function deleteById(id) {
     const building = await getByBuilding(id);
     if (building) {
-      throw new BadRequestError38(
+      throw new BadRequestError46(
         "Cannot delete building with existing room/facility. Please delete room/facility first."
       );
     }
@@ -7595,24 +8867,24 @@ function useBuildingService() {
 }
 
 // src/resources/building/building.controller.ts
-import { BadRequestError as BadRequestError39, logger as logger22 } from "@goweekdays/utils";
-import Joi26 from "joi";
+import { BadRequestError as BadRequestError47, logger as logger25 } from "@goweekdays/utils";
+import Joi34 from "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 = Joi26.object({
-      name: Joi26.string().required(),
-      school: Joi26.string().hex().required(),
-      levels: Joi26.number().integer().min(1).required(),
-      serial: Joi26.string().optional().allow("", null),
-      status: Joi26.string().optional().allow("", null)
+    const validation = Joi34.object({
+      name: Joi34.string().required(),
+      school: Joi34.string().hex().required(),
+      levels: Joi34.number().integer().min(1).required(),
+      serial: Joi34.string().optional().allow("", null),
+      status: Joi34.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new BadRequestError39(error.message));
-      logger22.info(`Controller: ${error.message}`);
+      next(new BadRequestError47(error.message));
+      logger25.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -7626,18 +8898,18 @@ function useBuildingController() {
   async function updateById(req, res, next) {
     const value = req.body;
     const id = req.params.id ?? "";
-    const validation = Joi26.object({
-      id: Joi26.string().hex().required(),
-      value: Joi26.object({
-        name: Joi26.string().required(),
-        serial: Joi26.string().optional().allow("", null),
-        levels: Joi26.number().integer().min(1).required()
+    const validation = Joi34.object({
+      id: Joi34.string().hex().required(),
+      value: Joi34.object({
+        name: Joi34.string().required(),
+        serial: Joi34.string().optional().allow("", null),
+        levels: Joi34.number().integer().min(1).required()
       })
     });
     const { error } = validation.validate({ id, value });
     if (error) {
-      next(new BadRequestError39(error.message));
-      logger22.info(`Controller: ${error.message}`);
+      next(new BadRequestError47(error.message));
+      logger25.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -7650,16 +8922,16 @@ function useBuildingController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = Joi26.object({
-      page: Joi26.number().min(1).optional().allow("", null),
-      limit: Joi26.number().min(1).optional().allow("", null),
-      search: Joi26.string().optional().allow("", null),
-      school: Joi26.string().hex().optional().allow("", null),
-      status: Joi26.string().optional().allow("", null)
+    const validation = Joi34.object({
+      page: Joi34.number().min(1).optional().allow("", null),
+      limit: Joi34.number().min(1).optional().allow("", null),
+      search: Joi34.string().optional().allow("", null),
+      school: Joi34.string().hex().optional().allow("", null),
+      status: Joi34.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new BadRequestError39(error.message));
+      next(new BadRequestError47(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -7693,12 +8965,12 @@ function useBuildingController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = Joi26.object({
-      id: Joi26.string().hex().required()
+    const validation = Joi34.object({
+      id: Joi34.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new BadRequestError39(error.message));
+      next(new BadRequestError47(error.message));
       return;
     }
     try {
@@ -7714,12 +8986,12 @@ function useBuildingController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = Joi26.object({
-      id: Joi26.string().hex().required()
+    const validation = Joi34.object({
+      id: Joi34.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new BadRequestError39(error.message));
+      next(new BadRequestError47(error.message));
       return;
     }
     try {
@@ -7740,11 +9012,11 @@ function useBuildingController() {
 }
 
 // src/resources/building/building-unit.service.ts
-import { useAtlas as useAtlas19 } from "@goweekdays/utils";
+import { useAtlas as useAtlas23 } from "@goweekdays/utils";
 function useBuildingUnitService() {
   const { add: _add } = useBuildingUnitRepo();
   async function add(value) {
-    const session = useAtlas19.getClient()?.startSession();
+    const session = useAtlas23.getClient()?.startSession();
     if (!session) {
       throw new Error("Unable to start session for building unit service.");
     }
@@ -7771,8 +9043,8 @@ function useBuildingUnitService() {
 }
 
 // src/resources/building/building-unit.controller.ts
-import { BadRequestError as BadRequestError40 } from "@goweekdays/utils";
-import Joi27 from "joi";
+import { BadRequestError as BadRequestError48 } from "@goweekdays/utils";
+import Joi35 from "joi";
 function useBuildingUnitController() {
   const {
     getAll: _getAll,
@@ -7783,27 +9055,27 @@ function useBuildingUnitController() {
   const { add: _add } = useBuildingUnitService();
   async function add(req, res, next) {
     const data = req.body;
-    const validation = Joi27.object({
-      building: Joi27.object({
-        school: Joi27.string().hex().required(),
-        name: Joi27.string().optional().allow("", null),
-        building: Joi27.string().hex().required(),
-        buildingName: Joi27.string().optional().allow("", null),
-        level: Joi27.number().integer().min(1).required(),
-        category: Joi27.string().required(),
-        type: Joi27.string().required(),
-        seating_capacity: Joi27.number().integer().min(0).required(),
-        standing_capacity: Joi27.number().integer().min(0).required(),
-        description: Joi27.string().optional().allow("", null),
-        unit_of_measurement: Joi27.string().valid("sqm").required(),
-        area: Joi27.number().positive().required(),
-        status: Joi27.string().optional().allow("", null)
+    const validation = Joi35.object({
+      building: Joi35.object({
+        school: Joi35.string().hex().required(),
+        name: Joi35.string().optional().allow("", null),
+        building: Joi35.string().hex().required(),
+        buildingName: Joi35.string().optional().allow("", null),
+        level: Joi35.number().integer().min(1).required(),
+        category: Joi35.string().required(),
+        type: Joi35.string().required(),
+        seating_capacity: Joi35.number().integer().min(0).required(),
+        standing_capacity: Joi35.number().integer().min(0).required(),
+        description: Joi35.string().optional().allow("", null),
+        unit_of_measurement: Joi35.string().valid("sqm").required(),
+        area: Joi35.number().positive().required(),
+        status: Joi35.string().optional().allow("", null)
       }),
-      qty: Joi27.number().integer().min(1).max(20).optional().default(1)
+      qty: Joi35.number().integer().min(1).max(20).optional().default(1)
     });
     const { error } = validation.validate(data);
     if (error) {
-      next(new BadRequestError40(error.message));
+      next(new BadRequestError48(error.message));
       return;
     }
     try {
@@ -7819,13 +9091,13 @@ function useBuildingUnitController() {
   async function updateById(req, res, next) {
     const data = req.body;
     const id = req.params.id ?? "";
-    const validation = Joi27.object({
-      id: Joi27.string().hex().required(),
+    const validation = Joi35.object({
+      id: Joi35.string().hex().required(),
       value: schemaUpdateOptions
     });
     const { error } = validation.validate({ id, value: data });
     if (error) {
-      next(new BadRequestError40(error.message));
+      next(new BadRequestError48(error.message));
       return;
     }
     try {
@@ -7840,17 +9112,17 @@ function useBuildingUnitController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = Joi27.object({
-      page: Joi27.number().min(1).optional().allow("", null),
-      limit: Joi27.number().min(1).optional().allow("", null),
-      search: Joi27.string().optional().allow("", null),
-      school: Joi27.string().hex().optional().allow("", null),
-      building: Joi27.string().hex().optional().allow("", null),
-      status: Joi27.string().optional().allow("", null)
+    const validation = Joi35.object({
+      page: Joi35.number().min(1).optional().allow("", null),
+      limit: Joi35.number().min(1).optional().allow("", null),
+      search: Joi35.string().optional().allow("", null),
+      school: Joi35.string().hex().optional().allow("", null),
+      building: Joi35.string().hex().optional().allow("", null),
+      status: Joi35.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new BadRequestError40(error.message));
+      next(new BadRequestError48(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -7886,12 +9158,12 @@ function useBuildingUnitController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = Joi27.object({
-      id: Joi27.string().hex().required()
+    const validation = Joi35.object({
+      id: Joi35.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new BadRequestError40(error.message));
+      next(new BadRequestError48(error.message));
       return;
     }
     try {
@@ -7907,12 +9179,12 @@ function useBuildingUnitController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = Joi27.object({
-      id: Joi27.string().hex().required()
+    const validation = Joi35.object({
+      id: Joi35.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new BadRequestError40(error.message));
+      next(new BadRequestError48(error.message));
       return;
     }
     try {
@@ -7933,14 +9205,14 @@ function useBuildingUnitController() {
 }
 
 // src/resources/counter/counter.model.ts
-import { BadRequestError as BadRequestError41 } from "@goweekdays/utils";
-import { ObjectId as ObjectId20 } from "mongodb";
+import { BadRequestError as BadRequestError49 } from "@goweekdays/utils";
+import { ObjectId as ObjectId25 } from "mongodb";
 import { z } from "zod";
 var TCounter = z.object({
   _id: z.union([
     z.string().length(24, "Invalid ObjectId hex string"),
-    z.instanceof(ObjectId20)
-  ]).transform((val) => typeof val === "string" ? new ObjectId20(val) : val).optional(),
+    z.instanceof(ObjectId25)
+  ]).transform((val) => typeof val === "string" ? new ObjectId25(val) : val).optional(),
   count: z.number().int().min(0).default(0),
   type: z.string(),
   createdAt: z.date().optional().default(() => /* @__PURE__ */ new Date()),
@@ -7953,7 +9225,7 @@ function useCounterModel(db) {
     try {
       return TCounter.parse(value);
     } catch (error) {
-      throw new BadRequestError41(error.issues[0].message);
+      throw new BadRequestError49(error.issues[0].message);
     }
   }
   function validateCounter(data) {
@@ -7967,23 +9239,23 @@ function useCounterModel(db) {
 }
 
 // src/resources/counter/counter.repository.ts
-import { useAtlas as useAtlas20, useCache as useCache15, makeCacheKey as makeCacheKey14, logger as logger23 } from "@goweekdays/utils";
+import { useAtlas as useAtlas24, useCache as useCache18, makeCacheKey as makeCacheKey17, logger as logger26 } from "@goweekdays/utils";
 function useCounterRepo() {
-  const db = useAtlas20.getDb();
+  const db = useAtlas24.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "counters";
   const { collection, createCounter } = useCounterModel(db);
-  const { getCache, setCache, delNamespace } = useCache15(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache18(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      logger23.log({
+      logger26.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      logger23.log({
+      logger26.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -8035,11 +9307,11 @@ function useCounterRepo() {
     }
   }
   async function getByType(type) {
-    const cacheKey = makeCacheKey14(namespace_collection, { type });
+    const cacheKey = makeCacheKey17(namespace_collection, { type });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger23.log({
+        logger26.log({
           level: "info",
           message: `Cache hit for getByType counter: ${cacheKey}`
         });
@@ -8048,12 +9320,12 @@ function useCounterRepo() {
       const data = await collection.findOne({ type });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          logger23.log({
+          logger26.log({
             level: "info",
             message: `Cache set for counter by type: ${cacheKey}`
           });
         }).catch((err) => {
-          logger23.log({
+          logger26.log({
             level: "error",
             message: `Failed to set cache for counter by type: ${err.message}`
           });
@@ -8074,7 +9346,7 @@ function useCounterRepo() {
 }
 
 // src/resources/file/file.service.ts
-import { logger as logger24, useS3 as useS32, useAtlas as useAtlas21 } from "@goweekdays/utils";
+import { logger as logger27, useS3 as useS32, useAtlas as useAtlas25 } from "@goweekdays/utils";
 import cron from "node-cron";
 import * as fs from "fs";
 function useFileService() {
@@ -8092,7 +9364,7 @@ function useFileService() {
     forcePathStyle: true
   });
   async function createFile(value) {
-    const session = useAtlas21.getClient()?.startSession();
+    const session = useAtlas25.getClient()?.startSession();
     session?.startTransaction();
     const file = {
       name: value.originalname,
@@ -8126,7 +9398,7 @@ function useFileService() {
     }
   }
   async function deleteFile(id) {
-    const session = useAtlas21.getClient()?.startSession();
+    const session = useAtlas25.getClient()?.startSession();
     session?.startTransaction();
     try {
       await deleteFileById(id, session);
@@ -8147,12 +9419,12 @@ function useFileService() {
         const file = files[index];
         try {
           await deleteFile(file._id.toString());
-          await logger24.log({
+          await logger27.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
         } catch (error) {
-          logger24.log({
+          logger27.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
@@ -8170,11 +9442,11 @@ function useFileService() {
 
 // src/resources/file/file.controller.ts
 import {
-  AppError as AppError17,
-  BadRequestError as BadRequestError42,
-  InternalServerError as InternalServerError21
+  AppError as AppError20,
+  BadRequestError as BadRequestError50,
+  InternalServerError as InternalServerError24
 } from "@goweekdays/utils";
-import Joi28 from "joi";
+import Joi36 from "joi";
 function useFileController() {
   const { createFile, deleteFile: _deleteFile } = useFileService();
   async function upload(req, res, next) {
@@ -8187,29 +9459,29 @@ function useFileController() {
       res.json({ message: "Successfully uploaded file", id });
       return;
     } catch (error) {
-      if (error instanceof AppError17) {
+      if (error instanceof AppError20) {
         next(error);
       } else {
-        next(new InternalServerError21(error));
+        next(new InternalServerError24(error));
       }
     }
   }
   async function deleteFile(req, res, next) {
     const id = req.params.id;
-    const validation = Joi28.string().required();
+    const validation = Joi36.string().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new BadRequestError42(error.message));
+      next(new BadRequestError50(error.message));
     }
     try {
       const message = await _deleteFile(id);
       res.json({ message });
       return;
     } catch (error2) {
-      if (error2 instanceof AppError17) {
+      if (error2 instanceof AppError20) {
         next(error2);
       } else {
-        next(new InternalServerError21(error2));
+        next(new InternalServerError24(error2));
       }
     }
   }
@@ -8220,11 +9492,11 @@ function useFileController() {
 }
 
 // src/resources/psgc/psgc.model.ts
-import Joi29 from "joi";
-var schemaPSGC = Joi29.object({
-  code: Joi29.string().length(10).required(),
-  name: Joi29.string().required(),
-  type: Joi29.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required()
+import Joi37 from "joi";
+var schemaPSGC = Joi37.object({
+  code: Joi37.string().length(10).required(),
+  name: Joi37.string().required(),
+  type: Joi37.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required()
 });
 function modelPSGC(data) {
   const { error } = schemaPSGC.validate(data);
@@ -8240,24 +9512,24 @@ function modelPSGC(data) {
 
 // src/resources/psgc/psgc.repository.ts
 import {
-  AppError as AppError18,
-  BadRequestError as BadRequestError43,
-  InternalServerError as InternalServerError22,
-  logger as logger25,
-  makeCacheKey as makeCacheKey15,
-  paginate as paginate11,
-  useAtlas as useAtlas22,
-  useCache as useCache16
+  AppError as AppError21,
+  BadRequestError as BadRequestError51,
+  InternalServerError as InternalServerError25,
+  logger as logger28,
+  makeCacheKey as makeCacheKey18,
+  paginate as paginate14,
+  useAtlas as useAtlas26,
+  useCache as useCache19
 } from "@goweekdays/utils";
-import { ObjectId as ObjectId21 } from "mongodb";
+import { ObjectId as ObjectId26 } from "mongodb";
 function usePSGCRepo() {
-  const db = useAtlas22.getDb();
+  const db = useAtlas26.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 } = useCache16(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache19(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -8271,12 +9543,12 @@ function usePSGCRepo() {
   }
   function delCachedData() {
     delNamespace().then(() => {
-      logger25.log({
+      logger28.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      logger25.log({
+      logger28.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -8289,16 +9561,16 @@ function usePSGCRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      logger25.log({
+      logger28.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof AppError18) {
+      if (error instanceof AppError21) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new BadRequestError43("Region already exists.");
+          throw new BadRequestError51("Region already exists.");
         }
         throw new Error("Failed to create PSGC.");
       }
@@ -8334,15 +9606,15 @@ function usePSGCRepo() {
       query.$text = { $search: search };
       cacheKeyOptions.search = search;
     }
-    const cacheKey = makeCacheKey15(namespace_collection, cacheKeyOptions);
-    logger25.log({
+    const cacheKey = makeCacheKey18(namespace_collection, cacheKeyOptions);
+    logger28.log({
       level: "info",
       message: `Cache key for getAll PSGC: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger25.log({
+        logger28.log({
           level: "info",
           message: `Cache hit for getAll PSGC: ${cacheKey}`
         });
@@ -8355,35 +9627,35 @@ function usePSGCRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate11(items, page, limit, length);
+      const data = paginate14(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        logger25.log({
+        logger28.log({
           level: "info",
           message: `Cache set for getAll PSGC: ${cacheKey}`
         });
       }).catch((err) => {
-        logger25.log({
+        logger28.log({
           level: "error",
           message: `Failed to set cache for getAll PSGC: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      logger25.log({ level: "error", message: `${error}` });
+      logger28.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new ObjectId21(_id);
+      _id = new ObjectId26(_id);
     } catch (error) {
-      throw new BadRequestError43("Invalid ID.");
+      throw new BadRequestError51("Invalid ID.");
     }
-    const cacheKey = makeCacheKey15(namespace_collection, { _id: String(_id) });
+    const cacheKey = makeCacheKey18(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger25.log({
+        logger28.log({
           level: "info",
           message: `Cache hit for getById PSGC: ${cacheKey}`
         });
@@ -8394,25 +9666,25 @@ function usePSGCRepo() {
         deletedAt: { $in: ["", null] }
       });
       if (!result) {
-        throw new BadRequestError43("Region not found.");
+        throw new BadRequestError51("Region not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        logger25.log({
+        logger28.log({
           level: "info",
           message: `Cache set for PSGC by id: ${cacheKey}`
         });
       }).catch((err) => {
-        logger25.log({
+        logger28.log({
           level: "error",
           message: `Failed to set cache for PSGC by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof AppError18) {
+      if (error instanceof AppError21) {
         throw error;
       } else {
-        throw new InternalServerError22("Failed to get PSGC.");
+        throw new InternalServerError25("Failed to get PSGC.");
       }
     }
   }
@@ -8436,15 +9708,15 @@ function usePSGCRepo() {
       query.code = { $regex: `^${prefix}` };
       cacheKeyOptions.prefix = prefix;
     }
-    const cacheKey = makeCacheKey15(namespace_collection, { name });
-    logger25.log({
+    const cacheKey = makeCacheKey18(namespace_collection, { name });
+    logger28.log({
       level: "info",
       message: `Query for getByName PSGC: ${JSON.stringify(query)}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger25.log({
+        logger28.log({
           level: "info",
           message: `Cache hit for getByName PSGC: ${cacheKey}`
         });
@@ -8452,36 +9724,36 @@ function usePSGCRepo() {
       }
       const result = await collection.findOne(query);
       setCache(cacheKey, result, 300).then(() => {
-        logger25.log({
+        logger28.log({
           level: "info",
           message: `Cache set for PSGC by name: ${cacheKey}`
         });
       }).catch((err) => {
-        logger25.log({
+        logger28.log({
           level: "error",
           message: `Failed to set cache for PSGC by name: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof AppError18) {
+      if (error instanceof AppError21) {
         throw error;
       } else {
-        throw new InternalServerError22("Failed to get PSGC.");
+        throw new InternalServerError25("Failed to get PSGC.");
       }
     }
   }
   async function updateFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["name"];
     if (!allowedFields.includes(field)) {
-      throw new BadRequestError43(
+      throw new BadRequestError51(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
-      _id = new ObjectId21(_id);
+      _id = new ObjectId26(_id);
     } catch (error) {
-      throw new BadRequestError43("Invalid ID.");
+      throw new BadRequestError51("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -8492,14 +9764,14 @@ function usePSGCRepo() {
       delCachedData();
       return `Successfully updated PSGC ${field}.`;
     } catch (error) {
-      throw new InternalServerError22(`Failed to update PSGC ${field}.`);
+      throw new InternalServerError25(`Failed to update PSGC ${field}.`);
     }
   }
   async function deleteById(_id) {
     try {
-      _id = new ObjectId21(_id);
+      _id = new ObjectId26(_id);
     } catch (error) {
-      throw new BadRequestError43("Invalid ID.");
+      throw new BadRequestError51("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -8509,7 +9781,7 @@ function usePSGCRepo() {
       delCachedData();
       return "Successfully deleted PSGC.";
     } catch (error) {
-      throw new InternalServerError22("Failed to delete PSGC.");
+      throw new InternalServerError25("Failed to delete PSGC.");
     }
   }
   return {
@@ -8524,8 +9796,8 @@ function usePSGCRepo() {
 }
 
 // src/resources/psgc/psgc.controller.ts
-import { BadRequestError as BadRequestError44 } from "@goweekdays/utils";
-import Joi30 from "joi";
+import { BadRequestError as BadRequestError52 } from "@goweekdays/utils";
+import Joi38 from "joi";
 function usePSGCController() {
   const {
     add: _add,
@@ -8539,7 +9811,7 @@ function usePSGCController() {
     const value = req.body;
     const { error } = schemaPSGC.validate(value);
     if (error) {
-      next(new BadRequestError44(error.message));
+      next(new BadRequestError52(error.message));
       return;
     }
     try {
@@ -8555,12 +9827,12 @@ function usePSGCController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = Joi30.object({
-      page: Joi30.number().min(1).optional().allow("", null),
-      limit: Joi30.number().min(1).optional().allow("", null),
-      search: Joi30.string().optional().allow("", null),
-      type: Joi30.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required(),
-      prefix: Joi30.string().optional().allow("", null)
+    const validation = Joi38.object({
+      page: Joi38.number().min(1).optional().allow("", null),
+      limit: Joi38.number().min(1).optional().allow("", null),
+      search: Joi38.string().optional().allow("", null),
+      type: Joi38.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required(),
+      prefix: Joi38.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
@@ -8570,16 +9842,16 @@ function usePSGCController() {
     const prefix = req.query.prefix ? String(req.query.prefix) : "";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new BadRequestError44("Invalid page number."));
+      next(new BadRequestError52("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new BadRequestError44("Invalid limit number."));
+      next(new BadRequestError52("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new BadRequestError44(error.message));
+      next(new BadRequestError52(error.message));
       return;
     }
     try {
@@ -8598,12 +9870,12 @@ function usePSGCController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = Joi30.object({
-      id: Joi30.string().hex().required()
+    const validation = Joi38.object({
+      id: Joi38.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new BadRequestError44(error.message));
+      next(new BadRequestError52(error.message));
       return;
     }
     try {
@@ -8619,12 +9891,12 @@ function usePSGCController() {
   }
   async function getByName(req, res, next) {
     const name = req.params.name;
-    const validation = Joi30.object({
-      name: Joi30.string().required()
+    const validation = Joi38.object({
+      name: Joi38.string().required()
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new BadRequestError44(error.message));
+      next(new BadRequestError52(error.message));
       return;
     }
     try {
@@ -8641,14 +9913,14 @@ function usePSGCController() {
   async function updateField(req, res, next) {
     const _id = req.params.id;
     const { field, value } = req.body;
-    const validation = Joi30.object({
-      _id: Joi30.string().hex().required(),
-      field: Joi30.string().valid("name", "director", "directorName").required(),
-      value: Joi30.string().required()
+    const validation = Joi38.object({
+      _id: Joi38.string().hex().required(),
+      field: Joi38.string().valid("name", "director", "directorName").required(),
+      value: Joi38.string().required()
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new BadRequestError44(error.message));
+      next(new BadRequestError52(error.message));
       return;
     }
     try {
@@ -8661,12 +9933,12 @@ function usePSGCController() {
   }
   async function deleteById(req, res, next) {
     const _id = req.params.id;
-    const validation = Joi30.object({
-      _id: Joi30.string().hex().required()
+    const validation = Joi38.object({
+      _id: Joi38.string().hex().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new BadRequestError44(error.message));
+      next(new BadRequestError52(error.message));
       return;
     }
     try {
@@ -8688,7 +9960,7 @@ function usePSGCController() {
 }
 
 // src/resources/utils/github.service.ts
-import { AppError as AppError19, BadRequestError as BadRequestError45 } from "@goweekdays/utils";
+import { AppError as AppError22, BadRequestError as BadRequestError53 } from "@goweekdays/utils";
 import { Octokit } from "@octokit/rest";
 import _sodium from "libsodium-wrappers";
 function useGitHubService() {
@@ -8702,23 +9974,23 @@ function useGitHubService() {
     try {
       const { data: repoData } = await octokit.repos.get({ owner, repo });
       if (!repoData.permissions?.admin) {
-        throw new BadRequestError45(
+        throw new BadRequestError53(
           "You do not have admin access to this repository."
         );
       }
     } catch (error) {
       if (error.status === 404) {
-        throw new BadRequestError45(
+        throw new BadRequestError53(
           "Repository not found or you don't have access to it."
         );
       } else if (error.status === 401) {
-        throw new BadRequestError45(
+        throw new BadRequestError53(
           "Invalid GitHub token or insufficient permissions."
         );
       } else if (error.message.includes("admin access")) {
         throw error;
       } else {
-        throw new BadRequestError45(
+        throw new BadRequestError53(
           `Failed to check repository permissions: ${error.message}`
         );
       }
@@ -8767,7 +10039,7 @@ function useGitHubService() {
               key_id: publicKeyRes.key_id
             });
           } catch (encryptionError) {
-            throw new BadRequestError45(
+            throw new BadRequestError53(
               `Failed to encrypt secret '${key}': ${encryptionError.message}`
             );
           }
@@ -8797,22 +10069,22 @@ function useGitHubService() {
       }
       return `Successfully set ${lines.length} ${type} variables/secrets in environment '${environment}'`;
     } catch (error) {
-      if (error instanceof AppError19)
+      if (error instanceof AppError22)
         throw error;
       if (error.status === 422) {
-        throw new BadRequestError45(
+        throw new BadRequestError53(
           `GitHub API validation error: ${error.message}`
         );
       } else if (error.status === 404) {
-        throw new BadRequestError45("Environment or repository not found.");
+        throw new BadRequestError53("Environment or repository not found.");
       } else if (error.status === 403) {
-        throw new BadRequestError45(
+        throw new BadRequestError53(
           "Forbidden: Insufficient permissions or rate limit exceeded."
         );
       } else if (error.message.includes("admin access") || error.message.includes("permissions")) {
         throw error;
       } else {
-        throw new BadRequestError45(
+        throw new BadRequestError53(
           `Failed to set GitHub variables: ${error.message}`
         );
       }
@@ -8824,12 +10096,12 @@ function useGitHubService() {
 }
 
 // src/resources/utils/util.controller.ts
-import Joi31 from "joi";
+import Joi39 from "joi";
 import {
-  AppError as AppError20,
-  BadRequestError as BadRequestError46,
-  InternalServerError as InternalServerError23,
-  logger as logger26
+  AppError as AppError23,
+  BadRequestError as BadRequestError54,
+  InternalServerError as InternalServerError26,
+  logger as logger29
 } from "@goweekdays/utils";
 function useUtilController() {
   async function healthCheck(req, res, next) {
@@ -8846,32 +10118,32 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      logger26.error("Health check failed", { error: error.message });
-      next(new InternalServerError23("Health check failed"));
+      logger29.error("Health check failed", { error: error.message });
+      next(new InternalServerError26("Health check failed"));
     }
   }
   async function setGitHubVariables(req, res, next) {
     try {
       const { githubToken, repoUrl, environment, type, keyValues } = req.body;
-      const validation = Joi31.object({
-        githubToken: Joi31.string().required().messages({
+      const validation = Joi39.object({
+        githubToken: Joi39.string().required().messages({
           "string.empty": "GitHub token is required",
           "any.required": "GitHub token is required"
         }),
-        repoUrl: Joi31.string().uri().required().messages({
+        repoUrl: Joi39.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: Joi31.string().required().messages({
+        environment: Joi39.string().required().messages({
           "string.empty": "Environment name is required",
           "any.required": "Environment name is required"
         }),
-        type: Joi31.string().valid("env", "secret").required().messages({
+        type: Joi39.string().valid("env", "secret").required().messages({
           "any.only": 'Type must be either "env" or "secret"',
           "any.required": "Type is required"
         }),
-        keyValues: Joi31.string().required().messages({
+        keyValues: Joi39.string().required().messages({
           "string.empty": "Key-value pairs are required",
           "any.required": "Key-value pairs are required"
         })
@@ -8884,13 +10156,13 @@ function useUtilController() {
         keyValues
       });
       if (error) {
-        next(new BadRequestError46(error.message));
+        next(new BadRequestError54(error.message));
         return;
       }
       const repoUrlPattern = /github\.com[:\/]([^\/]+)\/(.+)\.git$/;
       if (!repoUrlPattern.test(repoUrl)) {
         next(
-          new BadRequestError46(
+          new BadRequestError54(
             "Invalid GitHub repository URL format. Expected format: https://github.com/owner/repo.git"
           )
         );
@@ -8902,7 +10174,7 @@ function useUtilController() {
       );
       if (invalidLines.length > 0) {
         next(
-          new BadRequestError46(
+          new BadRequestError54(
             "Invalid key-value format. Each pair should be in format: KEY=value. Pairs should be separated by semicolons."
           )
         );
@@ -8916,7 +10188,7 @@ function useUtilController() {
         type,
         keyValues
       });
-      logger26.info(`GitHub variables set successfully`, {
+      logger29.info(`GitHub variables set successfully`, {
         repoUrl,
         environment,
         type,
@@ -8933,15 +10205,15 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      logger26.error("Failed to set GitHub variables", {
+      logger29.error("Failed to set GitHub variables", {
         error: error.message,
         stack: error.stack
       });
-      if (error instanceof AppError20) {
+      if (error instanceof AppError23) {
         next(error);
       } else {
         next(
-          new InternalServerError23(
+          new InternalServerError26(
             `Failed to set GitHub variables: ${error.message}`
           )
         );
@@ -8955,35 +10227,35 @@ function useUtilController() {
 }
 
 // src/resources/utils/transaction.schema.ts
-import Joi32 from "joi";
-var transactionSchema = Joi32.object({
-  _id: Joi32.string().hex().optional().allow("", null),
-  payment: Joi32.string().required(),
-  user: Joi32.string().hex().optional().allow("", null),
-  org: Joi32.string().hex().optional().allow("", null),
-  type: Joi32.string().required(),
-  amount: Joi32.number().positive().min(0).required(),
-  currency: Joi32.string().required(),
-  description: Joi32.string().optional().allow("", null),
-  metadata: Joi32.object({
-    subscriptionId: Joi32.string().hex().optional().allow("", null),
-    cycle: Joi32.number().optional().allow("", null),
-    seats: Joi32.number().optional().allow("", null),
-    promoCode: Joi32.string().optional().allow("", null)
+import Joi40 from "joi";
+var transactionSchema = Joi40.object({
+  _id: Joi40.string().hex().optional().allow("", null),
+  payment: Joi40.string().required(),
+  user: Joi40.string().hex().optional().allow("", null),
+  org: Joi40.string().hex().optional().allow("", null),
+  type: Joi40.string().required(),
+  amount: Joi40.number().positive().min(0).required(),
+  currency: Joi40.string().required(),
+  description: Joi40.string().optional().allow("", null),
+  metadata: Joi40.object({
+    subscriptionId: Joi40.string().hex().optional().allow("", null),
+    cycle: Joi40.number().optional().allow("", null),
+    seats: Joi40.number().optional().allow("", null),
+    promoCode: Joi40.string().optional().allow("", null)
   }).optional().allow("", null),
-  status: Joi32.string().optional().allow("", null),
-  createdAt: Joi32.string().optional().allow("", null),
-  updatedAt: Joi32.string().optional().allow("", null),
-  deletedAt: Joi32.string().optional().allow("", null)
+  status: Joi40.string().optional().allow("", null),
+  createdAt: Joi40.string().optional().allow("", null),
+  updatedAt: Joi40.string().optional().allow("", null),
+  deletedAt: Joi40.string().optional().allow("", null)
 });
 
 // src/resources/verification/verification.controller.ts
 import {
-  AppError as AppError21,
-  BadRequestError as BadRequestError47,
-  InternalServerError as InternalServerError24
+  AppError as AppError24,
+  BadRequestError as BadRequestError55,
+  InternalServerError as InternalServerError27
 } from "@goweekdays/utils";
-import Joi33 from "joi";
+import Joi41 from "joi";
 function useVerificationController() {
   const {
     createUserInvite: _createUserInvite,
@@ -8997,17 +10269,17 @@ function useVerificationController() {
   } = useVerificationService();
   const { getVerifications: _getVerifications } = useVerificationRepo();
   async function createUserInvite(req, res, next) {
-    const validation = Joi33.object({
-      email: Joi33.string().email().required(),
-      app: Joi33.string().required(),
-      role: Joi33.string().hex().required(),
-      roleName: Joi33.string().required(),
-      org: Joi33.string().hex().optional().optional().allow("", null),
-      orgName: Joi33.string().optional().optional().allow("", null)
+    const validation = Joi41.object({
+      email: Joi41.string().email().required(),
+      app: Joi41.string().required(),
+      role: Joi41.string().hex().required(),
+      roleName: Joi41.string().required(),
+      org: Joi41.string().hex().optional().optional().allow("", null),
+      orgName: Joi41.string().optional().optional().allow("", null)
     });
     const { error } = validation.validate(req.body);
     if (error) {
-      next(new BadRequestError47(error.message));
+      next(new BadRequestError55(error.message));
       return;
     }
     const email = req.body.email ?? "";
@@ -9035,10 +10307,10 @@ function useVerificationController() {
   }
   async function createForgetPassword(req, res, next) {
     const email = req.body.email || "";
-    const validation = Joi33.string().email().required();
+    const validation = Joi41.string().email().required();
     const { error } = validation.validate(email);
     if (error) {
-      next(new BadRequestError47(error.message));
+      next(new BadRequestError55(error.message));
       return;
     }
     try {
@@ -9048,26 +10320,26 @@ function useVerificationController() {
       });
       return;
     } catch (error2) {
-      if (error2 instanceof AppError21) {
+      if (error2 instanceof AppError24) {
         next(error2);
       } else {
-        next(new InternalServerError24("An unexpected error occurred"));
+        next(new InternalServerError27("An unexpected error occurred"));
       }
     }
   }
   async function getVerifications(req, res, next) {
-    const validation = Joi33.object({
-      status: Joi33.string().required(),
-      search: Joi33.string().optional().allow("", null),
-      page: Joi33.number().required(),
-      type: Joi33.string().optional().allow("", null),
-      email: Joi33.string().optional().allow("", null),
-      app: Joi33.string().optional().allow("", null),
-      org: Joi33.string().optional().allow("", null)
+    const validation = Joi41.object({
+      status: Joi41.string().required(),
+      search: Joi41.string().optional().allow("", null),
+      page: Joi41.number().required(),
+      type: Joi41.string().optional().allow("", null),
+      email: Joi41.string().optional().allow("", null),
+      app: Joi41.string().optional().allow("", null),
+      org: Joi41.string().optional().allow("", null)
     });
     const { error } = validation.validate(req.query);
     if (error) {
-      next(new BadRequestError47(error.message));
+      next(new BadRequestError55(error.message));
       return;
     }
     const status = req.query.status ?? "";
@@ -9100,10 +10372,10 @@ function useVerificationController() {
   }
   async function verify(req, res, next) {
     const id = req.params.id || "";
-    const validation = Joi33.string().hex().required();
+    const validation = Joi41.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new BadRequestError47(error.message));
+      next(new BadRequestError55(error.message));
       return;
     }
     try {
@@ -9116,10 +10388,10 @@ function useVerificationController() {
   }
   async function cancelUserInvitation(req, res, next) {
     const otpId = req.params.id || "";
-    const validation = Joi33.string().hex().required();
+    const validation = Joi41.string().hex().required();
     const { error } = validation.validate(otpId);
     if (error) {
-      next(new BadRequestError47(error.message));
+      next(new BadRequestError55(error.message));
       return;
     }
     try {
@@ -9132,10 +10404,10 @@ function useVerificationController() {
     }
   }
   async function signUp(req, res, next) {
-    const validation = Joi33.string().email().required();
+    const validation = Joi41.string().email().required();
     const { error } = validation.validate(req.body.email);
     if (error) {
-      next(new BadRequestError47(error.message));
+      next(new BadRequestError55(error.message));
       return;
     }
     const email = req.body.email ?? "";
@@ -9150,7 +10422,7 @@ function useVerificationController() {
   async function inviteMember(req, res, next) {
     const { error } = schemaInviteMember.validate(req.body);
     if (error) {
-      next(new BadRequestError47(error.message));
+      next(new BadRequestError55(error.message));
       return;
     }
     try {
@@ -9163,10 +10435,10 @@ function useVerificationController() {
   }
   async function cancelInviteMember(req, res, next) {
     const id = req.params.id || "";
-    const validation = Joi33.string().hex().required();
+    const validation = Joi41.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new BadRequestError47(error.message));
+      next(new BadRequestError55(error.message));
       return;
     }
     try {
@@ -9179,10 +10451,10 @@ function useVerificationController() {
   }
   async function forgetPassword(req, res, next) {
     const email = req.body.email ?? "";
-    const validation = Joi33.string().email().required();
+    const validation = Joi41.string().email().required();
     const { error } = validation.validate(email);
     if (error) {
-      next(new BadRequestError47(error.message));
+      next(new BadRequestError55(error.message));
       return;
     }
     try {
@@ -9192,10 +10464,10 @@ function useVerificationController() {
       });
       return;
     } catch (error2) {
-      if (error2 instanceof AppError21) {
+      if (error2 instanceof AppError24) {
         next(error2);
       } else {
-        next(new InternalServerError24("An unexpected error occurred"));
+        next(new InternalServerError27("An unexpected error occurred"));
       }
     }
   }
@@ -9252,6 +10524,7 @@ export {
   XENDIT_BASE_URL,
   XENDIT_SECRET_KEY,
   addressSchema,
+  currencies,
   isDev,
   modelApp,
   modelMember,
@@ -9259,7 +10532,10 @@ export {
   modelPSGC,
   modelPermission,
   modelPermissionGroup,
+  modelPlan,
   modelRole,
+  modelSubscription,
+  modelSubscriptionTransaction,
   modelUser,
   modelVerification,
   schemaApp,
@@ -9271,13 +10547,20 @@ export {
   schemaMemberRole,
   schemaMemberStatus,
   schemaOrg,
+  schemaOrgAdd,
+  schemaOrgUpdate,
   schemaPSGC,
   schemaPermission,
   schemaPermissionGroup,
   schemaPermissionGroupUpdate,
   schemaPermissionUpdate,
+  schemaPlan,
   schemaRole,
   schemaRoleUpdate,
+  schemaSubscription,
+  schemaSubscriptionSeats,
+  schemaSubscriptionTransaction,
+  schemaSubscriptionUpdate,
   schemaUpdateOptions,
   schemaUser,
   schemaVerification,
@@ -9314,9 +10597,16 @@ export {
   usePermissionGroupService,
   usePermissionRepo,
   usePermissionService,
+  usePlanController,
+  usePlanRepo,
+  usePlanService,
   useRoleController,
   useRoleRepo,
   useRoleService,
+  useSubscriptionController,
+  useSubscriptionRepo,
+  useSubscriptionTransactionController,
+  useSubscriptionTransactionRepo,
   useUserController,
   useUserRepo,
   useUserService,