@goweekdays/core 2.2.0 → 2.2.1

package/dist/index.js

@@ -51,11 +51,9 @@ __export(src_exports, {
   MMember: () => MMember,
   MONGO_DB: () => MONGO_DB,
   MONGO_URI: () => MONGO_URI,
-  MOrg: () => MOrg,
   MUser: () => MUser,
   MUserRole: () => MUserRole,
   MVerification: () => MVerification,
-  OrgTypes: () => OrgTypes,
   PAYPAL_API_URL: () => PAYPAL_API_URL,
   PAYPAL_CLIENT_ID: () => PAYPAL_CLIENT_ID,
   PAYPAL_CLIENT_SECRET: () => PAYPAL_CLIENT_SECRET,
@@ -78,6 +76,8 @@ __export(src_exports, {
   addressSchema: () => addressSchema,
   isDev: () => isDev,
   modelApp: () => modelApp,
+  modelMember: () => modelMember,
+  modelOrg: () => modelOrg,
   modelPSGC: () => modelPSGC,
   modelPermission: () => modelPermission,
   modelPermissionGroup: () => modelPermissionGroup,
@@ -86,6 +86,7 @@ __export(src_exports, {
   schemaAppUpdate: () => schemaAppUpdate,
   schemaBuilding: () => schemaBuilding,
   schemaBuildingUnit: () => schemaBuildingUnit,
+  schemaMember: () => schemaMember,
   schemaOrg: () => schemaOrg,
   schemaPSGC: () => schemaPSGC,
   schemaPermission: () => schemaPermission,
@@ -953,10 +954,10 @@ function useAuthService() {
 
 // src/resources/auth/auth.controller.ts
 var import_joi14 = __toESM(require("joi"));
-var import_utils25 = require("@goweekdays/utils");
+var import_utils26 = require("@goweekdays/utils");
 
 // src/resources/user/user.service.ts
-var import_utils24 = require("@goweekdays/utils");
+var import_utils25 = require("@goweekdays/utils");
 
 // src/resources/file/file.repository.ts
 var import_utils6 = require("@goweekdays/utils");
@@ -1459,6 +1460,56 @@ function MMember(value) {
     deletedAt: ""
   };
 }
+var schemaMember = import_joi3.default.object({
+  org: import_joi3.default.string().hex().optional().allow("", null),
+  orgName: import_joi3.default.string().optional().allow("", null),
+  name: import_joi3.default.string().required(),
+  user: import_joi3.default.string().hex().required(),
+  role: import_joi3.default.string().hex().required(),
+  roleName: import_joi3.default.string().optional().allow("", null),
+  type: import_joi3.default.string().required()
+});
+function modelMember(value) {
+  const { error } = schemaMember.validate(value);
+  if (error) {
+    throw new import_utils9.BadRequestError(error.message);
+  }
+  if (value.org) {
+    try {
+      value.org = new import_mongodb8.ObjectId(value.org);
+    } catch (error2) {
+      throw new import_utils9.BadRequestError("Invalid org ID.");
+    }
+  }
+  if (value.user) {
+    try {
+      value.user = new import_mongodb8.ObjectId(value.user);
+    } catch (error2) {
+      throw new import_utils9.BadRequestError("Invalid user ID.");
+    }
+  }
+  if (value.role) {
+    try {
+      value.role = new import_mongodb8.ObjectId(value.role);
+    } catch (error2) {
+      throw new import_utils9.BadRequestError("Invalid role ID.");
+    }
+  }
+  return {
+    _id: value._id,
+    org: value.org ?? "",
+    orgName: value.orgName ?? "",
+    name: value.name,
+    user: value.user,
+    type: value.type,
+    role: value.role,
+    roleName: value.roleName ?? "",
+    status: value.status ?? "active",
+    createdAt: value.createdAt || /* @__PURE__ */ new Date(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
 
 // src/resources/member/member.repository.ts
 var import_mongodb9 = require("mongodb");
@@ -1527,7 +1578,7 @@ function useMemberRepo() {
   }
   async function add(value, session) {
     try {
-      value = MMember(value);
+      value = modelMember(value);
       await collection.insertOne(value, { session });
       delCachedData();
       return "Successfully added member.";
@@ -2414,42 +2465,43 @@ var import_multer = require("multer");
 var import_mongodb15 = require("mongodb");
 
 // src/resources/role/role.repository.ts
-var import_utils12 = require("@goweekdays/utils");
+var import_utils13 = require("@goweekdays/utils");
 
 // src/resources/role/role.model.ts
+var import_utils12 = require("@goweekdays/utils");
 var import_joi4 = __toESM(require("joi"));
 var import_mongodb10 = require("mongodb");
 var schemaRole = import_joi4.default.object({
   name: import_joi4.default.string().required(),
   description: import_joi4.default.string().max(1024).optional().allow("", null),
   permissions: import_joi4.default.array().items(import_joi4.default.string()).required(),
-  type: import_joi4.default.string().required(),
-  org: import_joi4.default.string().hex().optional().allow("", null)
+  org: import_joi4.default.string().hex().optional().allow("", null),
+  createdBy: import_joi4.default.string().hex().required()
 });
 function modelRole(value) {
   const { error } = schemaRole.validate(value);
   if (error) {
-    throw new Error(error.message);
+    throw new import_utils12.BadRequestError(error.message);
   }
   if (value._id && typeof value._id === "string") {
     try {
       value._id = new import_mongodb10.ObjectId(value._id);
     } catch (error2) {
-      throw new Error("Invalid _id.");
+      throw new import_utils12.BadRequestError("Invalid _id.");
     }
   }
   if (value.org && typeof value.org === "string" && value.org.length === 24) {
     try {
       value.org = new import_mongodb10.ObjectId(value.org);
     } catch (error2) {
-      throw new Error("Invalid org.");
+      throw new import_utils12.BadRequestError("Invalid org.");
     }
   }
   if (value.createdBy && typeof value.createdBy === "string" && value.createdBy.length === 24) {
     try {
       value.createdBy = new import_mongodb10.ObjectId(value.createdBy);
     } catch (error2) {
-      throw new Error("Invalid createdBy.");
+      throw new import_utils12.BadRequestError("Invalid createdBy.");
     }
   }
   return {
@@ -2457,7 +2509,6 @@ function modelRole(value) {
     name: value.name,
     description: value.description ?? "",
     permissions: value.permissions,
-    type: value.type,
     org: value.org,
     status: value.status ?? "active",
     default: value.default ?? false,
@@ -2471,21 +2522,21 @@ function modelRole(value) {
 // src/resources/role/role.repository.ts
 var import_mongodb11 = require("mongodb");
 function useRoleRepo() {
-  const db = import_utils12.useAtlas.getDb();
+  const db = import_utils13.useAtlas.getDb();
   if (!db) {
-    throw new import_utils12.InternalServerError("Unable to connect to server.");
+    throw new import_utils13.InternalServerError("Unable to connect to server.");
   }
   const namespace_collection = "roles";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils12.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils13.useCache)(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils12.logger.log({
+      import_utils13.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils12.logger.log({
+      import_utils13.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -2498,14 +2549,14 @@ function useRoleRepo() {
       await collection.createIndex({ status: 1 });
       await collection.createIndex({ id: 1 });
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to create index on role.");
+      throw new import_utils13.InternalServerError("Failed to create index on role.");
     }
   }
   async function createTextIndex() {
     try {
       await collection.createIndex({ name: "text" });
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to create text index on role.");
+      throw new import_utils13.InternalServerError("Failed to create text index on role.");
     }
   }
   async function createUniqueIndex() {
@@ -2515,7 +2566,7 @@ function useRoleRepo() {
         { unique: true }
       );
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to create unique index on role.");
+      throw new import_utils13.InternalServerError("Failed to create unique index on role.");
     }
   }
   async function addRole(value, session, clearCache = true) {
@@ -2527,27 +2578,31 @@ function useRoleRepo() {
       }
       return res.insertedId;
     } catch (error) {
-      import_utils12.logger.log({ level: "error", message: `${error}` });
+      import_utils13.logger.log({ level: "error", message: `${error}` });
       const isDuplicated = error.message.includes("duplicate");
       if (isDuplicated) {
-        throw new import_utils12.BadRequestError("Role already exists");
+        throw new import_utils13.BadRequestError("Role already exists");
+      }
+      if (error instanceof import_utils13.AppError) {
+        throw error;
+      } else {
+        throw new import_utils13.InternalServerError("Failed to create role.");
       }
-      throw new import_utils12.InternalServerError("Failed to create role.");
     }
   }
   async function getRoleByUserId(value) {
     try {
       value = new import_mongodb11.ObjectId(value);
     } catch (error) {
-      throw new import_utils12.BadRequestError("Invalid user ID.");
+      throw new import_utils13.BadRequestError("Invalid user ID.");
     }
     try {
-      const cacheKey = (0, import_utils12.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_utils13.makeCacheKey)(namespace_collection, {
         user: String(value)
       });
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "info",
           message: `Cache hit for getRoleByUserId role: ${cacheKey}`
         });
@@ -2555,34 +2610,34 @@ function useRoleRepo() {
       }
       const data = await collection.findOne({ user: value });
       setCache(cacheKey, data, 300).then(() => {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "info",
           message: `Cache set for role by user ID: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "error",
           message: `Failed to set cache for role by user ID: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to retrieve role by user ID.");
+      throw new import_utils13.InternalServerError("Failed to retrieve role by user ID.");
     }
   }
   async function getById(_id) {
     try {
       _id = new import_mongodb11.ObjectId(_id);
     } catch (error) {
-      throw new import_utils12.BadRequestError("Invalid ID.");
+      throw new import_utils13.BadRequestError("Invalid ID.");
     }
     try {
-      const cacheKey = (0, import_utils12.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_utils13.makeCacheKey)(namespace_collection, {
         id: _id.toString()
       });
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "info",
           message: `Cache hit for getById role: ${cacheKey}`
         });
@@ -2590,32 +2645,32 @@ function useRoleRepo() {
       }
       const data = await collection.findOne({ _id });
       setCache(cacheKey, data, 300).then(() => {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "info",
           message: `Cache set for role by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "error",
           message: `Failed to set cache for role by id: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to retrieve role by ID.");
+      throw new import_utils13.InternalServerError("Failed to retrieve role by ID.");
     }
   }
   async function getRoleByName(name) {
     if (!name) {
-      throw new import_utils12.BadRequestError("Role name is required.");
+      throw new import_utils13.BadRequestError("Role name is required.");
     }
     try {
-      const cacheKey = (0, import_utils12.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_utils13.makeCacheKey)(namespace_collection, {
         name
       });
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "info",
           message: `Cache hit for getRoleByName role: ${cacheKey}`
         });
@@ -2623,19 +2678,19 @@ function useRoleRepo() {
       }
       const data = await collection.findOne({ name });
       setCache(cacheKey, data, 300).then(() => {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "info",
           message: `Cache set for role by name: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "error",
           message: `Failed to set cache for role by name: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to retrieve role by name.");
+      throw new import_utils13.InternalServerError("Failed to retrieve role by name.");
     }
   }
   async function getRoles({
@@ -2653,7 +2708,7 @@ function useRoleRepo() {
       try {
         id = new import_mongodb11.ObjectId(id);
       } catch (error) {
-        throw new import_utils12.BadRequestError("Invalid ID.");
+        throw new import_utils13.BadRequestError("Invalid ID.");
       }
     }
     const query = { status: "active" };
@@ -2678,10 +2733,10 @@ function useRoleRepo() {
     }
     sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
     cacheKeyOptions.sort = JSON.stringify(sort);
-    const cacheKey = (0, import_utils12.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    const cacheKey = (0, import_utils13.makeCacheKey)(namespace_collection, cacheKeyOptions);
     const cached = await getCache(cacheKey);
     if (cached) {
-      import_utils12.logger.log({
+      import_utils13.logger.log({
         level: "info",
         message: `Cache hit for getRoles: ${cacheKey}`
       });
@@ -2695,32 +2750,32 @@ function useRoleRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils12.paginate)(items, page, limit, length);
+      const data = (0, import_utils13.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "info",
           message: `Cache set for getRoles: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils12.logger.log({
+        import_utils13.logger.log({
           level: "error",
           message: `Failed to set cache for getRoles: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils12.logger.log({ level: "error", message: `${error}` });
+      import_utils13.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function updateRole(_id, value, session) {
     if (!_id) {
-      throw new import_utils12.BadRequestError("Role ID is required.");
+      throw new import_utils13.BadRequestError("Role ID is required.");
     }
     try {
       _id = new import_mongodb11.ObjectId(_id);
     } catch (error) {
-      throw new import_utils12.BadRequestError("Invalid role ID.");
+      throw new import_utils13.BadRequestError("Invalid role ID.");
     }
     if (!value.name) {
       delete value.name;
@@ -2734,26 +2789,26 @@ function useRoleRepo() {
         delCachedData();
         return "Successfully updated role.";
       } catch (error) {
-        throw new import_utils12.InternalServerError("Failed to update role.");
+        throw new import_utils13.InternalServerError("Failed to update role.");
       }
     } else {
-      throw new import_utils12.BadRequestError("No fields to update.");
+      throw new import_utils13.BadRequestError("No fields to update.");
     }
   }
   async function updatePermissionsById(_id, permissions, session) {
     if (!_id) {
-      throw new import_utils12.BadRequestError("Role ID is required.");
+      throw new import_utils13.BadRequestError("Role ID is required.");
     }
     try {
       _id = new import_mongodb11.ObjectId(_id);
     } catch (error) {
-      throw new import_utils12.BadRequestError("Invalid role ID.");
+      throw new import_utils13.BadRequestError("Invalid role ID.");
     }
     if (!permissions) {
-      throw new import_utils12.BadRequestError("Permissions are required.");
+      throw new import_utils13.BadRequestError("Permissions are required.");
     }
     if (permissions.length === 0) {
-      throw new import_utils12.BadRequestError("Permissions cannot be empty.");
+      throw new import_utils13.BadRequestError("Permissions cannot be empty.");
     }
     try {
       await collection.updateOne(
@@ -2764,14 +2819,14 @@ function useRoleRepo() {
       delCachedData();
       return "Successfully updated role permissions.";
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to update role permissions.");
+      throw new import_utils13.InternalServerError("Failed to update role permissions.");
     }
   }
   async function deleteById(_id, session) {
     try {
       _id = new import_mongodb11.ObjectId(_id);
     } catch (error) {
-      throw new import_utils12.BadRequestError("Invalid ID.");
+      throw new import_utils13.BadRequestError("Invalid ID.");
     }
     try {
       await collection.deleteOne(
@@ -2783,7 +2838,7 @@ function useRoleRepo() {
       delCachedData();
       return "Successfully deleted role.";
     } catch (error) {
-      throw new import_utils12.InternalServerError("Failed to delete role.");
+      throw new import_utils13.InternalServerError("Failed to delete role.");
     }
   }
   return {
@@ -2803,7 +2858,7 @@ function useRoleRepo() {
 }
 
 // src/resources/permission/permission.model.ts
-var import_utils13 = require("@goweekdays/utils");
+var import_utils14 = require("@goweekdays/utils");
 var import_joi5 = __toESM(require("joi"));
 var schemaPermission = import_joi5.default.object({
   app: import_joi5.default.string().required(),
@@ -2822,7 +2877,7 @@ var schemaPermissionUpdate = import_joi5.default.object({
 function modelPermission(value) {
   const { error } = schemaPermission.validate(value);
   if (error) {
-    throw new import_utils13.BadRequestError(error.message);
+    throw new import_utils14.BadRequestError(error.message);
   }
   return {
     _id: value._id,
@@ -2840,17 +2895,17 @@ function modelPermission(value) {
 }
 
 // src/resources/permission/permission.repository.ts
-var import_utils14 = require("@goweekdays/utils");
+var import_utils15 = require("@goweekdays/utils");
 var import_mongodb12 = require("mongodb");
 var import_joi6 = __toESM(require("joi"));
 function usePermissionRepo() {
-  const db = import_utils14.useAtlas.getDb();
+  const db = import_utils15.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "permissions";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils14.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils15.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -2879,7 +2934,7 @@ function usePermissionRepo() {
     }
   }
   createIndexes().catch((error) => {
-    import_utils14.logger.log({ level: "error", message: `Index creation error: ${error}` });
+    import_utils15.logger.log({ level: "error", message: `Index creation error: ${error}` });
   });
   async function add(value, session) {
     try {
@@ -2888,16 +2943,16 @@ function usePermissionRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils14.logger.log({
+      import_utils15.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils14.AppError) {
+      if (error instanceof import_utils15.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils14.BadRequestError("Permission already exists.");
+          throw new import_utils15.BadRequestError("Permission already exists.");
         }
         throw new Error("Failed to create permission.");
       }
@@ -2907,11 +2962,11 @@ function usePermissionRepo() {
     try {
       _id = new import_mongodb12.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils14.BadRequestError("Invalid ID.");
+      throw new import_utils15.BadRequestError("Invalid ID.");
     }
     const { error } = schemaPermissionUpdate.validate(value);
     if (error) {
-      throw new import_utils14.BadRequestError(`Invalid data: ${error.message}`);
+      throw new import_utils15.BadRequestError(`Invalid data: ${error.message}`);
     }
     try {
       const res = await collection.updateOne(
@@ -2922,11 +2977,11 @@ function usePermissionRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils14.logger.log({
+      import_utils15.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils14.AppError) {
+      if (error2 instanceof import_utils15.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to update permission.");
@@ -2959,15 +3014,15 @@ function usePermissionRepo() {
       query.app = app;
       cacheParams.app = app;
     }
-    const cacheKey = (0, import_utils14.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils14.logger.log({
+    const cacheKey = (0, import_utils15.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils15.logger.log({
       level: "info",
       message: `Cache key for getAll permissions: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "info",
           message: `Cache hit for getAll permissions: ${cacheKey}`
         });
@@ -2980,21 +3035,21 @@ function usePermissionRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils14.paginate)(items, page, limit, length);
+      const data = (0, import_utils15.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "info",
           message: `Cache set for getAll permissions: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "error",
           message: `Failed to set cache for getAll permissions: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils14.logger.log({ level: "error", message: `${error}` });
+      import_utils15.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -3002,13 +3057,13 @@ function usePermissionRepo() {
     try {
       _id = new import_mongodb12.ObjectId(_id);
     } catch (error) {
-      throw new import_utils14.BadRequestError("Invalid ID.");
+      throw new import_utils15.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils14.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils15.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "info",
           message: `Cache hit for getById permission: ${cacheKey}`
         });
@@ -3018,22 +3073,22 @@ function usePermissionRepo() {
         _id
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "info",
           message: `Cache set for permission by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "error",
           message: `Failed to set cache for permission by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils14.AppError) {
+      if (error instanceof import_utils15.AppError) {
         throw error;
       } else {
-        throw new import_utils14.InternalServerError("Failed to get permission.");
+        throw new import_utils15.InternalServerError("Failed to get permission.");
       }
     }
   }
@@ -3045,7 +3100,7 @@ function usePermissionRepo() {
     });
     const { error } = validation.validate({ key, group });
     if (error) {
-      throw new import_utils14.BadRequestError(`Invalid data: ${error.message}`);
+      throw new import_utils15.BadRequestError(`Invalid data: ${error.message}`);
     }
     const query = {};
     const cacheKeyOptions = {};
@@ -3059,11 +3114,11 @@ function usePermissionRepo() {
       query.app = app;
       cacheKeyOptions.app = app;
     }
-    const cacheKey = (0, import_utils14.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    const cacheKey = (0, import_utils15.makeCacheKey)(namespace_collection, cacheKeyOptions);
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "info",
           message: `Cache hit for getById permission: ${cacheKey}`
         });
@@ -3071,34 +3126,34 @@ function usePermissionRepo() {
       }
       const result = await collection.findOne(query);
       setCache(cacheKey, result, 300).then(() => {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "info",
           message: `Cache set for permission by key: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "error",
           message: `Failed to set cache for permission by key: ${err.message}`
         });
       });
       return result;
     } catch (error2) {
-      if (error2 instanceof import_utils14.AppError) {
+      if (error2 instanceof import_utils15.AppError) {
         throw error2;
       } else {
-        throw new import_utils14.InternalServerError("Failed to get permission.");
+        throw new import_utils15.InternalServerError("Failed to get permission.");
       }
     }
   }
   async function countByGroup(group) {
-    const cacheKey = (0, import_utils14.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils15.makeCacheKey)(namespace_collection, {
       group,
       tag: "countByGroup"
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "info",
           message: `Cache hit for getById permission: ${cacheKey}`
         });
@@ -3108,22 +3163,22 @@ function usePermissionRepo() {
         group
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "info",
           message: `Cache set for permission count by group: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils14.logger.log({
+        import_utils15.logger.log({
           level: "error",
           message: `Failed to set cache for permission by group: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils14.AppError) {
+      if (error instanceof import_utils15.AppError) {
         throw error;
       } else {
-        throw new import_utils14.InternalServerError("Failed to count permission by group.");
+        throw new import_utils15.InternalServerError("Failed to count permission by group.");
       }
     }
   }
@@ -3131,7 +3186,7 @@ function usePermissionRepo() {
     try {
       _id = new import_mongodb12.ObjectId(_id);
     } catch (error) {
-      throw new import_utils14.BadRequestError("Invalid ID.");
+      throw new import_utils15.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -3141,25 +3196,25 @@ function usePermissionRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils14.logger.log({
+      import_utils15.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils14.AppError) {
+      if (error instanceof import_utils15.AppError) {
         throw error;
       } else {
-        throw new import_utils14.InternalServerError("Failed to delete permission.");
+        throw new import_utils15.InternalServerError("Failed to delete permission.");
       }
     }
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils14.logger.log({
+      import_utils15.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils14.logger.log({
+      import_utils15.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -3198,7 +3253,7 @@ function usePermissionService() {
 }
 
 // src/resources/permission/permission.controller.ts
-var import_utils15 = require("@goweekdays/utils");
+var import_utils16 = require("@goweekdays/utils");
 var import_joi7 = __toESM(require("joi"));
 function usePermissionController() {
   const {
@@ -3212,8 +3267,8 @@ function usePermissionController() {
     const value = req.body;
     const { error } = schemaPermission.validate(value);
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
-      import_utils15.logger.info(`Controller: ${error.message}`);
+      next(new import_utils16.BadRequestError(error.message));
+      import_utils16.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -3235,7 +3290,7 @@ function usePermissionController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -3274,7 +3329,7 @@ function usePermissionController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     try {
@@ -3295,7 +3350,7 @@ function usePermissionController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     try {
@@ -3310,13 +3365,13 @@ function usePermissionController() {
     const id = req.params.id;
     const { error: errorId } = import_joi7.default.string().hex().required().validate(id);
     if (errorId) {
-      next(new import_utils15.BadRequestError(errorId.message));
+      next(new import_utils16.BadRequestError(errorId.message));
       return;
     }
     const payload = req.body;
     const { error } = schemaPermissionUpdate.validate(payload);
     if (error) {
-      next(new import_utils15.BadRequestError(error.message));
+      next(new import_utils16.BadRequestError(error.message));
       return;
     }
     try {
@@ -3337,7 +3392,7 @@ function usePermissionController() {
 }
 
 // src/resources/permission/permission.group.model.ts
-var import_utils16 = require("@goweekdays/utils");
+var import_utils17 = require("@goweekdays/utils");
 var import_joi8 = __toESM(require("joi"));
 var schemaPermissionGroup = import_joi8.default.object({
   app: import_joi8.default.string().required(),
@@ -3353,7 +3408,7 @@ var schemaPermissionGroupUpdate = import_joi8.default.object({
 function modelPermissionGroup(value) {
   const { error } = schemaPermissionGroup.validate(value);
   if (error) {
-    throw new import_utils16.BadRequestError(error.message);
+    throw new import_utils17.BadRequestError(error.message);
   }
   return {
     _id: value._id,
@@ -3369,18 +3424,18 @@ function modelPermissionGroup(value) {
 }
 
 // src/resources/permission/permission.group.repository.ts
-var import_utils17 = require("@goweekdays/utils");
+var import_utils18 = require("@goweekdays/utils");
 var import_mongodb13 = require("mongodb");
 var import_joi9 = __toESM(require("joi"));
 var init = false;
 function usePermissionGroupRepo() {
-  const db = import_utils17.useAtlas.getDb();
+  const db = import_utils18.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "permission.groups";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils17.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils18.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -3403,7 +3458,7 @@ function usePermissionGroupRepo() {
   }
   if (!init) {
     createIndexes().catch((error) => {
-      import_utils17.logger.log({
+      import_utils18.logger.log({
         level: "error",
         message: `Index creation error: ${error}`
       });
@@ -3417,16 +3472,16 @@ function usePermissionGroupRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils17.logger.log({
+      import_utils18.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils17.AppError) {
+      if (error instanceof import_utils18.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils17.BadRequestError("Permission group already exists.");
+          throw new import_utils18.BadRequestError("Permission group already exists.");
         }
         throw new Error("Failed to create permission group.");
       }
@@ -3436,11 +3491,11 @@ function usePermissionGroupRepo() {
     try {
       _id = new import_mongodb13.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils17.BadRequestError("Invalid ID.");
+      throw new import_utils18.BadRequestError("Invalid ID.");
     }
     const { error } = schemaPermissionGroupUpdate.validate(value);
     if (error) {
-      throw new import_utils17.BadRequestError(`Invalid data: ${error.message}`);
+      throw new import_utils18.BadRequestError(`Invalid data: ${error.message}`);
     }
     try {
       const res = await collection.updateOne(
@@ -3451,11 +3506,11 @@ function usePermissionGroupRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils17.logger.log({
+      import_utils18.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils17.AppError) {
+      if (error2 instanceof import_utils18.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to update permission group.");
@@ -3488,15 +3543,15 @@ function usePermissionGroupRepo() {
       query.app = app;
       cacheParams.app = app;
     }
-    const cacheKey = (0, import_utils17.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils17.logger.log({
+    const cacheKey = (0, import_utils18.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils18.logger.log({
       level: "info",
       message: `Cache key for getAll permission groups: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils17.logger.log({
+        import_utils18.logger.log({
           level: "info",
           message: `Cache hit for getAll permission groups: ${cacheKey}`
         });
@@ -3509,21 +3564,21 @@ function usePermissionGroupRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils17.paginate)(items, page, limit, length);
+      const data = (0, import_utils18.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils17.logger.log({
+        import_utils18.logger.log({
           level: "info",
           message: `Cache set for getAll permission groups: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils17.logger.log({
+        import_utils18.logger.log({
           level: "error",
           message: `Failed to set cache for getAll permission groups: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils17.logger.log({ level: "error", message: `${error}` });
+      import_utils18.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -3531,13 +3586,13 @@ function usePermissionGroupRepo() {
     try {
       _id = new import_mongodb13.ObjectId(_id);
     } catch (error) {
-      throw new import_utils17.BadRequestError("Invalid ID.");
+      throw new import_utils18.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils17.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils18.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils17.logger.log({
+        import_utils18.logger.log({
           level: "info",
           message: `Cache hit for getById permission group: ${cacheKey}`
         });
@@ -3547,22 +3602,22 @@ function usePermissionGroupRepo() {
         _id
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils17.logger.log({
+        import_utils18.logger.log({
           level: "info",
           message: `Cache set for permission group by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils17.logger.log({
+        import_utils18.logger.log({
           level: "error",
           message: `Failed to set cache for permission group by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils17.AppError) {
+      if (error instanceof import_utils18.AppError) {
         throw error;
       } else {
-        throw new import_utils17.InternalServerError("Failed to get permission group.");
+        throw new import_utils18.InternalServerError("Failed to get permission group.");
       }
     }
   }
@@ -3573,7 +3628,7 @@ function usePermissionGroupRepo() {
     });
     const { error } = validation.validate({ key, app });
     if (error) {
-      throw new import_utils17.BadRequestError("Invalid key.");
+      throw new import_utils18.BadRequestError("Invalid key.");
     }
     const query = { key };
     const cacheKeyOptions = { key, tag: "byKey" };
@@ -3581,11 +3636,11 @@ function usePermissionGroupRepo() {
       query.app = app;
       cacheKeyOptions.app = app;
     }
-    const cacheKey = (0, import_utils17.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    const cacheKey = (0, import_utils18.makeCacheKey)(namespace_collection, cacheKeyOptions);
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils17.logger.log({
+        import_utils18.logger.log({
           level: "info",
           message: `Cache hit for getById permission group: ${cacheKey}`
         });
@@ -3593,22 +3648,22 @@ function usePermissionGroupRepo() {
       }
       const result = await collection.findOne(query);
       setCache(cacheKey, result, 300).then(() => {
-        import_utils17.logger.log({
+        import_utils18.logger.log({
           level: "info",
           message: `Cache set for permission group by key: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils17.logger.log({
+        import_utils18.logger.log({
           level: "error",
           message: `Failed to set cache for permission group by key: ${err.message}`
         });
       });
       return result;
     } catch (error2) {
-      if (error2 instanceof import_utils17.AppError) {
+      if (error2 instanceof import_utils18.AppError) {
         throw error2;
       } else {
-        throw new import_utils17.InternalServerError("Failed to get permission group.");
+        throw new import_utils18.InternalServerError("Failed to get permission group.");
       }
     }
   }
@@ -3616,7 +3671,7 @@ function usePermissionGroupRepo() {
     try {
       _id = new import_mongodb13.ObjectId(_id);
     } catch (error) {
-      throw new import_utils17.BadRequestError("Invalid ID.");
+      throw new import_utils18.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -3626,25 +3681,25 @@ function usePermissionGroupRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils17.logger.log({
+      import_utils18.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils17.AppError) {
+      if (error instanceof import_utils18.AppError) {
         throw error;
       } else {
-        throw new import_utils17.InternalServerError("Failed to delete permission group.");
+        throw new import_utils18.InternalServerError("Failed to delete permission group.");
       }
     }
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils17.logger.log({
+      import_utils18.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils17.logger.log({
+      import_utils18.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -3662,10 +3717,10 @@ function usePermissionGroupRepo() {
 }
 
 // src/resources/permission/permission.group.service.ts
-var import_utils22 = require("@goweekdays/utils");
+var import_utils23 = require("@goweekdays/utils");
 
 // src/resources/app/app.model.ts
-var import_utils18 = require("@goweekdays/utils");
+var import_utils19 = require("@goweekdays/utils");
 var import_joi10 = __toESM(require("joi"));
 var schemaApp = import_joi10.default.object({
   code: import_joi10.default.string().alphanum().max(20).required(),
@@ -3681,7 +3736,7 @@ var schemaAppUpdate = import_joi10.default.object({
 function modelApp(value) {
   const { error } = schemaApp.validate(value);
   if (error) {
-    throw new import_utils18.BadRequestError(error.message);
+    throw new import_utils19.BadRequestError(error.message);
   }
   return {
     _id: value._id,
@@ -3697,18 +3752,18 @@ function modelApp(value) {
 }
 
 // src/resources/app/app.repository.ts
-var import_utils19 = require("@goweekdays/utils");
+var import_utils20 = require("@goweekdays/utils");
 var import_mongodb14 = require("mongodb");
 var import_joi11 = __toESM(require("joi"));
 var init2 = false;
 function useAppRepo() {
-  const db = import_utils19.useAtlas.getDb();
+  const db = import_utils20.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "apps";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils19.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils20.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -3737,7 +3792,7 @@ function useAppRepo() {
   }
   if (!init2) {
     createIndexes().catch((error) => {
-      import_utils19.logger.log({ level: "error", message: `Index creation error: ${error}` });
+      import_utils20.logger.log({ level: "error", message: `Index creation error: ${error}` });
     });
     init2 = true;
   }
@@ -3748,16 +3803,16 @@ function useAppRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils19.logger.log({
+      import_utils20.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils19.AppError) {
+      if (error instanceof import_utils20.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils19.BadRequestError("App already exists.");
+          throw new import_utils20.BadRequestError("App already exists.");
         }
         throw new Error("Failed to create app.");
       }
@@ -3767,7 +3822,7 @@ function useAppRepo() {
     try {
       _id = new import_mongodb14.ObjectId(_id);
     } catch (error) {
-      throw new import_utils19.BadRequestError("Invalid ID.");
+      throw new import_utils20.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -3778,11 +3833,11 @@ function useAppRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils19.logger.log({
+      import_utils20.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils19.AppError) {
+      if (error instanceof import_utils20.AppError) {
         throw error;
       } else {
         throw new Error("Failed to update app.");
@@ -3820,15 +3875,15 @@ function useAppRepo() {
       }
       cacheParams.type = type;
     }
-    const cacheKey = (0, import_utils19.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils19.logger.log({
+    const cacheKey = (0, import_utils20.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils20.logger.log({
       level: "info",
       message: `Cache key for getAll apps: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils19.logger.log({
+        import_utils20.logger.log({
           level: "info",
           message: `Cache hit for getAll apps: ${cacheKey}`
         });
@@ -3841,21 +3896,21 @@ function useAppRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils19.paginate)(items, page, limit, length);
+      const data = (0, import_utils20.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils19.logger.log({
+        import_utils20.logger.log({
           level: "info",
           message: `Cache set for getAll apps: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils19.logger.log({
+        import_utils20.logger.log({
           level: "error",
           message: `Failed to set cache for getAll apps: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils19.logger.log({ level: "error", message: `${error}` });
+      import_utils20.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -3863,13 +3918,13 @@ function useAppRepo() {
     try {
       _id = new import_mongodb14.ObjectId(_id);
     } catch (error) {
-      throw new import_utils19.BadRequestError("Invalid ID.");
+      throw new import_utils20.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils19.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils20.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils19.logger.log({
+        import_utils20.logger.log({
           level: "info",
           message: `Cache hit for getById app: ${cacheKey}`
         });
@@ -3879,22 +3934,22 @@ function useAppRepo() {
         _id
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils19.logger.log({
+        import_utils20.logger.log({
           level: "info",
           message: `Cache set for app by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils19.logger.log({
+        import_utils20.logger.log({
           level: "error",
           message: `Failed to set cache for app by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils19.AppError) {
+      if (error instanceof import_utils20.AppError) {
         throw error;
       } else {
-        throw new import_utils19.InternalServerError("Failed to get app.");
+        throw new import_utils20.InternalServerError("Failed to get app.");
       }
     }
   }
@@ -3902,16 +3957,16 @@ function useAppRepo() {
     const validate = import_joi11.default.string().required();
     const { error } = validate.validate(code);
     if (error) {
-      throw new import_utils19.BadRequestError("Invalid code.");
+      throw new import_utils20.BadRequestError("Invalid code.");
     }
-    const cacheKey = (0, import_utils19.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils20.makeCacheKey)(namespace_collection, {
       code,
       tag: "byCode"
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils19.logger.log({
+        import_utils20.logger.log({
           level: "info",
           message: `Cache hit for getByCode app: ${cacheKey}`
         });
@@ -3921,22 +3976,22 @@ function useAppRepo() {
         code
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils19.logger.log({
+        import_utils20.logger.log({
           level: "info",
           message: `Cache set for app by code: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils19.logger.log({
+        import_utils20.logger.log({
           level: "error",
           message: `Failed to set cache for app by code: ${err.message}`
         });
       });
       return result;
     } catch (error2) {
-      if (error2 instanceof import_utils19.AppError) {
+      if (error2 instanceof import_utils20.AppError) {
         throw error2;
       } else {
-        throw new import_utils19.InternalServerError("Failed to get app.");
+        throw new import_utils20.InternalServerError("Failed to get app.");
       }
     }
   }
@@ -3944,7 +3999,7 @@ function useAppRepo() {
     try {
       _id = new import_mongodb14.ObjectId(_id);
     } catch (error) {
-      throw new import_utils19.BadRequestError("Invalid ID.");
+      throw new import_utils20.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -3954,25 +4009,25 @@ function useAppRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils19.logger.log({
+      import_utils20.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils19.AppError) {
+      if (error instanceof import_utils20.AppError) {
         throw error;
       } else {
-        throw new import_utils19.InternalServerError("Failed to delete app.");
+        throw new import_utils20.InternalServerError("Failed to delete app.");
       }
     }
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils19.logger.log({
+      import_utils20.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils19.logger.log({
+      import_utils20.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -3990,7 +4045,7 @@ function useAppRepo() {
 }
 
 // src/resources/app/app.service.ts
-var import_utils20 = require("@goweekdays/utils");
+var import_utils21 = require("@goweekdays/utils");
 function useAppService() {
   const {
     updateById: _updateById,
@@ -4040,7 +4095,7 @@ function useAppService() {
         description: "Transportation and ride services."
       }
     ];
-    const session = import_utils20.useAtlas.getClient()?.startSession();
+    const session = import_utils21.useAtlas.getClient()?.startSession();
     if (!session) {
       throw new Error("Failed to start database session.");
     }
@@ -4053,14 +4108,14 @@ function useAppService() {
         }
       }
       await session.commitTransaction();
-      import_utils20.logger.log({
+      import_utils21.logger.log({
         level: "info",
         message: "Default apps added successfully."
       });
       return;
     } catch (error) {
       await session.abortTransaction();
-      import_utils20.logger.log({
+      import_utils21.logger.log({
         level: "error",
         message: `Failed to add default apps: ${error}`
       });
@@ -4084,7 +4139,7 @@ function useAppService() {
 }
 
 // src/resources/app/app.controller.ts
-var import_utils21 = require("@goweekdays/utils");
+var import_utils22 = require("@goweekdays/utils");
 var import_joi12 = __toESM(require("joi"));
 function useAppController() {
   const {
@@ -4098,7 +4153,7 @@ function useAppController() {
     const value = req.body;
     const { error } = schemaApp.validate(value);
     if (error) {
-      next(new import_utils21.BadRequestError(error.message));
+      next(new import_utils22.BadRequestError(error.message));
       return;
     }
     try {
@@ -4113,13 +4168,13 @@ function useAppController() {
     const id = req.params.id ?? "";
     const { error: errorId } = import_joi12.default.string().hex().required().validate(id);
     if (errorId) {
-      next(new import_utils21.BadRequestError(errorId.message));
+      next(new import_utils22.BadRequestError(errorId.message));
       return;
     }
     const value = req.body;
     const { error } = schemaAppUpdate.validate(value);
     if (error) {
-      next(new import_utils21.BadRequestError(error.message));
+      next(new import_utils22.BadRequestError(error.message));
       return;
     }
     try {
@@ -4141,7 +4196,7 @@ function useAppController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils21.BadRequestError(error.message));
+      next(new import_utils22.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -4180,7 +4235,7 @@ function useAppController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils21.BadRequestError(error.message));
+      next(new import_utils22.BadRequestError(error.message));
       return;
     }
     try {
@@ -4201,7 +4256,7 @@ function useAppController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils21.BadRequestError(error.message));
+      next(new import_utils22.BadRequestError(error.message));
       return;
     }
     try {
@@ -4237,7 +4292,7 @@ function usePermissionGroupService() {
     add: addPermission
   } = usePermissionRepo();
   async function addDefaultModule() {
-    const session = import_utils22.useAtlas.getClient()?.startSession();
+    const session = import_utils23.useAtlas.getClient()?.startSession();
     if (!session) {
       throw new Error("Failed to start database session.");
     }
@@ -4347,7 +4402,7 @@ function usePermissionGroupService() {
                 key: module2.key,
                 label: module2.label
               });
-              import_utils22.logger.log({
+              import_utils23.logger.log({
                 level: "info",
                 message: `Default permission group added: ${app.code} - ${module2.key}`
               });
@@ -4556,7 +4611,7 @@ function usePermissionGroupService() {
                   key: module2.key,
                   label: module2.label
                 });
-                import_utils22.logger.log({
+                import_utils23.logger.log({
                   level: "info",
                   message: `Default permission group added: ${app.code} - ${module2.key}`
                 });
@@ -4581,7 +4636,7 @@ function usePermissionGroupService() {
         }
         await session.commitTransaction();
       }
-      import_utils22.logger.log({
+      import_utils23.logger.log({
         level: "info",
         message: "Default permission groups added successfully."
       });
@@ -4601,7 +4656,7 @@ function usePermissionGroupService() {
     }
     const associatedPermissionsCount = await countByGroup(permission.key);
     if (associatedPermissionsCount > 0) {
-      throw new import_utils22.BadRequestError(
+      throw new import_utils23.BadRequestError(
         "Cannot delete Permission Group with associated Permissions."
       );
     }
@@ -4609,10 +4664,10 @@ function usePermissionGroupService() {
       await _deleteById(id);
       return "Permission deleted successfully.";
     } catch (error) {
-      if (error instanceof import_utils22.AppError) {
+      if (error instanceof import_utils23.AppError) {
         throw error;
       } else {
-        throw new import_utils22.InternalServerError("Failed to delete Permission Group.");
+        throw new import_utils23.InternalServerError("Failed to delete Permission Group.");
       }
     }
   }
@@ -4623,7 +4678,7 @@ function usePermissionGroupService() {
 }
 
 // src/resources/permission/permission.group.controller.ts
-var import_utils23 = require("@goweekdays/utils");
+var import_utils24 = require("@goweekdays/utils");
 var import_joi13 = __toESM(require("joi"));
 function usePermissionGroupController() {
   const {
@@ -4637,8 +4692,8 @@ function usePermissionGroupController() {
     const value = req.body;
     const { error } = schemaPermissionGroup.validate(value);
     if (error) {
-      next(new import_utils23.BadRequestError(error.message));
-      import_utils23.logger.info(`Controller: ${error.message}`);
+      next(new import_utils24.BadRequestError(error.message));
+      import_utils24.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -4660,7 +4715,7 @@ function usePermissionGroupController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils23.BadRequestError(error.message));
+      next(new import_utils24.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -4699,7 +4754,7 @@ function usePermissionGroupController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils23.BadRequestError(error.message));
+      next(new import_utils24.BadRequestError(error.message));
       return;
     }
     try {
@@ -4720,7 +4775,7 @@ function usePermissionGroupController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils23.BadRequestError(error.message));
+      next(new import_utils24.BadRequestError(error.message));
       return;
     }
     try {
@@ -4735,13 +4790,13 @@ function usePermissionGroupController() {
     const id = req.params.id;
     const { error: errorId } = import_joi13.default.string().hex().required().validate(id);
     if (errorId) {
-      next(new import_utils23.BadRequestError(errorId.message));
+      next(new import_utils24.BadRequestError(errorId.message));
       return;
     }
     const payload = req.body;
     const { error } = schemaPermissionGroupUpdate.validate(payload);
     if (error) {
-      next(new import_utils23.BadRequestError(error.message));
+      next(new import_utils24.BadRequestError(error.message));
       return;
     }
     try {
@@ -4776,16 +4831,16 @@ function useUserService() {
   const { add: addMember } = useMemberRepo();
   const { getAll: getAllPermission } = usePermissionRepo();
   async function createDefaultUser() {
-    const session = import_utils24.useAtlas.getClient()?.startSession();
+    const session = import_utils25.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       const _user = await getUserByEmail(DEFAULT_USER_EMAIL);
       if (_user) {
-        throw new import_utils24.BadRequestError(
+        throw new import_utils25.BadRequestError(
           `User already exists: ${DEFAULT_USER_EMAIL}.`
         );
       }
-      const hashedPassword = await (0, import_utils24.hashPassword)(DEFAULT_USER_PASSWORD);
+      const hashedPassword = await (0, import_utils25.hashPassword)(DEFAULT_USER_PASSWORD);
       const userId = new import_mongodb15.ObjectId();
       const user = {
         _id: userId,
@@ -4846,14 +4901,14 @@ function useUserService() {
     }
   }
   async function createUser(value) {
-    const session = import_utils24.useAtlas.getClient()?.startSession();
+    const session = import_utils25.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const _user = await getUserByEmail(value.email);
       if (_user) {
-        throw new import_utils24.BadRequestError(`User already exists: ${value.email}.`);
+        throw new import_utils25.BadRequestError(`User already exists: ${value.email}.`);
       }
-      const hashedPassword = await (0, import_utils24.hashPassword)(value.password);
+      const hashedPassword = await (0, import_utils25.hashPassword)(value.password);
       const userId = new import_mongodb15.ObjectId();
       const user = {
         _id: userId,
@@ -4885,25 +4940,25 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = import_utils24.useAtlas.getClient()?.startSession();
+    const session = import_utils25.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const invitation = await _getVerificationById(id);
       if (!invitation || !invitation.metadata?.app || !invitation.metadata?.role) {
-        throw new import_utils24.BadRequestError("Invalid invitation.");
+        throw new import_utils25.BadRequestError("Invalid invitation.");
       }
       if (invitation.status === "complete") {
-        throw new import_utils24.BadRequestError("Invitation already used.");
+        throw new import_utils25.BadRequestError("Invitation already used.");
       }
       const expired = new Date(invitation.expireAt) < /* @__PURE__ */ new Date();
       if (invitation.status === "expired" || expired) {
-        throw new import_utils24.BadRequestError("Invitation expired.");
+        throw new import_utils25.BadRequestError("Invitation expired.");
       }
       const email = invitation.email;
       const _user = await getUserByEmail(invitation.email);
       let userId = _user?._id ?? "";
       if (!_user) {
-        const hashedPassword = await (0, import_utils24.hashPassword)(password);
+        const hashedPassword = await (0, import_utils25.hashPassword)(password);
         const user = new MUser({
           email,
           password: hashedPassword,
@@ -4944,28 +4999,28 @@ function useUserService() {
     lastName = "",
     password = ""
   } = {}) {
-    const session = import_utils24.useAtlas.getClient()?.startSession();
+    const session = import_utils25.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const signUp = await _getVerificationById(id);
       if (!signUp) {
-        throw new import_utils24.BadRequestError("Invalid sign up link.");
+        throw new import_utils25.BadRequestError("Invalid sign up link.");
       }
       if (signUp.status === "complete") {
-        throw new import_utils24.BadRequestError(
+        throw new import_utils25.BadRequestError(
           "You have already an account created using this link."
         );
       }
       const expired = new Date(signUp.expireAt) < /* @__PURE__ */ new Date();
       if (signUp.status === "expired" || expired) {
-        throw new import_utils24.BadRequestError("Sign up link expired.");
+        throw new import_utils25.BadRequestError("Sign up link expired.");
       }
       const email = signUp.email;
       const _user = await getUserByEmail(signUp.email);
       if (_user) {
-        throw new import_utils24.BadRequestError(`User already exists: ${email}.`);
+        throw new import_utils25.BadRequestError(`User already exists: ${email}.`);
       }
-      const hashedPassword = await (0, import_utils24.hashPassword)(password);
+      const hashedPassword = await (0, import_utils25.hashPassword)(password);
       const userId = new import_mongodb15.ObjectId();
       const user = {
         _id: userId,
@@ -4997,21 +5052,21 @@ function useUserService() {
       throw error;
     }
     if (newPassword !== passwordConfirmation) {
-      throw new import_utils24.BadRequestError("Passwords do not match.");
+      throw new import_utils25.BadRequestError("Passwords do not match.");
     }
     let hashedPassword = "";
     try {
-      hashedPassword = await (0, import_utils24.hashPassword)(newPassword);
+      hashedPassword = await (0, import_utils25.hashPassword)(newPassword);
     } catch (error) {
-      throw new import_utils24.InternalServerError(`Error hashing password: ${error}`);
+      throw new import_utils25.InternalServerError(`Error hashing password: ${error}`);
     }
     try {
       const otpDoc = await getById(id);
       if (!otpDoc) {
-        throw new import_utils24.NotFoundError("You are using an invalid reset link.");
+        throw new import_utils25.NotFoundError("You are using an invalid reset link.");
       }
       if (otpDoc.status === "used") {
-        throw new import_utils24.BadRequestError("This link has already been invalidated.");
+        throw new import_utils25.BadRequestError("This link has already been invalidated.");
       }
       await updateStatusById(id, "used");
       return "Successfully reset password.";
@@ -5022,22 +5077,22 @@ function useUserService() {
   const { updateName: updateMemberName } = useMemberRepo();
   async function updateName(_id, firstName, lastName) {
     if (!_id) {
-      throw new import_utils24.BadRequestError("Invalid user ID");
+      throw new import_utils25.BadRequestError("Invalid user ID");
     }
     if (!firstName) {
-      throw new import_utils24.BadRequestError("Invalid firstName");
+      throw new import_utils25.BadRequestError("Invalid firstName");
     }
     if (!lastName) {
-      throw new import_utils24.BadRequestError("Invalid lastName");
+      throw new import_utils25.BadRequestError("Invalid lastName");
     }
-    const session = import_utils24.useAtlas.getClient()?.startSession();
+    const session = import_utils25.useAtlas.getClient()?.startSession();
     session?.startTransaction();
-    const cacheKey = (0, import_utils24.makeCacheKey)("users", { user: _id });
+    const cacheKey = (0, import_utils25.makeCacheKey)("users", { user: _id });
     try {
-      (0, import_utils24.useCache)().delCache(cacheKey).then(() => {
-        import_utils24.logger.info(`Cache cleared for user: ${_id}`);
+      (0, import_utils25.useCache)().delCache(cacheKey).then(() => {
+        import_utils25.logger.info(`Cache cleared for user: ${_id}`);
       }).catch((error) => {
-        import_utils24.logger.error(`Failed to clear cache for user: ${_id}`, error);
+        import_utils25.logger.error(`Failed to clear cache for user: ${_id}`, error);
       });
       await _updateName({ _id, firstName, lastName }, session);
       await updateMemberName(
@@ -5055,16 +5110,16 @@ function useUserService() {
   }
   async function updateBirthday(_id, month, day, year) {
     if (!_id) {
-      throw new import_utils24.BadRequestError("Invalid user ID");
+      throw new import_utils25.BadRequestError("Invalid user ID");
     }
     if (!month) {
-      throw new import_utils24.BadRequestError("Invalid birth month.");
+      throw new import_utils25.BadRequestError("Invalid birth month.");
     }
     if (!day) {
-      throw new import_utils24.BadRequestError("Invalid birthday.");
+      throw new import_utils25.BadRequestError("Invalid birthday.");
     }
     if (!year) {
-      throw new import_utils24.BadRequestError("Invalid birth year.");
+      throw new import_utils25.BadRequestError("Invalid birth year.");
     }
     try {
       await _updateBirthday({ _id, month, day, year });
@@ -5081,7 +5136,7 @@ function useUserService() {
     }
   }
   const { createFile: _createFile, deleteFileById } = useFileRepo();
-  const s3 = new import_utils24.useS3({
+  const s3 = new import_utils25.useS3({
     accessKeyId: SPACES_ACCESS_KEY,
     secretAccessKey: SPACES_SECRET_KEY,
     endpoint: SPACES_ENDPOINT,
@@ -5089,7 +5144,7 @@ function useUserService() {
     bucket: SPACES_BUCKET
   });
   async function updateUserProfile({ file, user, previousProfile } = {}) {
-    const session = import_utils24.useAtlas.getClient()?.startSession();
+    const session = import_utils25.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     const _file = {
       name: file.originalname,
@@ -5145,7 +5200,7 @@ function useAuthController() {
     });
     const { error } = validation.validate({ email, password });
     if (error) {
-      next(new import_utils25.BadRequestError(error.message));
+      next(new import_utils26.BadRequestError(error.message));
       return;
     }
     try {
@@ -5161,14 +5216,14 @@ function useAuthController() {
       res.cookie("sid", session.sid, cookieOptions).cookie("user", session.user, cookieOptions).json({ message: "Login successful" });
       return;
     } catch (error2) {
-      import_utils25.logger.log({
+      import_utils26.logger.log({
         level: "error",
         message: `Error during login: ${error2.message}`
       });
-      if (error2 instanceof import_utils25.AppError) {
+      if (error2 instanceof import_utils26.AppError) {
         next(error2);
       } else {
-        next(new import_utils25.InternalServerError("An unexpected error occurred"));
+        next(new import_utils26.InternalServerError("An unexpected error occurred"));
       }
       return;
     }
@@ -5176,17 +5231,17 @@ function useAuthController() {
   async function logout(req, res, next) {
     const sid = req.headers["authorization"] ?? "";
     if (!sid) {
-      next(new import_utils25.BadRequestError("Session ID is required"));
+      next(new import_utils26.BadRequestError("Session ID is required"));
       return;
     }
     try {
       await useAuthService().logout(sid);
       res.json({ message: "Logged out successfully" });
     } catch (error) {
-      if (error instanceof import_utils25.AppError) {
+      if (error instanceof import_utils26.AppError) {
         next(error);
       } else {
-        next(new import_utils25.InternalServerError("An unexpected error occurred"));
+        next(new import_utils26.InternalServerError("An unexpected error occurred"));
       }
     }
   }
@@ -5205,7 +5260,7 @@ function useAuthController() {
       passwordConfirmation
     });
     if (error) {
-      next(new import_utils25.BadRequestError(error.message));
+      next(new import_utils26.BadRequestError(error.message));
       return;
     }
     try {
@@ -5229,7 +5284,7 @@ function useAuthController() {
     });
     const { error } = validation.validate({ email, referralCode });
     if (error) {
-      next(new import_utils25.BadRequestError(error.message));
+      next(new import_utils26.BadRequestError(error.message));
       return;
     }
     try {
@@ -5254,7 +5309,7 @@ function useAuthController() {
 }
 
 // src/resources/building/building.model.ts
-var import_utils26 = require("@goweekdays/utils");
+var import_utils27 = require("@goweekdays/utils");
 var import_joi15 = __toESM(require("joi"));
 var import_mongodb16 = require("mongodb");
 var schemaBuilding = import_joi15.default.object({
@@ -5298,20 +5353,20 @@ var schemaUpdateOptions = import_joi15.default.object({
 function MBuilding(value) {
   const { error } = schemaBuilding.validate(value);
   if (error) {
-    import_utils26.logger.info(`Building Model: ${error.message}`);
-    throw new import_utils26.BadRequestError(error.message);
+    import_utils27.logger.info(`Building Model: ${error.message}`);
+    throw new import_utils27.BadRequestError(error.message);
   }
   if (value._id && typeof value._id === "string") {
     try {
       value._id = new import_mongodb16.ObjectId(value._id);
     } catch (error2) {
-      throw new import_utils26.BadRequestError("Invalid _id format");
+      throw new import_utils27.BadRequestError("Invalid _id format");
     }
   }
   try {
     value.school = new import_mongodb16.ObjectId(value.school);
   } catch (error2) {
-    throw new import_utils26.BadRequestError("Invalid school format");
+    throw new import_utils27.BadRequestError("Invalid school format");
   }
   return {
     _id: value._id ?? void 0,
@@ -5328,25 +5383,25 @@ function MBuilding(value) {
 function MBuildingUnit(value) {
   const { error } = schemaBuildingUnit.validate(value);
   if (error) {
-    import_utils26.logger.info(`Building Unit Model: ${error.message}`);
-    throw new import_utils26.BadRequestError(error.message);
+    import_utils27.logger.info(`Building Unit Model: ${error.message}`);
+    throw new import_utils27.BadRequestError(error.message);
   }
   if (value._id && typeof value._id === "string") {
     try {
       value._id = new import_mongodb16.ObjectId(value._id);
     } catch (error2) {
-      throw new import_utils26.BadRequestError("Invalid ID");
+      throw new import_utils27.BadRequestError("Invalid ID");
     }
   }
   try {
     value.school = new import_mongodb16.ObjectId(value.school);
   } catch (error2) {
-    throw new import_utils26.BadRequestError("Invalid school ID");
+    throw new import_utils27.BadRequestError("Invalid school ID");
   }
   try {
     value.building = new import_mongodb16.ObjectId(value.building);
   } catch (error2) {
-    throw new import_utils26.BadRequestError("Invalid building ID");
+    throw new import_utils27.BadRequestError("Invalid building ID");
   }
   return {
     _id: value._id ?? void 0,
@@ -5370,16 +5425,16 @@ function MBuildingUnit(value) {
 }
 
 // src/resources/building/building.repository.ts
-var import_utils27 = require("@goweekdays/utils");
+var import_utils28 = require("@goweekdays/utils");
 var import_mongodb17 = require("mongodb");
 function useBuildingRepo() {
-  const db = import_utils27.useAtlas.getDb();
+  const db = import_utils28.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "school.buildings";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils27.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils28.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -5392,7 +5447,7 @@ function useBuildingRepo() {
     }
   }
   createIndexes().catch((error) => {
-    import_utils27.logger.log({ level: "error", message: `Index creation error: ${error}` });
+    import_utils28.logger.log({ level: "error", message: `Index creation error: ${error}` });
   });
   async function add(value, session) {
     try {
@@ -5401,16 +5456,16 @@ function useBuildingRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils27.logger.log({
+      import_utils28.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils27.AppError) {
+      if (error instanceof import_utils28.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils27.BadRequestError("Building already exists.");
+          throw new import_utils28.BadRequestError("Building already exists.");
         }
         throw new Error("Failed to create building.");
       }
@@ -5420,7 +5475,7 @@ function useBuildingRepo() {
     try {
       _id = new import_mongodb17.ObjectId(_id);
     } catch (error) {
-      throw new import_utils27.BadRequestError("Invalid ID.");
+      throw new import_utils28.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -5431,11 +5486,11 @@ function useBuildingRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils27.logger.log({
+      import_utils28.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils27.AppError) {
+      if (error instanceof import_utils28.AppError) {
         throw error;
       } else {
         throw new Error("Failed to update building.");
@@ -5462,7 +5517,7 @@ function useBuildingRepo() {
       try {
         query.school = new import_mongodb17.ObjectId(school);
       } catch (error) {
-        throw new import_utils27.BadRequestError("Invalid school ID.");
+        throw new import_utils28.BadRequestError("Invalid school ID.");
       }
     }
     const cacheParams = {
@@ -5476,15 +5531,15 @@ function useBuildingRepo() {
       cacheParams.school = school;
     if (status !== "active")
       cacheParams.status = status;
-    const cacheKey = (0, import_utils27.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils27.logger.log({
+    const cacheKey = (0, import_utils28.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils28.logger.log({
       level: "info",
       message: `Cache key for getAll buildings: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils27.logger.log({
+        import_utils28.logger.log({
           level: "info",
           message: `Cache hit for getAll buildings: ${cacheKey}`
         });
@@ -5497,21 +5552,21 @@ function useBuildingRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils27.paginate)(items, page, limit, length);
+      const data = (0, import_utils28.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils27.logger.log({
+        import_utils28.logger.log({
           level: "info",
           message: `Cache set for getAll buildings: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils27.logger.log({
+        import_utils28.logger.log({
           level: "error",
           message: `Failed to set cache for getAll buildings: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils27.logger.log({ level: "error", message: `${error}` });
+      import_utils28.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -5519,13 +5574,13 @@ function useBuildingRepo() {
     try {
       _id = new import_mongodb17.ObjectId(_id);
     } catch (error) {
-      throw new import_utils27.BadRequestError("Invalid ID.");
+      throw new import_utils28.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils27.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils28.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils27.logger.log({
+        import_utils28.logger.log({
           level: "info",
           message: `Cache hit for getById building: ${cacheKey}`
         });
@@ -5535,22 +5590,22 @@ function useBuildingRepo() {
         _id
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils27.logger.log({
+        import_utils28.logger.log({
           level: "info",
           message: `Cache set for building by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils27.logger.log({
+        import_utils28.logger.log({
           level: "error",
           message: `Failed to set cache for building by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils27.AppError) {
+      if (error instanceof import_utils28.AppError) {
         throw error;
       } else {
-        throw new import_utils27.InternalServerError("Failed to get building.");
+        throw new import_utils28.InternalServerError("Failed to get building.");
       }
     }
   }
@@ -5558,7 +5613,7 @@ function useBuildingRepo() {
     try {
       _id = new import_mongodb17.ObjectId(_id);
     } catch (error) {
-      throw new import_utils27.BadRequestError("Invalid ID.");
+      throw new import_utils28.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -5568,25 +5623,25 @@ function useBuildingRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils27.logger.log({
+      import_utils28.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils27.AppError) {
+      if (error instanceof import_utils28.AppError) {
         throw error;
       } else {
-        throw new import_utils27.InternalServerError("Failed to delete building.");
+        throw new import_utils28.InternalServerError("Failed to delete building.");
       }
     }
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils27.logger.log({
+      import_utils28.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils27.logger.log({
+      import_utils28.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -5603,19 +5658,19 @@ function useBuildingRepo() {
 }
 
 // src/resources/building/building.service.ts
-var import_utils29 = require("@goweekdays/utils");
+var import_utils30 = require("@goweekdays/utils");
 
 // src/resources/building/building-unit.repository.ts
-var import_utils28 = require("@goweekdays/utils");
+var import_utils29 = require("@goweekdays/utils");
 var import_mongodb18 = require("mongodb");
 function useBuildingUnitRepo() {
-  const db = import_utils28.useAtlas.getDb();
+  const db = import_utils29.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "school.building-units";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils28.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils29.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -5643,12 +5698,12 @@ function useBuildingUnitRepo() {
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils28.logger.log({
+      import_utils29.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils28.logger.log({
+      import_utils29.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -5661,11 +5716,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils28.logger.log({
+      import_utils29.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils28.AppError) {
+      if (error instanceof import_utils29.AppError) {
         throw error;
       } else {
         throw new Error("Failed to create building unit.");
@@ -5675,12 +5730,12 @@ function useBuildingUnitRepo() {
   async function updateById(_id, value, session) {
     const { error } = schemaUpdateOptions.validate(value);
     if (error) {
-      throw new import_utils28.BadRequestError(error.message);
+      throw new import_utils29.BadRequestError(error.message);
     }
     try {
       _id = new import_mongodb18.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils28.BadRequestError("Invalid ID.");
+      throw new import_utils29.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -5691,11 +5746,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils28.logger.log({
+      import_utils29.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils28.AppError) {
+      if (error2 instanceof import_utils29.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to create building unit.");
@@ -5705,12 +5760,12 @@ function useBuildingUnitRepo() {
   async function updateByBuildingId(building, value, session) {
     const { error } = schemaUpdateOptions.validate(value);
     if (error) {
-      throw new import_utils28.BadRequestError(error.message);
+      throw new import_utils29.BadRequestError(error.message);
     }
     try {
       building = new import_mongodb18.ObjectId(building);
     } catch (error2) {
-      throw new import_utils28.BadRequestError("Invalid building ID.");
+      throw new import_utils29.BadRequestError("Invalid building ID.");
     }
     try {
       const res = await collection.updateMany(
@@ -5721,11 +5776,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils28.logger.log({
+      import_utils29.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils28.AppError) {
+      if (error2 instanceof import_utils29.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to update building unit.");
@@ -5754,14 +5809,14 @@ function useBuildingUnitRepo() {
       try {
         query.school = new import_mongodb18.ObjectId(school);
       } catch (error) {
-        throw new import_utils28.BadRequestError("Invalid school ID.");
+        throw new import_utils29.BadRequestError("Invalid school ID.");
       }
     }
     if (building) {
       try {
         query.building = new import_mongodb18.ObjectId(building);
       } catch (error) {
-        throw new import_utils28.BadRequestError("Invalid building ID.");
+        throw new import_utils29.BadRequestError("Invalid building ID.");
       }
     }
     const cacheParams = {
@@ -5777,15 +5832,15 @@ function useBuildingUnitRepo() {
       cacheParams.building = building;
     if (status !== "active")
       cacheParams.status = status;
-    const cacheKey = (0, import_utils28.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils28.logger.log({
+    const cacheKey = (0, import_utils29.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils29.logger.log({
       level: "info",
       message: `Cache key for getAll building units: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "info",
           message: `Cache hit for getAll building units: ${cacheKey}`
         });
@@ -5798,21 +5853,21 @@ function useBuildingUnitRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils28.paginate)(items, page, limit, length);
+      const data = (0, import_utils29.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "info",
           message: `Cache set for getAll building units: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "error",
           message: `Failed to set cache for getAll building units: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils28.logger.log({ level: "error", message: `${error}` });
+      import_utils29.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -5820,13 +5875,13 @@ function useBuildingUnitRepo() {
     try {
       _id = new import_mongodb18.ObjectId(_id);
     } catch (error) {
-      throw new import_utils28.BadRequestError("Invalid ID.");
+      throw new import_utils29.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils28.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils29.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -5837,25 +5892,25 @@ function useBuildingUnitRepo() {
         deletedAt: { $in: ["", null] }
       });
       if (!result) {
-        throw new import_utils28.BadRequestError("Building unit not found.");
+        throw new import_utils29.BadRequestError("Building unit not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils28.AppError) {
+      if (error instanceof import_utils29.AppError) {
         throw error;
       } else {
-        throw new import_utils28.InternalServerError("Failed to get building unit.");
+        throw new import_utils29.InternalServerError("Failed to get building unit.");
       }
     }
   }
@@ -5863,16 +5918,16 @@ function useBuildingUnitRepo() {
     try {
       building = new import_mongodb18.ObjectId(building);
     } catch (error) {
-      throw new import_utils28.BadRequestError("Invalid building ID.");
+      throw new import_utils29.BadRequestError("Invalid building ID.");
     }
-    const cacheKey = (0, import_utils28.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils29.makeCacheKey)(namespace_collection, {
       building: String(building),
       level
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -5884,22 +5939,22 @@ function useBuildingUnitRepo() {
         status: "active"
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils28.AppError) {
+      if (error instanceof import_utils29.AppError) {
         throw error;
       } else {
-        throw new import_utils28.InternalServerError("Failed to get building unit.");
+        throw new import_utils29.InternalServerError("Failed to get building unit.");
       }
     }
   }
@@ -5907,15 +5962,15 @@ function useBuildingUnitRepo() {
     try {
       building = new import_mongodb18.ObjectId(building);
     } catch (error) {
-      throw new import_utils28.BadRequestError("Invalid building ID.");
+      throw new import_utils29.BadRequestError("Invalid building ID.");
     }
-    const cacheKey = (0, import_utils28.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils29.makeCacheKey)(namespace_collection, {
       building: String(building)
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "info",
           message: `Cache hit for getById building unit: ${cacheKey}`
         });
@@ -5926,22 +5981,22 @@ function useBuildingUnitRepo() {
         status: "active"
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "info",
           message: `Cache set for building unit by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils28.logger.log({
+        import_utils29.logger.log({
           level: "error",
           message: `Failed to set cache for building unit by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils28.AppError) {
+      if (error instanceof import_utils29.AppError) {
         throw error;
       } else {
-        throw new import_utils28.InternalServerError("Failed to get building unit.");
+        throw new import_utils29.InternalServerError("Failed to get building unit.");
       }
     }
   }
@@ -5949,7 +6004,7 @@ function useBuildingUnitRepo() {
     try {
       _id = new import_mongodb18.ObjectId(_id);
     } catch (error) {
-      throw new import_utils28.BadRequestError("Invalid ID.");
+      throw new import_utils29.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -5960,11 +6015,11 @@ function useBuildingUnitRepo() {
       delCachedData();
       return "Room/Facility deleted successfully.";
     } catch (error) {
-      import_utils28.logger.log({
+      import_utils29.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils28.AppError) {
+      if (error instanceof import_utils29.AppError) {
         throw error;
       } else {
         throw new Error("Failed to deleted room/facility.");
@@ -5994,16 +6049,16 @@ function useBuildingService() {
   const { getByBuildingLevel, getByBuilding, updateByBuildingId } = useBuildingUnitRepo();
   async function updateById(id, data) {
     data.levels = Number(data.levels);
-    const session = import_utils29.useAtlas.getClient()?.startSession();
+    const session = import_utils30.useAtlas.getClient()?.startSession();
     try {
       const building = await _getById(id);
       if (!building) {
-        throw new import_utils29.NotFoundError("Building not found.");
+        throw new import_utils30.NotFoundError("Building not found.");
       }
       if (data.levels < building.levels) {
         const unit = await getByBuildingLevel(id, building.levels);
         if (unit) {
-          throw new import_utils29.BadRequestError(
+          throw new import_utils30.BadRequestError(
             "Cannot reduce floors, there are existing building units at higher floors."
           );
         }
@@ -6025,7 +6080,7 @@ function useBuildingService() {
   async function deleteById(id) {
     const building = await getByBuilding(id);
     if (building) {
-      throw new import_utils29.BadRequestError(
+      throw new import_utils30.BadRequestError(
         "Cannot delete building with existing room/facility. Please delete room/facility first."
       );
     }
@@ -6043,7 +6098,7 @@ function useBuildingService() {
 }
 
 // src/resources/building/building.controller.ts
-var import_utils30 = require("@goweekdays/utils");
+var import_utils31 = require("@goweekdays/utils");
 var import_joi16 = __toESM(require("joi"));
 function useBuildingController() {
   const { getAll: _getAll, getById: _getById, add: _add } = useBuildingRepo();
@@ -6059,8 +6114,8 @@ function useBuildingController() {
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_utils30.BadRequestError(error.message));
-      import_utils30.logger.info(`Controller: ${error.message}`);
+      next(new import_utils31.BadRequestError(error.message));
+      import_utils31.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -6084,8 +6139,8 @@ function useBuildingController() {
     });
     const { error } = validation.validate({ id, value });
     if (error) {
-      next(new import_utils30.BadRequestError(error.message));
-      import_utils30.logger.info(`Controller: ${error.message}`);
+      next(new import_utils31.BadRequestError(error.message));
+      import_utils31.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -6107,7 +6162,7 @@ function useBuildingController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils30.BadRequestError(error.message));
+      next(new import_utils31.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -6146,7 +6201,7 @@ function useBuildingController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils30.BadRequestError(error.message));
+      next(new import_utils31.BadRequestError(error.message));
       return;
     }
     try {
@@ -6167,7 +6222,7 @@ function useBuildingController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils30.BadRequestError(error.message));
+      next(new import_utils31.BadRequestError(error.message));
       return;
     }
     try {
@@ -6188,11 +6243,11 @@ function useBuildingController() {
 }
 
 // src/resources/building/building-unit.service.ts
-var import_utils31 = require("@goweekdays/utils");
+var import_utils32 = require("@goweekdays/utils");
 function useBuildingUnitService() {
   const { add: _add } = useBuildingUnitRepo();
   async function add(value) {
-    const session = import_utils31.useAtlas.getClient()?.startSession();
+    const session = import_utils32.useAtlas.getClient()?.startSession();
     if (!session) {
       throw new Error("Unable to start session for building unit service.");
     }
@@ -6219,7 +6274,7 @@ function useBuildingUnitService() {
 }
 
 // src/resources/building/building-unit.controller.ts
-var import_utils32 = require("@goweekdays/utils");
+var import_utils33 = require("@goweekdays/utils");
 var import_joi17 = __toESM(require("joi"));
 function useBuildingUnitController() {
   const {
@@ -6251,7 +6306,7 @@ function useBuildingUnitController() {
     });
     const { error } = validation.validate(data);
     if (error) {
-      next(new import_utils32.BadRequestError(error.message));
+      next(new import_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -6273,7 +6328,7 @@ function useBuildingUnitController() {
     });
     const { error } = validation.validate({ id, value: data });
     if (error) {
-      next(new import_utils32.BadRequestError(error.message));
+      next(new import_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -6298,7 +6353,7 @@ function useBuildingUnitController() {
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils32.BadRequestError(error.message));
+      next(new import_utils33.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -6339,7 +6394,7 @@ function useBuildingUnitController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils32.BadRequestError(error.message));
+      next(new import_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -6360,7 +6415,7 @@ function useBuildingUnitController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils32.BadRequestError(error.message));
+      next(new import_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -6381,7 +6436,7 @@ function useBuildingUnitController() {
 }
 
 // src/resources/counter/counter.model.ts
-var import_utils33 = require("@goweekdays/utils");
+var import_utils34 = require("@goweekdays/utils");
 var import_mongodb19 = require("mongodb");
 var import_zod = require("zod");
 var TCounter = import_zod.z.object({
@@ -6401,7 +6456,7 @@ function useCounterModel(db) {
     try {
       return TCounter.parse(value);
     } catch (error) {
-      throw new import_utils33.BadRequestError(error.issues[0].message);
+      throw new import_utils34.BadRequestError(error.issues[0].message);
     }
   }
   function validateCounter(data) {
@@ -6415,23 +6470,23 @@ function useCounterModel(db) {
 }
 
 // src/resources/counter/counter.repository.ts
-var import_utils34 = require("@goweekdays/utils");
+var import_utils35 = require("@goweekdays/utils");
 function useCounterRepo() {
-  const db = import_utils34.useAtlas.getDb();
+  const db = import_utils35.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "counters";
   const { collection, createCounter } = useCounterModel(db);
-  const { getCache, setCache, delNamespace } = (0, import_utils34.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils35.useCache)(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils34.logger.log({
+      import_utils35.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils34.logger.log({
+      import_utils35.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -6483,11 +6538,11 @@ function useCounterRepo() {
     }
   }
   async function getByType(type) {
-    const cacheKey = (0, import_utils34.makeCacheKey)(namespace_collection, { type });
+    const cacheKey = (0, import_utils35.makeCacheKey)(namespace_collection, { type });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils34.logger.log({
+        import_utils35.logger.log({
           level: "info",
           message: `Cache hit for getByType counter: ${cacheKey}`
         });
@@ -6496,12 +6551,12 @@ function useCounterRepo() {
       const data = await collection.findOne({ type });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          import_utils34.logger.log({
+          import_utils35.logger.log({
             level: "info",
             message: `Cache set for counter by type: ${cacheKey}`
           });
         }).catch((err) => {
-          import_utils34.logger.log({
+          import_utils35.logger.log({
             level: "error",
             message: `Failed to set cache for counter by type: ${err.message}`
           });
@@ -6522,7 +6577,7 @@ function useCounterRepo() {
 }
 
 // src/resources/file/file.service.ts
-var import_utils35 = require("@goweekdays/utils");
+var import_utils36 = require("@goweekdays/utils");
 var import_node_cron = __toESM(require("node-cron"));
 var fs = __toESM(require("fs"));
 function useFileService() {
@@ -6531,7 +6586,7 @@ function useFileService() {
     deleteFileById,
     getAllDraftedFiles
   } = useFileRepo();
-  const s3 = new import_utils35.useS3({
+  const s3 = new import_utils36.useS3({
     accessKeyId: SPACES_ACCESS_KEY,
     secretAccessKey: SPACES_SECRET_KEY,
     endpoint: SPACES_ENDPOINT,
@@ -6540,7 +6595,7 @@ function useFileService() {
     forcePathStyle: true
   });
   async function createFile(value) {
-    const session = import_utils35.useAtlas.getClient()?.startSession();
+    const session = import_utils36.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     const file = {
       name: value.originalname,
@@ -6574,7 +6629,7 @@ function useFileService() {
     }
   }
   async function deleteFile(id) {
-    const session = import_utils35.useAtlas.getClient()?.startSession();
+    const session = import_utils36.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       await deleteFileById(id, session);
@@ -6595,12 +6650,12 @@ function useFileService() {
         const file = files[index];
         try {
           await deleteFile(file._id.toString());
-          await import_utils35.logger.log({
+          await import_utils36.logger.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
         } catch (error) {
-          import_utils35.logger.log({
+          import_utils36.logger.log({
             level: "info",
             message: "Successfully deleted draft files."
           });
@@ -6617,7 +6672,7 @@ function useFileService() {
 }
 
 // src/resources/file/file.controller.ts
-var import_utils36 = require("@goweekdays/utils");
+var import_utils37 = require("@goweekdays/utils");
 var import_joi18 = __toESM(require("joi"));
 function useFileController() {
   const { createFile, deleteFile: _deleteFile } = useFileService();
@@ -6631,10 +6686,10 @@ function useFileController() {
       res.json({ message: "Successfully uploaded file", id });
       return;
     } catch (error) {
-      if (error instanceof import_utils36.AppError) {
+      if (error instanceof import_utils37.AppError) {
         next(error);
       } else {
-        next(new import_utils36.InternalServerError(error));
+        next(new import_utils37.InternalServerError(error));
       }
     }
   }
@@ -6643,17 +6698,17 @@ function useFileController() {
     const validation = import_joi18.default.string().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils36.BadRequestError(error.message));
+      next(new import_utils37.BadRequestError(error.message));
     }
     try {
       const message = await _deleteFile(id);
       res.json({ message });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils36.AppError) {
+      if (error2 instanceof import_utils37.AppError) {
         next(error2);
       } else {
-        next(new import_utils36.InternalServerError(error2));
+        next(new import_utils37.InternalServerError(error2));
       }
     }
   }
@@ -6665,7 +6720,7 @@ function useFileController() {
 
 // src/resources/member/member.controller.ts
 var import_joi19 = __toESM(require("joi"));
-var import_utils37 = require("@goweekdays/utils");
+var import_utils38 = require("@goweekdays/utils");
 function useMemberController() {
   const {
     getByUserId: _getByUserId,
@@ -6681,7 +6736,7 @@ function useMemberController() {
     });
     const { error } = validation.validate({ id: userId });
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils38.BadRequestError(error.message));
       return;
     }
     try {
@@ -6703,7 +6758,7 @@ function useMemberController() {
     });
     const { error } = validation.validate({ ...req.params, ...req.query });
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils38.BadRequestError(error.message));
       return;
     }
     const orgId = req.query.org;
@@ -6747,7 +6802,7 @@ function useMemberController() {
       status
     });
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils38.BadRequestError(error.message));
       return;
     }
     try {
@@ -6784,7 +6839,7 @@ function useMemberController() {
       limit
     });
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils38.BadRequestError(error.message));
     }
     try {
       const items = await _getOrgsByMembership({
@@ -6806,7 +6861,7 @@ function useMemberController() {
     });
     const { error } = validation.validate(req.params);
     if (error) {
-      next(new import_utils37.BadRequestError(error.message));
+      next(new import_utils38.BadRequestError(error.message));
       return;
     }
     const id = req.params.id;
@@ -6828,42 +6883,32 @@ function useMemberController() {
 }
 
 // src/resources/organization/organization.model.ts
-var import_utils38 = require("@goweekdays/utils");
+var import_utils39 = require("@goweekdays/utils");
 var import_joi20 = __toESM(require("joi"));
 var import_mongodb20 = require("mongodb");
-var OrgTypes = [
-  "marketplace",
-  "stay",
-  "eat",
-  "service",
-  "ride",
-  "experience"
-];
 var schemaOrg = import_joi20.default.object({
   name: import_joi20.default.string().max(255).required(),
   description: import_joi20.default.string().max(1024).optional().allow("", null),
-  type: import_joi20.default.string().allow(...OrgTypes).required(),
   email: import_joi20.default.string().email().max(255).optional().allow("", null),
   contact: import_joi20.default.string().max(50).optional().allow("", null),
   createdBy: import_joi20.default.string().hex().required()
 });
-function MOrg(value) {
+function modelOrg(value) {
   const { error } = schemaOrg.validate(value);
   if (error) {
-    throw new import_utils38.BadRequestError(error.message);
+    throw new import_utils39.BadRequestError(error.message);
   }
   if (value.createdBy && typeof value.createdBy === "string") {
     try {
       value.createdBy = new import_mongodb20.ObjectId(value.createdBy);
     } catch (error2) {
-      throw new import_utils38.BadRequestError("Invalid createdBy ObjectId");
+      throw new import_utils39.BadRequestError("Invalid createdBy ObjectId");
     }
   }
   return {
     _id: value._id,
     name: value.name,
-    description: value.description,
-    type: value.type,
+    description: value.description ?? "",
     email: value.email,
     contact: value.contact,
     createdBy: value.createdBy,
@@ -6875,16 +6920,16 @@ function MOrg(value) {
 }
 
 // src/resources/organization/organization.repository.ts
-var import_utils39 = require("@goweekdays/utils");
+var import_utils40 = require("@goweekdays/utils");
 var import_mongodb21 = require("mongodb");
 function useOrgRepo() {
-  const db = import_utils39.useAtlas.getDb();
+  const db = import_utils40.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "organizations";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils39.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils40.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -6900,16 +6945,16 @@ function useOrgRepo() {
     }
   }
   createIndexes().catch((error) => {
-    import_utils39.logger.log({ level: "error", message: `Index creation error: ${error}` });
+    import_utils40.logger.log({ level: "error", message: `Index creation error: ${error}` });
   });
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils39.logger.log({
+      import_utils40.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils39.logger.log({
+      import_utils40.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -6917,21 +6962,21 @@ function useOrgRepo() {
   }
   async function add(value, session) {
     try {
-      value = MOrg(value);
+      value = modelOrg(value);
       const res = await collection.insertOne(value, { session });
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils39.logger.log({
+      import_utils40.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils39.AppError) {
+      if (error instanceof import_utils40.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils39.BadRequestError("Organization already exist.");
+          throw new import_utils40.BadRequestError("Organization already exist.");
         }
         throw new Error("Failed to create organization.");
       }
@@ -6950,21 +6995,21 @@ function useOrgRepo() {
     if (search) {
       query.$text = { $search: search };
     }
-    const cacheKey = (0, import_utils39.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils40.makeCacheKey)(namespace_collection, {
       search,
       page,
       limit,
       sort: JSON.stringify(sort),
       status
     });
-    import_utils39.logger.log({
+    import_utils40.logger.log({
       level: "info",
       message: `Cache key for getAll organizations: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils39.logger.log({
+        import_utils40.logger.log({
           level: "info",
           message: `Cache hit for getAll organizations: ${cacheKey}`
         });
@@ -6986,21 +7031,21 @@ function useOrgRepo() {
         }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils39.paginate)(items, page, limit, length);
+      const data = (0, import_utils40.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils39.logger.log({
+        import_utils40.logger.log({
           level: "info",
           message: `Cache set for getAll organizations: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils39.logger.log({
+        import_utils40.logger.log({
           level: "error",
           message: `Failed to set cache for getAll organizations: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils39.logger.log({ level: "error", message: `${error}` });
+      import_utils40.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -7008,13 +7053,13 @@ function useOrgRepo() {
     try {
       _id = new import_mongodb21.ObjectId(_id);
     } catch (error) {
-      throw new import_utils39.BadRequestError("Invalid ID.");
+      throw new import_utils40.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils39.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils40.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils39.logger.log({
+        import_utils40.logger.log({
           level: "info",
           message: `Cache hit for getById organization: ${cacheKey}`
         });
@@ -7022,34 +7067,34 @@ function useOrgRepo() {
       }
       const result = await collection.findOne({ _id });
       if (!result) {
-        throw new import_utils39.BadRequestError("Organization not found.");
+        throw new import_utils40.BadRequestError("Organization not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        import_utils39.logger.log({
+        import_utils40.logger.log({
           level: "info",
           message: `Cache set for organization by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils39.logger.log({
+        import_utils40.logger.log({
           level: "error",
           message: `Failed to set cache for organization by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils39.AppError) {
+      if (error instanceof import_utils40.AppError) {
         throw error;
       } else {
-        throw new import_utils39.InternalServerError("Failed to get organization.");
+        throw new import_utils40.InternalServerError("Failed to get organization.");
       }
     }
   }
   async function getByName(name) {
-    const cacheKey = (0, import_utils39.makeCacheKey)(namespace_collection, { name });
+    const cacheKey = (0, import_utils40.makeCacheKey)(namespace_collection, { name });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils39.logger.log({
+        import_utils40.logger.log({
           level: "info",
           message: `Cache hit for getByName organization: ${cacheKey}`
         });
@@ -7057,39 +7102,39 @@ function useOrgRepo() {
       }
       const result = await collection.findOne({ name });
       if (!result) {
-        throw new import_utils39.BadRequestError("Organization not found.");
+        throw new import_utils40.BadRequestError("Organization not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        import_utils39.logger.log({
+        import_utils40.logger.log({
           level: "info",
           message: `Cache set for organization by name: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils39.logger.log({
+        import_utils40.logger.log({
           level: "error",
           message: `Failed to set cache for organization by name: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils39.AppError) {
+      if (error instanceof import_utils40.AppError) {
         throw error;
       } else {
-        throw new import_utils39.InternalServerError("Failed to get organization.");
+        throw new import_utils40.InternalServerError("Failed to get organization.");
       }
     }
   }
   async function updateFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["name", "description"];
     if (!allowedFields.includes(field)) {
-      throw new import_utils39.BadRequestError(
+      throw new import_utils40.BadRequestError(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
       _id = new import_mongodb21.ObjectId(_id);
     } catch (error) {
-      throw new import_utils39.BadRequestError("Invalid ID.");
+      throw new import_utils40.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -7101,14 +7146,14 @@ function useOrgRepo() {
       delCachedData();
       return `Successfully updated user ${field}.`;
     } catch (error) {
-      throw new import_utils39.InternalServerError(`Failed to update organization ${field}.`);
+      throw new import_utils40.InternalServerError(`Failed to update organization ${field}.`);
     }
   }
   async function deleteById(_id) {
     try {
       _id = new import_mongodb21.ObjectId(_id);
     } catch (error) {
-      throw new import_utils39.BadRequestError("Invalid ID.");
+      throw new import_utils40.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -7118,7 +7163,7 @@ function useOrgRepo() {
       delCachedData();
       return "Successfully deleted organization.";
     } catch (error) {
-      throw new import_utils39.InternalServerError("Failed to delete organization.");
+      throw new import_utils40.InternalServerError("Failed to delete organization.");
     }
   }
   return {
@@ -7133,10 +7178,10 @@ function useOrgRepo() {
 }
 
 // src/resources/organization/organization.service.ts
-var import_utils41 = require("@goweekdays/utils");
+var import_utils42 = require("@goweekdays/utils");
 
 // src/resources/user/user.controller.ts
-var import_utils40 = require("@goweekdays/utils");
+var import_utils41 = require("@goweekdays/utils");
 var import_joi21 = __toESM(require("joi"));
 function useUserController() {
   const {
@@ -7160,7 +7205,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ status, search, page });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     try {
@@ -7175,12 +7220,12 @@ function useUserController() {
     const id = req.params.id || "";
     const validation = import_joi21.default.string().hex().validate(id);
     if (validation.error) {
-      throw new import_utils40.BadRequestError("Invalid id.");
+      throw new import_utils41.BadRequestError("Invalid id.");
     }
     try {
       const user = await _getUserById(id);
       if (!user) {
-        throw new import_utils40.BadRequestError("User not found.");
+        throw new import_utils41.BadRequestError("User not found.");
       }
       res.json(user);
     } catch (error) {
@@ -7197,7 +7242,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ firstName, lastName });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     try {
@@ -7220,7 +7265,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ month, day, year });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     try {
@@ -7245,7 +7290,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     try {
@@ -7266,7 +7311,7 @@ function useUserController() {
     });
     const { error } = validation.validate({ previousProfile });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     const user = req.headers["user"] ?? "";
@@ -7279,10 +7324,10 @@ function useUserController() {
       res.json({ message: "Successfully updated profile picture." });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils40.AppError) {
+      if (error2 instanceof import_utils41.AppError) {
         next(error2);
       } else {
-        next(new import_utils40.InternalServerError(error2));
+        next(new import_utils41.InternalServerError(error2));
       }
     }
   }
@@ -7307,7 +7352,7 @@ function useUserController() {
       type
     });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     try {
@@ -7347,9 +7392,12 @@ function useOrgService() {
   const { add: addMember } = useMemberRepo();
   const { getUserById } = useUserRepo();
   async function add(value) {
-    const session = import_utils41.useAtlas.getClient()?.startSession();
-    session?.startTransaction();
+    const session = import_utils42.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new import_utils42.BadRequestError("Unable to start database session.");
+    }
     try {
+      session?.startTransaction();
       const org = await addOrg(value, session);
       const allPermissions = await getAllPermission({
         app: "org",
@@ -7362,39 +7410,41 @@ function useOrgService() {
       if (permissions.length === 0) {
         throw new Error("No permissions found for the organization type.");
       }
+      const createdBy = String(value.createdBy);
       const role = await addRole(
         {
-          id: org,
+          org: String(org),
           name: "Owner",
           description: "Owner of the organization",
-          permissions
+          permissions,
+          createdBy
         },
         session
       );
       if (!role) {
-        throw new import_utils41.BadRequestError("Role is required to create org member.");
+        throw new import_utils42.BadRequestError("Role is required to create org member.");
       }
-      const user = await getUserById(value.createdBy);
+      const user = await getUserById(createdBy);
       if (!user) {
-        throw new import_utils41.BadRequestError("User is required to create org member.");
+        throw new import_utils42.BadRequestError("User is required to create org member.");
       }
       await addMember(
         {
           role: String(role),
           org: String(org),
           name: `${user.firstName} ${user.lastName}`,
-          user: value.createdBy,
-          type: "owner"
+          user: createdBy,
+          type: "org"
         },
         session
       );
-      session?.commitTransaction();
-      return "Organization created successfully.";
+      await session?.commitTransaction();
+      return String(org);
     } catch (error) {
-      session?.abortTransaction();
+      await session?.abortTransaction();
       throw error;
     } finally {
-      session?.endSession();
+      await session?.endSession();
     }
   }
   return {
@@ -7403,7 +7453,7 @@ function useOrgService() {
 }
 
 // src/resources/organization/organization.controller.ts
-var import_utils42 = require("@goweekdays/utils");
+var import_utils43 = require("@goweekdays/utils");
 var import_joi22 = __toESM(require("joi"));
 function useOrgController() {
   const { add: _add } = useOrgService();
@@ -7413,16 +7463,19 @@ function useOrgController() {
     getAll: getAllOrg,
     getById: _getById
   } = useOrgRepo();
-  async function createOrg(req, res, next) {
+  async function add(req, res, next) {
     const value = req.body;
     const { error } = schemaOrg.validate(value);
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils43.BadRequestError(error.message));
       return;
     }
     try {
-      const message = await _add(value);
-      res.json({ message });
+      const org = await _add(value);
+      res.json({
+        message: "Organization created successfully.",
+        data: { org }
+      });
       return;
     } catch (error2) {
       next(error2);
@@ -7435,12 +7488,12 @@ function useOrgController() {
     const user = req.params.user ?? "";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_utils42.BadRequestError("Invalid page number."));
+      next(new import_utils43.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_utils42.BadRequestError("Invalid limit number."));
+      next(new import_utils43.BadRequestError("Invalid limit number."));
       return;
     }
     const validation = import_joi22.default.object({
@@ -7451,7 +7504,7 @@ function useOrgController() {
     });
     const { error } = validation.validate({ user, page, limit, search });
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils43.BadRequestError(error.message));
       return;
     }
     try {
@@ -7477,16 +7530,16 @@ function useOrgController() {
     const status = req.query.status ?? "active";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_utils42.BadRequestError("Invalid page number."));
+      next(new import_utils43.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_utils42.BadRequestError("Invalid limit number."));
+      next(new import_utils43.BadRequestError("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils43.BadRequestError(error.message));
       return;
     }
     try {
@@ -7504,7 +7557,7 @@ function useOrgController() {
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils43.BadRequestError(error.message));
       return;
     }
     try {
@@ -7522,7 +7575,7 @@ function useOrgController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils42.BadRequestError(error.message));
+      next(new import_utils43.BadRequestError(error.message));
       return;
     }
     try {
@@ -7534,7 +7587,7 @@ function useOrgController() {
     }
   }
   return {
-    createOrg,
+    add,
     getOrgsByUserId,
     getByName,
     getAll,
@@ -7562,16 +7615,16 @@ function modelPSGC(data) {
 }
 
 // src/resources/psgc/psgc.repository.ts
-var import_utils43 = require("@goweekdays/utils");
+var import_utils44 = require("@goweekdays/utils");
 var import_mongodb22 = require("mongodb");
 function usePSGCRepo() {
-  const db = import_utils43.useAtlas.getDb();
+  const db = import_utils44.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "psgc";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils43.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils44.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -7585,12 +7638,12 @@ function usePSGCRepo() {
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils43.logger.log({
+      import_utils44.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils43.logger.log({
+      import_utils44.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -7603,16 +7656,16 @@ function usePSGCRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils43.logger.log({
+      import_utils44.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils43.AppError) {
+      if (error instanceof import_utils44.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils43.BadRequestError("Region already exists.");
+          throw new import_utils44.BadRequestError("Region already exists.");
         }
         throw new Error("Failed to create PSGC.");
       }
@@ -7648,15 +7701,15 @@ function usePSGCRepo() {
       query.$text = { $search: search };
       cacheKeyOptions.search = search;
     }
-    const cacheKey = (0, import_utils43.makeCacheKey)(namespace_collection, cacheKeyOptions);
-    import_utils43.logger.log({
+    const cacheKey = (0, import_utils44.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_utils44.logger.log({
       level: "info",
       message: `Cache key for getAll PSGC: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils43.logger.log({
+        import_utils44.logger.log({
           level: "info",
           message: `Cache hit for getAll PSGC: ${cacheKey}`
         });
@@ -7669,21 +7722,21 @@ function usePSGCRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils43.paginate)(items, page, limit, length);
+      const data = (0, import_utils44.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils43.logger.log({
+        import_utils44.logger.log({
           level: "info",
           message: `Cache set for getAll PSGC: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils43.logger.log({
+        import_utils44.logger.log({
           level: "error",
           message: `Failed to set cache for getAll PSGC: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils43.logger.log({ level: "error", message: `${error}` });
+      import_utils44.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -7691,13 +7744,13 @@ function usePSGCRepo() {
     try {
       _id = new import_mongodb22.ObjectId(_id);
     } catch (error) {
-      throw new import_utils43.BadRequestError("Invalid ID.");
+      throw new import_utils44.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils43.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils44.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils43.logger.log({
+        import_utils44.logger.log({
           level: "info",
           message: `Cache hit for getById PSGC: ${cacheKey}`
         });
@@ -7708,25 +7761,25 @@ function usePSGCRepo() {
         deletedAt: { $in: ["", null] }
       });
       if (!result) {
-        throw new import_utils43.BadRequestError("Region not found.");
+        throw new import_utils44.BadRequestError("Region not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        import_utils43.logger.log({
+        import_utils44.logger.log({
           level: "info",
           message: `Cache set for PSGC by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils43.logger.log({
+        import_utils44.logger.log({
           level: "error",
           message: `Failed to set cache for PSGC by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils43.AppError) {
+      if (error instanceof import_utils44.AppError) {
         throw error;
       } else {
-        throw new import_utils43.InternalServerError("Failed to get PSGC.");
+        throw new import_utils44.InternalServerError("Failed to get PSGC.");
       }
     }
   }
@@ -7750,15 +7803,15 @@ function usePSGCRepo() {
       query.code = { $regex: `^${prefix}` };
       cacheKeyOptions.prefix = prefix;
     }
-    const cacheKey = (0, import_utils43.makeCacheKey)(namespace_collection, { name });
-    import_utils43.logger.log({
+    const cacheKey = (0, import_utils44.makeCacheKey)(namespace_collection, { name });
+    import_utils44.logger.log({
       level: "info",
       message: `Query for getByName PSGC: ${JSON.stringify(query)}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils43.logger.log({
+        import_utils44.logger.log({
           level: "info",
           message: `Cache hit for getByName PSGC: ${cacheKey}`
         });
@@ -7766,36 +7819,36 @@ function usePSGCRepo() {
       }
       const result = await collection.findOne(query);
       setCache(cacheKey, result, 300).then(() => {
-        import_utils43.logger.log({
+        import_utils44.logger.log({
           level: "info",
           message: `Cache set for PSGC by name: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils43.logger.log({
+        import_utils44.logger.log({
           level: "error",
           message: `Failed to set cache for PSGC by name: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils43.AppError) {
+      if (error instanceof import_utils44.AppError) {
         throw error;
       } else {
-        throw new import_utils43.InternalServerError("Failed to get PSGC.");
+        throw new import_utils44.InternalServerError("Failed to get PSGC.");
       }
     }
   }
   async function updateFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["name"];
     if (!allowedFields.includes(field)) {
-      throw new import_utils43.BadRequestError(
+      throw new import_utils44.BadRequestError(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
       _id = new import_mongodb22.ObjectId(_id);
     } catch (error) {
-      throw new import_utils43.BadRequestError("Invalid ID.");
+      throw new import_utils44.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -7806,14 +7859,14 @@ function usePSGCRepo() {
       delCachedData();
       return `Successfully updated PSGC ${field}.`;
     } catch (error) {
-      throw new import_utils43.InternalServerError(`Failed to update PSGC ${field}.`);
+      throw new import_utils44.InternalServerError(`Failed to update PSGC ${field}.`);
     }
   }
   async function deleteById(_id) {
     try {
       _id = new import_mongodb22.ObjectId(_id);
     } catch (error) {
-      throw new import_utils43.BadRequestError("Invalid ID.");
+      throw new import_utils44.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -7823,7 +7876,7 @@ function usePSGCRepo() {
       delCachedData();
       return "Successfully deleted PSGC.";
     } catch (error) {
-      throw new import_utils43.InternalServerError("Failed to delete PSGC.");
+      throw new import_utils44.InternalServerError("Failed to delete PSGC.");
     }
   }
   return {
@@ -7838,7 +7891,7 @@ function usePSGCRepo() {
 }
 
 // src/resources/psgc/psgc.controller.ts
-var import_utils44 = require("@goweekdays/utils");
+var import_utils45 = require("@goweekdays/utils");
 var import_joi24 = __toESM(require("joi"));
 function usePSGCController() {
   const {
@@ -7853,7 +7906,7 @@ function usePSGCController() {
     const value = req.body;
     const { error } = schemaPSGC.validate(value);
     if (error) {
-      next(new import_utils44.BadRequestError(error.message));
+      next(new import_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -7884,16 +7937,16 @@ function usePSGCController() {
     const prefix = req.query.prefix ? String(req.query.prefix) : "";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_utils44.BadRequestError("Invalid page number."));
+      next(new import_utils45.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_utils44.BadRequestError("Invalid limit number."));
+      next(new import_utils45.BadRequestError("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new import_utils44.BadRequestError(error.message));
+      next(new import_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -7917,7 +7970,7 @@ function usePSGCController() {
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils44.BadRequestError(error.message));
+      next(new import_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -7938,7 +7991,7 @@ function usePSGCController() {
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new import_utils44.BadRequestError(error.message));
+      next(new import_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -7962,7 +8015,7 @@ function usePSGCController() {
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new import_utils44.BadRequestError(error.message));
+      next(new import_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -7980,7 +8033,7 @@ function usePSGCController() {
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new import_utils44.BadRequestError(error.message));
+      next(new import_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -8002,7 +8055,7 @@ function usePSGCController() {
 }
 
 // src/resources/role/role.service.ts
-var import_utils45 = require("@goweekdays/utils");
+var import_utils46 = require("@goweekdays/utils");
 function useRoleService() {
   const { getByRole } = useMemberRepo();
   const { deleteById: _deleteById } = useRoleRepo();
@@ -8010,14 +8063,14 @@ function useRoleService() {
     try {
       const role = await getByRole(id);
       if (role) {
-        throw new import_utils45.BadRequestError("Cannot delete role assigned to members.");
+        throw new import_utils46.BadRequestError("Cannot delete role assigned to members.");
       }
       await _deleteById(id);
     } catch (error) {
-      if (error instanceof import_utils45.AppError) {
+      if (error instanceof import_utils46.AppError) {
         throw error;
       } else {
-        throw new import_utils45.InternalServerError("Failed to delete role.");
+        throw new import_utils46.InternalServerError("Failed to delete role.");
       }
     }
   }
@@ -8028,7 +8081,7 @@ function useRoleService() {
 
 // src/resources/role/role.controller.ts
 var import_joi25 = __toESM(require("joi"));
-var import_utils46 = require("@goweekdays/utils");
+var import_utils47 = require("@goweekdays/utils");
 function useRoleController() {
   const {
     addRole: _createRole,
@@ -8043,7 +8096,7 @@ function useRoleController() {
     const payload = req.body;
     const { error } = schemaRole.validate(payload);
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils47.BadRequestError(error.message));
       return;
     }
     try {
@@ -8069,7 +8122,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ search, page, limit, type, id });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils47.BadRequestError(error.message));
       return;
     }
     try {
@@ -8087,7 +8140,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ userId });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils47.BadRequestError(error.message));
       return;
     }
     try {
@@ -8105,7 +8158,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils47.BadRequestError(error.message));
       return;
     }
     try {
@@ -8127,7 +8180,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ _id, name, permissions });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils47.BadRequestError(error.message));
       return;
     }
     try {
@@ -8147,7 +8200,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ _id, permissions });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils47.BadRequestError(error.message));
       return;
     }
     try {
@@ -8165,7 +8218,7 @@ function useRoleController() {
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils47.BadRequestError(error.message));
       return;
     }
     try {
@@ -8188,7 +8241,7 @@ function useRoleController() {
 }
 
 // src/resources/utils/github.service.ts
-var import_utils47 = require("@goweekdays/utils");
+var import_utils48 = require("@goweekdays/utils");
 var import_rest = require("@octokit/rest");
 var import_libsodium_wrappers = __toESM(require("libsodium-wrappers"));
 function useGitHubService() {
@@ -8202,23 +8255,23 @@ function useGitHubService() {
     try {
       const { data: repoData } = await octokit.repos.get({ owner, repo });
       if (!repoData.permissions?.admin) {
-        throw new import_utils47.BadRequestError(
+        throw new import_utils48.BadRequestError(
           "You do not have admin access to this repository."
         );
       }
     } catch (error) {
       if (error.status === 404) {
-        throw new import_utils47.BadRequestError(
+        throw new import_utils48.BadRequestError(
           "Repository not found or you don't have access to it."
         );
       } else if (error.status === 401) {
-        throw new import_utils47.BadRequestError(
+        throw new import_utils48.BadRequestError(
           "Invalid GitHub token or insufficient permissions."
         );
       } else if (error.message.includes("admin access")) {
         throw error;
       } else {
-        throw new import_utils47.BadRequestError(
+        throw new import_utils48.BadRequestError(
           `Failed to check repository permissions: ${error.message}`
         );
       }
@@ -8267,7 +8320,7 @@ function useGitHubService() {
               key_id: publicKeyRes.key_id
             });
           } catch (encryptionError) {
-            throw new import_utils47.BadRequestError(
+            throw new import_utils48.BadRequestError(
               `Failed to encrypt secret '${key}': ${encryptionError.message}`
             );
           }
@@ -8297,22 +8350,22 @@ function useGitHubService() {
       }
       return `Successfully set ${lines.length} ${type} variables/secrets in environment '${environment}'`;
     } catch (error) {
-      if (error instanceof import_utils47.AppError)
+      if (error instanceof import_utils48.AppError)
         throw error;
       if (error.status === 422) {
-        throw new import_utils47.BadRequestError(
+        throw new import_utils48.BadRequestError(
           `GitHub API validation error: ${error.message}`
         );
       } else if (error.status === 404) {
-        throw new import_utils47.BadRequestError("Environment or repository not found.");
+        throw new import_utils48.BadRequestError("Environment or repository not found.");
       } else if (error.status === 403) {
-        throw new import_utils47.BadRequestError(
+        throw new import_utils48.BadRequestError(
           "Forbidden: Insufficient permissions or rate limit exceeded."
         );
       } else if (error.message.includes("admin access") || error.message.includes("permissions")) {
         throw error;
       } else {
-        throw new import_utils47.BadRequestError(
+        throw new import_utils48.BadRequestError(
           `Failed to set GitHub variables: ${error.message}`
         );
       }
@@ -8325,7 +8378,7 @@ function useGitHubService() {
 
 // src/resources/utils/util.controller.ts
 var import_joi26 = __toESM(require("joi"));
-var import_utils48 = require("@goweekdays/utils");
+var import_utils49 = require("@goweekdays/utils");
 function useUtilController() {
   async function healthCheck(req, res, next) {
     try {
@@ -8341,8 +8394,8 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_utils48.logger.error("Health check failed", { error: error.message });
-      next(new import_utils48.InternalServerError("Health check failed"));
+      import_utils49.logger.error("Health check failed", { error: error.message });
+      next(new import_utils49.InternalServerError("Health check failed"));
     }
   }
   async function setGitHubVariables(req, res, next) {
@@ -8379,13 +8432,13 @@ function useUtilController() {
         keyValues
       });
       if (error) {
-        next(new import_utils48.BadRequestError(error.message));
+        next(new import_utils49.BadRequestError(error.message));
         return;
       }
       const repoUrlPattern = /github\.com[:\/]([^\/]+)\/(.+)\.git$/;
       if (!repoUrlPattern.test(repoUrl)) {
         next(
-          new import_utils48.BadRequestError(
+          new import_utils49.BadRequestError(
             "Invalid GitHub repository URL format. Expected format: https://github.com/owner/repo.git"
           )
         );
@@ -8397,7 +8450,7 @@ function useUtilController() {
       );
       if (invalidLines.length > 0) {
         next(
-          new import_utils48.BadRequestError(
+          new import_utils49.BadRequestError(
             "Invalid key-value format. Each pair should be in format: KEY=value. Pairs should be separated by semicolons."
           )
         );
@@ -8411,7 +8464,7 @@ function useUtilController() {
         type,
         keyValues
       });
-      import_utils48.logger.info(`GitHub variables set successfully`, {
+      import_utils49.logger.info(`GitHub variables set successfully`, {
         repoUrl,
         environment,
         type,
@@ -8428,15 +8481,15 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_utils48.logger.error("Failed to set GitHub variables", {
+      import_utils49.logger.error("Failed to set GitHub variables", {
         error: error.message,
         stack: error.stack
       });
-      if (error instanceof import_utils48.AppError) {
+      if (error instanceof import_utils49.AppError) {
         next(error);
       } else {
         next(
-          new import_utils48.InternalServerError(
+          new import_utils49.InternalServerError(
             `Failed to set GitHub variables: ${error.message}`
           )
         );
@@ -8473,7 +8526,7 @@ var transactionSchema = import_joi27.default.object({
 });
 
 // src/resources/verification/verification.controller.ts
-var import_utils49 = require("@goweekdays/utils");
+var import_utils50 = require("@goweekdays/utils");
 var import_joi28 = __toESM(require("joi"));
 function useVerificationController() {
   const {
@@ -8494,7 +8547,7 @@ function useVerificationController() {
     });
     const { error } = validation.validate(req.body);
     if (error) {
-      next(new import_utils49.BadRequestError(error.message));
+      next(new import_utils50.BadRequestError(error.message));
       return;
     }
     const email = req.body.email ?? "";
@@ -8525,7 +8578,7 @@ function useVerificationController() {
     const validation = import_joi28.default.string().email().required();
     const { error } = validation.validate(email);
     if (error) {
-      next(new import_utils49.BadRequestError(error.message));
+      next(new import_utils50.BadRequestError(error.message));
       return;
     }
     try {
@@ -8535,10 +8588,10 @@ function useVerificationController() {
       });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils49.AppError) {
+      if (error2 instanceof import_utils50.AppError) {
         next(error2);
       } else {
-        next(new import_utils49.InternalServerError("An unexpected error occurred"));
+        next(new import_utils50.InternalServerError("An unexpected error occurred"));
       }
     }
   }
@@ -8553,7 +8606,7 @@ function useVerificationController() {
     });
     const { error } = validation.validate(req.query);
     if (error) {
-      next(new import_utils49.BadRequestError(error.message));
+      next(new import_utils50.BadRequestError(error.message));
       return;
     }
     const status = req.query.status ?? "";
@@ -8587,7 +8640,7 @@ function useVerificationController() {
     const validation = import_joi28.default.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils49.BadRequestError(error.message));
+      next(new import_utils50.BadRequestError(error.message));
       return;
     }
     try {
@@ -8603,7 +8656,7 @@ function useVerificationController() {
     const validation = import_joi28.default.string().hex().required();
     const { error } = validation.validate(otpId);
     if (error) {
-      next(new import_utils49.BadRequestError(error.message));
+      next(new import_utils50.BadRequestError(error.message));
       return;
     }
     try {
@@ -8646,11 +8699,9 @@ function useVerificationController() {
   MMember,
   MONGO_DB,
   MONGO_URI,
-  MOrg,
   MUser,
   MUserRole,
   MVerification,
-  OrgTypes,
   PAYPAL_API_URL,
   PAYPAL_CLIENT_ID,
   PAYPAL_CLIENT_SECRET,
@@ -8673,6 +8724,8 @@ function useVerificationController() {
   addressSchema,
   isDev,
   modelApp,
+  modelMember,
+  modelOrg,
   modelPSGC,
   modelPermission,
   modelPermissionGroup,
@@ -8681,6 +8734,7 @@ function useVerificationController() {
   schemaAppUpdate,
   schemaBuilding,
   schemaBuildingUnit,
+  schemaMember,
   schemaOrg,
   schemaPSGC,
   schemaPermission,