@eeplatform/core 1.8.8 → 1.8.9

package/dist/index.js

@@ -78,12 +78,24 @@ __export(src_exports, {
   XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
   addressSchema: () => addressSchema,
   isDev: () => isDev,
+  modelApp: () => modelApp,
   modelPSGC: () => modelPSGC,
+  modelPermission: () => modelPermission,
+  modelPermissionGroup: () => modelPermissionGroup,
+  schemaApp: () => schemaApp,
+  schemaAppUpdate: () => schemaAppUpdate,
   schemaOrg: () => schemaOrg,
   schemaPSGC: () => schemaPSGC,
+  schemaPermission: () => schemaPermission,
+  schemaPermissionGroup: () => schemaPermissionGroup,
+  schemaPermissionGroupUpdate: () => schemaPermissionGroupUpdate,
+  schemaPermissionUpdate: () => schemaPermissionUpdate,
   transactionSchema: () => transactionSchema,
   useAddressController: () => useAddressController,
   useAddressRepo: () => useAddressRepo,
+  useAppController: () => useAppController,
+  useAppRepo: () => useAppRepo,
+  useAppService: () => useAppService,
   useAudioTranscriptionController: () => useAudioTranscriptionController,
   useAuthController: () => useAuthController,
   useAuthService: () => useAuthService,
@@ -101,6 +113,12 @@ __export(src_exports, {
   useOrgService: () => useOrgService,
   usePSGCController: () => usePSGCController,
   usePSGCRepo: () => usePSGCRepo,
+  usePermissionController: () => usePermissionController,
+  usePermissionGroupController: () => usePermissionGroupController,
+  usePermissionGroupRepo: () => usePermissionGroupRepo,
+  usePermissionGroupService: () => usePermissionGroupService,
+  usePermissionRepo: () => usePermissionRepo,
+  usePermissionService: () => usePermissionService,
   useRoleController: () => useRoleController,
   useRoleRepo: () => useRoleRepo,
   useTokenRepo: () => useTokenRepo,
@@ -184,26 +202,25 @@ function useUserRepo() {
       });
     });
   }
-  async function createTextIndex() {
-    try {
-      await collection.createIndex({
-        firstName: "text",
-        middleName: "text",
-        lastName: "text",
-        email: "text"
-      });
-    } catch (error) {
-      throw new Error("Failed to create text index on email.");
-    }
-  }
-  async function createUniqueIndex() {
+  async function createIndexes() {
     try {
-      await collection.createIndex(
-        { email: 1, deletedAt: 1 },
-        { unique: true }
-      );
+      await collection.createIndexes([
+        {
+          key: {
+            firstName: "text",
+            middleName: "text",
+            lastName: "text",
+            email: "text"
+          },
+          name: "search_index"
+        },
+        {
+          key: { email: 1, deletedAt: 1 },
+          unique: true
+        }
+      ]);
     } catch (error) {
-      throw new Error("Failed to create unique index on email.");
+      throw new Error("Failed to create user indexes.");
     }
   }
   async function createUser(value, session) {
@@ -500,8 +517,7 @@ function useUserRepo() {
     }
   }
   return {
-    createTextIndex,
-    createUniqueIndex,
+    createIndexes,
     createUser,
     getUserByEmail,
     getUserById,
@@ -1229,46 +1245,33 @@ function useMemberRepo() {
       });
     });
   }
-  async function createIndex() {
-    try {
-      await collection.createIndex([
-        {
-          name: 1
-        },
-        {
-          status: 1
-        }
-      ]);
-    } catch (error) {
-      throw new Error("Failed to create index.");
-    }
-  }
-  async function createUniqueIndex() {
+  async function createIndexes() {
     try {
-      await collection.createIndex(
+      await collection.createIndexes([
         {
-          org: 1,
-          user: 1,
-          type: 1
+          key: {
+            name: 1,
+            status: 1
+          }
         },
-        { partialFilterExpression: { deletedAt: "" }, unique: true }
-      );
-    } catch (error) {
-      throw new Error("Failed to create unique index.");
-    }
-  }
-  async function createTextIndex() {
-    try {
-      await collection.createIndex([
         {
-          name: "text"
+          key: {
+            org: 1,
+            user: 1,
+            type: 1
+          },
+          partialFilterExpression: { deletedAt: "" },
+          unique: true
         },
         {
-          orgName: "text"
+          key: {
+            name: "text",
+            orgName: "text"
+          },
+          name: "search_index"
         }
       ]);
     } catch (error) {
-      throw new Error("Failed to create text index.");
     }
   }
   async function add(value, session) {
@@ -1806,9 +1809,7 @@ function useMemberRepo() {
     }
   }
   return {
-    createIndex,
-    createUniqueIndex,
-    createTextIndex,
+    createIndexes,
     add,
     getById,
     getByOrg,
@@ -2223,21 +2224,22 @@ function useRoleRepo() {
       });
     });
   }
