@eeplatform/core 1.8.7 → 1.8.9

package/dist/index.mjs

@@ -75,26 +75,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) {
@@ -391,8 +390,7 @@ function useUserRepo() {
     }
   }
   return {
-    createTextIndex,
-    createUniqueIndex,
+    createIndexes,
     createUser,
     getUserByEmail,
     getUserById,
@@ -1182,46 +1180,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) {
@@ -1759,9 +1744,7 @@ function useMemberRepo() {
     }
   }
   return {
-    createIndex,
-    createUniqueIndex,
-    createTextIndex,
+    createIndexes,
     add,
     getById,
     getByOrg,
@@ -1831,7 +1814,7 @@ function useVerificationService() {
           to: email,
           subject: "Member Invite",
           html: emailContent2,
-          from: "EEPlatform"
+          from: `"EEPlatform" <support@goweekdays.com>`
         }).catch((error) => {
           logger6.log({
             level: "error",
@@ -1853,7 +1836,7 @@ function useVerificationService() {
         to: email,
         subject: "User Invite",
         html: emailContent,
-        from: "EEPlatform"
+        from: `"EEPlatform" <support@goweekdays.com>`
       }).catch((error) => {
         logger6.log({
           level: "error",
@@ -1887,7 +1870,7 @@ function useVerificationService() {
       mailer.sendMail({
         to: email,
         subject: "Forget Password",
-        from: "EEPlatform",
+        from: `"EEPlatform" <support@goweekdays.com>`,
         html: emailContent
       }).catch((error) => {
         logger6.log({
@@ -2082,7 +2065,7 @@ function useVerificationService() {
         to: email,
         subject: "Sign Up Verification",
         html: emailContent,
-        from: "EEPlatform"
+        from: `"EEPlatform" <support@goweekdays.com>`
       }).catch((error) => {
         logger6.log({
           level: "error",
@@ -2184,21 +2167,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 InternalServerError8("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 InternalServerError8("Failed to create text index on role.");
+      throw new InternalServerError8("Failed to create role indexes.");
     }
   }
   async function createUniqueIndex() {
@@ -2481,8 +2465,7 @@ function useRoleRepo() {
     }
   }
   return {
-    createIndex,
-    createTextIndex,
+    createIndexes,
     createUniqueIndex,
     addRole,
     getRoles,
@@ -3711,140 +3694,2166 @@ function useOrgController() {
   };
 }
 
-// src/resources/role/role.controller.ts
-import Joi8 from "joi";
-import { BadRequestError as BadRequestError18 } from "@eeplatform/nodejs-utils";
+// src/resources/app/app.model.ts
+import { BadRequestError as BadRequestError16 } from "@eeplatform/nodejs-utils";
+import Joi6 from "joi";
+var schemaApp = Joi6.object({
+  code: Joi6.string().alphanum().max(20).required(),
+  name: Joi6.string().max(255).required(),
+  description: Joi6.string().max(1024).optional().allow("", null),
+  type: Joi6.string().allow("default", "standard").optional().allow("", null)
+});
+var schemaAppUpdate = Joi6.object({
+  code: Joi6.string().alphanum().max(20).optional().allow("", null),
+  name: Joi6.string().max(255).optional().allow("", null),
+  description: Joi6.string().max(1024).optional().allow("", null)
+});
+function modelApp(value) {
+  const { error } = schemaApp.validate(value);
+  if (error) {
+    throw new BadRequestError16(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
 import {
   AppError as AppError6,
   BadRequestError as BadRequestError17,
-  InternalServerError as InternalServerError13
+  InternalServerError as InternalServerError13,
+  logger as logger11,
+  makeCacheKey as makeCacheKey9,
+  paginate as paginate6,
+  useRepo
 } from "@eeplatform/nodejs-utils";
+import { ObjectId as ObjectId14 } from "mongodb";
 import Joi7 from "joi";
-
-// src/resources/member/member.controller.ts
-import Joi6 from "joi";
-import { BadRequestError as BadRequestError16 } from "@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 = Joi6.object({
-      id: Joi6.string().hex().required()
-    });
-    const { error } = validation.validate({ id: userId });
-    if (error) {
-      next(new BadRequestError16(error.message));
-      return;
+function useAppRepo() {
+  const namespace_collection = "apps";
+  const repo = 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) {
+      logger11.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError6) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new BadRequestError17("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 = Joi6.object({
-      org: Joi6.string().hex().optional().allow("", null),
-      user: Joi6.string().hex().required(),
-      type: Joi6.string().required()
-    });
-    const { error } = validation.validate({ ...req.params, ...req.query });
-    if (error) {
-      next(new BadRequestError16(error.message));
-      return;
+  async function updateById(_id, value, session) {
+    try {
+      _id = new ObjectId14(_id);
+    } catch (error) {
+      throw new BadRequestError17("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) {
+      logger11.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError6) {
+        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 = Joi6.object({
-      limit: Joi6.number().min(10).max(300).required(),
-      search: Joi6.string().optional().allow("", null),
-      page: Joi6.number().required(),
-      user: Joi6.string().hex().optional().allow("", null),
-      org: Joi6.string().hex().optional().allow("", null),
-      type: Joi6.string().required(),
-      status: Joi6.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 BadRequestError16(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 = makeCacheKey9(namespace_collection, cacheParams);
+    logger11.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) {
+        logger11.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 = paginate6(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        logger11.log({
+          level: "info",
+          message: `Cache set for getAll apps: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger11.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) {
+      logger11.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 = Joi6.object({
-      limit: Joi6.number().min(10).max(50).required(),
-      search: Joi6.string().optional().allow("", null),
-      page: Joi6.number().required(),
-      user: Joi6.string().hex().optional().allow("", null)
-    });
-    const { error } = validation.validate({
-      search,
-      page,
-      user,
+  async function getById(_id) {
+    try {
+      _id = new ObjectId14(_id);
+    } catch (error) {
+      throw new BadRequestError17("Invalid ID.");
+    }
+    const cacheKey = makeCacheKey9(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger11.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(() => {
+        logger11.log({
+          level: "info",
+          message: `Cache set for app by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger11.log({
+          level: "error",
+          message: `Failed to set cache for app by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError6) {
+        throw error;
+      } else {
+        throw new InternalServerError13("Failed to get app.");
+      }
+    }
+  }
+  async function getByCode(code) {
+    const validate = Joi7.string().required();
+    const { error } = validate.validate(code);
+    if (error) {
+      throw new BadRequestError17("Invalid code.");
+    }
+    const cacheKey = makeCacheKey9(namespace_collection, {
+      code,
+      tag: "byCode"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger11.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(() => {
+        logger11.log({
+          level: "info",
+          message: `Cache set for app by code: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger11.log({
+          level: "error",
+          message: `Failed to set cache for app by code: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof AppError6) {
+        throw error2;
+      } else {
+        throw new InternalServerError13("Failed to get app.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId14(_id);
+    } catch (error) {
+      throw new BadRequestError17("Invalid ID.");
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error) {
+      logger11.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError6) {
+        throw error;
+      } else {
+        throw new InternalServerError13("Failed to delete app.");
+      }
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getByCode,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/app/app.service.ts
+import { logger as logger12, useAtlas as useAtlas11 } from "@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 = useAtlas11.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();
+      logger12.log({
+        level: "info",
+        message: "Default apps added successfully."
+      });
+      return;
+    } catch (error) {
+      await session.abortTransaction();
+      logger12.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
+import { BadRequestError as BadRequestError18 } from "@eeplatform/nodejs-utils";
+import Joi8 from "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 BadRequestError18(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 } = Joi8.string().hex().required().validate(id);
+    if (errorId) {
+      next(new BadRequestError18(errorId.message));
+      return;
+    }
+    const value = req.body;
+    const { error } = schemaAppUpdate.validate(value);
+    if (error) {
+      next(new BadRequestError18(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 = Joi8.object({
+      page: Joi8.number().min(1).optional().allow("", null),
+      limit: Joi8.number().min(1).optional().allow("", null),
+      search: Joi8.string().optional().allow("", null),
+      status: Joi8.string().optional().allow("", null),
+      type: Joi8.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError18(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 = Joi8.object({
+      id: Joi8.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError18(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 = Joi8.object({
+      id: Joi8.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError18(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
+import { BadRequestError as BadRequestError19 } from "@eeplatform/nodejs-utils";
+import Joi9 from "joi";
+var schemaPermission = Joi9.object({
+  app: Joi9.string().required(),
+  key: Joi9.string().required(),
+  name: Joi9.string().required(),
+  group: Joi9.string().required(),
+  description: Joi9.string().required(),
+  deprecated: Joi9.boolean().optional().allow(null)
+});
+var schemaPermissionUpdate = Joi9.object({
+  key: Joi9.string().optional().allow("", null),
+  name: Joi9.string().optional().allow("", null),
+  group: Joi9.string().optional().allow("", null),
+  description: Joi9.string().max(1024).optional().allow("", null)
+});
+function modelPermission(value) {
+  const { error } = schemaPermission.validate(value);
+  if (error) {
+    throw new BadRequestError19(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
+import {
+  AppError as AppError7,
+  BadRequestError as BadRequestError20,
+  InternalServerError as InternalServerError14,
+  logger as logger14,
+  makeCacheKey as makeCacheKey10,
+  paginate as paginate7,
+  useRepo as useRepo2
+} from "@eeplatform/nodejs-utils";
+import { ObjectId as ObjectId15 } from "mongodb";
+import Joi10 from "joi";
+function usePermissionRepo() {
+  const namespace_collection = "permissions";
+  const repo = useRepo2(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) {
+      logger14.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError7) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new BadRequestError20("Permission already exists.");
+        }
+        throw new Error("Failed to create permission.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new ObjectId15(_id);
+    } catch (error2) {
+      throw new BadRequestError20("Invalid ID.");
+    }
+    const { error } = schemaPermissionUpdate.validate(value);
+    if (error) {
+      throw new BadRequestError20(`Invalid data: ${error.message}`);
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error2) {
+      logger14.log({
+        level: "error",
+        message: error2.message
+      });
+      if (error2 instanceof AppError7) {
+        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 = makeCacheKey10(namespace_collection, cacheParams);
+    logger14.log({
+      level: "info",
+      message: `Cache key for getAll permissions: ${cacheKey}`
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger14.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 = paginate7(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        logger14.log({
+          level: "info",
+          message: `Cache set for getAll permissions: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger14.log({
+          level: "error",
+          message: `Failed to set cache for getAll permissions: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      logger14.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId15(_id);
+    } catch (error) {
+      throw new BadRequestError20("Invalid ID.");
+    }
+    const cacheKey = makeCacheKey10(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger14.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(() => {
+        logger14.log({
+          level: "info",
+          message: `Cache set for permission by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger14.log({
+          level: "error",
+          message: `Failed to set cache for permission by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError7) {
+        throw error;
+      } else {
+        throw new InternalServerError14("Failed to get permission.");
+      }
+    }
+  }
+  async function getByKey(key, group, app) {
+    const validation = Joi10.object({
+      key: Joi10.string().required(),
+      group: Joi10.string().optional().allow("", null),
+      app: Joi10.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({ key, group });
+    if (error) {
+      throw new BadRequestError20(`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 = makeCacheKey10(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger14.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(() => {
+        logger14.log({
+          level: "info",
+          message: `Cache set for permission by key: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger14.log({
+          level: "error",
+          message: `Failed to set cache for permission by key: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof AppError7) {
+        throw error2;
+      } else {
+        throw new InternalServerError14("Failed to get permission.");
+      }
+    }
+  }
+  async function countByGroup(group) {
+    const cacheKey = makeCacheKey10(namespace_collection, {
+      group,
+      tag: "countByGroup"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger14.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(() => {
+        logger14.log({
+          level: "info",
+          message: `Cache set for permission count by group: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger14.log({
+          level: "error",
+          message: `Failed to set cache for permission by group: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError7) {
+        throw error;
+      } else {
+        throw new InternalServerError14("Failed to count permission by group.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId15(_id);
+    } catch (error) {
+      throw new BadRequestError20("Invalid ID.");
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error) {
+      logger14.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError7) {
+        throw error;
+      } else {
+        throw new InternalServerError14("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
+import { BadRequestError as BadRequestError21, logger as logger15 } from "@eeplatform/nodejs-utils";
+import Joi11 from "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 BadRequestError21(error.message));
+      logger15.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 = Joi11.object({
+      page: Joi11.number().min(1).optional().allow("", null),
+      limit: Joi11.number().min(1).optional().allow("", null),
+      search: Joi11.string().optional().allow("", null),
+      app: Joi11.string().optional().allow("", null),
+      status: Joi11.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError21(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 = Joi11.object({
+      id: Joi11.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError21(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 = Joi11.object({
+      id: Joi11.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError21(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 } = Joi11.string().hex().required().validate(id);
+    if (errorId) {
+      next(new BadRequestError21(errorId.message));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaPermissionUpdate.validate(payload);
+    if (error) {
+      next(new BadRequestError21(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
+import { BadRequestError as BadRequestError22 } from "@eeplatform/nodejs-utils";
+import Joi12 from "joi";
+var schemaPermissionGroup = Joi12.object({
+  app: Joi12.string().required(),
+  key: Joi12.string().required(),
+  label: Joi12.string().required(),
+  order: Joi12.number().integer().optional().allow("", null)
+});
+var schemaPermissionGroupUpdate = Joi12.object({
+  key: Joi12.string().optional().allow("", null),
+  label: Joi12.string().optional().allow("", null),
+  order: Joi12.number().integer().optional().allow("", null)
+});
+function modelPermissionGroup(value) {
+  const { error } = schemaPermissionGroup.validate(value);
+  if (error) {
+    throw new BadRequestError22(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
+import {
+  AppError as AppError8,
+  BadRequestError as BadRequestError23,
+  InternalServerError as InternalServerError15,
+  logger as logger16,
+  makeCacheKey as makeCacheKey11,
+  paginate as paginate8,
+  useRepo as useRepo3
+} from "@eeplatform/nodejs-utils";
+import { ObjectId as ObjectId16 } from "mongodb";
+import Joi13 from "joi";
+function usePermissionGroupRepo() {
+  const namespace_collection = "permission.groups";
+  const repo = useRepo3(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) {
+      logger16.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError8) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new BadRequestError23("Permission group already exists.");
+        }
+        throw new Error("Failed to create permission group.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new ObjectId16(_id);
+    } catch (error2) {
+      throw new BadRequestError23("Invalid ID.");
+    }
+    const { error } = schemaPermissionGroupUpdate.validate(value);
+    if (error) {
+      throw new BadRequestError23(`Invalid data: ${error.message}`);
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error2) {
+      logger16.log({
+        level: "error",
+        message: error2.message
+      });
+      if (error2 instanceof AppError8) {
+        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 = makeCacheKey11(namespace_collection, cacheParams);
+    logger16.log({
+      level: "info",
+      message: `Cache key for getAll permission groups: ${cacheKey}`
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger16.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 = paginate8(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        logger16.log({
+          level: "info",
+          message: `Cache set for getAll permission groups: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger16.log({
+          level: "error",
+          message: `Failed to set cache for getAll permission groups: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      logger16.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId16(_id);
+    } catch (error) {
+      throw new BadRequestError23("Invalid ID.");
+    }
+    const cacheKey = makeCacheKey11(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger16.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(() => {
+        logger16.log({
+          level: "info",
+          message: `Cache set for permission group by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger16.log({
+          level: "error",
+          message: `Failed to set cache for permission group by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError8) {
+        throw error;
+      } else {
+        throw new InternalServerError15("Failed to get permission group.");
+      }
+    }
+  }
+  async function getByKey(key, app) {
+    const validation = Joi13.object({
+      key: Joi13.string().required(),
+      app: Joi13.string().optional().allow(null, "")
+    });
+    const { error } = validation.validate({ key, app });
+    if (error) {
+      throw new BadRequestError23("Invalid key.");
+    }
+    const query = { key };
+    const cacheKeyOptions = { key, tag: "byKey" };
+    if (app) {
+      query.app = app;
+      cacheKeyOptions.app = app;
+    }
+    const cacheKey = makeCacheKey11(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger16.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(() => {
+        logger16.log({
+          level: "info",
+          message: `Cache set for permission group by key: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger16.log({
+          level: "error",
+          message: `Failed to set cache for permission group by key: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof AppError8) {
+        throw error2;
+      } else {
+        throw new InternalServerError15("Failed to get permission group.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId16(_id);
+    } catch (error) {
+      throw new BadRequestError23("Invalid ID.");
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      repo.delCachedData();
+      return res;
+    } catch (error) {
+      logger16.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError8) {
+        throw error;
+      } else {
+        throw new InternalServerError15("Failed to delete permission group.");
+      }
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getByKey,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/permission/permission.group.service.ts
+import {
+  AppError as AppError9,
+  BadRequestError as BadRequestError24,
+  InternalServerError as InternalServerError16,
+  logger as logger17,
+  useAtlas as useAtlas12
+} from "@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 = useAtlas12.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 module of modules) {
+            const existingGroup = await _getByKey(module.key, app.code);
+            if (!existingGroup) {
+              await _add({
+                app: app.code,
+                key: module.key,
+                label: module.label
+              });
+              logger17.log({
+                level: "info",
+                message: `Default permission group added: ${app.code} - ${module.key}`
+              });
+            }
+            for (const permission of module.permissions) {
+              const existingPermission = await getPermissionByKey(
+                permission.key,
+                module.key,
+                app.code
+              );
+              if (!existingPermission) {
+                await addPermission({
+                  app: app.code,
+                  group: module.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 module of modules2) {
+              const existingGroup = await _getByKey(module.key, app.code);
+              if (!existingGroup) {
+                await _add({
+                  app: app.code,
+                  key: module.key,
+                  label: module.label
+                });
+                logger17.log({
+                  level: "info",
+                  message: `Default permission group added: ${app.code} - ${module.key}`
+                });
+              }
+              for (const permission of module.permissions) {
+                const existingPermission = await getPermissionByKey(
+                  permission.key,
+                  module.key
+                );
+                if (!existingPermission) {
+                  await addPermission({
+                    app: app.code,
+                    group: module.key,
+                    key: permission.key,
+                    name: permission.name,
+                    description: permission.description
+                  });
+                }
+              }
+            }
+          }
+        }
+        await session.commitTransaction();
+      }
+      logger17.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 BadRequestError24(
+        "Cannot delete Permission Group with associated Permissions."
+      );
+    }
+    try {
+      await _deleteById(id);
+      return "Permission deleted successfully.";
+    } catch (error) {
+      if (error instanceof AppError9) {
+        throw error;
+      } else {
+        throw new InternalServerError16("Failed to delete Permission Group.");
+      }
+    }
+  }
+  return {
+    addDefaultModule,
+    deleteById
+  };
+}
+
+// src/resources/permission/permission.group.controller.ts
+import { BadRequestError as BadRequestError25, logger as logger18 } from "@eeplatform/nodejs-utils";
+import Joi14 from "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 BadRequestError25(error.message));
+      logger18.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 = Joi14.object({
+      page: Joi14.number().min(1).optional().allow("", null),
+      limit: Joi14.number().min(1).optional().allow("", null),
+      search: Joi14.string().optional().allow("", null),
+      app: Joi14.string().optional().allow("", null),
+      status: Joi14.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError25(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 = Joi14.object({
+      id: Joi14.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError25(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 = Joi14.object({
+      id: Joi14.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError25(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 } = Joi14.string().hex().required().validate(id);
+    if (errorId) {
+      next(new BadRequestError25(errorId.message));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaPermissionGroupUpdate.validate(payload);
+    if (error) {
+      next(new BadRequestError25(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
+import { logger as logger19, useS3 as useS32, useAtlas as useAtlas13 } from "@eeplatform/nodejs-utils";
+import cron from "node-cron";
+import * as fs from "fs";
+function useFileService() {
+  const {
+    createFile: _createFile,
+    deleteFileById,
+    getAllDraftedFiles
+  } = useFileRepo();
+  const s3 = new useS32({
+    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 = useAtlas13.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 = useAtlas13.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() {
+    cron.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 logger19.log({
+            level: "info",
+            message: "Successfully deleted draft files."
+          });
+        } catch (error) {
+          logger19.log({
+            level: "info",
+            message: "Successfully deleted draft files."
+          });
+          return;
+        }
+      }
+    });
+  }
+  return {
+    createFile,
+    deleteFile,
+    deleteDraft
+  };
+}
+
+// src/resources/file/file.controller.ts
+import {
+  AppError as AppError10,
+  BadRequestError as BadRequestError26,
+  InternalServerError as InternalServerError17
+} from "@eeplatform/nodejs-utils";
+import Joi15 from "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 AppError10) {
+        next(error);
+      } else {
+        next(new InternalServerError17(error));
+      }
+    }
+  }
+  async function deleteFile(req, res, next) {
+    const id = req.params.id;
+    const validation = Joi15.string().required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new BadRequestError26(error.message));
+    }
+    try {
+      const message = await _deleteFile(id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      if (error2 instanceof AppError10) {
+        next(error2);
+      } else {
+        next(new InternalServerError17(error2));
+      }
+    }
+  }
+  return {
+    upload,
+    deleteFile
+  };
+}
+
+// src/resources/role/role.controller.ts
+import Joi18 from "joi";
+import { BadRequestError as BadRequestError29 } from "@eeplatform/nodejs-utils";
+
+// src/resources/role/role.service.ts
+import {
+  AppError as AppError11,
+  BadRequestError as BadRequestError28,
+  InternalServerError as InternalServerError18
+} from "@eeplatform/nodejs-utils";
+import Joi17 from "joi";
+
+// src/resources/member/member.controller.ts
+import Joi16 from "joi";
+import { BadRequestError as BadRequestError27 } from "@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 = Joi16.object({
+      id: Joi16.string().hex().required()
+    });
+    const { error } = validation.validate({ id: userId });
+    if (error) {
+      next(new BadRequestError27(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 = Joi16.object({
+      org: Joi16.string().hex().optional().allow("", null),
+      user: Joi16.string().hex().required(),
+      type: Joi16.string().required()
+    });
+    const { error } = validation.validate({ ...req.params, ...req.query });
+    if (error) {
+      next(new BadRequestError27(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 = Joi16.object({
+      limit: Joi16.number().min(10).max(300).required(),
+      search: Joi16.string().optional().allow("", null),
+      page: Joi16.number().required(),
+      user: Joi16.string().hex().optional().allow("", null),
+      org: Joi16.string().hex().optional().allow("", null),
+      type: Joi16.string().required(),
+      status: Joi16.string().required()
+    });
+    const { error } = validation.validate({
+      search,
+      page,
+      user,
+      org,
+      type,
+      limit,
+      status
+    });
+    if (error) {
+      next(new BadRequestError27(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 = Joi16.object({
+      limit: Joi16.number().min(10).max(50).required(),
+      search: Joi16.string().optional().allow("", null),
+      page: Joi16.number().required(),
+      user: Joi16.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate({
+      search,
+      page,
+      user,
       limit
     });
     if (error) {
-      next(new BadRequestError16(error.message));
+      next(new BadRequestError27(error.message));
     }
     try {
       const items = await _getOrgsByMembership({
@@ -3860,13 +5869,13 @@ function useMemberController() {
     }
   }
   async function updateStatusByUserId(req, res, next) {
-    const validation = Joi6.object({
-      id: Joi6.string().hex().required(),
-      status: Joi6.string().valid("active", "suspended", "deleted").required()
+    const validation = Joi16.object({
+      id: Joi16.string().hex().required(),
+      status: Joi16.string().valid("active", "suspended", "deleted").required()
     });
     const { error } = validation.validate(req.params);
     if (error) {
-      next(new BadRequestError16(error.message));
+      next(new BadRequestError27(error.message));
       return;
     }
     const id = req.params.id;
@@ -3892,26 +5901,26 @@ function useRoleService() {
   const { getByOrg } = useMemberRepo();
   const { deleteRole, getRoleById } = useRoleRepo();
   async function deleteById(_id) {
-    const { error } = Joi7.string().hex().length(24).validate(_id);
+    const { error } = Joi17.string().hex().length(24).validate(_id);
     if (error) {
-      throw new BadRequestError17("Invalid Role ID");
+      throw new BadRequestError28("Invalid Role ID");
     }
     try {
       const role = await getRoleById(_id);
       if (!role) {
-        throw new BadRequestError17("Role not found");
+        throw new BadRequestError28("Role not found");
       }
       const org = await getByOrg(String(role.id));
       if (org) {
-        throw new BadRequestError17("Cannot delete role assigned to members");
+        throw new BadRequestError28("Cannot delete role assigned to members");
       }
       await deleteRole(_id);
       return "Role deleted successfully";
     } catch (error2) {
-      if (error2 instanceof AppError6) {
+      if (error2 instanceof AppError11) {
         throw error2;
       }
-      throw new InternalServerError13("Failed to delete role");
+      throw new InternalServerError18("Failed to delete role");
     }
   }
   return {
@@ -3931,15 +5940,15 @@ function useRoleController() {
   } = useRoleRepo();
   async function createRole(req, res, next) {
     const payload = req.body;
-    const validation = Joi8.object({
-      name: Joi8.string().required(),
-      permissions: Joi8.array().items(Joi8.string()).required(),
-      type: Joi8.string().valid("school", "division", "region", "account").required(),
-      id: Joi8.string().hex().optional().allow("", null)
+    const validation = Joi18.object({
+      name: Joi18.string().required(),
+      permissions: Joi18.array().items(Joi18.string()).required(),
+      type: Joi18.string().valid("school", "division", "region", "account").required(),
+      id: Joi18.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate(payload);
     if (error) {
-      next(new BadRequestError18(error.message));
+      next(new BadRequestError29(error.message));
       return;
     }
     try {
@@ -3956,16 +5965,16 @@ function useRoleController() {
     const limit = parseInt(req.query.limit ?? "10");
     const type = req.query.type ?? "";
     const id = req.query.id ?? "";
-    const validation = Joi8.object({
-      search: Joi8.string().optional().allow("", null),
-      page: Joi8.number().required(),
-      limit: Joi8.number().required(),
-      type: Joi8.string().optional().allow("", null),
-      id: Joi8.string().hex().optional().allow("", null)
+    const validation = Joi18.object({
+      search: Joi18.string().optional().allow("", null),
+      page: Joi18.number().required(),
+      limit: Joi18.number().required(),
+      type: Joi18.string().optional().allow("", null),
+      id: Joi18.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate({ search, page, limit, type, id });
     if (error) {
-      next(new BadRequestError18(error.message));
+      next(new BadRequestError29(error.message));
       return;
     }
     try {
@@ -3978,12 +5987,12 @@ function useRoleController() {
   }
   async function getRoleByUserId(req, res, next) {
     const userId = req.params.userId;
-    const validation = Joi8.object({
-      userId: Joi8.string().required()
+    const validation = Joi18.object({
+      userId: Joi18.string().required()
     });
     const { error } = validation.validate({ userId });
     if (error) {
-      next(new BadRequestError18(error.message));
+      next(new BadRequestError29(error.message));
       return;
     }
     try {
@@ -3996,12 +6005,12 @@ function useRoleController() {
   }
   async function getRoleById(req, res, next) {
     const _id = req.params.id;
-    const validation = Joi8.object({
-      _id: Joi8.string().hex().required()
+    const validation = Joi18.object({
+      _id: Joi18.string().hex().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new BadRequestError18(error.message));
+      next(new BadRequestError29(error.message));
       return;
     }
     try {
@@ -4016,14 +6025,14 @@ function useRoleController() {
     const _id = req.params.id;
     const name = req.body.name ?? "";
     const permissions = req.body.permissions ?? [];
-    const validation = Joi8.object({
-      _id: Joi8.string().required(),
-      name: Joi8.string().required(),
-      permissions: Joi8.array().items(Joi8.string()).required()
+    const validation = Joi18.object({
+      _id: Joi18.string().required(),
+      name: Joi18.string().required(),
+      permissions: Joi18.array().items(Joi18.string()).required()
     });
     const { error } = validation.validate({ _id, name, permissions });
     if (error) {
-      next(new BadRequestError18(error.message));
+      next(new BadRequestError29(error.message));
       return;
     }
     try {
@@ -4037,13 +6046,13 @@ function useRoleController() {
   async function updatePermissionsById(req, res, next) {
     const _id = req.params.id;
     const permissions = req.body.permissions ?? [];
-    const validation = Joi8.object({
-      _id: Joi8.string().required(),
-      permissions: Joi8.array().items(Joi8.string()).required()
+    const validation = Joi18.object({
+      _id: Joi18.string().required(),
+      permissions: Joi18.array().items(Joi18.string()).required()
     });
     const { error } = validation.validate({ _id, permissions });
     if (error) {
-      next(new BadRequestError18(error.message));
+      next(new BadRequestError29(error.message));
       return;
     }
     try {
@@ -4057,12 +6066,12 @@ function useRoleController() {
   const { deleteById } = useRoleService();
   async function deleteRole(req, res, next) {
     const _id = req.params.id;
-    const validation = Joi8.object({
-      _id: Joi8.string().required()
+    const validation = Joi18.object({
+      _id: Joi18.string().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new BadRequestError18(error.message));
+      next(new BadRequestError29(error.message));
       return;
     }
     try {
@@ -4084,159 +6093,13 @@ function useRoleController() {
   };
 }
 
-// src/resources/file/file.service.ts
-import { logger as logger11, useS3 as useS32, useAtlas as useAtlas11 } from "@eeplatform/nodejs-utils";
-import cron from "node-cron";
-import * as fs from "fs";
-function useFileService() {
-  const {
-    createFile: _createFile,
-    deleteFileById,
-    getAllDraftedFiles
-  } = useFileRepo();
-  const s3 = new useS32({
-    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 = useAtlas11.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 = useAtlas11.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() {
-    cron.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 logger11.log({
-            level: "info",
-            message: "Successfully deleted draft files."
-          });
-        } catch (error) {
-          logger11.log({
-            level: "info",
-            message: "Successfully deleted draft files."
-          });
-          return;
-        }
-      }
-    });
-  }
-  return {
-    createFile,
-    deleteFile,
-    deleteDraft
-  };
-}
-
-// src/resources/file/file.controller.ts
-import {
-  AppError as AppError7,
-  BadRequestError as BadRequestError19,
-  InternalServerError as InternalServerError15
-} from "@eeplatform/nodejs-utils";
-import Joi9 from "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 AppError7) {
-        next(error);
-      } else {
-        next(new InternalServerError15(error));
-      }
-    }
-  }
-  async function deleteFile(req, res, next) {
-    const id = req.params.id;
-    const validation = Joi9.string().required();
-    const { error } = validation.validate(id);
-    if (error) {
-      next(new BadRequestError19(error.message));
-    }
-    try {
-      const message = await _deleteFile(id);
-      res.json({ message });
-      return;
-    } catch (error2) {
-      if (error2 instanceof AppError7) {
-        next(error2);
-      } else {
-        next(new InternalServerError15(error2));
-      }
-    }
-  }
-  return {
-    upload,
-    deleteFile
-  };
-}
-
 // src/resources/verification/verification.controller.ts
 import {
-  AppError as AppError8,
-  BadRequestError as BadRequestError20,
-  InternalServerError as InternalServerError16
+  AppError as AppError12,
+  BadRequestError as BadRequestError30,
+  InternalServerError as InternalServerError20
 } from "@eeplatform/nodejs-utils";
-import Joi10 from "joi";
+import Joi19 from "joi";
 function useVerificationController() {
   const {
     createUserInvite: _createUserInvite,
@@ -4246,17 +6109,17 @@ function useVerificationController() {
   } = useVerificationService();
   const { getVerifications: _getVerifications } = useVerificationRepo();
   async function createUserInvite(req, res, next) {
-    const validation = Joi10.object({
-      email: Joi10.string().email().required(),
-      app: Joi10.string().required(),
-      role: Joi10.string().hex().required(),
-      roleName: Joi10.string().required(),
-      org: Joi10.string().hex().optional().optional().allow("", null),
-      orgName: Joi10.string().optional().optional().allow("", null)
+    const validation = Joi19.object({
+      email: Joi19.string().email().required(),
+      app: Joi19.string().required(),
+      role: Joi19.string().hex().required(),
+      roleName: Joi19.string().required(),
+      org: Joi19.string().hex().optional().optional().allow("", null),
+      orgName: Joi19.string().optional().optional().allow("", null)
     });
     const { error } = validation.validate(req.body);
     if (error) {
-      next(new BadRequestError20(error.message));
+      next(new BadRequestError30(error.message));
       return;
     }
     const email = req.body.email ?? "";
@@ -4284,10 +6147,10 @@ function useVerificationController() {
   }
   async function createForgetPassword(req, res, next) {
     const email = req.body.email || "";
-    const validation = Joi10.string().email().required();
+    const validation = Joi19.string().email().required();
     const { error } = validation.validate(email);
     if (error) {
-      next(new BadRequestError20(error.message));
+      next(new BadRequestError30(error.message));
       return;
     }
     try {
@@ -4297,25 +6160,25 @@ function useVerificationController() {
       });
       return;
     } catch (error2) {
-      if (error2 instanceof AppError8) {
+      if (error2 instanceof AppError12) {
         next(error2);
       } else {
-        next(new InternalServerError16("An unexpected error occurred"));
+        next(new InternalServerError20("An unexpected error occurred"));
       }
     }
   }
   async function getVerifications(req, res, next) {
-    const validation = Joi10.object({
-      status: Joi10.string().required(),
-      search: Joi10.string().optional().allow("", null),
-      page: Joi10.number().required(),
-      type: Joi10.string().optional().allow("", null),
-      email: Joi10.string().optional().allow("", null),
-      app: Joi10.string().optional().allow("", null)
+    const validation = Joi19.object({
+      status: Joi19.string().required(),
+      search: Joi19.string().optional().allow("", null),
+      page: Joi19.number().required(),
+      type: Joi19.string().optional().allow("", null),
+      email: Joi19.string().optional().allow("", null),
+      app: Joi19.string().optional().allow("", null)
     });
     const { error } = validation.validate(req.query);
     if (error) {
-      next(new BadRequestError20(error.message));
+      next(new BadRequestError30(error.message));
       return;
     }
     const status = req.query.status ?? "";
@@ -4346,10 +6209,10 @@ function useVerificationController() {
   }
   async function verify(req, res, next) {
     const id = req.params.id || "";
-    const validation = Joi10.string().hex().required();
+    const validation = Joi19.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new BadRequestError20(error.message));
+      next(new BadRequestError30(error.message));
       return;
     }
     try {
@@ -4362,10 +6225,10 @@ function useVerificationController() {
   }
   async function cancelUserInvitation(req, res, next) {
     const otpId = req.params.id || "";
-    const validation = Joi10.string().hex().required();
+    const validation = Joi19.string().hex().required();
     const { error } = validation.validate(otpId);
     if (error) {
-      next(new BadRequestError20(error.message));
+      next(new BadRequestError30(error.message));
       return;
     }
     try {
@@ -4387,34 +6250,34 @@ function useVerificationController() {
 }
 
 // src/resources/address/address.model.ts
-import { BadRequestError as BadRequestError21 } from "@eeplatform/nodejs-utils";
-import Joi11 from "joi";
-import { ObjectId as ObjectId14 } from "mongodb";
-var addressSchema = Joi11.object({
-  type: Joi11.string().required(),
-  user: Joi11.string().hex().optional().allow("", null),
-  org: Joi11.string().hex().optional().allow("", null),
-  country: Joi11.string().required(),
-  address: Joi11.string().required(),
-  continuedAddress: Joi11.string().optional().allow("", null),
-  city: Joi11.string().required(),
-  province: Joi11.string().required(),
-  postalCode: Joi11.string().required(),
-  taxId: Joi11.string().optional().allow("", null)
+import { BadRequestError as BadRequestError31 } from "@eeplatform/nodejs-utils";
+import Joi20 from "joi";
+import { ObjectId as ObjectId17 } from "mongodb";
+var addressSchema = Joi20.object({
+  type: Joi20.string().required(),
+  user: Joi20.string().hex().optional().allow("", null),
+  org: Joi20.string().hex().optional().allow("", null),
+  country: Joi20.string().required(),
+  address: Joi20.string().required(),
+  continuedAddress: Joi20.string().optional().allow("", null),
+  city: Joi20.string().required(),
+  province: Joi20.string().required(),
+  postalCode: Joi20.string().required(),
+  taxId: Joi20.string().optional().allow("", null)
 });
 function MAddress(value) {
   if (value.user) {
     try {
-      value.user = new ObjectId14(value.user);
+      value.user = new ObjectId17(value.user);
     } catch (error) {
-      throw new BadRequestError21("Invalid user ID.");
+      throw new BadRequestError31("Invalid user ID.");
     }
   }
   if (value.org) {
     try {
-      value.org = new ObjectId14(value.org);
+      value.org = new ObjectId17(value.org);
     } catch (error) {
-      throw new BadRequestError21("Invalid org ID.");
+      throw new BadRequestError31("Invalid org ID.");
     }
   }
   return {
@@ -4433,29 +6296,29 @@ function MAddress(value) {
 
 // src/resources/address/address.repository.ts
 import {
-  BadRequestError as BadRequestError22,
-  useAtlas as useAtlas12,
+  BadRequestError as BadRequestError32,
+  useAtlas as useAtlas14,
   useCache as useCache10,
-  makeCacheKey as makeCacheKey9,
-  logger as logger12
+  makeCacheKey as makeCacheKey12,
+  logger as logger20
 } from "@eeplatform/nodejs-utils";
-import { ObjectId as ObjectId15 } from "mongodb";
+import { ObjectId as ObjectId18 } from "mongodb";
 function useAddressRepo() {
-  const db = useAtlas12.getDb();
+  const db = useAtlas14.getDb();
   if (!db) {
-    throw new BadRequestError22("Unable to connect to server.");
+    throw new BadRequestError32("Unable to connect to server.");
   }
   const namespace_collection = "addresses";
   const collection = db.collection(namespace_collection);
   const { getCache, setCache, delNamespace } = useCache10(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      logger12.log({
+      logger20.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      logger12.log({
+      logger20.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -4469,7 +6332,7 @@ function useAddressRepo() {
         { key: { orgId: 1 } }
       ]);
     } catch (error) {
-      throw new BadRequestError22("Failed to create index on address.");
+      throw new BadRequestError32("Failed to create index on address.");
     }
   }
   async function add(value, session) {
@@ -4479,20 +6342,20 @@ function useAddressRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      throw new BadRequestError22("Failed to create address.");
+      throw new BadRequestError32("Failed to create address.");
     }
   }
   async function updateById(_id, value, session) {
     try {
-      _id = new ObjectId15(_id);
+      _id = new ObjectId18(_id);
     } catch (error) {
-      throw new BadRequestError22("Invalid address ID.");
+      throw new BadRequestError32("Invalid address ID.");
     }
     if (value.org) {
       try {
-        value.org = new ObjectId15(value.org);
+        value.org = new ObjectId18(value.org);
       } catch (error) {
-        throw new BadRequestError22("Invalid org ID.");
+        throw new BadRequestError32("Invalid org ID.");
       }
     }
     try {
@@ -4504,20 +6367,20 @@ function useAddressRepo() {
       delCachedData();
       return "Successfully updated address.";
     } catch (error) {
-      throw new BadRequestError22("Failed to update address.");
+      throw new BadRequestError32("Failed to update address.");
     }
   }
   async function getByUserId(user) {
     try {
-      user = new ObjectId15(user);
+      user = new ObjectId18(user);
     } catch (error) {
-      throw new BadRequestError22("Invalid user ID.");
+      throw new BadRequestError32("Invalid user ID.");
     }
-    const cacheKey = makeCacheKey9(namespace_collection, { user: String(user) });
+    const cacheKey = makeCacheKey12(namespace_collection, { user: String(user) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger12.log({
+        logger20.log({
           level: "info",
           message: `Cache hit for getByUserId address: ${cacheKey}`
         });
@@ -4526,12 +6389,12 @@ function useAddressRepo() {
       const data = await collection.findOne({ user });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          logger12.log({
+          logger20.log({
             level: "info",
             message: `Cache set for address by user ID: ${cacheKey}`
           });
         }).catch((err) => {
-          logger12.log({
+          logger20.log({
             level: "error",
             message: `Failed to set cache for address by user ID: ${err.message}`
           });
@@ -4539,20 +6402,20 @@ function useAddressRepo() {
       }
       return data;
     } catch (error) {
-      throw new BadRequestError22("Failed to get address by ID.");
+      throw new BadRequestError32("Failed to get address by ID.");
     }
   }
   async function getByOrgId(org) {
     try {
-      org = new ObjectId15(org);
+      org = new ObjectId18(org);
     } catch (error) {
-      throw new BadRequestError22("Invalid orgId.");
+      throw new BadRequestError32("Invalid orgId.");
     }
-    const cacheKey = makeCacheKey9(namespace_collection, { org: String(org) });
+    const cacheKey = makeCacheKey12(namespace_collection, { org: String(org) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger12.log({
+        logger20.log({
           level: "info",
           message: `Cache hit for getByOrgId address: ${cacheKey}`
         });
@@ -4561,12 +6424,12 @@ function useAddressRepo() {
       const data = await collection.findOne({ org });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          logger12.log({
+          logger20.log({
             level: "info",
             message: `Cache set for address by org ID: ${cacheKey}`
           });
         }).catch((err) => {
-          logger12.log({
+          logger20.log({
             level: "error",
             message: `Failed to set cache for address by org ID: ${err.message}`
           });
@@ -4574,7 +6437,7 @@ function useAddressRepo() {
       }
       return data;
     } catch (error) {
-      throw new BadRequestError22("Failed to get address by orgId.");
+      throw new BadRequestError32("Failed to get address by orgId.");
     }
   }
   return {
@@ -4587,8 +6450,8 @@ function useAddressRepo() {
 }
 
 // src/resources/address/address.controller.ts
-import { BadRequestError as BadRequestError23, NotFoundError as NotFoundError4 } from "@eeplatform/nodejs-utils";
-import Joi12 from "joi";
+import { BadRequestError as BadRequestError33, NotFoundError as NotFoundError4 } from "@eeplatform/nodejs-utils";
+import Joi21 from "joi";
 function useAddressController() {
   const {
     add: _add,
@@ -4598,21 +6461,21 @@ function useAddressController() {
   } = useAddressRepo();
   async function add(req, res, next) {
     const value = req.body;
-    const validation = Joi12.object({
-      type: Joi12.string().required(),
-      user: Joi12.string().hex().optional().allow("", null),
-      org: Joi12.string().hex().optional().allow("", null),
-      country: Joi12.string().required(),
-      address: Joi12.string().required(),
-      continuedAddress: Joi12.string().optional().allow("", null),
-      city: Joi12.string().required(),
-      province: Joi12.string().required(),
-      postalCode: Joi12.string().required(),
-      taxId: Joi12.string().optional().allow("", null)
+    const validation = Joi21.object({
+      type: Joi21.string().required(),
+      user: Joi21.string().hex().optional().allow("", null),
+      org: Joi21.string().hex().optional().allow("", null),
+      country: Joi21.string().required(),
+      address: Joi21.string().required(),
+      continuedAddress: Joi21.string().optional().allow("", null),
+      city: Joi21.string().required(),
+      province: Joi21.string().required(),
+      postalCode: Joi21.string().required(),
+      taxId: Joi21.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new BadRequestError23(error.message));
+      next(new BadRequestError33(error.message));
     }
     try {
       const value2 = req.body;
@@ -4626,20 +6489,20 @@ function useAddressController() {
   async function updateById(req, res, next) {
     const id = req.params.id ?? "";
     const value = req.body;
-    const validation = Joi12.object({
-      id: Joi12.string().hex().required(),
-      country: Joi12.string().required(),
-      address: Joi12.string().required(),
-      continuedAddress: Joi12.string().optional().allow("", null),
-      city: Joi12.string().required(),
-      province: Joi12.string().required(),
-      postalCode: Joi12.string().required(),
-      taxId: Joi12.string().optional().allow("", null),
-      org: Joi12.string().hex().optional().allow("", null)
+    const validation = Joi21.object({
+      id: Joi21.string().hex().required(),
+      country: Joi21.string().required(),
+      address: Joi21.string().required(),
+      continuedAddress: Joi21.string().optional().allow("", null),
+      city: Joi21.string().required(),
+      province: Joi21.string().required(),
+      postalCode: Joi21.string().required(),
+      taxId: Joi21.string().optional().allow("", null),
+      org: Joi21.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate({ id, ...value });
     if (error) {
-      next(new BadRequestError23(error.message));
+      next(new BadRequestError33(error.message));
       return;
     }
     try {
@@ -4652,10 +6515,10 @@ function useAddressController() {
   }
   async function getByUserId(req, res, next) {
     const user = req.params.user;
-    const validation = Joi12.string().hex().required();
+    const validation = Joi21.string().hex().required();
     const { error } = validation.validate(user);
     if (error) {
-      next(new BadRequestError23(error.message));
+      next(new BadRequestError33(error.message));
     }
     try {
       const address = await _getByUserId(user);
@@ -4671,10 +6534,10 @@ function useAddressController() {
   }
   async function getByOrgId(req, res, next) {
     const id = req.params.id;
-    const validation = Joi12.string().hex().required();
+    const validation = Joi21.string().hex().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new BadRequestError23(error.message));
+      next(new BadRequestError33(error.message));
     }
     try {
       const address = await _getByOrgId(id);
@@ -4697,24 +6560,24 @@ function useAddressController() {
 }
 
 // src/resources/token/token.model.ts
-import { ObjectId as ObjectId16 } from "mongodb";
+import { ObjectId as ObjectId19 } from "mongodb";
 var MToken = class {
   constructor(value) {
     this.token = value.token ?? "";
-    this.user = value.user ?? new ObjectId16();
+    this.user = value.user ?? new ObjectId19();
     this.createdAt = value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
   }
 };
 
 // src/resources/counter/counter.model.ts
-import { BadRequestError as BadRequestError24 } from "@eeplatform/nodejs-utils";
-import { ObjectId as ObjectId17 } from "mongodb";
+import { BadRequestError as BadRequestError34 } from "@eeplatform/nodejs-utils";
+import { ObjectId as ObjectId20 } from "mongodb";
 import { z } from "zod";
 var TCounter = z.object({
   _id: z.union([
     z.string().length(24, "Invalid ObjectId hex string"),
-    z.instanceof(ObjectId17)
-  ]).transform((val) => typeof val === "string" ? new ObjectId17(val) : val).optional(),
+    z.instanceof(ObjectId20)
+  ]).transform((val) => typeof val === "string" ? new ObjectId20(val) : val).optional(),
   count: z.number().int().min(0).default(0),
   type: z.string(),
   createdAt: z.date().optional().default(() => /* @__PURE__ */ new Date()),
@@ -4727,7 +6590,7 @@ function useCounterModel(db) {
     try {
       return TCounter.parse(value);
     } catch (error) {
-      throw new BadRequestError24(error.issues[0].message);
+      throw new BadRequestError34(error.issues[0].message);
     }
   }
   function validateCounter(data) {
@@ -4742,13 +6605,13 @@ function useCounterModel(db) {
 
 // src/resources/counter/counter.repository.ts
 import {
-  useAtlas as useAtlas13,
+  useAtlas as useAtlas15,
   useCache as useCache11,
-  makeCacheKey as makeCacheKey10,
-  logger as logger13
+  makeCacheKey as makeCacheKey13,
+  logger as logger21
 } from "@eeplatform/nodejs-utils";
 function useCounterRepo() {
-  const db = useAtlas13.getDb();
+  const db = useAtlas15.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
@@ -4757,12 +6620,12 @@ function useCounterRepo() {
   const { getCache, setCache, delNamespace } = useCache11(namespace_collection);
   function delCachedData() {
     delNamespace().then(() => {
-      logger13.log({
+      logger21.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      logger13.log({
+      logger21.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -4814,11 +6677,11 @@ function useCounterRepo() {
     }
   }
   async function getByType(type) {
-    const cacheKey = makeCacheKey10(namespace_collection, { type });
+    const cacheKey = makeCacheKey13(namespace_collection, { type });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger13.log({
+        logger21.log({
           level: "info",
           message: `Cache hit for getByType counter: ${cacheKey}`
         });
@@ -4827,12 +6690,12 @@ function useCounterRepo() {
       const data = await collection.findOne({ type });
       if (data) {
         setCache(cacheKey, data, 300).then(() => {
-          logger13.log({
+          logger21.log({
             level: "info",
             message: `Cache set for counter by type: ${cacheKey}`
           });
         }).catch((err) => {
-          logger13.log({
+          logger21.log({
             level: "error",
             message: `Failed to set cache for counter by type: ${err.message}`
           });
@@ -5170,7 +7033,7 @@ IMPORTANT: Only consider it a match if the target phoneme is the FIRST sound pro
 }
 
 // src/resources/utils/github.service.ts
-import { AppError as AppError9, BadRequestError as BadRequestError25 } from "@eeplatform/nodejs-utils";
+import { AppError as AppError13, BadRequestError as BadRequestError35 } from "@eeplatform/nodejs-utils";
 import { Octokit } from "@octokit/rest";
 import _sodium from "libsodium-wrappers";
 function useGitHubService() {
@@ -5184,23 +7047,23 @@ function useGitHubService() {
     try {
       const { data: repoData } = await octokit.repos.get({ owner, repo });
       if (!repoData.permissions?.admin) {
-        throw new BadRequestError25(
+        throw new BadRequestError35(
           "You do not have admin access to this repository."
         );
       }
     } catch (error) {
       if (error.status === 404) {
-        throw new BadRequestError25(
+        throw new BadRequestError35(
           "Repository not found or you don't have access to it."
         );
       } else if (error.status === 401) {
-        throw new BadRequestError25(
+        throw new BadRequestError35(
           "Invalid GitHub token or insufficient permissions."
         );
       } else if (error.message.includes("admin access")) {
         throw error;
       } else {
-        throw new BadRequestError25(
+        throw new BadRequestError35(
           `Failed to check repository permissions: ${error.message}`
         );
       }
@@ -5249,7 +7112,7 @@ function useGitHubService() {
               key_id: publicKeyRes.key_id
             });
           } catch (encryptionError) {
-            throw new BadRequestError25(
+            throw new BadRequestError35(
               `Failed to encrypt secret '${key}': ${encryptionError.message}`
             );
           }
@@ -5265,22 +7128,22 @@ function useGitHubService() {
       }
       return `Successfully set ${lines.length} ${type} variables/secrets in environment '${environment}'`;
     } catch (error) {
-      if (error instanceof AppError9)
+      if (error instanceof AppError13)
         throw error;
       if (error.status === 422) {
-        throw new BadRequestError25(
+        throw new BadRequestError35(
           `GitHub API validation error: ${error.message}`
         );
       } else if (error.status === 404) {
-        throw new BadRequestError25("Environment or repository not found.");
+        throw new BadRequestError35("Environment or repository not found.");
       } else if (error.status === 403) {
-        throw new BadRequestError25(
+        throw new BadRequestError35(
           "Forbidden: Insufficient permissions or rate limit exceeded."
         );
       } else if (error.message.includes("admin access") || error.message.includes("permissions")) {
         throw error;
       } else {
-        throw new BadRequestError25(
+        throw new BadRequestError35(
           `Failed to set GitHub variables: ${error.message}`
         );
       }
@@ -5292,7 +7155,7 @@ function useGitHubService() {
 }
 
 // src/resources/utils/transcribe.service.ts
-import { AppError as AppError10, BadRequestError as BadRequestError26, useRedis } from "@eeplatform/nodejs-utils";
+import { AppError as AppError14, BadRequestError as BadRequestError36, useRedis } from "@eeplatform/nodejs-utils";
 function useTranscribeService() {
   const { createFile } = useFileService();
   const { getClient } = useRedis();
@@ -5301,10 +7164,10 @@ function useTranscribeService() {
     try {
       const fileId = await createFile(file);
     } catch (error) {
-      if (error instanceof AppError10) {
+      if (error instanceof AppError14) {
         throw error;
       } else {
-        throw new BadRequestError26("Failed to transcribe audio file");
+        throw new BadRequestError36("Failed to transcribe audio file");
       }
     }
   }
@@ -5315,31 +7178,31 @@ function useTranscribeService() {
 
 // src/resources/utils/audio-transcription.controller.ts
 import {
-  AppError as AppError11,
-  BadRequestError as BadRequestError27,
-  InternalServerError as InternalServerError17
+  AppError as AppError15,
+  BadRequestError as BadRequestError37,
+  InternalServerError as InternalServerError21
 } from "@eeplatform/nodejs-utils";
-import Joi13 from "joi";
+import Joi22 from "joi";
 function useAudioTranscriptionController() {
   const geminiService = useGeminiAiService();
-  const transcriptionOptionsSchema = Joi13.object({
-    language: Joi13.string().optional().max(50),
-    enableTimestamps: Joi13.boolean().optional(),
-    prompt: Joi13.string().optional().max(1e3),
-    maxTokens: Joi13.number().integer().min(1).max(8192).optional()
+  const transcriptionOptionsSchema = Joi22.object({
+    language: Joi22.string().optional().max(50),
+    enableTimestamps: Joi22.boolean().optional(),
+    prompt: Joi22.string().optional().max(1e3),
+    maxTokens: Joi22.number().integer().min(1).max(8192).optional()
   });
-  const phonemeOptionsSchema = Joi13.object({
-    language: Joi13.string().optional().max(50),
-    caseSensitive: Joi13.boolean().optional(),
-    partialMatch: Joi13.boolean().optional()
+  const phonemeOptionsSchema = Joi22.object({
+    language: Joi22.string().optional().max(50),
+    caseSensitive: Joi22.boolean().optional(),
+    partialMatch: Joi22.boolean().optional()
   });
-  const phonemeMatchSchema = Joi13.object({
-    targetPhoneme: Joi13.string().required().min(1).max(10),
+  const phonemeMatchSchema = Joi22.object({
+    targetPhoneme: Joi22.string().required().min(1).max(10),
     options: phonemeOptionsSchema.optional()
   });
   async function transcribeFromFile(req, res, next) {
     if (!req.file) {
-      next(new BadRequestError27("Audio file is required"));
+      next(new BadRequestError37("Audio file is required"));
       return;
     }
     try {
@@ -5347,14 +7210,14 @@ function useAudioTranscriptionController() {
         req.body
       );
       if (error) {
-        next(new BadRequestError27(error.message));
+        next(new BadRequestError37(error.message));
         return;
       }
       const { buffer, mimetype, originalname, size } = req.file;
       if (!geminiService.validateAudioFormat(mimetype)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `Unsupported audio format: ${mimetype}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5365,7 +7228,7 @@ function useAudioTranscriptionController() {
       const maxSizeBytes = 25 * 1024 * 1024;
       if (size > maxSizeBytes) {
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `File size too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5395,11 +7258,11 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof AppError11) {
+      if (error instanceof AppError15) {
         next(error);
       } else {
         next(
-          new InternalServerError17(
+          new InternalServerError21(
             `Audio transcription failed: ${error.message}`
           )
         );
@@ -5408,21 +7271,21 @@ function useAudioTranscriptionController() {
   }
   async function transcribeFromBase64(req, res, next) {
     try {
-      const bodySchema = Joi13.object({
-        audioData: Joi13.string().required(),
-        mimeType: Joi13.string().required(),
+      const bodySchema = Joi22.object({
+        audioData: Joi22.string().required(),
+        mimeType: Joi22.string().required(),
         options: transcriptionOptionsSchema.optional()
       });
       const { error, value } = bodySchema.validate(req.body);
       if (error) {
-        next(new BadRequestError27(error.message));
+        next(new BadRequestError37(error.message));
         return;
       }
       const { audioData, mimeType, options = {} } = value;
       if (!geminiService.validateAudioFormat(mimeType)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `Unsupported audio format: ${mimeType}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5434,13 +7297,13 @@ function useAudioTranscriptionController() {
       try {
         audioBuffer = Buffer.from(audioData, "base64");
       } catch (conversionError) {
-        next(new BadRequestError27("Invalid base64 audio data"));
+        next(new BadRequestError37("Invalid base64 audio data"));
         return;
       }
       const maxSizeBytes = 25 * 1024 * 1024;
       if (audioBuffer.length > maxSizeBytes) {
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `Audio data too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5469,11 +7332,11 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof AppError11) {
+      if (error instanceof AppError15) {
         next(error);
       } else {
         next(
-          new InternalServerError17(
+          new InternalServerError21(
             `Audio transcription failed: ${error.message}`
           )
         );
@@ -5493,7 +7356,7 @@ function useAudioTranscriptionController() {
       });
     } catch (error) {
       next(
-        new InternalServerError17(
+        new InternalServerError21(
           `Failed to get supported formats: ${error.message}`
         )
       );
@@ -5501,12 +7364,12 @@ function useAudioTranscriptionController() {
   }
   async function validateFormat(req, res, next) {
     try {
-      const schema = Joi13.object({
-        mimeType: Joi13.string().required()
+      const schema = Joi22.object({
+        mimeType: Joi22.string().required()
       });
       const { error, value } = schema.validate(req.body);
       if (error) {
-        next(new BadRequestError27(error.message));
+        next(new BadRequestError37(error.message));
         return;
       }
       const { mimeType } = value;
@@ -5522,19 +7385,19 @@ function useAudioTranscriptionController() {
       });
     } catch (error) {
       next(
-        new InternalServerError17(`Format validation failed: ${error.message}`)
+        new InternalServerError21(`Format validation failed: ${error.message}`)
       );
     }
   }
   async function checkPhonemeFromFile(req, res, next) {
     if (!req.file) {
-      next(new BadRequestError27("Audio file is required"));
+      next(new BadRequestError37("Audio file is required"));
       return;
     }
     try {
       const { error, value } = phonemeMatchSchema.validate(req.body);
       if (error) {
-        next(new BadRequestError27(error.message));
+        next(new BadRequestError37(error.message));
         return;
       }
       const { targetPhoneme, options = {} } = value;
@@ -5542,7 +7405,7 @@ function useAudioTranscriptionController() {
       if (!geminiService.validateAudioFormat(mimetype)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `Unsupported audio format: ${mimetype}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5553,7 +7416,7 @@ function useAudioTranscriptionController() {
       const maxSizeBytes = 25 * 1024 * 1024;
       if (size > maxSizeBytes) {
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `File size too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5568,7 +7431,7 @@ function useAudioTranscriptionController() {
       );
       const processingTime = Date.now() - startTime;
       if (!result.isMatch) {
-        throw new BadRequestError27(
+        throw new BadRequestError37(
           `Phoneme "${targetPhoneme}" not found in the provided audio. Transcription: "${result.transcription}"`
         );
       }
@@ -5596,33 +7459,33 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof AppError11) {
+      if (error instanceof AppError15) {
         next(error);
       } else {
         next(
-          new InternalServerError17(`Phoneme analysis failed: ${error.message}`)
+          new InternalServerError21(`Phoneme analysis failed: ${error.message}`)
         );
       }
     }
   }
   async function checkPhonemeFromBase64(req, res, next) {
     try {
-      const bodySchema = Joi13.object({
-        audioData: Joi13.string().required(),
-        mimeType: Joi13.string().required(),
-        targetPhoneme: Joi13.string().required().min(1).max(10),
+      const bodySchema = Joi22.object({
+        audioData: Joi22.string().required(),
+        mimeType: Joi22.string().required(),
+        targetPhoneme: Joi22.string().required().min(1).max(10),
         options: phonemeOptionsSchema.optional()
       });
       const { error, value } = bodySchema.validate(req.body);
       if (error) {
-        next(new BadRequestError27(error.message));
+        next(new BadRequestError37(error.message));
         return;
       }
       const { audioData, mimeType, targetPhoneme, options = {} } = value;
       if (!geminiService.validateAudioFormat(mimeType)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `Unsupported audio format: ${mimeType}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5634,13 +7497,13 @@ function useAudioTranscriptionController() {
       try {
         audioBuffer = Buffer.from(audioData, "base64");
       } catch (conversionError) {
-        next(new BadRequestError27("Invalid base64 audio data"));
+        next(new BadRequestError37("Invalid base64 audio data"));
         return;
       }
       const maxSizeBytes = 25 * 1024 * 1024;
       if (audioBuffer.length > maxSizeBytes) {
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `Audio data too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5655,7 +7518,7 @@ function useAudioTranscriptionController() {
       );
       const processingTime = Date.now() - startTime;
       if (!result.isMatch) {
-        throw new BadRequestError27(
+        throw new BadRequestError37(
           `Phoneme "${targetPhoneme}" not found in the provided audio. Transcription: "${result.transcription}"`
         );
       }
@@ -5682,28 +7545,28 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof AppError11) {
+      if (error instanceof AppError15) {
         next(error);
       } else {
         next(
-          new InternalServerError17(`Phoneme analysis failed: ${error.message}`)
+          new InternalServerError21(`Phoneme analysis failed: ${error.message}`)
         );
       }
     }
   }
   async function batchPhonemeCheck(req, res, next) {
     if (!req.file) {
-      next(new BadRequestError27("Audio file is required"));
+      next(new BadRequestError37("Audio file is required"));
       return;
     }
     try {
-      const batchSchema = Joi13.object({
-        targetPhonemes: Joi13.array().items(Joi13.string().min(1).max(10)).min(1).max(20).required(),
+      const batchSchema = Joi22.object({
+        targetPhonemes: Joi22.array().items(Joi22.string().min(1).max(10)).min(1).max(20).required(),
         options: phonemeOptionsSchema.optional()
       });
       const { error, value } = batchSchema.validate(req.body);
       if (error) {
-        next(new BadRequestError27(error.message));
+        next(new BadRequestError37(error.message));
         return;
       }
       const { targetPhonemes, options = {} } = value;
@@ -5711,7 +7574,7 @@ function useAudioTranscriptionController() {
       if (!geminiService.validateAudioFormat(mimetype)) {
         const supportedFormats = geminiService.getSupportedAudioFormats();
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `Unsupported audio format: ${mimetype}. Supported formats: ${supportedFormats.join(
               ", "
             )}`
@@ -5722,7 +7585,7 @@ function useAudioTranscriptionController() {
       const maxSizeBytes = 25 * 1024 * 1024;
       if (size > maxSizeBytes) {
         next(
-          new BadRequestError27(
+          new BadRequestError37(
             `File size too large. Maximum allowed size is ${maxSizeBytes / (1024 * 1024)}MB`
           )
         );
@@ -5778,11 +7641,11 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      if (error instanceof AppError11) {
+      if (error instanceof AppError15) {
         next(error);
       } else {
         next(
-          new InternalServerError17(
+          new InternalServerError21(
             `Batch phoneme analysis failed: ${error.message}`
           )
         );
@@ -5803,7 +7666,7 @@ function useAudioTranscriptionController() {
         }
       });
     } catch (error) {
-      next(new InternalServerError17(`Health check failed: ${error.message}`));
+      next(new InternalServerError21(`Health check failed: ${error.message}`));
     }
   }
   return {
@@ -5819,12 +7682,12 @@ function useAudioTranscriptionController() {
 }
 
 // src/resources/utils/util.controller.ts
-import Joi14 from "joi";
+import Joi23 from "joi";
 import {
-  AppError as AppError12,
-  BadRequestError as BadRequestError28,
-  InternalServerError as InternalServerError18,
-  logger as logger14
+  AppError as AppError16,
+  BadRequestError as BadRequestError38,
+  InternalServerError as InternalServerError22,
+  logger as logger22
 } from "@eeplatform/nodejs-utils";
 function useUtilController() {
   async function healthCheck(req, res, next) {
@@ -5841,32 +7704,32 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      logger14.error("Health check failed", { error: error.message });
-      next(new InternalServerError18("Health check failed"));
+      logger22.error("Health check failed", { error: error.message });
+      next(new InternalServerError22("Health check failed"));
     }
   }
   async function setGitHubVariables(req, res, next) {
     try {
       const { githubToken, repoUrl, environment, type, keyValues } = req.body;
-      const validation = Joi14.object({
-        githubToken: Joi14.string().required().messages({
+      const validation = Joi23.object({
+        githubToken: Joi23.string().required().messages({
           "string.empty": "GitHub token is required",
           "any.required": "GitHub token is required"
         }),
-        repoUrl: Joi14.string().uri().required().messages({
+        repoUrl: Joi23.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: Joi14.string().required().messages({
+        environment: Joi23.string().required().messages({
           "string.empty": "Environment name is required",
           "any.required": "Environment name is required"
         }),
-        type: Joi14.string().valid("env", "secret").required().messages({
+        type: Joi23.string().valid("env", "secret").required().messages({
           "any.only": 'Type must be either "env" or "secret"',
           "any.required": "Type is required"
         }),
-        keyValues: Joi14.string().required().messages({
+        keyValues: Joi23.string().required().messages({
           "string.empty": "Key-value pairs are required",
           "any.required": "Key-value pairs are required"
         })
@@ -5879,13 +7742,13 @@ function useUtilController() {
         keyValues
       });
       if (error) {
-        next(new BadRequestError28(error.message));
+        next(new BadRequestError38(error.message));
         return;
       }
       const repoUrlPattern = /github\.com[:\/]([^\/]+)\/(.+)\.git$/;
       if (!repoUrlPattern.test(repoUrl)) {
         next(
-          new BadRequestError28(
+          new BadRequestError38(
             "Invalid GitHub repository URL format. Expected format: https://github.com/owner/repo.git"
           )
         );
@@ -5897,7 +7760,7 @@ function useUtilController() {
       );
       if (invalidLines.length > 0) {
         next(
-          new BadRequestError28(
+          new BadRequestError38(
             "Invalid key-value format. Each pair should be in format: KEY=value. Pairs should be separated by semicolons."
           )
         );
@@ -5911,7 +7774,7 @@ function useUtilController() {
         type,
         keyValues
       });
-      logger14.info(`GitHub variables set successfully`, {
+      logger22.info(`GitHub variables set successfully`, {
         repoUrl,
         environment,
         type,
@@ -5928,15 +7791,15 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      logger14.error("Failed to set GitHub variables", {
+      logger22.error("Failed to set GitHub variables", {
         error: error.message,
         stack: error.stack
       });
-      if (error instanceof AppError12) {
+      if (error instanceof AppError16) {
         next(error);
       } else {
         next(
-          new InternalServerError18(
+          new InternalServerError22(
             `Failed to set GitHub variables: ${error.message}`
           )
         );
@@ -5950,34 +7813,34 @@ function useUtilController() {
 }
 
 // src/resources/utils/transaction.schema.ts
-import Joi15 from "joi";
-var transactionSchema = Joi15.object({
-  _id: Joi15.string().hex().optional().allow("", null),
-  payment: Joi15.string().required(),
-  user: Joi15.string().hex().optional().allow("", null),
-  org: Joi15.string().hex().optional().allow("", null),
-  type: Joi15.string().required(),
-  amount: Joi15.number().positive().min(0).required(),
-  currency: Joi15.string().required(),
-  description: Joi15.string().optional().allow("", null),
-  metadata: Joi15.object({
-    subscriptionId: Joi15.string().hex().optional().allow("", null),
-    cycle: Joi15.number().optional().allow("", null),
-    seats: Joi15.number().optional().allow("", null),
-    promoCode: Joi15.string().optional().allow("", null)
+import Joi24 from "joi";
+var transactionSchema = Joi24.object({
+  _id: Joi24.string().hex().optional().allow("", null),
+  payment: Joi24.string().required(),
+  user: Joi24.string().hex().optional().allow("", null),
+  org: Joi24.string().hex().optional().allow("", null),
+  type: Joi24.string().required(),
+  amount: Joi24.number().positive().min(0).required(),
+  currency: Joi24.string().required(),
+  description: Joi24.string().optional().allow("", null),
+  metadata: Joi24.object({
+    subscriptionId: Joi24.string().hex().optional().allow("", null),
+    cycle: Joi24.number().optional().allow("", null),
+    seats: Joi24.number().optional().allow("", null),
+    promoCode: Joi24.string().optional().allow("", null)
   }).optional().allow("", null),
-  status: Joi15.string().optional().allow("", null),
-  createdAt: Joi15.string().optional().allow("", null),
-  updatedAt: Joi15.string().optional().allow("", null),
-  deletedAt: Joi15.string().optional().allow("", null)
+  status: Joi24.string().optional().allow("", null),
+  createdAt: Joi24.string().optional().allow("", null),
+  updatedAt: Joi24.string().optional().allow("", null),
+  deletedAt: Joi24.string().optional().allow("", null)
 });
 
 // src/resources/psgc/psgc.model.ts
-import Joi16 from "joi";
-var schemaPSGC = Joi16.object({
-  code: Joi16.string().length(10).required(),
-  name: Joi16.string().required(),
-  type: Joi16.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required()
+import Joi25 from "joi";
+var schemaPSGC = Joi25.object({
+  code: Joi25.string().length(10).required(),
+  name: Joi25.string().required(),
+  type: Joi25.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required()
 });
 function modelPSGC(data) {
   const { error } = schemaPSGC.validate(data);
@@ -5993,18 +7856,18 @@ function modelPSGC(data) {
 
 // src/resources/psgc/psgc.repository.ts
 import {
-  AppError as AppError13,
-  BadRequestError as BadRequestError29,
-  InternalServerError as InternalServerError19,
-  logger as logger15,
-  makeCacheKey as makeCacheKey11,
-  paginate as paginate6,
-  useAtlas as useAtlas14,
+  AppError as AppError17,
+  BadRequestError as BadRequestError39,
+  InternalServerError as InternalServerError23,
+  logger as logger23,
+  makeCacheKey as makeCacheKey14,
+  paginate as paginate9,
+  useAtlas as useAtlas16,
   useCache as useCache12
 } from "@eeplatform/nodejs-utils";
-import { ObjectId as ObjectId18 } from "mongodb";
+import { ObjectId as ObjectId21 } from "mongodb";
 function usePSGCRepo() {
-  const db = useAtlas14.getDb();
+  const db = useAtlas16.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
@@ -6024,12 +7887,12 @@ function usePSGCRepo() {
   }
   function delCachedData() {
     delNamespace().then(() => {
-      logger15.log({
+      logger23.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      logger15.log({
+      logger23.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -6042,16 +7905,16 @@ function usePSGCRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      logger15.log({
+      logger23.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof AppError13) {
+      if (error instanceof AppError17) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new BadRequestError29("Region already exists.");
+          throw new BadRequestError39("Region already exists.");
         }
         throw new Error("Failed to create PSGC.");
       }
@@ -6087,15 +7950,15 @@ function usePSGCRepo() {
       query.$text = { $search: search };
       cacheKeyOptions.search = search;
     }
-    const cacheKey = makeCacheKey11(namespace_collection, cacheKeyOptions);
-    logger15.log({
+    const cacheKey = makeCacheKey14(namespace_collection, cacheKeyOptions);
+    logger23.log({
       level: "info",
       message: `Cache key for getAll PSGC: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger15.log({
+        logger23.log({
           level: "info",
           message: `Cache hit for getAll PSGC: ${cacheKey}`
         });
@@ -6108,35 +7971,35 @@ function usePSGCRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate6(items, page, limit, length);
+      const data = paginate9(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        logger15.log({
+        logger23.log({
           level: "info",
           message: `Cache set for getAll PSGC: ${cacheKey}`
         });
       }).catch((err) => {
-        logger15.log({
+        logger23.log({
           level: "error",
           message: `Failed to set cache for getAll PSGC: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      logger15.log({ level: "error", message: `${error}` });
+      logger23.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(_id) {
     try {
-      _id = new ObjectId18(_id);
+      _id = new ObjectId21(_id);
     } catch (error) {
-      throw new BadRequestError29("Invalid ID.");
+      throw new BadRequestError39("Invalid ID.");
     }
-    const cacheKey = makeCacheKey11(namespace_collection, { _id: String(_id) });
+    const cacheKey = makeCacheKey14(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger15.log({
+        logger23.log({
           level: "info",
           message: `Cache hit for getById PSGC: ${cacheKey}`
         });
@@ -6147,25 +8010,25 @@ function usePSGCRepo() {
         deletedAt: { $in: ["", null] }
       });
       if (!result) {
-        throw new BadRequestError29("Region not found.");
+        throw new BadRequestError39("Region not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        logger15.log({
+        logger23.log({
           level: "info",
           message: `Cache set for PSGC by id: ${cacheKey}`
         });
       }).catch((err) => {
-        logger15.log({
+        logger23.log({
           level: "error",
           message: `Failed to set cache for PSGC by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof AppError13) {
+      if (error instanceof AppError17) {
         throw error;
       } else {
-        throw new InternalServerError19("Failed to get PSGC.");
+        throw new InternalServerError23("Failed to get PSGC.");
       }
     }
   }
@@ -6189,15 +8052,15 @@ function usePSGCRepo() {
       query.code = { $regex: `^${prefix}` };
       cacheKeyOptions.prefix = prefix;
     }
-    const cacheKey = makeCacheKey11(namespace_collection, { name });
-    logger15.log({
+    const cacheKey = makeCacheKey14(namespace_collection, { name });
+    logger23.log({
       level: "info",
       message: `Query for getByName PSGC: ${JSON.stringify(query)}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        logger15.log({
+        logger23.log({
           level: "info",
           message: `Cache hit for getByName PSGC: ${cacheKey}`
         });
@@ -6205,36 +8068,36 @@ function usePSGCRepo() {
       }
       const result = await collection.findOne(query);
       setCache(cacheKey, result, 300).then(() => {
-        logger15.log({
+        logger23.log({
           level: "info",
           message: `Cache set for PSGC by name: ${cacheKey}`
         });
       }).catch((err) => {
-        logger15.log({
+        logger23.log({
           level: "error",
           message: `Failed to set cache for PSGC by name: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof AppError13) {
+      if (error instanceof AppError17) {
         throw error;
       } else {
-        throw new InternalServerError19("Failed to get PSGC.");
+        throw new InternalServerError23("Failed to get PSGC.");
       }
     }
   }
   async function updateFieldById({ _id, field, value } = {}, session) {
     const allowedFields = ["name"];
     if (!allowedFields.includes(field)) {
-      throw new BadRequestError29(
+      throw new BadRequestError39(
         `Field "${field}" is not allowed to be updated.`
       );
     }
     try {
-      _id = new ObjectId18(_id);
+      _id = new ObjectId21(_id);
     } catch (error) {
-      throw new BadRequestError29("Invalid ID.");
+      throw new BadRequestError39("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -6245,14 +8108,14 @@ function usePSGCRepo() {
       delCachedData();
       return `Successfully updated PSGC ${field}.`;
     } catch (error) {
-      throw new InternalServerError19(`Failed to update PSGC ${field}.`);
+      throw new InternalServerError23(`Failed to update PSGC ${field}.`);
     }
   }
   async function deleteById(_id) {
     try {
-      _id = new ObjectId18(_id);
+      _id = new ObjectId21(_id);
     } catch (error) {
-      throw new BadRequestError29("Invalid ID.");
+      throw new BadRequestError39("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -6262,7 +8125,7 @@ function usePSGCRepo() {
       delCachedData();
       return "Successfully deleted PSGC.";
     } catch (error) {
-      throw new InternalServerError19("Failed to delete PSGC.");
+      throw new InternalServerError23("Failed to delete PSGC.");
     }
   }
   async function setRegionProvinceName() {
@@ -6312,8 +8175,8 @@ function usePSGCRepo() {
 }
 
 // src/resources/psgc/psgc.controller.ts
-import { BadRequestError as BadRequestError30 } from "@eeplatform/nodejs-utils";
-import Joi17 from "joi";
+import { BadRequestError as BadRequestError40 } from "@eeplatform/nodejs-utils";
+import Joi26 from "joi";
 function usePSGCController() {
   const {
     add: _add,
@@ -6327,7 +8190,7 @@ function usePSGCController() {
     const value = req.body;
     const { error } = schemaPSGC.validate(value);
     if (error) {
-      next(new BadRequestError30(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6343,12 +8206,12 @@ function usePSGCController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = Joi17.object({
-      page: Joi17.number().min(1).optional().allow("", null),
-      limit: Joi17.number().min(1).optional().allow("", null),
-      search: Joi17.string().optional().allow("", null),
-      type: Joi17.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required(),
-      prefix: Joi17.string().optional().allow("", null)
+    const validation = Joi26.object({
+      page: Joi26.number().min(1).optional().allow("", null),
+      limit: Joi26.number().min(1).optional().allow("", null),
+      search: Joi26.string().optional().allow("", null),
+      type: Joi26.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required(),
+      prefix: Joi26.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
@@ -6358,16 +8221,16 @@ function usePSGCController() {
     const prefix = req.query.prefix ? String(req.query.prefix) : "";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new BadRequestError30("Invalid page number."));
+      next(new BadRequestError40("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new BadRequestError30("Invalid limit number."));
+      next(new BadRequestError40("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new BadRequestError30(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6386,12 +8249,12 @@ function usePSGCController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = Joi17.object({
-      id: Joi17.string().hex().required()
+    const validation = Joi26.object({
+      id: Joi26.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new BadRequestError30(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6407,12 +8270,12 @@ function usePSGCController() {
   }
   async function getByName(req, res, next) {
     const name = req.params.name;
-    const validation = Joi17.object({
-      name: Joi17.string().required()
+    const validation = Joi26.object({
+      name: Joi26.string().required()
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new BadRequestError30(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6429,14 +8292,14 @@ function usePSGCController() {
   async function updateField(req, res, next) {
     const _id = req.params.id;
     const { field, value } = req.body;
-    const validation = Joi17.object({
-      _id: Joi17.string().hex().required(),
-      field: Joi17.string().valid("name", "director", "directorName").required(),
-      value: Joi17.string().required()
+    const validation = Joi26.object({
+      _id: Joi26.string().hex().required(),
+      field: Joi26.string().valid("name", "director", "directorName").required(),
+      value: Joi26.string().required()
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new BadRequestError30(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6449,12 +8312,12 @@ function usePSGCController() {
   }
   async function deleteById(req, res, next) {
     const _id = req.params.id;
-    const validation = Joi17.object({
-      _id: Joi17.string().hex().required()
+    const validation = Joi26.object({
+      _id: Joi26.string().hex().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new BadRequestError30(error.message));
+      next(new BadRequestError40(error.message));
       return;
     }
     try {
@@ -6523,12 +8386,24 @@ export {
   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,
@@ -6546,6 +8421,12 @@ export {
   useOrgService,
   usePSGCController,
   usePSGCRepo,
+  usePermissionController,
+  usePermissionGroupController,
+  usePermissionGroupRepo,
+  usePermissionGroupService,
+  usePermissionRepo,
+  usePermissionService,
   useRoleController,
   useRoleRepo,
   useTokenRepo,