@goweekdays/core 2.1.0 → 2.1.2

package/dist/index.js

@@ -6557,7 +6557,8 @@ var import_joi19 = __toESM(require("joi"));
 var schemaApp = import_joi19.default.object({
   code: import_joi19.default.string().alphanum().max(20).required(),
   name: import_joi19.default.string().max(255).required(),
-  description: import_joi19.default.string().max(1024).optional().allow("", null)
+  description: import_joi19.default.string().max(1024).optional().allow("", null),
+  type: import_joi19.default.string().allow("default", "standard").optional().allow("", null)
 });
 var schemaAppUpdate = import_joi19.default.object({
   code: import_joi19.default.string().alphanum().max(20).optional().allow("", null),
@@ -6574,6 +6575,7 @@ function modelApp(value) {
     code: value.code,
     name: value.name,
     description: value.description,
+    type: value.type ?? "standard",
     status: value.status ?? "active",
     createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
     updatedAt: "",
@@ -6584,6 +6586,8 @@ function modelApp(value) {
 // src/resources/app/app.repository.ts
 var import_utils39 = require("@goweekdays/utils");
 var import_mongodb19 = require("mongodb");
+var import_joi20 = __toESM(require("joi"));
+var init = false;
 function useAppRepo() {
   const db = import_utils39.useAtlas.getDb();
   if (!db) {
@@ -6618,9 +6622,12 @@ function useAppRepo() {
       throw new Error("Failed to create index on apps.");
     }
   }
-  createIndexes().catch((error) => {
-    import_utils39.logger.log({ level: "error", message: `Index creation error: ${error}` });
-  });
+  if (!init) {
+    createIndexes().catch((error) => {
+      import_utils39.logger.log({ level: "error", message: `Index creation error: ${error}` });
+    });
+    init = true;
+  }
   async function add(value, session) {
     try {
       value = modelApp(value);
@@ -6674,35 +6681,32 @@ function useAppRepo() {
     page = 1,
     limit = 10,
     sort = {},
-    school = "",
-    status = "active"
+    status = "active",
+    type = "standard"
   } = {}) {
     page = page > 0 ? page - 1 : 0;
     const query = {
       status
     };
     sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
-    if (search) {
-      query.$text = { $search: search };
-    }
-    if (school) {
-      try {
-        query.school = new import_mongodb19.ObjectId(school);
-      } catch (error) {
-        throw new import_utils39.BadRequestError("Invalid school ID.");
-      }
-    }
     const cacheParams = {
+      status,
       page,
       limit,
       sort: JSON.stringify(sort)
     };
-    if (search)
+    if (search) {
+      query.$text = { $search: search };
       cacheParams.search = search;
-    if (school)
-      cacheParams.school = school;
-    if (status !== "active")
-      cacheParams.status = status;
+    }
+    if (type) {
+      if (Array.isArray(type)) {
+        query.type = { $in: type };
+      } else {
+        query.type = type;
+      }
+      cacheParams.type = type;
+    }
     const cacheKey = (0, import_utils39.makeCacheKey)(namespace_collection, cacheParams);
     import_utils39.logger.log({
       level: "info",
@@ -6781,6 +6785,48 @@ function useAppRepo() {
       }
     }
   }
+  async function getByCode(code) {
+    const validate = import_joi20.default.string().required();
+    const { error } = validate.validate(code);
+    if (error) {
+      throw new import_utils39.BadRequestError("Invalid code.");
+    }
+    const cacheKey = (0, import_utils39.makeCacheKey)(namespace_collection, {
+      code,
+      tag: "byCode"
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils39.logger.log({
+          level: "info",
+          message: `Cache hit for getByCode app: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        code
+      });
+      setCache(cacheKey, result, 300).then(() => {
+        import_utils39.logger.log({
+          level: "info",
+          message: `Cache set for app by code: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils39.logger.log({
+          level: "error",
+          message: `Failed to set cache for app by code: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof import_utils39.AppError) {
+        throw error2;
+      } else {
+        throw new import_utils39.InternalServerError("Failed to get app.");
+      }
+    }
+  }
   async function deleteById(_id, session) {
     try {
       _id = new import_mongodb19.ObjectId(_id);
@@ -6824,18 +6870,96 @@ function useAppRepo() {
     add,
     getAll,
     getById,
+    getByCode,
     updateById,
     deleteById
   };
 }
 
 // src/resources/app/app.service.ts
+var import_utils40 = require("@goweekdays/utils");
+var init2 = false;
 function useAppService() {
   const {
     updateById: _updateById,
     getById: _getById,
-    deleteById: _deleteById
+    deleteById: _deleteById,
+    getByCode: _getByCode,
+    add: _add
   } = useAppRepo();
+  async function addDefaultApps() {
+    const apps = [
+      {
+        code: "admin",
+        name: "Admin",
+        description: "Administrative application.",
+        type: "default"
+      },
+      {
+        code: "marketplace",
+        name: "Marketplace",
+        description: "Marketplace for product listings."
+      },
+      {
+        code: "service",
+        name: "Services",
+        description: "Service offerings and management."
+      },
+      {
+        code: "stay",
+        name: "Stay",
+        description: "Accommodation and lodging services."
+      },
+      { code: "eat", name: "Eat", description: "Food and dining services." },
+      {
+        code: "experience",
+        name: "Experience",
+        description: "Experiential touring, travel, activities and events."
+      },
+      {
+        code: "ride",
+        name: "Ride",
+        description: "Transportation and ride services."
+      }
+    ];
+    const session = import_utils40.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session?.startTransaction();
+      for (const app of apps) {
+        const existingApp = await _getByCode(app.code);
+        if (!existingApp) {
+          await _add(app, session);
+        }
+      }
+      await session.commitTransaction();
+      import_utils40.logger.log({
+        level: "info",
+        message: "Default apps added successfully."
+      });
+      return;
+    } catch (error) {
+      await session.abortTransaction();
+      import_utils40.logger.log({
+        level: "error",
+        message: `Failed to add default apps: ${error}`
+      });
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  if (!init2) {
+    addDefaultApps().catch((error) => {
+      import_utils40.logger.log({
+        level: "error",
+        message: `Error in addDefaultApps: ${error}`
+      });
+    });
+    init2 = true;
+  }
   async function deleteById(id) {
     try {
       await _deleteById(id);
@@ -6850,8 +6974,8 @@ function useAppService() {
 }
 
 // src/resources/app/app.controller.ts
-var import_utils40 = require("@goweekdays/utils");
-var import_joi20 = __toESM(require("joi"));
+var import_utils41 = require("@goweekdays/utils");
+var import_joi21 = __toESM(require("joi"));
 function useAppController() {
   const {
     getAll: _getAll,
@@ -6864,7 +6988,7 @@ function useAppController() {
     const value = req.body;
     const { error } = schemaApp.validate(value);
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     try {
@@ -6877,15 +7001,15 @@ function useAppController() {
   }
   async function updateById(req, res, next) {
     const id = req.params.id ?? "";
-    const { error: errorId } = import_joi20.default.string().hex().required().validate(id);
+    const { error: errorId } = import_joi21.default.string().hex().required().validate(id);
     if (errorId) {
-      next(new import_utils40.BadRequestError(errorId.message));
+      next(new import_utils41.BadRequestError(errorId.message));
       return;
     }
     const value = req.body;
     const { error } = schemaAppUpdate.validate(value);
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     try {
@@ -6898,16 +7022,16 @@ function useAppController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi20.default.object({
-      page: import_joi20.default.number().min(1).optional().allow("", null),
-      limit: import_joi20.default.number().min(1).optional().allow("", null),
-      search: import_joi20.default.string().optional().allow("", null),
-      school: import_joi20.default.string().hex().optional().allow("", null),
-      status: import_joi20.default.string().optional().allow("", null)
+    const validation = import_joi21.default.object({
+      page: import_joi21.default.number().min(1).optional().allow("", null),
+      limit: import_joi21.default.number().min(1).optional().allow("", null),
+      search: import_joi21.default.string().optional().allow("", null),
+      status: import_joi21.default.string().optional().allow("", null),
+      type: import_joi21.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -6922,16 +7046,16 @@ function useAppController() {
       });
     }
     const status = req.query.status ?? "active";
-    const school = req.query.school ?? "";
     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,
-        school,
-        search
+        search,
+        type
       });
       res.json(buildings);
       return;
@@ -6941,12 +7065,12 @@ function useAppController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi20.default.object({
-      id: import_joi20.default.string().hex().required()
+    const validation = import_joi21.default.object({
+      id: import_joi21.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     try {
@@ -6962,12 +7086,12 @@ function useAppController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi20.default.object({
-      id: import_joi20.default.string().hex().required()
+    const validation = import_joi21.default.object({
+      id: import_joi21.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils40.BadRequestError(error.message));
+      next(new import_utils41.BadRequestError(error.message));
       return;
     }
     try {
@@ -6988,24 +7112,24 @@ function useAppController() {
 }
 
 // src/resources/permission/permission.model.ts
-var import_utils41 = require("@goweekdays/utils");
-var import_joi21 = __toESM(require("joi"));
-var schemaPermission = import_joi21.default.object({
-  app: import_joi21.default.string().required(),
-  key: import_joi21.default.string().required(),
-  group: import_joi21.default.string().required(),
-  description: import_joi21.default.string().max(1024).required(),
-  deprecated: import_joi21.default.boolean().optional().allow(null)
+var import_utils42 = require("@goweekdays/utils");
+var import_joi22 = __toESM(require("joi"));
+var schemaPermission = import_joi22.default.object({
+  app: import_joi22.default.string().required(),
+  key: import_joi22.default.string().required(),
+  group: import_joi22.default.string().required(),
+  description: import_joi22.default.string().required(),
+  deprecated: import_joi22.default.boolean().optional().allow(null)
 });
-var schemaPermissionUpdate = import_joi21.default.object({
-  key: import_joi21.default.string().optional().allow("", null),
-  group: import_joi21.default.string().optional().allow("", null),
-  description: import_joi21.default.string().max(1024).optional().allow("", null)
+var schemaPermissionUpdate = import_joi22.default.object({
+  key: import_joi22.default.string().optional().allow("", null),
+  group: import_joi22.default.string().optional().allow("", null),
+  description: import_joi22.default.string().max(1024).optional().allow("", null)
 });
 function modelPermission(value) {
   const { error } = schemaPermission.validate(value);
   if (error) {
-    throw new import_utils41.BadRequestError(error.message);
+    throw new import_utils42.BadRequestError(error.message);
   }
   return {
     _id: value._id,
@@ -7022,16 +7146,17 @@ function modelPermission(value) {
 }
 
 // src/resources/permission/permission.repository.ts
-var import_utils42 = require("@goweekdays/utils");
+var import_utils43 = require("@goweekdays/utils");
 var import_mongodb20 = require("mongodb");
+var import_joi23 = __toESM(require("joi"));
 function usePermissionRepo() {
-  const db = import_utils42.useAtlas.getDb();
+  const db = import_utils43.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "permissions";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils42.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils43.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -7053,7 +7178,7 @@ function usePermissionRepo() {
     }
   }
   createIndexes().catch((error) => {
-    import_utils42.logger.log({ level: "error", message: `Index creation error: ${error}` });
+    import_utils43.logger.log({ level: "error", message: `Index creation error: ${error}` });
   });
   async function add(value, session) {
     try {
@@ -7062,16 +7187,16 @@ function usePermissionRepo() {
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils42.logger.log({
+      import_utils43.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils42.AppError) {
+      if (error instanceof import_utils43.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils42.BadRequestError("Permission already exists.");
+          throw new import_utils43.BadRequestError("Permission already exists.");
         }
         throw new Error("Failed to create permission.");
       }
@@ -7081,11 +7206,11 @@ function usePermissionRepo() {
     try {
       _id = new import_mongodb20.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils42.BadRequestError("Invalid ID.");
+      throw new import_utils43.BadRequestError("Invalid ID.");
     }
     const { error } = schemaPermissionUpdate.validate(value);
     if (error) {
-      throw new import_utils42.BadRequestError(`Invalid data: ${error.message}`);
+      throw new import_utils43.BadRequestError(`Invalid data: ${error.message}`);
     }
     try {
       const res = await collection.updateOne(
@@ -7096,11 +7221,11 @@ function usePermissionRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils42.logger.log({
+      import_utils43.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils42.AppError) {
+      if (error2 instanceof import_utils43.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to update permission.");
@@ -7133,15 +7258,15 @@ function usePermissionRepo() {
       query.app = app;
       cacheParams.app = app;
     }
-    const cacheKey = (0, import_utils42.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils42.logger.log({
+    const cacheKey = (0, import_utils43.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils43.logger.log({
       level: "info",
       message: `Cache key for getAll permissions: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils42.logger.log({
+        import_utils43.logger.log({
           level: "info",
           message: `Cache hit for getAll permissions: ${cacheKey}`
         });
@@ -7154,21 +7279,21 @@ function usePermissionRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils42.paginate)(items, page, limit, length);
+      const data = (0, import_utils43.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils42.logger.log({
+        import_utils43.logger.log({
           level: "info",
           message: `Cache set for getAll permissions: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils42.logger.log({
+        import_utils43.logger.log({
           level: "error",
           message: `Failed to set cache for getAll permissions: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils42.logger.log({ level: "error", message: `${error}` });
+      import_utils43.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -7176,13 +7301,13 @@ function usePermissionRepo() {
     try {
       _id = new import_mongodb20.ObjectId(_id);
     } catch (error) {
-      throw new import_utils42.BadRequestError("Invalid ID.");
+      throw new import_utils43.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils42.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils43.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils42.logger.log({
+        import_utils43.logger.log({
           level: "info",
           message: `Cache hit for getById permission: ${cacheKey}`
         });
@@ -7192,59 +7317,107 @@ function usePermissionRepo() {
         _id
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils42.logger.log({
+        import_utils43.logger.log({
           level: "info",
           message: `Cache set for permission by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils42.logger.log({
+        import_utils43.logger.log({
           level: "error",
           message: `Failed to set cache for permission by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils42.AppError) {
+      if (error instanceof import_utils43.AppError) {
         throw error;
       } else {
-        throw new import_utils42.InternalServerError("Failed to get permission.");
+        throw new import_utils43.InternalServerError("Failed to get permission.");
+      }
+    }
+  }
+  async function getByKey(key, group) {
+    const validation = import_joi23.default.object({
+      key: import_joi23.default.string().required(),
+      group: import_joi23.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({ key, group });
+    if (error) {
+      throw new import_utils43.BadRequestError(`Invalid data: ${error.message}`);
+    }
+    const query = {};
+    const cacheKeyOptions = {};
+    query.key = key;
+    cacheKeyOptions.key = key;
+    if (group) {
+      query.group = group;
+      cacheKeyOptions.group = group;
+    }
+    const cacheKey = (0, import_utils43.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils43.logger.log({
+          level: "info",
+          message: `Cache hit for getById permission: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne(query);
+      setCache(cacheKey, result, 300).then(() => {
+        import_utils43.logger.log({
+          level: "info",
+          message: `Cache set for permission by key: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils43.logger.log({
+          level: "error",
+          message: `Failed to set cache for permission by key: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof import_utils43.AppError) {
+        throw error2;
+      } else {
+        throw new import_utils43.InternalServerError("Failed to get permission.");
       }
     }
   }
   async function countByGroup(group) {
-    const cacheKey = (0, import_utils42.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils43.makeCacheKey)(namespace_collection, {
       group,
       tag: "countByGroup"
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils42.logger.log({
+        import_utils43.logger.log({
           level: "info",
           message: `Cache hit for getById permission: ${cacheKey}`
         });
         return cached;
       }
       const result = await collection.countDocuments({
-        key: group
+        group
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils42.logger.log({
+        import_utils43.logger.log({
           level: "info",
           message: `Cache set for permission count by group: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils42.logger.log({
+        import_utils43.logger.log({
           level: "error",
           message: `Failed to set cache for permission by group: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils42.AppError) {
+      if (error instanceof import_utils43.AppError) {
         throw error;
       } else {
-        throw new import_utils42.InternalServerError("Failed to count permission by group.");
+        throw new import_utils43.InternalServerError("Failed to count permission by group.");
       }
     }
   }
@@ -7252,7 +7425,7 @@ function usePermissionRepo() {
     try {
       _id = new import_mongodb20.ObjectId(_id);
     } catch (error) {
-      throw new import_utils42.BadRequestError("Invalid ID.");
+      throw new import_utils43.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -7262,25 +7435,25 @@ function usePermissionRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils42.logger.log({
+      import_utils43.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils42.AppError) {
+      if (error instanceof import_utils43.AppError) {
         throw error;
       } else {
-        throw new import_utils42.InternalServerError("Failed to delete permission.");
+        throw new import_utils43.InternalServerError("Failed to delete permission.");
       }
     }
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils42.logger.log({
+      import_utils43.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils42.logger.log({
+      import_utils43.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -7291,6 +7464,7 @@ function usePermissionRepo() {
     add,
     getAll,
     getById,
+    getByKey,
     updateById,
     deleteById,
     countByGroup
@@ -7318,8 +7492,8 @@ function usePermissionService() {
 }
 
 // src/resources/permission/permission.controller.ts
-var import_utils43 = require("@goweekdays/utils");
-var import_joi22 = __toESM(require("joi"));
+var import_utils44 = require("@goweekdays/utils");
+var import_joi24 = __toESM(require("joi"));
 function usePermissionController() {
   const {
     getAll: _getAll,
@@ -7332,8 +7506,8 @@ function usePermissionController() {
     const value = req.body;
     const { error } = schemaPermission.validate(value);
     if (error) {
-      next(new import_utils43.BadRequestError(error.message));
-      import_utils43.logger.info(`Controller: ${error.message}`);
+      next(new import_utils44.BadRequestError(error.message));
+      import_utils44.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -7346,16 +7520,16 @@ function usePermissionController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi22.default.object({
-      page: import_joi22.default.number().min(1).optional().allow("", null),
-      limit: import_joi22.default.number().min(1).optional().allow("", null),
-      search: import_joi22.default.string().optional().allow("", null),
-      app: import_joi22.default.string().optional().allow("", null),
-      status: import_joi22.default.string().optional().allow("", null)
+    const validation = import_joi24.default.object({
+      page: import_joi24.default.number().min(1).optional().allow("", null),
+      limit: import_joi24.default.number().min(1).optional().allow("", null),
+      search: import_joi24.default.string().optional().allow("", null),
+      app: import_joi24.default.string().optional().allow("", null),
+      status: import_joi24.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils43.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -7389,12 +7563,12 @@ function usePermissionController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi22.default.object({
-      id: import_joi22.default.string().hex().required()
+    const validation = import_joi24.default.object({
+      id: import_joi24.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils43.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -7410,12 +7584,12 @@ function usePermissionController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi22.default.object({
-      id: import_joi22.default.string().hex().required()
+    const validation = import_joi24.default.object({
+      id: import_joi24.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils43.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -7428,15 +7602,15 @@ function usePermissionController() {
   }
   async function updateById(req, res, next) {
     const id = req.params.id;
-    const { error: errorId } = import_joi22.default.string().hex().required().validate(id);
+    const { error: errorId } = import_joi24.default.string().hex().required().validate(id);
     if (errorId) {
-      next(new import_utils43.BadRequestError(errorId.message));
+      next(new import_utils44.BadRequestError(errorId.message));
       return;
     }
     const payload = req.body;
     const { error } = schemaPermissionUpdate.validate(payload);
     if (error) {
-      next(new import_utils43.BadRequestError(error.message));
+      next(new import_utils44.BadRequestError(error.message));
       return;
     }
     try {
@@ -7457,23 +7631,23 @@ function usePermissionController() {
 }
 
 // src/resources/permission/permission.group.model.ts
-var import_utils44 = require("@goweekdays/utils");
-var import_joi23 = __toESM(require("joi"));
-var schemaPermissionGroup = import_joi23.default.object({
-  app: import_joi23.default.string().required(),
-  key: import_joi23.default.string().required(),
-  label: import_joi23.default.string().required(),
-  order: import_joi23.default.number().integer().optional().allow("", null)
+var import_utils45 = require("@goweekdays/utils");
+var import_joi25 = __toESM(require("joi"));
+var schemaPermissionGroup = import_joi25.default.object({
+  app: import_joi25.default.string().required(),
+  key: import_joi25.default.string().required(),
+  label: import_joi25.default.string().required(),
+  order: import_joi25.default.number().integer().optional().allow("", null)
 });
-var schemaPermissionGroupUpdate = import_joi23.default.object({
-  key: import_joi23.default.string().optional().allow("", null),
-  label: import_joi23.default.string().optional().allow("", null),
-  order: import_joi23.default.number().integer().optional().allow("", null)
+var schemaPermissionGroupUpdate = import_joi25.default.object({
+  key: import_joi25.default.string().optional().allow("", null),
+  label: import_joi25.default.string().optional().allow("", null),
+  order: import_joi25.default.number().integer().optional().allow("", null)
 });
 function modelPermissionGroup(value) {
   const { error } = schemaPermissionGroup.validate(value);
   if (error) {
-    throw new import_utils44.BadRequestError(error.message);
+    throw new import_utils45.BadRequestError(error.message);
   }
   return {
     _id: value._id,
@@ -7489,16 +7663,18 @@ function modelPermissionGroup(value) {
 }
 
 // src/resources/permission/permission.group.repository.ts
-var import_utils45 = require("@goweekdays/utils");
+var import_utils46 = require("@goweekdays/utils");
 var import_mongodb21 = require("mongodb");
+var import_joi26 = __toESM(require("joi"));
+var init3 = false;
 function usePermissionGroupRepo() {
-  const db = import_utils45.useAtlas.getDb();
+  const db = import_utils46.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
   const namespace_collection = "permission.groups";
   const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_utils45.useCache)(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils46.useCache)(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -7519,26 +7695,33 @@ function usePermissionGroupRepo() {
       throw new Error("Failed to create index on permission groups.");
     }
   }
-  createIndexes().catch((error) => {
-    import_utils45.logger.log({ level: "error", message: `Index creation error: ${error}` });
-  });
+  if (!init3) {
+    createIndexes().catch((error) => {
+      import_utils46.logger.log({
+        level: "error",
+        message: `Index creation error: ${error}`
+      });
+    });
+    init3 = true;
+  }
   async function add(value, session) {
     try {
       value = modelPermissionGroup(value);
+      console.log(value);
       const res = await collection.insertOne(value, { session });
       delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils45.logger.log({
+      import_utils46.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils45.AppError) {
+      if (error instanceof import_utils46.AppError) {
         throw error;
       } else {
         const isDuplicated = error.message.includes("duplicate");
         if (isDuplicated) {
-          throw new import_utils45.BadRequestError("App already exists.");
+          throw new import_utils46.BadRequestError("Permission group already exists.");
         }
         throw new Error("Failed to create permission group.");
       }
@@ -7548,11 +7731,11 @@ function usePermissionGroupRepo() {
     try {
       _id = new import_mongodb21.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils45.BadRequestError("Invalid ID.");
+      throw new import_utils46.BadRequestError("Invalid ID.");
     }
     const { error } = schemaPermissionGroupUpdate.validate(value);
     if (error) {
-      throw new import_utils45.BadRequestError(`Invalid data: ${error.message}`);
+      throw new import_utils46.BadRequestError(`Invalid data: ${error.message}`);
     }
     try {
       const res = await collection.updateOne(
@@ -7563,11 +7746,11 @@ function usePermissionGroupRepo() {
       delCachedData();
       return res;
     } catch (error2) {
-      import_utils45.logger.log({
+      import_utils46.logger.log({
         level: "error",
         message: error2.message
       });
-      if (error2 instanceof import_utils45.AppError) {
+      if (error2 instanceof import_utils46.AppError) {
         throw error2;
       } else {
         throw new Error("Failed to update permission group.");
@@ -7600,15 +7783,15 @@ function usePermissionGroupRepo() {
       query.app = app;
       cacheParams.app = app;
     }
-    const cacheKey = (0, import_utils45.makeCacheKey)(namespace_collection, cacheParams);
-    import_utils45.logger.log({
+    const cacheKey = (0, import_utils46.makeCacheKey)(namespace_collection, cacheParams);
+    import_utils46.logger.log({
       level: "info",
       message: `Cache key for getAll permission groups: ${cacheKey}`
     });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils45.logger.log({
+        import_utils46.logger.log({
           level: "info",
           message: `Cache hit for getAll permission groups: ${cacheKey}`
         });
@@ -7621,21 +7804,21 @@ function usePermissionGroupRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_utils45.paginate)(items, page, limit, length);
+      const data = (0, import_utils46.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 600).then(() => {
-        import_utils45.logger.log({
+        import_utils46.logger.log({
           level: "info",
           message: `Cache set for getAll permission groups: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils45.logger.log({
+        import_utils46.logger.log({
           level: "error",
           message: `Failed to set cache for getAll permission groups: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils45.logger.log({ level: "error", message: `${error}` });
+      import_utils46.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -7643,13 +7826,13 @@ function usePermissionGroupRepo() {
     try {
       _id = new import_mongodb21.ObjectId(_id);
     } catch (error) {
-      throw new import_utils45.BadRequestError("Invalid ID.");
+      throw new import_utils46.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_utils45.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_utils46.makeCacheKey)(namespace_collection, { _id: String(_id) });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils45.logger.log({
+        import_utils46.logger.log({
           level: "info",
           message: `Cache hit for getById permission group: ${cacheKey}`
         });
@@ -7659,22 +7842,68 @@ function usePermissionGroupRepo() {
         _id
       });
       setCache(cacheKey, result, 300).then(() => {
-        import_utils45.logger.log({
+        import_utils46.logger.log({
           level: "info",
           message: `Cache set for permission group by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils45.logger.log({
+        import_utils46.logger.log({
           level: "error",
           message: `Failed to set cache for permission group by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils45.AppError) {
+      if (error instanceof import_utils46.AppError) {
         throw error;
       } else {
-        throw new import_utils45.InternalServerError("Failed to get permission group.");
+        throw new import_utils46.InternalServerError("Failed to get permission group.");
+      }
+    }
+  }
+  async function getByKey(key, app) {
+    const validation = import_joi26.default.object({
+      key: import_joi26.default.string().required(),
+      app: import_joi26.default.string().optional().allow(null, "")
+    });
+    const { error } = validation.validate({ key, app });
+    if (error) {
+      throw new import_utils46.BadRequestError("Invalid key.");
+    }
+    const query = { key };
+    const cacheKeyOptions = { key, tag: "byKey" };
+    if (app) {
+      query.app = app;
+      cacheKeyOptions.app = app;
+    }
+    const cacheKey = (0, import_utils46.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils46.logger.log({
+          level: "info",
+          message: `Cache hit for getById permission group: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne(query);
+      setCache(cacheKey, result, 300).then(() => {
+        import_utils46.logger.log({
+          level: "info",
+          message: `Cache set for permission group by key: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils46.logger.log({
+          level: "error",
+          message: `Failed to set cache for permission group by key: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error2) {
+      if (error2 instanceof import_utils46.AppError) {
+        throw error2;
+      } else {
+        throw new import_utils46.InternalServerError("Failed to get permission group.");
       }
     }
   }
@@ -7682,7 +7911,7 @@ function usePermissionGroupRepo() {
     try {
       _id = new import_mongodb21.ObjectId(_id);
     } catch (error) {
-      throw new import_utils45.BadRequestError("Invalid ID.");
+      throw new import_utils46.BadRequestError("Invalid ID.");
     }
     try {
       const res = await collection.updateOne(
@@ -7692,25 +7921,25 @@ function usePermissionGroupRepo() {
       delCachedData();
       return res;
     } catch (error) {
-      import_utils45.logger.log({
+      import_utils46.logger.log({
         level: "error",
         message: error.message
       });
-      if (error instanceof import_utils45.AppError) {
+      if (error instanceof import_utils46.AppError) {
         throw error;
       } else {
-        throw new import_utils45.InternalServerError("Failed to delete permission group.");
+        throw new import_utils46.InternalServerError("Failed to delete permission group.");
       }
     }
   }
   function delCachedData() {
     delNamespace().then(() => {
-      import_utils45.logger.log({
+      import_utils46.logger.log({
         level: "info",
         message: `Cache namespace cleared for ${namespace_collection}`
       });
     }).catch((err) => {
-      import_utils45.logger.log({
+      import_utils46.logger.log({
         level: "error",
         message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
       });
@@ -7721,19 +7950,339 @@ function usePermissionGroupRepo() {
     add,
     getAll,
     getById,
+    getByKey,
     updateById,
     deleteById
   };
 }
 
 // src/resources/permission/permission.group.service.ts
+var import_utils47 = require("@goweekdays/utils");
+var init4 = false;
 function usePermissionGroupService() {
   const {
     updateById: _updateById,
     getById: _getById,
-    deleteById: _deleteById
+    deleteById: _deleteById,
+    getByKey: _getByKey,
+    add: _add
   } = usePermissionGroupRepo();
-  const { countByGroup } = usePermissionRepo();
+  const { getAll: getAllApps } = useAppRepo();
+  const {
+    countByGroup,
+    getByKey: getPermissionByKey,
+    add: addPermission
+  } = usePermissionRepo();
+  async function addDefaultModule() {
+    const session = import_utils47.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session?.startTransaction();
+      const apps = await getAllApps({ limit: 20 });
+      if (apps && apps.items && apps.items.length) {
+        const modules = [
+          {
+            key: "members",
+            label: "Members",
+            permissions: [
+              {
+                key: "members.view",
+                description: "View members"
+              },
+              {
+                key: "members.view.details",
+                description: "View member details"
+              },
+              {
+                key: "members.add",
+                description: "Add new members"
+              },
+              {
+                key: "members.edit.details",
+                description: "Edit member details"
+              },
+              {
+                key: "members.delete",
+                description: "Delete members"
+              }
+            ]
+          },
+          {
+            key: "roles",
+            label: "Roles",
+            permissions: [
+              {
+                key: "roles.view",
+                description: "View roles"
+              },
+              { key: "roles.view.details", description: "View role details" },
+              {
+                key: "roles.add",
+                description: "Add new roles"
+              },
+              {
+                key: "roles.edit.details",
+                description: "Edit role details"
+              },
+              {
+                key: "roles.delete",
+                description: "Delete roles"
+              }
+            ]
+          },
+          {
+            key: "invitations",
+            label: "Invitations",
+            permissions: [
+              {
+                key: "invitations.view",
+                description: "View invitations"
+              },
+              {
+                key: "invitations.view.details",
+                description: "View invitation details"
+              },
+              { key: "invitations.send", description: "Send invitations" },
+              { key: "invitations.revoke", description: "Revoke invitations" }
+            ]
+          }
+        ];
+        for (const app of apps.items) {
+          for (const module2 of modules) {
+            const existingGroup = await _getByKey(module2.key);
+            if (!existingGroup) {
+              await _add({
+                app: app.code,
+                key: module2.key,
+                label: module2.label
+              });
+              import_utils47.logger.log({
+                level: "info",
+                message: `Default permission group added: ${app.code} - ${module2.key}`
+              });
+            }
+            for (const permission of module2.permissions) {
+              const existingPermission = await getPermissionByKey(
+                permission.key,
+                module2.key
+              );
+              if (!existingPermission) {
+                await addPermission({
+                  app: app.code,
+                  group: module2.key,
+                  key: permission.key,
+                  description: permission.description
+                });
+              }
+            }
+          }
+          if (app.code === "admin") {
+            const modules2 = [
+              {
+                key: "applications",
+                label: "Applications",
+                permissions: [
+                  {
+                    key: "applications.add",
+                    description: "Add new applications"
+                  },
+                  {
+                    key: "applications.view",
+                    description: "View applications"
+                  },
+                  {
+                    key: "applications.view.details",
+                    description: "View application details"
+                  },
+                  {
+                    key: "applications.edit",
+                    description: "Edit existing applications"
+                  },
+                  {
+                    key: "applications.update.details",
+                    description: "Update application details"
+                  },
+                  {
+                    key: "applications.delete",
+                    description: "Delete applications"
+                  }
+                ]
+              },
+              {
+                key: "organizations",
+                label: "Organizations",
+                permissions: [
+                  {
+                    key: "organizations.add",
+                    description: "Add new organizations"
+                  },
+                  {
+                    key: "organizations.view",
+                    description: "View organizations"
+                  },
+                  {
+                    key: "organizations.view.details",
+                    description: "View organization details"
+                  },
+                  {
+                    key: "organizations.edit.status",
+                    description: "Edit organization status"
+                  },
+                  {
+                    key: "organizations.delete",
+                    description: "Delete organizations"
+                  }
+                ]
+              },
+              {
+                key: "users",
+                label: "Users",
+                permissions: [
+                  {
+                    key: "users.add",
+                    description: "Add new users"
+                  },
+                  {
+                    key: "users.view",
+                    description: "View users"
+                  },
+                  {
+                    key: "users.view.details",
+                    description: "View user details"
+                  },
+                  {
+                    key: "users.edit.status",
+                    description: "Edit user status"
+                  },
+                  {
+                    key: "users.delete",
+                    description: "Delete users"
+                  }
+                ]
+              },
+              {
+                key: "subscriptions",
+                label: "Subscriptions",
+                permissions: [
+                  {
+                    key: "subscriptions.view",
+                    description: "View subscriptions"
+                  },
+                  {
+                    key: "subscriptions.view.details",
+                    description: "View subscription details"
+                  },
+                  {
+                    key: "subscriptions.edit.details",
+                    description: "Edit subscription details"
+                  }
+                ]
+              },
+              {
+                key: "promo.codes",
+                label: "Promo Codes",
+                permissions: [
+                  {
+                    key: "promo.codes.view",
+                    description: "View promo codes"
+                  },
+                  {
+                    key: "promo.codes.view.details",
+                    description: "View promo code details"
+                  },
+                  {
+                    key: "promo.codes.add",
+                    description: "Add new promo codes"
+                  },
+                  {
+                    key: "promo.codes.edit.details",
+                    description: "Edit promo code details"
+                  },
+                  {
+                    key: "promo.codes.update.status",
+                    description: "Update promo code status"
+                  },
+                  {
+                    key: "promo.codes.delete",
+                    description: "Delete promo codes"
+                  }
+                ]
+              },
+              {
+                key: "affiliates",
+                label: "Affiliates",
+                permissions: [
+                  {
+                    key: "affiliates.view",
+                    description: "View affiliates"
+                  },
+                  {
+                    key: "affiliates.view.details",
+                    description: "View affiliate details"
+                  },
+                  {
+                    key: "affiliates.edit.status",
+                    description: "Edit affiliate status"
+                  }
+                ]
+              }
+            ];
+            for (const module2 of modules2) {
+              const existingGroup = await _getByKey(module2.key, app.code);
+              if (!existingGroup) {
+                await _add({
+                  app: app.code,
+                  key: module2.key,
+                  label: module2.label
+                });
+                import_utils47.logger.log({
+                  level: "info",
+                  message: `Default permission group added: ${app.code} - ${module2.key}`
+                });
+              }
+              for (const permission of module2.permissions) {
+                const existingPermission = await getPermissionByKey(
+                  permission.key,
+                  module2.key
+                );
+                if (!existingPermission) {
+                  await addPermission({
+                    app: app.code,
+                    group: module2.key,
+                    key: permission.key,
+                    description: permission.description
+                  });
+                }
+              }
+            }
+          }
+        }
+        await session.commitTransaction();
+      }
+      import_utils47.logger.log({
+        level: "info",
+        message: "Default permission groups added successfully."
+      });
+      return;
+    } catch (error) {
+      console.log(error);
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  if (!init4) {
+    addDefaultModule().catch((error) => {
+      import_utils47.logger.log({
+        level: "error",
+        message: `Error in addDefaultModule: ${error}`
+      });
+    });
+    init4 = true;
+  }
   async function deleteById(id) {
     const permission = await _getById(id);
     if (!permission) {
@@ -7741,7 +8290,7 @@ function usePermissionGroupService() {
     }
     const associatedPermissionsCount = await countByGroup(permission.key);
     if (associatedPermissionsCount > 0) {
-      throw new Error(
+      throw new import_utils47.BadRequestError(
         "Cannot delete Permission Group with associated Permissions."
       );
     }
@@ -7749,7 +8298,11 @@ function usePermissionGroupService() {
       await _deleteById(id);
       return "Permission deleted successfully.";
     } catch (error) {
-      throw error;
+      if (error instanceof import_utils47.AppError) {
+        throw error;
+      } else {
+        throw new import_utils47.InternalServerError("Failed to delete Permission Group.");
+      }
     }
   }
   return {
@@ -7758,8 +8311,8 @@ function usePermissionGroupService() {
 }
 
 // src/resources/permission/permission.group.controller.ts
-var import_utils46 = require("@goweekdays/utils");
-var import_joi24 = __toESM(require("joi"));
+var import_utils48 = require("@goweekdays/utils");
+var import_joi27 = __toESM(require("joi"));
 function usePermissionGroupController() {
   const {
     getAll: _getAll,
@@ -7772,8 +8325,8 @@ function usePermissionGroupController() {
     const value = req.body;
     const { error } = schemaPermissionGroup.validate(value);
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
-      import_utils46.logger.info(`Controller: ${error.message}`);
+      next(new import_utils48.BadRequestError(error.message));
+      import_utils48.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -7786,16 +8339,16 @@ function usePermissionGroupController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi24.default.object({
-      page: import_joi24.default.number().min(1).optional().allow("", null),
-      limit: import_joi24.default.number().min(1).optional().allow("", null),
-      search: import_joi24.default.string().optional().allow("", null),
-      app: import_joi24.default.string().optional().allow("", null),
-      status: import_joi24.default.string().optional().allow("", null)
+    const validation = import_joi27.default.object({
+      page: import_joi27.default.number().min(1).optional().allow("", null),
+      limit: import_joi27.default.number().min(1).optional().allow("", null),
+      search: import_joi27.default.string().optional().allow("", null),
+      app: import_joi27.default.string().optional().allow("", null),
+      status: import_joi27.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils48.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -7829,12 +8382,12 @@ function usePermissionGroupController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi24.default.object({
-      id: import_joi24.default.string().hex().required()
+    const validation = import_joi27.default.object({
+      id: import_joi27.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils48.BadRequestError(error.message));
       return;
     }
     try {
@@ -7850,12 +8403,12 @@ function usePermissionGroupController() {
   }
   async function deleteById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi24.default.object({
-      id: import_joi24.default.string().hex().required()
+    const validation = import_joi27.default.object({
+      id: import_joi27.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils48.BadRequestError(error.message));
       return;
     }
     try {
@@ -7868,15 +8421,15 @@ function usePermissionGroupController() {
   }
   async function updateById(req, res, next) {
     const id = req.params.id;
-    const { error: errorId } = import_joi24.default.string().hex().required().validate(id);
+    const { error: errorId } = import_joi27.default.string().hex().required().validate(id);
     if (errorId) {
-      next(new import_utils46.BadRequestError(errorId.message));
+      next(new import_utils48.BadRequestError(errorId.message));
       return;
     }
     const payload = req.body;
     const { error } = schemaPermissionGroupUpdate.validate(payload);
     if (error) {
-      next(new import_utils46.BadRequestError(error.message));
+      next(new import_utils48.BadRequestError(error.message));
       return;
     }
     try {