-  async function createIndex() {
-    try {
-      await collection.createIndex({ name: 1 });
-      await collection.createIndex({ type: 1 });
-      await collection.createIndex({ status: 1 });
-      await collection.createIndex({ id: 1 });
-    } catch (error) {
-      throw new import_nodejs_utils10.InternalServerError("Failed to create index on role.");
-    }
-  }
-  async function createTextIndex() {
+  async function createIndexes() {
     try {
-      await collection.createIndex({ name: "text" });
+      await collection.createIndexes([
+        {
+          key: {
+            name: "text"
+          },
+          name: "text_index"
+        },
+        {
+          key: { name: 1, type: 1, status: 1, id: 1 },
+          unique: true
+        }
+      ]);
     } catch (error) {
-      throw new import_nodejs_utils10.InternalServerError("Failed to create text index on role.");
+      throw new import_nodejs_utils10.InternalServerError("Failed to create role indexes.");
     }
   }
   async function createUniqueIndex() {
@@ -2520,8 +2522,7 @@ function useRoleRepo() {
     }
   }
   return {
-    createIndex,
-    createTextIndex,
+    createIndexes,
     createUniqueIndex,
     addRole,
     getRoles,
@@ -3737,136 +3738,2128 @@ function useOrgController() {
   };
 }
 
-// src/resources/role/role.controller.ts
-var import_joi8 = __toESM(require("joi"));
-var import_nodejs_utils20 = require("@eeplatform/nodejs-utils");
+// src/resources/app/app.model.ts
+var import_nodejs_utils18 = require("@eeplatform/nodejs-utils");
+var import_joi6 = __toESM(require("joi"));
+var schemaApp = import_joi6.default.object({
+  code: import_joi6.default.string().alphanum().max(20).required(),
+  name: import_joi6.default.string().max(255).required(),
+  description: import_joi6.default.string().max(1024).optional().allow("", null),
+  type: import_joi6.default.string().allow("default", "standard").optional().allow("", null)
+});
+var schemaAppUpdate = import_joi6.default.object({
+  code: import_joi6.default.string().alphanum().max(20).optional().allow("", null),
+  name: import_joi6.default.string().max(255).optional().allow("", null),
+  description: import_joi6.default.string().max(1024).optional().allow("", null)
+});
+function modelApp(value) {
+  const { error } = schemaApp.validate(value);
+  if (error) {
+    throw new import_nodejs_utils18.BadRequestError(error.message);
+  }
+  return {
+    _id: value._id,
+    code: value.code,
+    name: value.name,
+    description: value.description,
+    type: value.type ?? "standard",
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
 
-// src/resources/role/role.service.ts
+// src/resources/app/app.repository.ts
 var import_nodejs_utils19 = require("@eeplatform/nodejs-utils");
+var import_mongodb14 = require("mongodb");
 var import_joi7 = __toESM(require("joi"));
-
-// src/resources/member/member.controller.ts
-var import_joi6 = __toESM(require("joi"));
-var import_nodejs_utils18 = require("@eeplatform/nodejs-utils");
-function useMemberController() {
-  const {
-    getByUserId: _getByUserId,
-    getAll: _getAll,
-    getOrgsByMembership: _getOrgsByMembership,
-    updateStatusByUserId: _updateStatusByUserId,
-    getByUserType: _getByUserType
-  } = useMemberRepo();
-  async function getByUserId(req, res, next) {
-    const userId = req.params.id;
-    const validation = import_joi6.default.object({
-      id: import_joi6.default.string().hex().required()
-    });
-    const { error } = validation.validate({ id: userId });
-    if (error) {
-      next(new import_nodejs_utils18.BadRequestError(error.message));
-      return;
+function useAppRepo() {
+  const namespace_collection = "apps";
+  const repo = (0, import_nodejs_utils19.useRepo)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { code: 1 } },
+        { key: { status: 1 } },
+        {
+          key: { code: "text", name: "text", description: "text" },
+          name: "text_index"
+        },
+        {
+          key: { code: 1, status: 1 },
+          unique: true,
+          name: "unique_code",
+          partialFilterExpression: { status: { $in: ["active", "draft"] } }
+        },
+        {
+          key: { name: 1, status: 1 },
+          unique: true,
+          name: "unique_name",
+          partialFilterExpression: { status: { $in: ["active", "draft"] } }
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on apps.");
     }
+  }
+  async function add(value, session) {
     try {
-      const member = await _getByUserId(userId);
-      if (!member) {
-        res.status(404).json({ message: "Member not found." });
-        return;
+      value = modelApp(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils19.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils19.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils19.BadRequestError("App already exists.");
+        }
+        throw new Error("Failed to create app.");
       }
-      res.json(member);
-    } catch (error2) {
-      next(error2);
     }
   }
-  async function getByUserType(req, res, next) {
-    const validation = import_joi6.default.object({
-      org: import_joi6.default.string().hex().optional().allow("", null),
-      user: import_joi6.default.string().hex().required(),
-      type: import_joi6.default.string().required()
-    });
-    const { error } = validation.validate({ ...req.params, ...req.query });
-    if (error) {
-      next(new import_nodejs_utils18.BadRequestError(error.message));
-      return;
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb14.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils19.BadRequestError("Invalid ID.");
     }
-    const orgId = req.query.org;
-    const userId = req.params.user;
-    const type = req.params.type;
     try {
-      const member = await _getByUserType(userId, type, orgId);
-      if (!member) {
-        res.status(404).json({ message: "Member not found." });
-        return;
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils19.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils19.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to update app.");
       }
-      res.json(member);
-    } catch (error2) {
-      next(error2);
     }
   }
-  async function getAll(req, res, next) {
-    const limit = Number(req.query.limit) ?? 10;
-    const search = req.query.search ?? "";
-    const page = Number(req.query.page) ?? 1;
-    const user = req.query.user ?? "";
-    const org = req.query.org ?? "";
-    const type = req.query.type ?? "main";
-    const status = req.query.status ?? "active";
-    const validation = import_joi6.default.object({
-      limit: import_joi6.default.number().min(10).max(300).required(),
-      search: import_joi6.default.string().optional().allow("", null),
-      page: import_joi6.default.number().required(),
-      user: import_joi6.default.string().hex().optional().allow("", null),
-      org: import_joi6.default.string().hex().optional().allow("", null),
-      type: import_joi6.default.string().required(),
-      status: import_joi6.default.string().required()
-    });
-    const { error } = validation.validate({
-      search,
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active",
+    type = "standard"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    const cacheParams = {
+      status,
       page,
-      user,
-      org,
-      type,
       limit,
-      status
-    });
-    if (error) {
-      next(new import_nodejs_utils18.BadRequestError(error.message));
-      return;
+      sort: JSON.stringify(sort)
+    };
+    if (search) {
+      query.$text = { $search: search };
+      cacheParams.search = search;
+    }
+    if (type) {
+      if (Array.isArray(type)) {
+        query.type = { $in: type };
+      } else {
+        query.type = type;
+      }
+      cacheParams.type = type;
     }
+    const cacheKey = (0, import_nodejs_utils19.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils19.logger.log({
+      level: "info",
+      message: `Cache key for getAll apps: ${cacheKey}`
+    });
     try {
-      const items = await _getAll({
-        search,
-        page,
-        user,
-        org,
-        type,
-        limit,
-        status
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils19.logger.log({
+          level: "info",
+          message: `Cache hit for getAll apps: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await repo.collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await repo.collection.countDocuments(query);
+      const data = (0, import_nodejs_utils19.paginate)(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils19.logger.log({
+          level: "info",
+          message: `Cache set for getAll apps: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils19.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll apps: ${err.message}`
+        });
       });
-      res.json(items);
-      return;
-    } catch (error2) {
-      next(error2);
+      return data;
+    } catch (error) {
+      import_nodejs_utils19.logger.log({ level: "error", message: `${error}` });
+      throw error;
     }
   }
-  async function getOrgsByMembership(req, res, next) {
-    const limit = Number(req.query.limit) ?? 10;
-    const search = req.query.search ?? "";
-    const page = Number(req.query.page) ?? 1;
-    const user = req.query.user ?? "";
-    const validation = import_joi6.default.object({
-      limit: import_joi6.default.number().min(10).max(50).required(),
-      search: import_joi6.default.string().optional().allow("", null),
-      page: import_joi6.default.number().required(),
-      user: import_joi6.default.string().hex().optional().allow("", null)
-    });
-    const { error } = validation.validate({
-      search,
-      page,
-      user,
-      limit
-    });
-    if (error) {
-      next(new import_nodejs_utils18.BadRequestError(error.message));
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb14.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils19.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils19.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils19.logger.log({
+          level: "info",
+          message: `Cache hit for getById app: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await repo.collection.findOne({
+        _id
+      });
+      repo.setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils19.logger.log({
+          level: "info",
+          message: `Cache set for app by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils19.logger.log({
+          level: "error",
+          message: `Failed to set cache for app by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils19.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils19.InternalServerError("Failed to get app.");
+      }
+    }
+  }
+  async function getByCode(code) {
+    const validate = import_joi7.default.string().required();
+    const { error } = validate.validate(code);
+    if (error) {
+      throw new import_nodejs_utils19.BadRequestError("Invalid code.");
+    }
+    const cacheKey = (0, import_nodejs_utils19.makeCacheKey)(namespace_collection, {
+      code,
+      tag: "byCode"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils19.logger.log({
+          level: "info",
+          message: `Cache hit for getByCode app: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await repo.collection.findOne({
+        code
+      });
+      repo.setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils19.logger.log({
+          level: "info",
+          message: `Cache set for app by code: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils19.logger.log({
+          level: "error",
+          message: `Failed to set cache for app by code: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof import_nodejs_utils19.AppError) {
+        throw error2;
+      } else {
+        throw new import_nodejs_utils19.InternalServerError("Failed to get app.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb14.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils19.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils19.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils19.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils19.InternalServerError("Failed to delete app.");
+      }
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getByCode,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/app/app.service.ts
+var import_nodejs_utils20 = require("@eeplatform/nodejs-utils");
+function useAppService() {
+  const {
+    updateById: _updateById,
+    getById: _getById,
+    deleteById: _deleteById,
+    getByCode: _getByCode,
+    add: _add
+  } = useAppRepo();
+  async function addDefaultApps() {
+    const apps = [
+      {
+        code: "admin",
+        name: "Admin",
+        description: "Administrative application.",
+        type: "default"
+      },
+      {
+        code: "basic-edu-ro",
+        name: "Basic Education Regional Office",
+        description: "Basic Education Regional Office application."
+      },
+      {
+        code: "basic-edu-sdo",
+        name: "Basic Education School Division Office",
+        description: "Basic Education School Division Office application."
+      },
+      {
+        code: "basic-edu-school",
+        name: "Basic Education School",
+        description: "Basic Education School application."
+      }
+    ];
+    const session = import_nodejs_utils20.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session?.startTransaction();
+      for (const app of apps) {
+        const existingApp = await _getByCode(app.code);
+        if (!existingApp) {
+          await _add(app, session);
+        }
+      }
+      await session.commitTransaction();
+      import_nodejs_utils20.logger.log({
+        level: "info",
+        message: "Default apps added successfully."
+      });
+      return;
+    } catch (error) {
+      await session.abortTransaction();
+      import_nodejs_utils20.logger.log({
+        level: "error",
+        message: `Failed to add default apps: ${error}`
+      });
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function deleteById(id) {
+    try {
+      await _deleteById(id);
+      return "App deleted successfully.";
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    addDefaultApps,
+    deleteById
+  };
+}
+
+// src/resources/app/app.controller.ts
+var import_nodejs_utils21 = require("@eeplatform/nodejs-utils");
+var import_joi8 = __toESM(require("joi"));
+function useAppController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    add: _add,
+    updateById: _updateById
+  } = useAppRepo();
+  const { deleteById: _deleteById } = useAppService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaApp.validate(value);
+    if (error) {
+      next(new import_nodejs_utils21.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _add(value);
+      res.json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const id = req.params.id ?? "";
+    const { error: errorId } = import_joi8.default.string().hex().required().validate(id);
+    if (errorId) {
+      next(new import_nodejs_utils21.BadRequestError(errorId.message));
+      return;
+    }
+    const value = req.body;
+    const { error } = schemaAppUpdate.validate(value);
+    if (error) {
+      next(new import_nodejs_utils21.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _updateById(req.params.id, value);
+      res.json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi8.default.object({
+      page: import_joi8.default.number().min(1).optional().allow("", null),
+      limit: import_joi8.default.number().min(1).optional().allow("", null),
+      search: import_joi8.default.string().optional().allow("", null),
+      status: import_joi8.default.string().optional().allow("", null),
+      type: import_joi8.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_nodejs_utils21.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const status = req.query.status ?? "active";
+    const search = req.query.search ?? "";
+    let type = req.query.type ? req.query.type.split(",") : "standard";
+    try {
+      const buildings = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        status,
+        search,
+        type
+      });
+      res.json(buildings);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi8.default.object({
+      id: import_joi8.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils21.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json({
+        message: "Successfully retrieved app.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi8.default.object({
+      id: import_joi8.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils21.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    updateById,
+    getAll,
+    getById,
+    deleteById
+  };
+}
+
+// src/resources/permission/permission.model.ts
+var import_nodejs_utils22 = require("@eeplatform/nodejs-utils");
+var import_joi9 = __toESM(require("joi"));
+var schemaPermission = import_joi9.default.object({
+  app: import_joi9.default.string().required(),
+  key: import_joi9.default.string().required(),
+  name: import_joi9.default.string().required(),
+  group: import_joi9.default.string().required(),
+  description: import_joi9.default.string().required(),
+  deprecated: import_joi9.default.boolean().optional().allow(null)
+});
+var schemaPermissionUpdate = import_joi9.default.object({
+  key: import_joi9.default.string().optional().allow("", null),
+  name: import_joi9.default.string().optional().allow("", null),
+  group: import_joi9.default.string().optional().allow("", null),
+  description: import_joi9.default.string().max(1024).optional().allow("", null)
+});
+function modelPermission(value) {
+  const { error } = schemaPermission.validate(value);
+  if (error) {
+    throw new import_nodejs_utils22.BadRequestError(error.message);
+  }
+  return {
+    _id: value._id,
+    app: value.app,
+    key: value.key,
+    name: value.name,
+    group: value.group,
+    description: value.description,
+    deprecated: value.deprecated ?? false,
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
+
+// src/resources/permission/permission.repository.ts
+var import_nodejs_utils23 = require("@eeplatform/nodejs-utils");
+var import_mongodb15 = require("mongodb");
+var import_joi10 = __toESM(require("joi"));
+function usePermissionRepo() {
+  const namespace_collection = "permissions";
+  const repo = (0, import_nodejs_utils23.useRepo)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { app: 1 } },
+        { key: { name: 1 } },
+        { key: { key: 1 } },
+        { key: { group: 1 } },
+        {
+          key: {
+            app: "text",
+            name: "text",
+            key: "text",
+            description: "text",
+            group: "text"
+          },
+          name: "text_index"
+        },
+        {
+          key: { app: 1, name: 1, key: 1, group: 1 },
+          unique: true,
+          name: "unique_permission"
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on permissions.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelPermission(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils23.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils23.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils23.BadRequestError("Permission already exists.");
+        }
+        throw new Error("Failed to create permission.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb15.ObjectId(_id);
+    } catch (error2) {
+      throw new import_nodejs_utils23.BadRequestError("Invalid ID.");
+    }
+    const { error } = schemaPermissionUpdate.validate(value);
+    if (error) {
+      throw new import_nodejs_utils23.BadRequestError(`Invalid data: ${error.message}`);
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error2) {
+      import_nodejs_utils23.logger.log({
+        level: "error",
+        message: error2.message
+      });
+      if (error2 instanceof import_nodejs_utils23.AppError) {
+        throw error2;
+      } else {
+        throw new Error("Failed to update permission.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    app = "",
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {};
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    query.status = status;
+    cacheParams.status = status;
+    if (search) {
+      query.$text = { $search: search };
+      cacheParams.search = search;
+    }
+    if (app) {
+      query.app = app;
+      cacheParams.app = app;
+    }
+    const cacheKey = (0, import_nodejs_utils23.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils23.logger.log({
+      level: "info",
+      message: `Cache key for getAll permissions: ${cacheKey}`
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils23.logger.log({
+          level: "info",
+          message: `Cache hit for getAll permissions: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await repo.collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await repo.collection.countDocuments(query);
+      const data = (0, import_nodejs_utils23.paginate)(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils23.logger.log({
+          level: "info",
+          message: `Cache set for getAll permissions: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils23.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll permissions: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils23.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb15.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils23.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils23.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils23.logger.log({
+          level: "info",
+          message: `Cache hit for getById permission: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await repo.collection.findOne({
+        _id
+      });
+      repo.setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils23.logger.log({
+          level: "info",
+          message: `Cache set for permission by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils23.logger.log({
+          level: "error",
+          message: `Failed to set cache for permission by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils23.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils23.InternalServerError("Failed to get permission.");
+      }
+    }
+  }
+  async function getByKey(key, group, app) {
+    const validation = import_joi10.default.object({
+      key: import_joi10.default.string().required(),
+      group: import_joi10.default.string().optional().allow("", null),
+      app: import_joi10.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({ key, group });
+    if (error) {
+      throw new import_nodejs_utils23.BadRequestError(`Invalid data: ${error.message}`);
+    }
+    const query = {};
+    const cacheKeyOptions = {};
+    query.key = key;
+    cacheKeyOptions.key = key;
+    if (group) {
+      query.group = group;
+      cacheKeyOptions.group = group;
+    }
+    if (app) {
+      query.app = app;
+      cacheKeyOptions.app = app;
+    }
+    const cacheKey = (0, import_nodejs_utils23.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils23.logger.log({
+          level: "info",
+          message: `Cache hit for getById permission: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await repo.collection.findOne(query);
+      repo.setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils23.logger.log({
+          level: "info",
+          message: `Cache set for permission by key: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils23.logger.log({
+          level: "error",
+          message: `Failed to set cache for permission by key: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof import_nodejs_utils23.AppError) {
+        throw error2;
+      } else {
+        throw new import_nodejs_utils23.InternalServerError("Failed to get permission.");
+      }
+    }
+  }
+  async function countByGroup(group) {
+    const cacheKey = (0, import_nodejs_utils23.makeCacheKey)(namespace_collection, {
+      group,
+      tag: "countByGroup"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils23.logger.log({
+          level: "info",
+          message: `Cache hit for getById permission: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await repo.collection.countDocuments({
+        group
+      });
+      repo.setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils23.logger.log({
+          level: "info",
+          message: `Cache set for permission count by group: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils23.logger.log({
+          level: "error",
+          message: `Failed to set cache for permission by group: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils23.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils23.InternalServerError("Failed to count permission by group.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb15.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils23.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils23.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils23.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils23.InternalServerError("Failed to delete permission.");
+      }
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getByKey,
+    updateById,
+    deleteById,
+    countByGroup
+  };
+}
+
+// src/resources/permission/permission.service.ts
+function usePermissionService() {
+  const {
+    updateById: _updateById,
+    getById: _getById,
+    deleteById: _deleteById
+  } = usePermissionRepo();
+  async function deleteById(id) {
+    try {
+      await _deleteById(id);
+      return "Permission deleted successfully.";
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    deleteById
+  };
+}
+
+// src/resources/permission/permission.controller.ts
+var import_nodejs_utils24 = require("@eeplatform/nodejs-utils");
+var import_joi11 = __toESM(require("joi"));
+function usePermissionController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    add: _add,
+    updateById: _updateById
+  } = usePermissionRepo();
+  const { deleteById: _deleteById } = usePermissionService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaPermission.validate(value);
+    if (error) {
+      next(new import_nodejs_utils24.BadRequestError(error.message));
+      import_nodejs_utils24.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _add(value);
+      res.json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi11.default.object({
+      page: import_joi11.default.number().min(1).optional().allow("", null),
+      limit: import_joi11.default.number().min(1).optional().allow("", null),
+      search: import_joi11.default.string().optional().allow("", null),
+      app: import_joi11.default.string().optional().allow("", null),
+      status: import_joi11.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_nodejs_utils24.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const app = req.query.app ?? "";
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "active";
+    try {
+      const buildings = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        app,
+        search,
+        status
+      });
+      res.json(buildings);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi11.default.object({
+      id: import_joi11.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils24.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json({
+        message: "Successfully retrieved permission.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi11.default.object({
+      id: import_joi11.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils24.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const id = req.params.id;
+    const { error: errorId } = import_joi11.default.string().hex().required().validate(id);
+    if (errorId) {
+      next(new import_nodejs_utils24.BadRequestError(errorId.message));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaPermissionUpdate.validate(payload);
+    if (error) {
+      next(new import_nodejs_utils24.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateById(id, payload);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    deleteById,
+    updateById
+  };
+}
+
+// src/resources/permission/permission.group.model.ts
+var import_nodejs_utils25 = require("@eeplatform/nodejs-utils");
+var import_joi12 = __toESM(require("joi"));
+var schemaPermissionGroup = import_joi12.default.object({
+  app: import_joi12.default.string().required(),
+  key: import_joi12.default.string().required(),
+  label: import_joi12.default.string().required(),
+  order: import_joi12.default.number().integer().optional().allow("", null)
+});
+var schemaPermissionGroupUpdate = import_joi12.default.object({
+  key: import_joi12.default.string().optional().allow("", null),
+  label: import_joi12.default.string().optional().allow("", null),
+  order: import_joi12.default.number().integer().optional().allow("", null)
+});
+function modelPermissionGroup(value) {
+  const { error } = schemaPermissionGroup.validate(value);
+  if (error) {
+    throw new import_nodejs_utils25.BadRequestError(error.message);
+  }
+  return {
+    _id: value._id,
+    app: value.app,
+    key: value.key,
+    label: value.label,
+    order: value.order ?? Date.now(),
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
+
+// src/resources/permission/permission.group.repository.ts
+var import_nodejs_utils26 = require("@eeplatform/nodejs-utils");
+var import_mongodb16 = require("mongodb");
+var import_joi13 = __toESM(require("joi"));
+function usePermissionGroupRepo() {
+  const namespace_collection = "permission.groups";
+  const repo = (0, import_nodejs_utils26.useRepo)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { app: 1 } },
+        { key: { key: 1 } },
+        { key: { label: 1 } },
+        {
+          key: { app: "text", key: "text", label: "text" },
+          name: "text_index"
+        },
+        {
+          key: { app: 1, key: 1, label: 1 },
+          unique: true,
+          name: "unique_permission_group"
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on permission groups.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelPermissionGroup(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils26.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils26.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils26.BadRequestError("Permission group already exists.");
+        }
+        throw new Error("Failed to create permission group.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb16.ObjectId(_id);
+    } catch (error2) {
+      throw new import_nodejs_utils26.BadRequestError("Invalid ID.");
+    }
+    const { error } = schemaPermissionGroupUpdate.validate(value);
+    if (error) {
+      throw new import_nodejs_utils26.BadRequestError(`Invalid data: ${error.message}`);
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error2) {
+      import_nodejs_utils26.logger.log({
+        level: "error",
+        message: error2.message
+      });
+      if (error2 instanceof import_nodejs_utils26.AppError) {
+        throw error2;
+      } else {
+        throw new Error("Failed to update permission group.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    app = "",
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {};
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    query.status = status;
+    cacheParams.status = status;
+    if (search) {
+      query.$text = { $search: search };
+      cacheParams.search = search;
+    }
+    if (app) {
+      query.app = app;
+      cacheParams.app = app;
+    }
+    const cacheKey = (0, import_nodejs_utils26.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils26.logger.log({
+      level: "info",
+      message: `Cache key for getAll permission groups: ${cacheKey}`
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils26.logger.log({
+          level: "info",
+          message: `Cache hit for getAll permission groups: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await repo.collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await repo.collection.countDocuments(query);
+      const data = (0, import_nodejs_utils26.paginate)(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils26.logger.log({
+          level: "info",
+          message: `Cache set for getAll permission groups: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils26.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll permission groups: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils26.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb16.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils26.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils26.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils26.logger.log({
+          level: "info",
+          message: `Cache hit for getById permission group: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await repo.collection.findOne({
+        _id
+      });
+      repo.setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils26.logger.log({
+          level: "info",
+          message: `Cache set for permission group by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils26.logger.log({
+          level: "error",
+          message: `Failed to set cache for permission group by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils26.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils26.InternalServerError("Failed to get permission group.");
+      }
+    }
+  }
+  async function getByKey(key, app) {
+    const validation = import_joi13.default.object({
+      key: import_joi13.default.string().required(),
+      app: import_joi13.default.string().optional().allow(null, "")
+    });
+    const { error } = validation.validate({ key, app });
+    if (error) {
+      throw new import_nodejs_utils26.BadRequestError("Invalid key.");
+    }
+    const query = { key };
+    const cacheKeyOptions = { key, tag: "byKey" };
+    if (app) {
+      query.app = app;
+      cacheKeyOptions.app = app;
+    }
+    const cacheKey = (0, import_nodejs_utils26.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils26.logger.log({
+          level: "info",
+          message: `Cache hit for getById permission group: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await repo.collection.findOne(query);
+      repo.setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils26.logger.log({
+          level: "info",
+          message: `Cache set for permission group by key: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils26.logger.log({
+          level: "error",
+          message: `Failed to set cache for permission group by key: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof import_nodejs_utils26.AppError) {
+        throw error2;
+      } else {
+        throw new import_nodejs_utils26.InternalServerError("Failed to get permission group.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb16.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils26.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils26.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils26.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils26.InternalServerError("Failed to delete permission group.");
+      }
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getByKey,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/permission/permission.group.service.ts
+var import_nodejs_utils27 = require("@eeplatform/nodejs-utils");
+function usePermissionGroupService() {
+  const {
+    updateById: _updateById,
+    getById: _getById,
+    deleteById: _deleteById,
+    getByKey: _getByKey,
+    add: _add
+  } = usePermissionGroupRepo();
+  const { getAll: getAllApps } = useAppRepo();
+  const {
+    countByGroup,
+    getByKey: getPermissionByKey,
+    add: addPermission
+  } = usePermissionRepo();
+  async function addDefaultModule() {
+    const session = import_nodejs_utils27.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session?.startTransaction();
+      const apps = await getAllApps({
+        limit: 20,
+        type: ["default", "standard"]
+      });
+      if (apps && apps.items && apps.items.length) {
+        const modules = [
+          {
+            key: "members",
+            label: "Members",
+            permissions: [
+              {
+                key: "members.view",
+                name: "View Members",
+                description: "Allow user to view members"
+              },
+              {
+                key: "members.view.details",
+                name: "View Member Details",
+                description: "Allow user to view member details"
+              },
+              {
+                key: "members.add",
+                name: "Add Members",
+                description: "Allow user to add new members"
+              },
+              {
+                key: "members.edit.details",
+                name: "Edit Member Details",
+                description: "Allow user to edit member details"
+              },
+              {
+                key: "members.delete",
+                name: "Delete Members",
+                description: "Allow user to delete members"
+              }
+            ]
+          },
+          {
+            key: "roles",
+            label: "Roles",
+            permissions: [
+              {
+                key: "roles.view",
+                name: "View Roles",
+                description: "Allow user to view roles"
+              },
+              {
+                key: "roles.view.details",
+                name: "View Role Details",
+                description: "Allow user to view role details"
+              },
+              {
+                key: "roles.add",
+                name: "Add Roles",
+                description: "Allow user to add new roles"
+              },
+              {
+                key: "roles.edit.details",
+                name: "Edit Role Details",
+                description: "Allow user to edit role details"
+              },
+              {
+                key: "roles.delete",
+                name: "Delete Roles",
+                description: "Allow user to delete roles"
+              }
+            ]
+          },
+          {
+            key: "invitations",
+            label: "Invitations",
+            permissions: [
+              {
+                key: "invitations.view",
+                name: "View Invitations",
+                description: "Allow user to view invitations"
+              },
+              {
+                key: "invitations.view.details",
+                name: "View Invitation Details",
+                description: "Allow user to view invitation details"
+              },
+              {
+                key: "invitations.send",
+                name: "Send Invitations",
+                description: "Allow user to send invitations"
+              },
+              {
+                key: "invitations.revoke",
+                name: "Revoke Invitations",
+                description: "Allow user to revoke invitations"
+              }
+            ]
+          }
+        ];
+        for (const app of apps.items) {
+          for (const module2 of modules) {
+            const existingGroup = await _getByKey(module2.key, app.code);
+            if (!existingGroup) {
+              await _add({
+                app: app.code,
+                key: module2.key,
+                label: module2.label
+              });
+              import_nodejs_utils27.logger.log({
+                level: "info",
+                message: `Default permission group added: ${app.code} - ${module2.key}`
+              });
+            }
+            for (const permission of module2.permissions) {
+              const existingPermission = await getPermissionByKey(
+                permission.key,
+                module2.key,
+                app.code
+              );
+              if (!existingPermission) {
+                await addPermission({
+                  app: app.code,
+                  group: module2.key,
+                  key: permission.key,
+                  name: permission.name,
+                  description: permission.description
+                });
+              }
+            }
+          }
+          if (app.code === "admin") {
+            const modules2 = [
+              {
+                key: "applications",
+                label: "Applications",
+                permissions: [
+                  {
+                    key: "applications.add",
+                    name: "Add Applications",
+                    description: "Allow user to add new applications"
+                  },
+                  {
+                    key: "applications.view",
+                    name: "View Applications",
+                    description: "Allow user to view applications"
+                  },
+                  {
+                    key: "applications.view.details",
+                    name: "View Application Details",
+                    description: "Allow user to view application details"
+                  },
+                  {
+                    key: "applications.edit",
+                    name: "Edit Applications",
+                    description: "Allow user to edit existing applications"
+                  },
+                  {
+                    key: "applications.update.details",
+                    name: "Update Application Details",
+                    description: "Allow user to update application details"
+                  },
+                  {
+                    key: "applications.delete",
+                    name: "Delete Applications",
+                    description: "Allow user to delete applications"
+                  }
+                ]
+              },
+              {
+                key: "deped-ro",
+                label: "Regional Offices",
+                permissions: [
+                  {
+                    key: "deped-ro.add",
+                    name: "Add Regional Office",
+                    description: "Allow user to add new regional office"
+                  },
+                  {
+                    key: "deped-ro.view",
+                    name: "View Regional Offices",
+                    description: "Allow user to view regional offices"
+                  },
+                  {
+                    key: "deped-ro.view.details",
+                    name: "View Regional Office Details",
+                    description: "Allow user to view regional office details"
+                  },
+                  {
+                    key: "deped-ro.update.details",
+                    name: "Update Regional Office Details",
+                    description: "Allow user to update regional office details"
+                  },
+                  {
+                    key: "deped-ro.delete",
+                    name: "Delete Regional Office",
+                    description: "Allow user to delete regional office"
+                  }
+                ]
+              },
+              {
+                key: "deped-sdo",
+                label: "School Division Offices",
+                permissions: [
+                  {
+                    key: "deped-sdo.add",
+                    name: "Add School Division Office",
+                    description: "Allow user to add new school division office"
+                  },
+                  {
+                    key: "deped-sdo.view",
+                    name: "View School Division Offices",
+                    description: "Allow user to view school division offices"
+                  },
+                  {
+                    key: "deped-sdo.view.details",
+                    name: "View School Division Office Details",
+                    description: "Allow user to view school division office details"
+                  },
+                  {
+                    key: "deped-sdo.update.details",
+                    name: "Update School Division Office Details",
+                    description: "Allow user to update school division office details"
+                  },
+                  {
+                    key: "deped-sdo.delete",
+                    name: "Delete School Division Office",
+                    description: "Allow user to delete school division office"
+                  }
+                ]
+              },
+              {
+                key: "deped-school",
+                label: "Schools",
+                permissions: [
+                  {
+                    key: "deped-school.add",
+                    name: "Add School",
+                    description: "Allow user to add new school"
+                  },
+                  {
+                    key: "deped-school.view",
+                    name: "View Schools",
+                    description: "Allow user to view schools"
+                  },
+                  {
+                    key: "deped-school.view.details",
+                    name: "View School Details",
+                    description: "Allow user to view school details"
+                  },
+                  {
+                    key: "deped-school.update.details",
+                    name: "Update School Details",
+                    description: "Allow user to update school details"
+                  },
+                  {
+                    key: "deped-school.delete",
+                    name: "Delete School",
+                    description: "Allow user to delete school"
+                  }
+                ]
+              },
+              {
+                key: "users",
+                label: "Users",
+                permissions: [
+                  {
+                    key: "users.add",
+                    name: "Add Users",
+                    description: "Allow user to add new users"
+                  },
+                  {
+                    key: "users.view",
+                    name: "View Users",
+                    description: "Allow user to view users"
+                  },
+                  {
+                    key: "users.view.details",
+                    name: "View User Details",
+                    description: "Allow user to view user details"
+                  },
+                  {
+                    key: "users.edit.status",
+                    name: "Edit User Status",
+                    description: "Allow user to edit user status"
+                  },
+                  {
+                    key: "users.delete",
+                    name: "Delete Users",
+                    description: "Allow user to delete users"
+                  }
+                ]
+              }
+            ];
+            for (const module2 of modules2) {
+              const existingGroup = await _getByKey(module2.key, app.code);
+              if (!existingGroup) {
+                await _add({
+                  app: app.code,
+                  key: module2.key,
+                  label: module2.label
+                });
+                import_nodejs_utils27.logger.log({
+                  level: "info",
+                  message: `Default permission group added: ${app.code} - ${module2.key}`
+                });
+              }
+              for (const permission of module2.permissions) {
+                const existingPermission = await getPermissionByKey(
+                  permission.key,
+                  module2.key
+                );
+                if (!existingPermission) {
+                  await addPermission({
+                    app: app.code,
+                    group: module2.key,
+                    key: permission.key,
+                    name: permission.name,
+                    description: permission.description
+                  });
+                }
+              }
+            }
+          }
+        }
+        await session.commitTransaction();
+      }
+      import_nodejs_utils27.logger.log({
+        level: "info",
+        message: "Default permission groups added successfully."
+      });
+      return;
+    } catch (error) {
+      console.log(error);
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function deleteById(id) {
+    const permission = await _getById(id);
+    if (!permission) {
+      throw new Error("Permission Group not found.");
+    }
+    const associatedPermissionsCount = await countByGroup(permission.key);
+    if (associatedPermissionsCount > 0) {
+      throw new import_nodejs_utils27.BadRequestError(
+        "Cannot delete Permission Group with associated Permissions."
+      );
+    }
+    try {
+      await _deleteById(id);
+      return "Permission deleted successfully.";
+    } catch (error) {
+      if (error instanceof import_nodejs_utils27.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils27.InternalServerError("Failed to delete Permission Group.");
+      }
+    }
+  }
+  return {
+    addDefaultModule,
+    deleteById
+  };
+}
+
+// src/resources/permission/permission.group.controller.ts
+var import_nodejs_utils28 = require("@eeplatform/nodejs-utils");
+var import_joi14 = __toESM(require("joi"));
+function usePermissionGroupController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    add: _add,
+    updateById: _updateById
+  } = usePermissionGroupRepo();
+  const { deleteById: _deleteById } = usePermissionGroupService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaPermissionGroup.validate(value);
+    if (error) {
+      next(new import_nodejs_utils28.BadRequestError(error.message));
+      import_nodejs_utils28.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _add(value);
+      res.json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi14.default.object({
+      page: import_joi14.default.number().min(1).optional().allow("", null),
+      limit: import_joi14.default.number().min(1).optional().allow("", null),
+      search: import_joi14.default.string().optional().allow("", null),
+      app: import_joi14.default.string().optional().allow("", null),
+      status: import_joi14.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_nodejs_utils28.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const app = req.query.app ?? "";
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "active";
+    try {
+      const buildings = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        app,
+        search,
+        status
+      });
+      res.json(buildings);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi14.default.object({
+      id: import_joi14.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils28.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json({
+        message: "Successfully retrieved permission group.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi14.default.object({
+      id: import_joi14.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils28.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const id = req.params.id;
+    const { error: errorId } = import_joi14.default.string().hex().required().validate(id);
+    if (errorId) {
+      next(new import_nodejs_utils28.BadRequestError(errorId.message));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaPermissionGroupUpdate.validate(payload);
+    if (error) {
+      next(new import_nodejs_utils28.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateById(id, payload);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    deleteById,
+    updateById
+  };
+}
+
+// src/resources/file/file.service.ts
+var import_nodejs_utils29 = require("@eeplatform/nodejs-utils");
+var import_node_cron = __toESM(require("node-cron"));
+var fs = __toESM(require("fs"));
+function useFileService() {
+  const {
+    createFile: _createFile,
+    deleteFileById,
+    getAllDraftedFiles
+  } = useFileRepo();
+  const s3 = new import_nodejs_utils29.useS3({
+    accessKeyId: SPACES_ACCESS_KEY,
+    secretAccessKey: SPACES_SECRET_KEY,
+    endpoint: SPACES_ENDPOINT,
+    region: SPACES_REGION,
+    bucket: SPACES_BUCKET,
+    forcePathStyle: true
+  });
+  async function createFile(value) {
+    const session = import_nodejs_utils29.useAtlas.getClient()?.startSession();
+    session?.startTransaction();
+    const file = {
+      name: value.originalname,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const id = await _createFile(file, session);
+      const fileBuffer = value.buffer || await fs.promises.readFile(value.path);
+      await s3.uploadObject({
+        key: id,
+        body: fileBuffer,
+        contentType: value.mimetype
+      });
+      await session?.commitTransaction();
+      if (value.path) {
+        try {
+          await fs.promises.unlink(value.path);
+        } catch (cleanupError) {
+          console.error(
+            `Failed to cleanup temporary file ${value.path}:`,
+            cleanupError
+          );
+        }
+      }
+      return id;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  async function deleteFile(id) {
+    const session = import_nodejs_utils29.useAtlas.getClient()?.startSession();
+    session?.startTransaction();
+    try {
+      await deleteFileById(id, session);
+      await s3.deleteObject(id);
+      await session?.commitTransaction();
+      return "File deleted successfully";
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  function deleteDraft() {
+    import_node_cron.default.schedule("0 0 * * *", async () => {
+      const files = await getAllDraftedFiles();
+      for (let index = 0; index < files.length; index++) {
+        const file = files[index];
+        try {
+          await deleteFile(file._id.toString());
+          await import_nodejs_utils29.logger.log({
+            level: "info",
+            message: "Successfully deleted draft files."
+          });
+        } catch (error) {
+          import_nodejs_utils29.logger.log({
+            level: "info",
+            message: "Successfully deleted draft files."
+          });
+          return;
+        }
+      }
+    });
+  }
+  return {
+    createFile,
+    deleteFile,
+    deleteDraft
+  };
+}
+
+// src/resources/file/file.controller.ts
+var import_nodejs_utils30 = require("@eeplatform/nodejs-utils");
+var import_joi15 = __toESM(require("joi"));
+function useFileController() {
+  const { createFile, deleteFile: _deleteFile } = useFileService();
+  async function upload(req, res, next) {
+    if (!req.file) {
+      res.status(400).send("File is required!");
+      return;
+    }
+    try {
+      const id = await createFile(req.file);
+      res.json({ message: "Successfully uploaded file", id });
+      return;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils30.AppError) {
+        next(error);
+      } else {
+        next(new import_nodejs_utils30.InternalServerError(error));
+      }
+    }
+  }
+  async function deleteFile(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi15.default.string().required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_nodejs_utils30.BadRequestError(error.message));
+    }
+    try {
+      const message = await _deleteFile(id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      if (error2 instanceof import_nodejs_utils30.AppError) {
+        next(error2);
+      } else {
+        next(new import_nodejs_utils30.InternalServerError(error2));
+      }
+    }
+  }
+  return {
+    upload,
+    deleteFile
+  };
+}
+
+// src/resources/role/role.controller.ts
+var import_joi18 = __toESM(require("joi"));
+var import_nodejs_utils33 = require("@eeplatform/nodejs-utils");
+
+// src/resources/role/role.service.ts
+var import_nodejs_utils32 = require("@eeplatform/nodejs-utils");
+var import_joi17 = __toESM(require("joi"));
+
+// src/resources/member/member.controller.ts
+var import_joi16 = __toESM(require("joi"));
+var import_nodejs_utils31 = require("@eeplatform/nodejs-utils");
+function useMemberController() {
+  const {
+    getByUserId: _getByUserId,
+    getAll: _getAll,
+    getOrgsByMembership: _getOrgsByMembership,
+    updateStatusByUserId: _updateStatusByUserId,
+    getByUserType: _getByUserType
+  } = useMemberRepo();
+  async function getByUserId(req, res, next) {
+    const userId = req.params.id;
+    const validation = import_joi16.default.object({
+      id: import_joi16.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id: userId });
+    if (error) {
+      next(new import_nodejs_utils31.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const member = await _getByUserId(userId);
+      if (!member) {
+        res.status(404).json({ message: "Member not found." });
+        return;
+      }
+      res.json(member);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByUserType(req, res, next) {
+    const validation = import_joi16.default.object({
+      org: import_joi16.default.string().hex().optional().allow("", null),
+      user: import_joi16.default.string().hex().required(),
+      type: import_joi16.default.string().required()
+    });
+    const { error } = validation.validate({ ...req.params, ...req.query });
+    if (error) {
+      next(new import_nodejs_utils31.BadRequestError(error.message));
+      return;
+    }
+    const orgId = req.query.org;
+    const userId = req.params.user;
+    const type = req.params.type;
+    try {
+      const member = await _getByUserType(userId, type, orgId);
+      if (!member) {
+        res.status(404).json({ message: "Member not found." });
+        return;
+      }
+      res.json(member);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const limit = Number(req.query.limit) ?? 10;
+    const search = req.query.search ?? "";
+    const page = Number(req.query.page) ?? 1;
+    const user = req.query.user ?? "";
+    const org = req.query.org ?? "";
+    const type = req.query.type ?? "main";
+    const status = req.query.status ?? "active";
+    const validation = import_joi16.default.object({
+      limit: import_joi16.default.number().min(10).max(300).required(),
+      search: import_joi16.default.string().optional().allow("", null),
+      page: import_joi16.default.number().required(),
+      user: import_joi16.default.string().hex().optional().allow("", null),
+      org: import_joi16.default.string().hex().optional().allow("", null),
+      type: import_joi16.default.string().required(),
+      status: import_joi16.default.string().required()
+    });
+    const { error } = validation.validate({
+      search,
+      page,
+      user,
+      org,
+      type,
+      limit,
+      status
+    });
+    if (error) {
+      next(new import_nodejs_utils31.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const items = await _getAll({
+        search,
+        page,
+        user,
+        org,
+        type,
+        limit,
+        status
+      });
+      res.json(items);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getOrgsByMembership(req, res, next) {
+    const limit = Number(req.query.limit) ?? 10;
+    const search = req.query.search ?? "";
+    const page = Number(req.query.page) ?? 1;
+    const user = req.query.user ?? "";
+    const validation = import_joi16.default.object({
+      limit: import_joi16.default.number().min(10).max(50).required(),
+      search: import_joi16.default.string().optional().allow("", null),
+      page: import_joi16.default.number().required(),
+      user: import_joi16.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate({
+      search,
+      page,
+      user,
+      limit
+    });
+    if (error) {
+      next(new import_nodejs_utils31.BadRequestError(error.message));
     }
     try {
       const items = await _getOrgsByMembership({
@@ -3882,13 +5875,13 @@ function useMemberController() {
     }
   }
   async function updateStatusByUserId(req, res, next) {
-    const validation = import_joi6.default.object({
-      id: import_joi6.default.string().hex().required(),
-      status: import_joi6.default.string().valid("active", "suspended", "deleted").required()
+    const validation = import_joi16.default.object({
+      id: import_joi16.default.string().hex().required(),
+      status: import_joi16.default.string().valid("active", "suspended", "deleted").required()
     });
     const { error } = validation.validate(req.params);
     if (error) {
-      next(new import_nodejs_utils18.BadRequestError(error.message));
+      next(new import_nodejs_utils31.BadRequestError(error.message));
       return;
     }
     const id = req.params.id;
@@ -3914,26 +5907,26 @@ function useRoleService() {
   const { getByOrg } = useMemberRepo();
   const { deleteRole, getRoleById } = useRoleRepo();
   async function deleteById(_id) {
-    const { error } = import_joi7.default.string().hex().length(24).validate(_id);
+    const { error } = import_joi17.default.string().hex().length(24).validate(_id);
     if (error) {
-      throw new import_nodejs_utils19.BadRequestError("Invalid Role ID");
+      throw new import_nodejs_utils32.BadRequestError("Invalid Role ID");
     }
     try {
       const role = await getRoleById(_id);
       if (!role) {
-        throw new import_nodejs_utils19.BadRequestError("Role not found");
+        throw new import_nodejs_utils32.BadRequestError("Role not found");
       }
       const org = await getByOrg(String(role.id));
       if (org) {
-        throw new import_nodejs_utils19.BadRequestError("Cannot delete role assigned to members");
+        throw new import_nodejs_utils32.BadRequestError("Cannot delete role assigned to members");
       }
       await deleteRole(_id);
       return "Role deleted successfully";
     } catch (error2) {
-      if (error2 instanceof import_nodejs_utils19.AppError) {
+      if (error2 instanceof import_nodejs_utils32.AppError) {
         throw error2;
       }
-      throw new import_nodejs_utils19.InternalServerError("Failed to delete role");
+      throw new import_nodejs_utils32.InternalServerError("Failed to delete role");
     }
   }
   return {
@@ -3953,15 +5946,15 @@ function useRoleController() {
   } = useRoleRepo();
   async function createRole(req, res, next) {
     const payload = req.body;
-    const validation = import_joi8.default.object({
-      name: import_joi8.default.string().required(),
-      permissions: import_joi8.default.array().items(import_joi8.default.string()).required(),
-      type: import_joi8.default.string().valid("school", "division", "region", "account").required(),
-      id: import_joi8.default.string().hex().optional().allow("", null)
+    const validation = import_joi18.default.object({
+      name: import_joi18.default.string().required(),
+      permissions: import_joi18.default.array().items(import_joi18.default.string()).required(),
+      type: import_joi18.default.string().valid("school", "division", "region", "account").required(),
+      id: import_joi18.default.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate(payload);
     if (error) {
-      next(new import_nodejs_utils20.BadRequestError(error.message));
+      next(new import_nodejs_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -3978,16 +5971,16 @@ function useRoleController() {
     const limit = parseInt(req.query.limit ?? "10");
     const type = req.query.type ?? "";
     const id = req.query.id ?? "";
-    const validation = import_joi8.default.object({
-      search: import_joi8.default.string().optional().allow("", null),
-      page: import_joi8.default.number().required(),
-      limit: import_joi8.default.number().required(),
-      type: import_joi8.default.string().optional().allow("", null),
-      id: import_joi8.default.string().hex().optional().allow("", null)
+    const validation = import_joi18.default.object({
+      search: import_joi18.default.string().optional().allow("", null),
+      page: import_joi18.default.number().required(),
+      limit: import_joi18.default.number().required(),
+      type: import_joi18.default.string().optional().allow("", null),
+      id: import_joi18.default.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate({ search, page, limit, type, id });
     if (error) {
-      next(new import_nodejs_utils20.BadRequestError(error.message));
+      next(new import_nodejs_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -4000,12 +5993,12 @@ function useRoleController() {
   }
   async function getRoleByUserId(req, res, next) {
     const userId = req.params.userId;
-    const validation = import_joi8.default.object({
-      userId: import_joi8.default.string().required()
+    const validation = import_joi18.default.object({
+      userId: import_joi18.default.string().required()
     });
     const { error } = validation.validate({ userId });
     if (error) {
-      next(new import_nodejs_utils20.BadRequestError(error.message));
+      next(new import_nodejs_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -4018,12 +6011,12 @@ function useRoleController() {
   }
   async function getRoleById(req, res, next) {
     const _id = req.params.id;
-    const validation = import_joi8.default.object({
-      _id: import_joi8.default.string().hex().required()
+    const validation = import_joi18.default.object({
+      _id: import_joi18.default.string().hex().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new import_nodejs_utils20.BadRequestError(error.message));
+      next(new import_nodejs_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -4038,14 +6031,14 @@ function useRoleController() {
     const _id = req.params.id;
     const name = req.body.name ?? "";
     const permissions = req.body.permissions ?? [];
-    const validation = import_joi8.default.object({
-      _id: import_joi8.default.string().required(),
-      name: import_joi8.default.string().required(),
-      permissions: import_joi8.default.array().items(import_joi8.default.string()).required()
+    const validation = import_joi18.default.object({
+      _id: import_joi18.default.string().required(),
+      name: import_joi18.default.string().required(),
+      permissions: import_joi18.default.array().items(import_joi18.default.string()).required()
     });
     const { error } = validation.validate({ _id, name, permissions });
     if (error) {
-      next(new import_nodejs_utils20.BadRequestError(error.message));
+      next(new import_nodejs_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -4059,13 +6052,13 @@ function useRoleController() {
   async function updatePermissionsById(req, res, next) {
     const _id = req.params.id;
     const permissions = req.body.permissions ?? [];
-    const validation = import_joi8.default.object({
-      _id: import_joi8.default.string().required(),
-      permissions: import_joi8.default.array().items(import_joi8.default.string()).required()
+    const validation = import_joi18.default.object({
+      _id: import_joi18.default.string().required(),
+      permissions: import_joi18.default.array().items(import_joi18.default.string()).required()
     });
     const { error } = validation.validate({ _id, permissions });
     if (error) {
-      next(new import_nodejs_utils20.BadRequestError(error.message));
+      next(new import_nodejs_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -4079,12 +6072,12 @@ function useRoleController() {
   const { deleteById } = useRoleService();
   async function deleteRole(req, res, next) {
     const _id = req.params.id;
-    const validation = import_joi8.default.object({
-      _id: import_joi8.default.string().required()
+    const validation = import_joi18.default.object({
+      _id: import_joi18.default.string().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new import_nodejs_utils20.BadRequestError(error.message));
+      next(new import_nodejs_utils33.BadRequestError(error.message));
       return;
     }
     try {
@@ -4106,151 +6099,9 @@ function useRoleController() {
   };
 }
 
-// src/resources/file/file.service.ts
-var import_nodejs_utils21 = require("@eeplatform/nodejs-utils");
-var import_node_cron = __toESM(require("node-cron"));
-var fs = __toESM(require("fs"));
-function useFileService() {
-  const {
-    createFile: _createFile,
-    deleteFileById,
-    getAllDraftedFiles
-  } = useFileRepo();
-  const s3 = new import_nodejs_utils21.useS3({
-    accessKeyId: SPACES_ACCESS_KEY,
-    secretAccessKey: SPACES_SECRET_KEY,
-    endpoint: SPACES_ENDPOINT,
-    region: SPACES_REGION,
-    bucket: SPACES_BUCKET,
-    forcePathStyle: true
-  });
-  async function createFile(value) {
-    const session = import_nodejs_utils21.useAtlas.getClient()?.startSession();
-    session?.startTransaction();
-    const file = {
-      name: value.originalname,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    try {
-      const id = await _createFile(file, session);
-      const fileBuffer = value.buffer || await fs.promises.readFile(value.path);
-      await s3.uploadObject({
-        key: id,
-        body: fileBuffer,
-        contentType: value.mimetype
-      });
-      await session?.commitTransaction();
-      if (value.path) {
-        try {
-          await fs.promises.unlink(value.path);
-        } catch (cleanupError) {
-          console.error(
-            `Failed to cleanup temporary file ${value.path}:`,
-            cleanupError
-          );
-        }
-      }
-      return id;
-    } catch (error) {
-      await session?.abortTransaction();
-      throw error;
-    } finally {
-      session?.endSession();
-    }
-  }
-  async function deleteFile(id) {
-    const session = import_nodejs_utils21.useAtlas.getClient()?.startSession();
-    session?.startTransaction();
-    try {
-      await deleteFileById(id, session);
-      await s3.deleteObject(id);
-      await session?.commitTransaction();
-      return "File deleted successfully";
-    } catch (error) {
-      await session?.abortTransaction();
-      throw error;
-    } finally {
-      session?.endSession();
-    }
-  }
-  function deleteDraft() {
-    import_node_cron.default.schedule("0 0 * * *", async () => {
-      const files = await getAllDraftedFiles();
-      for (let index = 0; index < files.length; index++) {
-        const file = files[index];
-        try {
-          await deleteFile(file._id.toString());
-          await import_nodejs_utils21.logger.log({
-            level: "info",
-            message: "Successfully deleted draft files."
-          });
-        } catch (error) {
-          import_nodejs_utils21.logger.log({
-            level: "info",
-            message: "Successfully deleted draft files."
-          });
-          return;
-        }
-      }
-    });
-  }
-  return {
-    createFile,
-    deleteFile,
-    deleteDraft
-  };
-}
-
-// src/resources/file/file.controller.ts
-var import_nodejs_utils22 = require("@eeplatform/nodejs-utils");
-var import_joi9 = __toESM(require("joi"));
-function useFileController() {
-  const { createFile, deleteFile: _deleteFile } = useFileService();
-  async function upload(req, res, next) {
-    if (!req.file) {
-      res.status(400).send("File is required!");
-      return;
-    }
-    try {
-      const id = await createFile(req.file);
-      res.json({ message: "Successfully uploaded file", id });
-      return;
-    } catch (error) {
-      if (error instanceof import_nodejs_utils22.AppError) {
-        next(error);
-      } else {
-        next(new import_nodejs_utils22.InternalServerError(error));
-      }
-    }
-  }
-  async function deleteFile(req, res, next) {
-    const id = req.params.id;
-    const validation = import_joi9.default.string().required();
-    const { error } = validation.validate(id);
-    if (error) {
-      next(new import_nodejs_utils22.BadRequestError(error.message));
-    }
-    try {
-      const message = await _deleteFile(id);
-      res.json({ message });
-      return;
-    } catch (error2) {
-      if (error2 instanceof import_nodejs_utils22.AppError) {
-        next(error2);
-      } else {
-        next(new import_nodejs_utils22.InternalServerError(error2));
-      }
-    }
-  }
-  return {
-    upload,
-    deleteFile
-  };
-}
-
 // src/resources/verification/verification.controller.ts
-var import_nodejs_utils23 = require("@eeplatform/nodejs-utils");
-var import_joi10 = __toESM(require("joi"));
+var import_nodejs_utils34 = require("@eeplatform/nodejs-utils");
+var import_joi19 = __toESM(require("joi"));
 function useVerificationController() {
   const {
     createUserInvite: _createUserInvite,
@@ -4260,17 +6111,17 @@ function useVerificationController() {
   } = useVerificationService();
   const { getVerifications: _getVerifications } = useVerificationRepo();
   async function createUserInvite(req, res, next) {
-    const validation = import_joi10.default.object({
-      email: import_joi10.default.string().email().required(),
-      app: import_joi10.default.string().required(),
-      role: import_joi10.default.string().hex().required(),
-      roleName: import_joi10.default.string().required(),
-      org: import_joi10.default.string().hex().optional().optional().allow("", null),
-      orgName: import_joi10.default.string().optional().optional().allow("", null)
+    const validation = import_joi19.default.object({
+      email: import_joi19.default.string().email().required(),
+      app: import_joi19.default.string().required(),
+      role: import_joi19.default.string().hex().required(),
+      roleName: import_joi19.default.string().required(),
+      org: import_joi19.default.string().hex().optional().optional().allow("", null),
+      orgName: import_joi19.default.string().optional().optional().allow("", null)
     });
     const { error } = validation.validate(req.body);
     if (error) {
-      next(new import_nodejs_utils23.BadRequestError(error.message));
+      next(new import_nodejs_utils34.BadRequestError(error.message));
       return;
     }
     const email = req.body.email ?? "";
@@ -4298,10 +6149,10 @@ function useVerificationController() {
   }
   async function createForgetPassword(req, res, next) {
     const email = req.body.email || "";
-    const validation = import_joi10.default.string().email().required();
+    const validation = import_joi19.default.string().email().required();
     const { error } = validation.validate(email);
     if (error) {
-      next(new import_nodejs_utils23.BadRequestError(error.message));
+      next(new import_nodejs_utils34.BadRequestError(error.message));
       return;
     }
     try {
@@ -4311,25 +6162,25 @@ function useVerificationController() {
       });
       return;
     } catch (error2) {
-      if (error2 instanceof import_nodejs_utils23.AppError) {
+      if (error2 instanceof import_nodejs_utils34.AppError) {
         next(error2);
       } else {
-        next(new import_nodejs_utils23.InternalServerError("An unexpected error occurred"));
+        next(new import_nodejs_utils34.InternalServerError("An unexpected error occurred"));
       }
     }
   }
   async function getVerifications(req, res, next) {
-    const validation = import_joi10.default.object({
-      status: import_joi10.default.string().required(),
-      search: import_joi10.default.string().optional().allow("", null),
-      page: import_joi10.default.number().required(),
-      type: import_joi10.default.string().optional().allow("", null),
-      email: import_joi10.default.string().optional().allow("", null),
-      app: import_joi10.default.string().optional().allow("", null)
+    const validation = import_joi19.default.object({
+      status: import_joi19.default.string().required(),
+      search: import_joi19.default.string().optional().allow("", null),
+      page: import_joi19.default.number().required(),
+      type: import_joi19.default.string().optional().allow("", null),
+      email: import_joi19.default.string().optional().allow("", null),
+      app: import_joi19.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(req.query);
     if (error) {
-      next(new import_nodejs_utils23.BadRequestError(error.message));
+      next(new import_nodejs_utils34.BadRequestError(error.message));
       return;
     }
     const status = req.query.status ?? "";
@@ -4360,10 +6211,10 @@ function useVerificationController() {
   }
   async function verify(req, res, next) {
     const id = req.params.id || "";
-    const validation = import_joi10.default.string().hex().required();
+    const validation = import_joi19.default.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_nodejs_utils23.BadRequestError(error.message));
+      next(new import_nodejs_utils34.BadRequestError(error.message));
       return;
     }
     try {
@@ -4376,10 +6227,10 @@ function useVerificationController() {
   }
   async function cancelUserInvitation(req, res, next) {
     const otpId = req.params.id || "";
-    const validation = import_joi10.default.string().hex().required();
+    const validation = import_joi19.default.string().hex().required();
     const { error } = validation.validate(otpId);
     if (error) {
-      next(new import_nodejs_utils23.BadRequestError(error.message));
+      next(new import_nodejs_utils34.BadRequestError(error.message));
       return;
     }
     try {
@@ -4401,34 +6252,34 @@ function useVerificationController() {
 }
 
 // src/resources/address/address.model.ts
-var import_nodejs_utils24 = require("@eeplatform/nodejs-utils");
-var import_joi11 = __toESM(require("joi"));
-var import_mongodb14 = require("mongodb");
-var addressSchema = import_joi11.default.object({
-  type: import_joi11.default.string().required(),
-  user: import_joi11.default.string().hex().optional().allow("", null),
-  org: import_joi11.default.string().hex().optional().allow("", null),
-  country: import_joi11.default.string().required(),
-  address: import_joi11.default.string().required(),
-  continuedAddress: import_joi11.default.string().optional().allow("", null),
-  city: import_joi11.default.string().required(),
-  province: import_joi11.default.string().required(),
-  postalCode: import_joi11.default.string().required(),
-  taxId: import_joi11.default.string().optional().allow("", null)
+var import_nodejs_utils35 = require("@eeplatform/nodejs-utils");
+var import_joi20 = __toESM(require("joi"));
+var import_mongodb17 = require("mongodb");
+var addressSchema = import_joi20.default.object({
+  type: import_joi20.default.string().required(),
+  user: import_joi20.default.string().hex().optional().allow("", null),
+  org: import_joi20.default.string().hex().optional().allow("", null),
+  country: import_joi20.default.string().required(),
+  address: import_joi20.default.string().required(),
+  continuedAddress: import_joi20.default.string().optional().allow("", null),
+  city: import_joi20.default.string().required(),
+  province: import_joi20.default.string().required(),
+  postalCode: import_joi20.default.string().required(),
+  taxId: import_joi20.default.string().optional().allow("", null)
 });
 function MAddress(value) {
   if (value.user) {
     try {
-      value.user = new import_mongodb14.ObjectId(value.user);
+      value.user = new import_mongodb17.ObjectId(value.user);
     } catch (error) {
-      throw new import_nodejs_utils24.BadRequestError("Invalid user ID.");
+      throw new import_nodejs_utils35.BadRequestError("Invalid user ID.");
     }
   }
   if (value.org) {
     try {
-      value.org = new import_mongodb14.ObjectId(value.org);
+      value.org = new import_mongodb17.ObjectId(value.org);
     } catch (error) {
-      throw new import_nodejs_utils24.BadRequestError("Invalid org ID.");
+      throw new import_nodejs_utils35.BadRequestError("Invalid org ID.");
     }
   }
   return {
@@ -4446,24 +6297,24 @@ function MAddress(value) {
 }
 
 // src/resources/address/address.repository.ts
-var import_nodejs_utils25 = require("@eeplatform/nodejs-utils");
-var import_mongodb15 = require("mongodb");
+var import_nodejs_utils36 = require("@eeplatform/nodejs-utils");
+var import_mongodb18 = require("mongodb");
 function useAddressRepo() {
-  const db = import_nodejs_utils25.useAtlas.getDb();
+  const db = import_nodejs_utils36.useAtlas.getDb();
   if (!db) {
-    throw new import_nodejs_utils25.BadRequestError("Unable to connect to server.");
+    throw new import_nodejs_utils36.BadRequestError("Unable to connect to server.");
   }
   const namespace_collection = "addresses";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils25.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils36.useCache)(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      import_nodejs_utils25.logger.log({
+      import_nodejs_utils36.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_nodejs_utils25.logger.log({
+      import_nodejs_utils36.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -4477,7 +6328,7 @@ function useAddressRepo() {
         { key: { orgId: 1 } }
       ]);
     } catch (error) {
-      throw new import_nodejs_utils25.BadRequestError("Failed to create index on address.");
+      throw new import_nodejs_utils36.BadRequestError("Failed to create index on address.");
     }
   }
   async function add(value, session) {
@@ -4487,20 +6338,20 @@ function useAddressRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      throw new import_nodejs_utils25.BadRequestError("Failed to create address.");
+      throw new import_nodejs_utils36.BadRequestError("Failed to create address.");
     }
   }
   async function updateById(_id, value, session) {
     try {
-      _id = new import_mongodb15.ObjectId(_id);
+      _id = new import_mongodb18.ObjectId(_id);
     } catch (error) {
-      throw new import_nodejs_utils25.BadRequestError("Invalid address ID.");
+      throw new import_nodejs_utils36.BadRequestError("Invalid address ID.");
     }
     if (value.org) {
       try {
-        value.org = new import_mongodb15.ObjectId(value.org);
+        value.org = new import_mongodb18.ObjectId(value.org);
       } catch (error) {
-        throw new import_nodejs_utils25.BadRequestError("Invalid org ID.");
+        throw new import_nodejs_utils36.BadRequestError("Invalid org ID.");
       }
     }
     try {
@@ -4512,20 +6363,20 @@ function useAddressRepo() {
       delCachedData();
       return "Successfully updated address.";
     } catch (error) {
-      throw new import_nodejs_utils25.BadRequestError("Failed to update address.");
+      throw new import_nodejs_utils36.BadRequestError("Failed to update address.");
     }
   }
   async function getByUserId(user) {
     try {
-      user = new import_mongodb15.ObjectId(user);
+      user = new import_mongodb18.ObjectId(user);
     } catch (error) {
-      throw new import_nodejs_utils25.BadRequestError("Invalid user ID.");
+      throw new import_nodejs_utils36.BadRequestError("Invalid user ID.");
     }
-    const cacheKey = (0, import_nodejs_utils25.makeCacheKey)(namespace_collection, { user: String(user) });
+    const cacheKey = (0, import_nodejs_utils36.makeCacheKey)(namespace_collection, { user: String(user) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_nodejs_utils25.logger.log({
+        import_nodejs_utils36.logger.log({
           level: "info",
           message: `Cache hit for getByUserId address: ${cacheKey}`
         });
@@ -4534,12 +6385,12 @@ function useAddressRepo() {
       const data = await collection.findOne({ user });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          import_nodejs_utils25.logger.log({
+          import_nodejs_utils36.logger.log({
             level: "info",
             message: `Cache set for address by user ID: ${cacheKey}`
           });
         }).catch((err) => {
-          import_nodejs_utils25.logger.log({
+          import_nodejs_utils36.logger.log({
             level: "error",
             message: `Failed to set cache for address by user ID: ${err.message}`
           });
@@ -4547,20 +6398,20 @@ function useAddressRepo() {
       }
       return data;
     } catch (error) {
-      throw new import_nodejs_utils25.BadRequestError("Failed to get address by ID.");
+      throw new import_nodejs_utils36.BadRequestError("Failed to get address by ID.");
     }
   }
   async function getByOrgId(org) {
     try {
-      org = new import_mongodb15.ObjectId(org);
+      org = new import_mongodb18.ObjectId(org);
     } catch (error) {
-      throw new import_nodejs_utils25.BadRequestError("Invalid orgId.");
+      throw new import_nodejs_utils36.BadRequestError("Invalid orgId.");
     }
-    const cacheKey = (0, import_nodejs_utils25.makeCacheKey)(namespace_collection, { org: String(org) });
+    const cacheKey = (0, import_nodejs_utils36.makeCacheKey)(namespace_collection, { org: String(org) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_nodejs_utils25.logger.log({
+        import_nodejs_utils36.logger.log({
           level: "info",
           message: `Cache hit for getByOrgId address: ${cacheKey}`
         });
@@ -4569,12 +6420,12 @@ function useAddressRepo() {
       const data = await collection.findOne({ org });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          import_nodejs_utils25.logger.log({
+          import_nodejs_utils36.logger.log({
             level: "info",
             message: `Cache set for address by org ID: ${cacheKey}`
           });
         }).catch((err) => {
-          import_nodejs_utils25.logger.log({
+          import_nodejs_utils36.logger.log({
             level: "error",
             message: `Failed to set cache for address by org ID: ${err.message}`
           });
@@ -4582,7 +6433,7 @@ function useAddressRepo() {
       }
       return data;
     } catch (error) {
-      throw new import_nodejs_utils25.BadRequestError("Failed to get address by orgId.");
+      throw new import_nodejs_utils36.BadRequestError("Failed to get address by orgId.");
     }
   }
   return {
@@ -4595,8 +6446,8 @@ function useAddressRepo() {
 }
 
 // src/resources/address/address.controller.ts
-var import_nodejs_utils26 = require("@eeplatform/nodejs-utils");
-var import_joi12 = __toESM(require("joi"));
+var import_nodejs_utils37 = require("@eeplatform/nodejs-utils");
+var import_joi21 = __toESM(require("joi"));
 function useAddressController() {
   const {
     add: _add,
@@ -4606,21 +6457,21 @@ function useAddressController() {
   } = useAddressRepo();
   async function add(req, res, next) {
     const value = req.body;
-    const validation = import_joi12.default.object({
-      type: import_joi12.default.string().required(),
-      user: import_joi12.default.string().hex().optional().allow("", null),
-      org: import_joi12.default.string().hex().optional().allow("", null),
-      country: import_joi12.default.string().required(),
-      address: import_joi12.default.string().required(),
-      continuedAddress: import_joi12.default.string().optional().allow("", null),
-      city: import_joi12.default.string().required(),
-      province: import_joi12.default.string().required(),
-      postalCode: import_joi12.default.string().required(),
-      taxId: import_joi12.default.string().optional().allow("", null)
+    const validation = import_joi21.default.object({
+      type: import_joi21.default.string().required(),
+      user: import_joi21.default.string().hex().optional().allow("", null),
+      org: import_joi21.default.string().hex().optional().allow("", null),
+      country: import_joi21.default.string().required(),
+      address: import_joi21.default.string().required(),
+      continuedAddress: import_joi21.default.string().optional().allow("", null),
+      city: import_joi21.default.string().required(),
+      province: import_joi21.default.string().required(),
+      postalCode: import_joi21.default.string().required(),
+      taxId: import_joi21.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_nodejs_utils26.BadRequestError(error.message));
+      next(new import_nodejs_utils37.BadRequestError(error.message));
     }
     try {
       const value2 = req.body;
@@ -4634,20 +6485,20 @@ function useAddressController() {
   async function updateById(req, res, next) {
     const id = req.params.id ?? "";
     const value = req.body;
-    const validation = import_joi12.default.object({
-      id: import_joi12.default.string().hex().required(),
-      country: import_joi12.default.string().required(),
-      address: import_joi12.default.string().required(),
-      continuedAddress: import_joi12.default.string().optional().allow("", null),
-      city: import_joi12.default.string().required(),
-      province: import_joi12.default.string().required(),
-      postalCode: import_joi12.default.string().required(),
-      taxId: import_joi12.default.string().optional().allow("", null),
-      org: import_joi12.default.string().hex().optional().allow("", null)
+    const validation = import_joi21.default.object({
+      id: import_joi21.default.string().hex().required(),
+      country: import_joi21.default.string().required(),
+      address: import_joi21.default.string().required(),
+      continuedAddress: import_joi21.default.string().optional().allow("", null),
+      city: import_joi21.default.string().required(),
+      province: import_joi21.default.string().required(),
+      postalCode: import_joi21.default.string().required(),
+      taxId: import_joi21.default.string().optional().allow("", null),
+      org: import_joi21.default.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate({ id, ...value });
     if (error) {
-      next(new import_nodejs_utils26.BadRequestError(error.message));
+      next(new import_nodejs_utils37.BadRequestError(error.message));
       return;
     }
     try {
@@ -4660,15 +6511,15 @@ function useAddressController() {
   }
   async function getByUserId(req, res, next) {
     const user = req.params.user;
-    const validation = import_joi12.default.string().hex().required();
+    const validation = import_joi21.default.string().hex().required();
     const { error } = validation.validate(user);
     if (error) {
-      next(new import_nodejs_utils26.BadRequestError(error.message));
+      next(new import_nodejs_utils37.BadRequestError(error.message));
     }
     try {
       const address = await _getByUserId(user);
       if (!address) {
-        next(new import_nodejs_utils26.NotFoundError("Address not found."));
+        next(new import_nodejs_utils37.NotFoundError("Address not found."));
         return;
       }
       res.json(address);
@@ -4679,15 +6530,15 @@ function useAddressController() {
   }
   async function getByOrgId(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi12.default.string().hex().required();
+    const validation = import_joi21.default.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_nodejs_utils26.BadRequestError(error.message));
+      next(new import_nodejs_utils37.BadRequestError(error.message));
     }
     try {
       const address = await _getByOrgId(id);
       if (!address) {
-        next(new import_nodejs_utils26.NotFoundError("Address not found."));
+        next(new import_nodejs_utils37.NotFoundError("Address not found."));
         return;
       }
       res.json(address);
@@ -4705,24 +6556,24 @@ function useAddressController() {
 }
 
 // src/resources/token/token.model.ts
-var import_mongodb16 = require("mongodb");
+var import_mongodb19 = require("mongodb");
 var MToken = class {
   constructor(value) {
     this.token = value.token ?? "";
-    this.user = value.user ?? new import_mongodb16.ObjectId();
+    this.user = value.user ?? new import_mongodb19.ObjectId();
     this.createdAt = value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
   }
 };
 
 // src/resources/counter/counter.model.ts
-var import_nodejs_utils27 = require("@eeplatform/nodejs-utils");
-var import_mongodb17 = require("mongodb");
+var import_nodejs_utils38 = require("@eeplatform/nodejs-utils");
+var import_mongodb20 = require("mongodb");
 var import_zod = require("zod");
 var TCounter = import_zod.z.object({
   _id: import_zod.z.union([
     import_zod.z.string().length(24, "Invalid ObjectId hex string"),
-    import_zod.z.instanceof(import_mongodb17.ObjectId)
-  ]).transform((val) => typeof val === "string" ? new import_mongodb17.ObjectId(val) : val).optional(),
+    import_zod.z.instanceof(import_mongodb20.ObjectId)
+  ]).transform((val) => typeof val === "string" ? new import_mongodb20.ObjectId(val) : val).optional(),
   count: import_zod.z.number().int().min(0).default(0),
   type: import_zod.z.string(),
   createdAt: import_zod.z.date().optional().default(() => /* @__PURE__ */ new Date()),
@@ -4735,7 +6586,7 @@ function useCounterModel(db) {
     try {
       return TCounter.parse(value);
     } catch (error) {
-      throw new import_nodejs_utils27.BadRequestError(error.issues[0].message);
+      throw new import_nodejs_utils38.BadRequestError(error.issues[0].message);
     }
   }
   function validateCounter(data) {
@@ -4749,23 +6600,23 @@ function useCounterModel(db) {
 }
 
 // src/resources/counter/counter.repository.ts
-var import_nodejs_utils28 = require("@eeplatform/nodejs-utils");
+var import_nodejs_utils39 = require("@eeplatform/nodejs-utils");
 function useCounterRepo() {
-  const db = import_nodejs_utils28.useAtlas.getDb();
+  const db = import_nodejs_utils39.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_nodejs_utils28.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils39.useCache)(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      import_nodejs_utils28.logger.log({
+      import_nodejs_utils39.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_nodejs_utils28.logger.log({
+      import_nodejs_utils39.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -4817,11 +6668,11 @@ function useCounterRepo() {
     }
   }
   async function getByType(type) {
-    const cacheKey = (0, import_nodejs_utils28.makeCacheKey)(namespace_collection, { type });
+    const cacheKey = (0, import_nodejs_utils39.makeCacheKey)(namespace_collection, { type });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_nodejs_utils28.logger.log({
+        import_nodejs_utils39.logger.log({
           level: "info",
           message: `Cache hit for getByType counter: ${cacheKey}`
         });
@@ -4830,12 +6681,12 @@ function useCounterRepo() {
       const data = await collection.findOne({ type });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          import_nodejs_utils28.logger.log({
+          import_nodejs_utils39.logger.log({
             level: "info",
             message: `Cache set for counter by type: ${cacheKey}`
           });
         }).catch((err) => {
-          import_nodejs_utils28.logger.log({
+          import_nodejs_utils39.logger.log({
             level: "error",
             message: `Failed to set cache for counter by type: ${err.message}`
           });
@@ -5173,7 +7024,7 @@ IMPORTANT: Only consider it a match if the target phoneme is the FIRST sound pro
 }
 
 // src/resources/utils/github.service.ts
-var import_nodejs_utils29 = require("@eeplatform/nodejs-utils");
+var import_nodejs_utils40 = require("@eeplatform/nodejs-utils");
 var import_rest = require("@octokit/rest");
 var import_libsodium_wrappers = __toESM(require("libsodium-wrappers"));
 function useGitHubService() {
@@ -5187,23 +7038,23 @@ function useGitHubService() {
     try {
       const { data: repoData } = await octokit.repos.get({ owner, repo });
       if (!repoData.permissions?.admin) {
-        throw new import_nodejs_utils29.BadRequestError(
+        throw new import_nodejs_utils40.BadRequestError(
           "You do not have admin access to this repository."
         );
       }
     } catch (error) {
       if (error.status === 404) {
-        throw new import_nodejs_utils29.BadRequestError(
+        throw new import_nodejs_utils40.BadRequestError(
           "Repository not found or you don't have access to it."
         );
       } else if (error.status === 401) {
-        throw new import_nodejs_utils29.BadRequestError(
+        throw new import_nodejs_utils40.BadRequestError(
           "Invalid GitHub token or insufficient permissions."
         );
       } else if (error.message.includes("admin access")) {
         throw error;
       } else {
-        throw new import_nodejs_utils29.BadRequestError(
+        throw new import_nodejs_utils40.BadRequestError(
           `Failed to check repository permissions: ${error.message}`
         );
       }
@@ -5252,7 +7103,7 @@ function useGitHubService() {
               key_id: publicKeyRes.key_id
             });
           } catch (encryptionError) {
-            throw new import_nodejs_utils29.BadRequestError(
+            throw new import_nodejs_utils40.BadRequestError(
               `Failed to encrypt secret '${key}': ${encryptionError.message}`
             );
           }
@@ -5268,22 +7119,22 @@ function useGitHubService() {
       }
       return `Successfully set ${lines.length} ${type} variables/secrets in environment '${environment}'`;
     } catch (error) {
-      if (error instanceof import_nodejs_utils29.AppError)
+      if (error instanceof import_nodejs_utils40.AppError)
         throw error;
       if (error.status === 422) {
-        throw new import_nodejs_utils29.BadRequestError(
+        throw new import_nodejs_utils40.BadRequestError(
           `GitHub API validation error: ${error.message}`
         );
       } else if (error.status === 404) {
-        throw new import_nodejs_utils29.BadRequestError("Environment or repository not found.");
+        throw new import_nodejs_utils40.BadRequestError("Environment or repository not found.");
       } else if (error.status === 403) {
-        throw new import_nodejs_utils29.BadRequestError(
+        throw new import_nodejs_utils40.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_nodejs_utils29.BadRequestError(
+        throw new import_nodejs_utils40.BadRequestError(
           `Failed to set GitHub variables: ${error.message}`
         );
       }
@@ -5295,19 +7146,19 @@ function useGitHubService() {
 }
 
 // src/resources/utils/transcribe.service.ts
-var import_nodejs_utils30 = require("@eeplatform/nodejs-utils");
+var import_nodejs_utils41 = require("@eeplatform/nodejs-utils");
 function useTranscribeService() {
   const { createFile } = useFileService();
-  const { getClient } = (0, import_nodejs_utils30.useRedis)();
+  const { getClient } = (0, import_nodejs_utils41.useRedis)();
   const redisClient = getClient();
   async function transcribeAudio(file) {
     try {
       const fileId = await createFile(file);
     } catch (error) {
-      if (error instanceof import_nodejs_utils30.AppError) {
+      if (error instanceof import_nodejs_utils41.AppError) {
         throw error;
       } else {
-        throw new import_nodejs_utils30.BadRequestError("Failed to transcribe audio file");
+        throw new import_nodejs_utils41.BadRequestError("Failed to transcribe audio file");
       }
     }
   }
@@ -5317,28 +7168,28 @@ function useTranscribeService() {
 }
 
 // src/resources/utils/audio-transcription.controller.ts
-var import_nodejs_utils31 = require("@eeplatform/nodejs-utils");
-var import_joi13 = __toESM(require("joi"));
+var import_nodejs_utils42 = require("@eeplatform/nodejs-utils");
+var import_joi22 = __toESM(require("joi"));
 function useAudioTranscriptionController() {
   const geminiService = useGeminiAiService();
-  const transcriptionOptionsSchema = import_joi13.default.object({
-    language: import_joi13.default.string().optional().max(50),
-    enableTimestamps: import_joi13.default.boolean().optional(),
-    prompt: import_joi13.default.string().optional().max(1e3),
-    maxTokens: import_joi13.default.number().integer().min(1).max(8192).optional()
+  const transcriptionOptionsSchema = import_joi22.default.object({
+    language: import_joi22.default.string().optional().max(50),
+    enableTimestamps: import_joi22.default.boolean().optional(),
+    prompt: import_joi22.default.string().optional().max(1e3),
+    maxTokens: import_joi22.default.number().integer().min(1).max(8192).optional()
   });
-  const phonemeOptionsSchema = import_joi13.default.object({
-    language: import_joi13.default.string().optional().max(50),
-    caseSensitive: import_joi13.default.boolean().optional(),
-    partialMatch: import_joi13.default.boolean().optional()
+  const phonemeOptionsSchema = import_joi22.default.object({
+    language: import_joi22.default.string().optional().max(50),
+    caseSensitive: import_joi22.default.boolean().optional(),
+    partialMatch: import_joi22.default.boolean().optional()
   });
-  const phonemeMatchSchema = import_joi13.default.object({
-    targetPhoneme: import_joi13.default.string().required().min(1).max(10),
+  const phonemeMatchSchema = import_joi22.default.object({
+    targetPhoneme: import_joi22.default.string().required().min(1).max(10),
     options: phonemeOptionsSchema.optional()
   });
   async function transcribeFromFile(req, res, next) {
     if (!req.file) {
-      next(new import_nodejs_utils31.BadRequestError("Audio file is required"));
+      next(new import_nodejs_utils42.BadRequestError("Audio file is required"));
       return;
     }
     try {
@@ -5346,14 +7197,14 @@ function useAudioTranscriptionController() {
         req.body
       );
       if (error) {
-        next(new import_nodejs_utils31.BadRequestError(error.message));
+        next(new import_nodejs_utils42.BadRequestError(error.message));
         return;
       }
       const { buffer, mimetype, originalname, size } = req.file;
       if (!geminiService.validateAudioFormat(mimetype)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `Unsupported audio format: ${mimetype}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5364,7 +7215,7 @@ function useAudioTranscriptionController() {
       const maxSizeBytes = 25 * 1024 * 1024;
       if (size > maxSizeBytes) {
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `File size too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5394,11 +7245,11 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof import_nodejs_utils31.AppError) {
+      if (error instanceof import_nodejs_utils42.AppError) {
         next(error);
       } else {
         next(
-          new import_nodejs_utils31.InternalServerError(
+          new import_nodejs_utils42.InternalServerError(
             `Audio transcription failed: ${error.message}`
           )
         );
@@ -5407,21 +7258,21 @@ function useAudioTranscriptionController() {
   }
   async function transcribeFromBase64(req, res, next) {
     try {
-      const bodySchema = import_joi13.default.object({
-        audioData: import_joi13.default.string().required(),
-        mimeType: import_joi13.default.string().required(),
+      const bodySchema = import_joi22.default.object({
+        audioData: import_joi22.default.string().required(),
+        mimeType: import_joi22.default.string().required(),
         options: transcriptionOptionsSchema.optional()
       });
       const { error, value } = bodySchema.validate(req.body);
       if (error) {
-        next(new import_nodejs_utils31.BadRequestError(error.message));
+        next(new import_nodejs_utils42.BadRequestError(error.message));
         return;
       }
       const { audioData, mimeType, options = {} } = value;
       if (!geminiService.validateAudioFormat(mimeType)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `Unsupported audio format: ${mimeType}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5433,13 +7284,13 @@ function useAudioTranscriptionController() {
       try {
         audioBuffer = Buffer.from(audioData, "base64");
       } catch (conversionError) {
-        next(new import_nodejs_utils31.BadRequestError("Invalid base64 audio data"));
+        next(new import_nodejs_utils42.BadRequestError("Invalid base64 audio data"));
         return;
       }
       const maxSizeBytes = 25 * 1024 * 1024;
       if (audioBuffer.length > maxSizeBytes) {
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `Audio data too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5468,11 +7319,11 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof import_nodejs_utils31.AppError) {
+      if (error instanceof import_nodejs_utils42.AppError) {
         next(error);
       } else {
         next(
-          new import_nodejs_utils31.InternalServerError(
+          new import_nodejs_utils42.InternalServerError(
             `Audio transcription failed: ${error.message}`
           )
         );
@@ -5492,7 +7343,7 @@ function useAudioTranscriptionController() {
       });
     } catch (error) {
       next(
-        new import_nodejs_utils31.InternalServerError(
+        new import_nodejs_utils42.InternalServerError(
           `Failed to get supported formats: ${error.message}`
         )
       );
@@ -5500,12 +7351,12 @@ function useAudioTranscriptionController() {
   }
   async function validateFormat(req, res, next) {
     try {
-      const schema = import_joi13.default.object({
-        mimeType: import_joi13.default.string().required()
+      const schema = import_joi22.default.object({
+        mimeType: import_joi22.default.string().required()
       });
       const { error, value } = schema.validate(req.body);
       if (error) {
-        next(new import_nodejs_utils31.BadRequestError(error.message));
+        next(new import_nodejs_utils42.BadRequestError(error.message));
         return;
       }
       const { mimeType } = value;
@@ -5521,19 +7372,19 @@ function useAudioTranscriptionController() {
       });
     } catch (error) {
       next(
-        new import_nodejs_utils31.InternalServerError(`Format validation failed: ${error.message}`)
+        new import_nodejs_utils42.InternalServerError(`Format validation failed: ${error.message}`)
       );
     }
   }
   async function checkPhonemeFromFile(req, res, next) {
     if (!req.file) {
-      next(new import_nodejs_utils31.BadRequestError("Audio file is required"));
+      next(new import_nodejs_utils42.BadRequestError("Audio file is required"));
       return;
     }
     try {
       const { error, value } = phonemeMatchSchema.validate(req.body);
       if (error) {
-        next(new import_nodejs_utils31.BadRequestError(error.message));
+        next(new import_nodejs_utils42.BadRequestError(error.message));
         return;
       }
       const { targetPhoneme, options = {} } = value;
@@ -5541,7 +7392,7 @@ function useAudioTranscriptionController() {
       if (!geminiService.validateAudioFormat(mimetype)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `Unsupported audio format: ${mimetype}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5552,7 +7403,7 @@ function useAudioTranscriptionController() {
       const maxSizeBytes = 25 * 1024 * 1024;
       if (size > maxSizeBytes) {
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `File size too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5567,7 +7418,7 @@ function useAudioTranscriptionController() {
       );
       const processingTime = Date.now() - startTime;
       if (!result.isMatch) {
-        throw new import_nodejs_utils31.BadRequestError(
+        throw new import_nodejs_utils42.BadRequestError(
           `Phoneme "${targetPhoneme}" not found in the provided audio. Transcription: "${result.transcription}"`
         );
       }
@@ -5595,33 +7446,33 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof import_nodejs_utils31.AppError) {
+      if (error instanceof import_nodejs_utils42.AppError) {
         next(error);
       } else {
         next(
-          new import_nodejs_utils31.InternalServerError(`Phoneme analysis failed: ${error.message}`)
+          new import_nodejs_utils42.InternalServerError(`Phoneme analysis failed: ${error.message}`)
         );
       }
     }
   }
   async function checkPhonemeFromBase64(req, res, next) {
     try {
-      const bodySchema = import_joi13.default.object({
-        audioData: import_joi13.default.string().required(),
-        mimeType: import_joi13.default.string().required(),
-        targetPhoneme: import_joi13.default.string().required().min(1).max(10),
+      const bodySchema = import_joi22.default.object({
+        audioData: import_joi22.default.string().required(),
+        mimeType: import_joi22.default.string().required(),
+        targetPhoneme: import_joi22.default.string().required().min(1).max(10),
         options: phonemeOptionsSchema.optional()
       });
       const { error, value } = bodySchema.validate(req.body);
       if (error) {
-        next(new import_nodejs_utils31.BadRequestError(error.message));
+        next(new import_nodejs_utils42.BadRequestError(error.message));
         return;
       }
       const { audioData, mimeType, targetPhoneme, options = {} } = value;
       if (!geminiService.validateAudioFormat(mimeType)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `Unsupported audio format: ${mimeType}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5633,13 +7484,13 @@ function useAudioTranscriptionController() {
       try {
         audioBuffer = Buffer.from(audioData, "base64");
       } catch (conversionError) {
-        next(new import_nodejs_utils31.BadRequestError("Invalid base64 audio data"));
+        next(new import_nodejs_utils42.BadRequestError("Invalid base64 audio data"));
         return;
       }
       const maxSizeBytes = 25 * 1024 * 1024;
       if (audioBuffer.length > maxSizeBytes) {
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `Audio data too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5654,7 +7505,7 @@ function useAudioTranscriptionController() {
       );
       const processingTime = Date.now() - startTime;
       if (!result.isMatch) {
-        throw new import_nodejs_utils31.BadRequestError(
+        throw new import_nodejs_utils42.BadRequestError(
           `Phoneme "${targetPhoneme}" not found in the provided audio. Transcription: "${result.transcription}"`
         );
       }
@@ -5681,28 +7532,28 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof import_nodejs_utils31.AppError) {
+      if (error instanceof import_nodejs_utils42.AppError) {
         next(error);
       } else {
         next(
-          new import_nodejs_utils31.InternalServerError(`Phoneme analysis failed: ${error.message}`)
+          new import_nodejs_utils42.InternalServerError(`Phoneme analysis failed: ${error.message}`)
         );
       }
     }
   }
   async function batchPhonemeCheck(req, res, next) {
     if (!req.file) {
-      next(new import_nodejs_utils31.BadRequestError("Audio file is required"));
+      next(new import_nodejs_utils42.BadRequestError("Audio file is required"));
       return;
     }
     try {
-      const batchSchema = import_joi13.default.object({
-        targetPhonemes: import_joi13.default.array().items(import_joi13.default.string().min(1).max(10)).min(1).max(20).required(),
+      const batchSchema = import_joi22.default.object({
+        targetPhonemes: import_joi22.default.array().items(import_joi22.default.string().min(1).max(10)).min(1).max(20).required(),
         options: phonemeOptionsSchema.optional()
       });
       const { error, value } = batchSchema.validate(req.body);
       if (error) {
-        next(new import_nodejs_utils31.BadRequestError(error.message));
+        next(new import_nodejs_utils42.BadRequestError(error.message));
         return;
       }
       const { targetPhonemes, options = {} } = value;
@@ -5710,7 +7561,7 @@ function useAudioTranscriptionController() {
       if (!geminiService.validateAudioFormat(mimetype)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `Unsupported audio format: ${mimetype}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5721,7 +7572,7 @@ function useAudioTranscriptionController() {
       const maxSizeBytes = 25 * 1024 * 1024;
       if (size > maxSizeBytes) {
         next(
-          new import_nodejs_utils31.BadRequestError(
+          new import_nodejs_utils42.BadRequestError(
             `File size too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5777,11 +7628,11 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof import_nodejs_utils31.AppError) {
+      if (error instanceof import_nodejs_utils42.AppError) {
         next(error);
       } else {
         next(
-          new import_nodejs_utils31.InternalServerError(
+          new import_nodejs_utils42.InternalServerError(
             `Batch phoneme analysis failed: ${error.message}`
           )
         );
@@ -5802,7 +7653,7 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      next(new import_nodejs_utils31.InternalServerError(`Health check failed: ${error.message}`));
+      next(new import_nodejs_utils42.InternalServerError(`Health check failed: ${error.message}`));
     }
   }
   return {
@@ -5818,8 +7669,8 @@ function useAudioTranscriptionController() {
 }
 
 // src/resources/utils/util.controller.ts
-var import_joi14 = __toESM(require("joi"));
-var import_nodejs_utils32 = require("@eeplatform/nodejs-utils");
+var import_joi23 = __toESM(require("joi"));
+var import_nodejs_utils43 = require("@eeplatform/nodejs-utils");
 function useUtilController() {
   async function healthCheck(req, res, next) {
     try {
@@ -5835,32 +7686,32 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_nodejs_utils32.logger.error("Health check failed", { error: error.message });
-      next(new import_nodejs_utils32.InternalServerError("Health check failed"));
+      import_nodejs_utils43.logger.error("Health check failed", { error: error.message });
+      next(new import_nodejs_utils43.InternalServerError("Health check failed"));
     }
   }
   async function setGitHubVariables(req, res, next) {
     try {
       const { githubToken, repoUrl, environment, type, keyValues } = req.body;
-      const validation = import_joi14.default.object({
-        githubToken: import_joi14.default.string().required().messages({
+      const validation = import_joi23.default.object({
+        githubToken: import_joi23.default.string().required().messages({
           "string.empty": "GitHub token is required",
           "any.required": "GitHub token is required"
         }),
-        repoUrl: import_joi14.default.string().uri().required().messages({
+        repoUrl: import_joi23.default.string().uri().required().messages({
           "string.empty": "Repository URL is required",
           "string.uri": "Repository URL must be a valid URL",
           "any.required": "Repository URL is required"
         }),
-        environment: import_joi14.default.string().required().messages({
+        environment: import_joi23.default.string().required().messages({
           "string.empty": "Environment name is required",
           "any.required": "Environment name is required"
         }),
-        type: import_joi14.default.string().valid("env", "secret").required().messages({
+        type: import_joi23.default.string().valid("env", "secret").required().messages({
           "any.only": 'Type must be either "env" or "secret"',
           "any.required": "Type is required"
         }),
-        keyValues: import_joi14.default.string().required().messages({
+        keyValues: import_joi23.default.string().required().messages({
           "string.empty": "Key-value pairs are required",
           "any.required": "Key-value pairs are required"
         })
@@ -5873,13 +7724,13 @@ function useUtilController() {
         keyValues
       });
       if (error) {
-        next(new import_nodejs_utils32.BadRequestError(error.message));
+        next(new import_nodejs_utils43.BadRequestError(error.message));
         return;
       }
       const repoUrlPattern = /github\.com[:\/]([^\/]+)\/(.+)\.git$/;
       if (!repoUrlPattern.test(repoUrl)) {
         next(
-          new import_nodejs_utils32.BadRequestError(
+          new import_nodejs_utils43.BadRequestError(
             "Invalid GitHub repository URL format. Expected format: https://github.com/owner/repo.git"
           )
         );
@@ -5891,7 +7742,7 @@ function useUtilController() {
       );
       if (invalidLines.length > 0) {
         next(
-          new import_nodejs_utils32.BadRequestError(
+          new import_nodejs_utils43.BadRequestError(
             "Invalid key-value format. Each pair should be in format: KEY=value. Pairs should be separated by semicolons."
           )
         );
@@ -5905,7 +7756,7 @@ function useUtilController() {
         type,
         keyValues
       });
-      import_nodejs_utils32.logger.info(`GitHub variables set successfully`, {
+      import_nodejs_utils43.logger.info(`GitHub variables set successfully`, {
         repoUrl,
         environment,
         type,
@@ -5922,15 +7773,15 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_nodejs_utils32.logger.error("Failed to set GitHub variables", {
+      import_nodejs_utils43.logger.error("Failed to set GitHub variables", {
         error: error.message,
         stack: error.stack
       });
-      if (error instanceof import_nodejs_utils32.AppError) {
+      if (error instanceof import_nodejs_utils43.AppError) {
         next(error);
       } else {
         next(
-          new import_nodejs_utils32.InternalServerError(
+          new import_nodejs_utils43.InternalServerError(
             `Failed to set GitHub variables: ${error.message}`
           )
         );
@@ -5944,34 +7795,34 @@ function useUtilController() {
 }
 
 // src/resources/utils/transaction.schema.ts
-var import_joi15 = __toESM(require("joi"));
-var transactionSchema = import_joi15.default.object({
-  _id: import_joi15.default.string().hex().optional().allow("", null),
-  payment: import_joi15.default.string().required(),
-  user: import_joi15.default.string().hex().optional().allow("", null),
-  org: import_joi15.default.string().hex().optional().allow("", null),
-  type: import_joi15.default.string().required(),
-  amount: import_joi15.default.number().positive().min(0).required(),
-  currency: import_joi15.default.string().required(),
-  description: import_joi15.default.string().optional().allow("", null),
-  metadata: import_joi15.default.object({
-    subscriptionId: import_joi15.default.string().hex().optional().allow("", null),
-    cycle: import_joi15.default.number().optional().allow("", null),
-    seats: import_joi15.default.number().optional().allow("", null),
-    promoCode: import_joi15.default.string().optional().allow("", null)
+var import_joi24 = __toESM(require("joi"));
+var transactionSchema = import_joi24.default.object({
+  _id: import_joi24.default.string().hex().optional().allow("", null),
+  payment: import_joi24.default.string().required(),
+  user: import_joi24.default.string().hex().optional().allow("", null),
+  org: import_joi24.default.string().hex().optional().allow("", null),
+  type: import_joi24.default.string().required(),
+  amount: import_joi24.default.number().positive().min(0).required(),
+  currency: import_joi24.default.string().required(),
+  description: import_joi24.default.string().optional().allow("", null),
+  metadata: import_joi24.default.object({
+    subscriptionId: import_joi24.default.string().hex().optional().allow("", null),
+    cycle: import_joi24.default.number().optional().allow("", null),
+    seats: import_joi24.default.number().optional().allow("", null),
+    promoCode: import_joi24.default.string().optional().allow("", null)
   }).optional().allow("", null),
-  status: import_joi15.default.string().optional().allow("", null),
-  createdAt: import_joi15.default.string().optional().allow("", null),
-  updatedAt: import_joi15.default.string().optional().allow("", null),
-  deletedAt: import_joi15.default.string().optional().allow("", null)
+  status: import_joi24.default.string().optional().allow("", null),
+  createdAt: import_joi24.default.string().optional().allow("", null),
+  updatedAt: import_joi24.default.string().optional().allow("", null),
+  deletedAt: import_joi24.default.string().optional().allow("", null)
 });
 
 // src/resources/psgc/psgc.model.ts
-var import_joi16 = __toESM(require("joi"));
-var schemaPSGC = import_joi16.default.object({
-  code: import_joi16.default.string().length(10).required(),
-  name: import_joi16.default.string().required(),
-  type: import_joi16.default.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required()
+var import_joi25 = __toESM(require("joi"));
+var schemaPSGC = import_joi25.default.object({
+  code: import_joi25.default.string().length(10).required(),
+  name: import_joi25.default.string().required(),
+  type: import_joi25.default.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required()
 });
 function modelPSGC(data) {
   const { error } = schemaPSGC.validate(data);
@@ -5986,16 +7837,16 @@ function modelPSGC(data) {
 }
 
 // src/resources/psgc/psgc.repository.ts
-var import_nodejs_utils33 = require("@eeplatform/nodejs-utils");
-var import_mongodb18 = require("mongodb");
+var import_nodejs_utils44 = require("@eeplatform/nodejs-utils");
+var import_mongodb21 = require("mongodb");
 function usePSGCRepo() {
-  const db = import_nodejs_utils33.useAtlas.getDb();
+  const db = import_nodejs_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_nodejs_utils33.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils44.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -6009,12 +7860,12 @@ function usePSGCRepo() {
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_nodejs_utils33.logger.log({
+      import_nodejs_utils44.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_nodejs_utils33.logger.log({
+      import_nodejs_utils44.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -6027,16 +7878,16 @@ function usePSGCRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_nodejs_utils33.logger.log({
+      import_nodejs_utils44.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_nodejs_utils33.AppError) {
+      if (error instanceof import_nodejs_utils44.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_nodejs_utils33.BadRequestError("Region already exists.");
+          throw new import_nodejs_utils44.BadRequestError("Region already exists.");
         }
         throw new Error("Failed to create PSGC.");
       }
@@ -6072,15 +7923,15 @@ function usePSGCRepo() {
       query.$text = { $search: search };
       cacheKeyOptions.search = search;
     }
-    const cacheKey = (0, import_nodejs_utils33.makeCacheKey)(namespace_collection, cacheKeyOptions);
-    import_nodejs_utils33.logger.log({
+    const cacheKey = (0, import_nodejs_utils44.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_nodejs_utils44.logger.log({
       level: "info",
       message: `Cache key for getAll PSGC: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_nodejs_utils33.logger.log({
+        import_nodejs_utils44.logger.log({
           level: "info",
           message: `Cache hit for getAll PSGC: ${cacheKey}`
         });
@@ -6093,35 +7944,35 @@ function usePSGCRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_nodejs_utils33.paginate)(items, page, limit, length);
+      const data = (0, import_nodejs_utils44.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_nodejs_utils33.logger.log({
+        import_nodejs_utils44.logger.log({
           level: "info",
           message: `Cache set for getAll PSGC: ${cacheKey}`
         });
       }).catch((err) => {
-        import_nodejs_utils33.logger.log({
+        import_nodejs_utils44.logger.log({
           level: "error",
           message: `Failed to set cache for getAll PSGC: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_nodejs_utils33.logger.log({ level: "error", message: `${error}` });
+      import_nodejs_utils44.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new import_mongodb18.ObjectId(_id);
+      _id = new import_mongodb21.ObjectId(_id);
     } catch (error) {
-      throw new import_nodejs_utils33.BadRequestError("Invalid ID.");
+      throw new import_nodejs_utils44.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_nodejs_utils33.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_nodejs_utils44.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_nodejs_utils33.logger.log({
+        import_nodejs_utils44.logger.log({
           level: "info",
           message: `Cache hit for getById PSGC: ${cacheKey}`
         });
@@ -6132,25 +7983,25 @@ function usePSGCRepo() {
         deletedAt: { $in: ["", null] }
       });
       if (!result) {
-        throw new import_nodejs_utils33.BadRequestError("Region not found.");
+        throw new import_nodejs_utils44.BadRequestError("Region not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        import_nodejs_utils33.logger.log({
+        import_nodejs_utils44.logger.log({
           level: "info",
           message: `Cache set for PSGC by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_nodejs_utils33.logger.log({
+        import_nodejs_utils44.logger.log({
           level: "error",
           message: `Failed to set cache for PSGC by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_nodejs_utils33.AppError) {
+      if (error instanceof import_nodejs_utils44.AppError) {
         throw error;
       } else {
-        throw new import_nodejs_utils33.InternalServerError("Failed to get PSGC.");
+        throw new import_nodejs_utils44.InternalServerError("Failed to get PSGC.");
       }
     }
   }
@@ -6174,15 +8025,15 @@ function usePSGCRepo() {
       query.code = { $regex: `^${prefix}` };
       cacheKeyOptions.prefix = prefix;
     }
-    const cacheKey = (0, import_nodejs_utils33.makeCacheKey)(namespace_collection, { name });
-    import_nodejs_utils33.logger.log({
+    const cacheKey = (0, import_nodejs_utils44.makeCacheKey)(namespace_collection, { name });
+    import_nodejs_utils44.logger.log({
       level: "info",
       message: `Query for getByName PSGC: ${JSON.stringify(query)}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_nodejs_utils33.logger.log({
+        import_nodejs_utils44.logger.log({
           level: "info",
           message: `Cache hit for getByName PSGC: ${cacheKey}`
         });
@@ -6190,36 +8041,36 @@ function usePSGCRepo() {
       }
       const result = await collection.findOne(query);
       setCache(cacheKey, result, 300).then(() => {
-        import_nodejs_utils33.logger.log({
+        import_nodejs_utils44.logger.log({
           level: "info",
           message: `Cache set for PSGC by name: ${cacheKey}`
         });
       }).catch((err) => {
-        import_nodejs_utils33.logger.log({
+        import_nodejs_utils44.logger.log({
           level: "error",
           message: `Failed to set cache for PSGC by name: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_nodejs_utils33.AppError) {
+      if (error instanceof import_nodejs_utils44.AppError) {
         throw error;
       } else {
-        throw new import_nodejs_utils33.InternalServerError("Failed to get PSGC.");
+        throw new import_nodejs_utils44.InternalServerError("Failed to get PSGC.");
       }
     }
   }
   async function updateFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["name"];
     if (!allowedFields.includes(field)) {
-      throw new import_nodejs_utils33.BadRequestError(
+      throw new import_nodejs_utils44.BadRequestError(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
-      _id = new import_mongodb18.ObjectId(_id);
+      _id = new import_mongodb21.ObjectId(_id);
     } catch (error) {
-      throw new import_nodejs_utils33.BadRequestError("Invalid ID.");
+      throw new import_nodejs_utils44.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -6230,14 +8081,14 @@ function usePSGCRepo() {
       delCachedData();
       return `Successfully updated PSGC ${field}.`;
     } catch (error) {
-      throw new import_nodejs_utils33.InternalServerError(`Failed to update PSGC ${field}.`);
+      throw new import_nodejs_utils44.InternalServerError(`Failed to update PSGC ${field}.`);
     }
   }
   async function deleteById(_id) {
     try {
-      _id = new import_mongodb18.ObjectId(_id);
+      _id = new import_mongodb21.ObjectId(_id);
     } catch (error) {
-      throw new import_nodejs_utils33.BadRequestError("Invalid ID.");
+      throw new import_nodejs_utils44.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -6247,7 +8098,7 @@ function usePSGCRepo() {
       delCachedData();
       return "Successfully deleted PSGC.";
     } catch (error) {
-      throw new import_nodejs_utils33.InternalServerError("Failed to delete PSGC.");
+      throw new import_nodejs_utils44.InternalServerError("Failed to delete PSGC.");
     }
   }
   async function setRegionProvinceName() {
@@ -6297,8 +8148,8 @@ function usePSGCRepo() {
 }
 
 // src/resources/psgc/psgc.controller.ts
-var import_nodejs_utils34 = require("@eeplatform/nodejs-utils");
-var import_joi17 = __toESM(require("joi"));
+var import_nodejs_utils45 = require("@eeplatform/nodejs-utils");
+var import_joi26 = __toESM(require("joi"));
 function usePSGCController() {
   const {
     add: _add,
@@ -6312,7 +8163,7 @@ function usePSGCController() {
     const value = req.body;
     const { error } = schemaPSGC.validate(value);
     if (error) {
-      next(new import_nodejs_utils34.BadRequestError(error.message));
+      next(new import_nodejs_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -6328,12 +8179,12 @@ function usePSGCController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi17.default.object({
-      page: import_joi17.default.number().min(1).optional().allow("", null),
-      limit: import_joi17.default.number().min(1).optional().allow("", null),
-      search: import_joi17.default.string().optional().allow("", null),
-      type: import_joi17.default.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required(),
-      prefix: import_joi17.default.string().optional().allow("", null)
+    const validation = import_joi26.default.object({
+      page: import_joi26.default.number().min(1).optional().allow("", null),
+      limit: import_joi26.default.number().min(1).optional().allow("", null),
+      search: import_joi26.default.string().optional().allow("", null),
+      type: import_joi26.default.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required(),
+      prefix: import_joi26.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
@@ -6343,16 +8194,16 @@ function usePSGCController() {
     const prefix = req.query.prefix ? String(req.query.prefix) : "";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_nodejs_utils34.BadRequestError("Invalid page number."));
+      next(new import_nodejs_utils45.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_nodejs_utils34.BadRequestError("Invalid limit number."));
+      next(new import_nodejs_utils45.BadRequestError("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new import_nodejs_utils34.BadRequestError(error.message));
+      next(new import_nodejs_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -6371,12 +8222,12 @@ function usePSGCController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi17.default.object({
-      id: import_joi17.default.string().hex().required()
+    const validation = import_joi26.default.object({
+      id: import_joi26.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_nodejs_utils34.BadRequestError(error.message));
+      next(new import_nodejs_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -6392,12 +8243,12 @@ function usePSGCController() {
   }
   async function getByName(req, res, next) {
     const name = req.params.name;
-    const validation = import_joi17.default.object({
-      name: import_joi17.default.string().required()
+    const validation = import_joi26.default.object({
+      name: import_joi26.default.string().required()
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new import_nodejs_utils34.BadRequestError(error.message));
+      next(new import_nodejs_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -6414,14 +8265,14 @@ function usePSGCController() {
   async function updateField(req, res, next) {
     const _id = req.params.id;
     const { field, value } = req.body;
-    const validation = import_joi17.default.object({
-      _id: import_joi17.default.string().hex().required(),
-      field: import_joi17.default.string().valid("name", "director", "directorName").required(),
-      value: import_joi17.default.string().required()
+    const validation = import_joi26.default.object({
+      _id: import_joi26.default.string().hex().required(),
+      field: import_joi26.default.string().valid("name", "director", "directorName").required(),
+      value: import_joi26.default.string().required()
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new import_nodejs_utils34.BadRequestError(error.message));
+      next(new import_nodejs_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -6434,12 +8285,12 @@ function usePSGCController() {
   }
   async function deleteById(req, res, next) {
     const _id = req.params.id;
-    const validation = import_joi17.default.object({
-      _id: import_joi17.default.string().hex().required()
+    const validation = import_joi26.default.object({
+      _id: import_joi26.default.string().hex().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new import_nodejs_utils34.BadRequestError(error.message));
+      next(new import_nodejs_utils45.BadRequestError(error.message));
       return;
     }
     try {
@@ -6509,12 +8360,24 @@ function usePSGCController() {
   XENDIT_SECRET_KEY,
   addressSchema,
   isDev,
+  modelApp,
   modelPSGC,
+  modelPermission,
+  modelPermissionGroup,
+  schemaApp,
+  schemaAppUpdate,
   schemaOrg,
   schemaPSGC,
+  schemaPermission,
+  schemaPermissionGroup,
+  schemaPermissionGroupUpdate,
+  schemaPermissionUpdate,
   transactionSchema,
   useAddressController,
   useAddressRepo,
+  useAppController,
+  useAppRepo,
+  useAppService,
   useAudioTranscriptionController,
   useAuthController,
   useAuthService,
@@ -6532,6 +8395,12 @@ function usePSGCController() {
   useOrgService,
   usePSGCController,
   usePSGCRepo,
+  usePermissionController,
+  usePermissionGroupController,
+  usePermissionGroupRepo,
+  usePermissionGroupService,
+  usePermissionRepo,
+  usePermissionService,
   useRoleController,
   useRoleRepo,
   useTokenRepo,