@eeplatform/basic-edu 1.0.0

package/dist/index.js

@@ -0,0 +1,1405 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  modelDivision: () => modelDivision,
+  modelRegion: () => modelRegion,
+  modelSchool: () => modelSchool,
+  schemaDivision: () => schemaDivision,
+  schemaRegion: () => schemaRegion,
+  schemaSchool: () => schemaSchool,
+  useDivisionController: () => useDivisionController,
+  useDivisionRepo: () => useDivisionRepo,
+  useRegionController: () => useRegionController,
+  useRegionRepo: () => useRegionRepo,
+  useSchoolController: () => useSchoolController,
+  useSchoolRepo: () => useSchoolRepo
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/models/region.model.ts
+var import_nodejs_utils = require("@eeplatform/nodejs-utils");
+var import_joi = __toESM(require("joi"));
+var import_mongodb = require("mongodb");
+var schemaRegion = import_joi.default.object({
+  _id: import_joi.default.string().hex().optional().allow(null, ""),
+  name: import_joi.default.string().min(1).max(100).required(),
+  createdAt: import_joi.default.string().isoDate().optional(),
+  updatedAt: import_joi.default.string().isoDate().optional(),
+  deletedAt: import_joi.default.string().isoDate().optional().allow(null, "")
+});
+function modelRegion(value) {
+  const { error } = schemaRegion.validate(value);
+  if (error) {
+    throw new import_nodejs_utils.BadRequestError(`Invalid region data: ${error.message}`);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = import_mongodb.ObjectId.createFromTime(value._id);
+    } catch (error2) {
+      throw new Error("Invalid _id.");
+    }
+  }
+  return {
+    _id: value._id,
+    name: value.name,
+    createdAt: value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/region.repository.ts
+var import_nodejs_utils2 = require("@eeplatform/nodejs-utils");
+var import_mongodb2 = require("mongodb");
+function useRegionRepo() {
+  const db = import_nodejs_utils2.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "deped.regions";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils2.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { name: 1 } },
+        { key: { createdAt: 1 } },
+        { key: { name: "text" } },
+        { key: { name: 1 }, unique: true, name: "unique_name" }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on regions.");
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils2.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils2.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = modelRegion(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils2.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils2.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils2.BadRequestError("Region already exists.");
+        }
+        throw new Error("Failed to create region.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      deletedAt: { $in: ["", null] },
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: 1 };
+    const cacheKeyOptions = {
+      status,
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search) {
+      query.$text = { $search: search };
+      cacheKeyOptions.search = search;
+    }
+    const cacheKey = (0, import_nodejs_utils2.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_nodejs_utils2.logger.log({
+      level: "info",
+      message: `Cache key for getAll regions: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils2.logger.log({
+          level: "info",
+          message: `Cache hit for getAll regions: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils2.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils2.logger.log({
+          level: "info",
+          message: `Cache set for getAll regions: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils2.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll regions: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils2.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb2.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils2.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils2.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils2.logger.log({
+          level: "info",
+          message: `Cache hit for getById region: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils2.BadRequestError("Region not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils2.logger.log({
+          level: "info",
+          message: `Cache set for region by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils2.logger.log({
+          level: "error",
+          message: `Failed to set cache for region by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils2.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils2.InternalServerError("Failed to get region.");
+      }
+    }
+  }
+  async function getByName(name) {
+    const cacheKey = (0, import_nodejs_utils2.makeCacheKey)(namespace_collection, { name });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils2.logger.log({
+          level: "info",
+          message: `Cache hit for getByName region: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        name,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils2.BadRequestError("Region not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils2.logger.log({
+          level: "info",
+          message: `Cache set for region by name: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils2.logger.log({
+          level: "error",
+          message: `Failed to set cache for region by name: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils2.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils2.InternalServerError("Failed to get region.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["name"];
+    if (!allowedFields.includes(field)) {
+      throw new import_nodejs_utils2.BadRequestError(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new import_mongodb2.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils2.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id, deletedAt: { $in: ["", null] } },
+        { $set: { [field]: value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated region ${field}.`;
+    } catch (error) {
+      throw new import_nodejs_utils2.InternalServerError(`Failed to update region ${field}.`);
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new import_mongodb2.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils2.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+      );
+      delCachedData();
+      return "Successfully deleted region.";
+    } catch (error) {
+      throw new import_nodejs_utils2.InternalServerError("Failed to delete region.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateFieldById,
+    deleteById,
+    getByName
+  };
+}
+
+// src/controllers/region.controller.ts
+var import_nodejs_utils3 = require("@eeplatform/nodejs-utils");
+var import_joi2 = __toESM(require("joi"));
+function useRegionController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById,
+    getByName: _getByName,
+    updateFieldById: _updateFieldById,
+    deleteById: _deleteById
+  } = useRegionRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaRegion.validate(value);
+    if (error) {
+      next(new import_nodejs_utils3.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _add(value);
+      res.json({
+        message: "Successfully created region.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi2.default.object({
+      page: import_joi2.default.number().min(1).optional().allow("", null),
+      limit: import_joi2.default.number().min(1).optional().allow("", null),
+      search: import_joi2.default.string().optional().allow("", null),
+      status: import_joi2.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "active";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_nodejs_utils3.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_nodejs_utils3.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_nodejs_utils3.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAll({ page, limit, search, status });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi2.default.object({
+      id: import_joi2.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils3.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json({
+        message: "Successfully retrieved region.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByName(req, res, next) {
+    const name = req.params.name;
+    const validation = import_joi2.default.object({
+      name: import_joi2.default.string().required()
+    });
+    const { error } = validation.validate({ name });
+    if (error) {
+      next(new import_nodejs_utils3.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getByName(name);
+      res.json({
+        message: "Successfully retrieved region.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateField(req, res, next) {
+    const _id = req.params.id;
+    const { field, value } = req.body;
+    const validation = import_joi2.default.object({
+      _id: import_joi2.default.string().hex().required(),
+      field: import_joi2.default.string().valid("name", "director", "directorName").required(),
+      value: import_joi2.default.string().required()
+    });
+    const { error } = validation.validate({ _id, field, value });
+    if (error) {
+      next(new import_nodejs_utils3.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateFieldById({ _id, field, value });
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const _id = req.params.id;
+    const validation = import_joi2.default.object({
+      _id: import_joi2.default.string().hex().required()
+    });
+    const { error } = validation.validate({ _id });
+    if (error) {
+      next(new import_nodejs_utils3.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(_id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    getByName,
+    updateField,
+    deleteById
+  };
+}
+
+// src/models/division.model.ts
+var import_nodejs_utils4 = require("@eeplatform/nodejs-utils");
+var import_joi3 = __toESM(require("joi"));
+var import_mongodb3 = require("mongodb");
+var schemaDivision = import_joi3.default.object({
+  _id: import_joi3.default.string().hex().optional().allow(null, ""),
+  name: import_joi3.default.string().min(1).max(100).required(),
+  region: import_joi3.default.string().hex().optional().allow(null, ""),
+  regionName: import_joi3.default.string().min(1).max(100).optional().allow(null, ""),
+  superintendent: import_joi3.default.string().hex().optional().allow(null, ""),
+  superintendentName: import_joi3.default.string().min(1).max(100).optional().allow(null, ""),
+  createdAt: import_joi3.default.string().isoDate().optional(),
+  updatedAt: import_joi3.default.string().isoDate().optional(),
+  deletedAt: import_joi3.default.string().isoDate().optional().allow(null, "")
+});
+function modelDivision(value) {
+  const { error } = schemaDivision.validate(value);
+  if (error) {
+    throw new import_nodejs_utils4.BadRequestError(`Invalid sdo data: ${error.message}`);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = import_mongodb3.ObjectId.createFromTime(value._id);
+    } catch (error2) {
+      throw new Error("Invalid _id.");
+    }
+  }
+  return {
+    _id: value._id,
+    name: value.name,
+    region: value.region,
+    regionName: value.regionName ?? "",
+    superintendent: value.superintendent,
+    superintendentName: value.superintendentName ?? "",
+    createdAt: value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/division.repository.ts
+var import_nodejs_utils5 = require("@eeplatform/nodejs-utils");
+var import_mongodb4 = require("mongodb");
+function useDivisionRepo() {
+  const db = import_nodejs_utils5.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "deped.divisions";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils5.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { name: 1 } },
+        { key: { createdAt: 1 } },
+        { key: { name: "text" } },
+        { key: { name: 1 }, unique: true, name: "unique_name" }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on divisions.");
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils5.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils5.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = modelDivision(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils5.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils5.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils5.BadRequestError("Division already exists.");
+        }
+        throw new Error("Failed to create division.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      deletedAt: { $in: ["", null] },
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: 1 };
+    const cacheKeyOptions = {
+      status,
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search) {
+      query.$text = { $search: search };
+      cacheKeyOptions.search = search;
+    }
+    const cacheKey = (0, import_nodejs_utils5.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_nodejs_utils5.logger.log({
+      level: "info",
+      message: `Cache key for getAll divisions: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils5.logger.log({
+          level: "info",
+          message: `Cache hit for getAll divisions: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils5.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils5.logger.log({
+          level: "info",
+          message: `Cache set for getAll divisions: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils5.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll divisions: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils5.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb4.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils5.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils5.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils5.logger.log({
+          level: "info",
+          message: `Cache hit for getById division: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils5.BadRequestError("Division not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils5.logger.log({
+          level: "info",
+          message: `Cache set for division by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils5.logger.log({
+          level: "error",
+          message: `Failed to set cache for division by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils5.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils5.InternalServerError("Failed to get division.");
+      }
+    }
+  }
+  async function getByName(name) {
+    const cacheKey = (0, import_nodejs_utils5.makeCacheKey)(namespace_collection, { name });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils5.logger.log({
+          level: "info",
+          message: `Cache hit for getByName division: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        name,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils5.BadRequestError("Division not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils5.logger.log({
+          level: "info",
+          message: `Cache set for division by name: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils5.logger.log({
+          level: "error",
+          message: `Failed to set cache for division by name: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils5.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils5.InternalServerError("Failed to get division.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["name"];
+    if (!allowedFields.includes(field)) {
+      throw new import_nodejs_utils5.BadRequestError(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new import_mongodb4.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils5.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id, deletedAt: { $in: ["", null] } },
+        { $set: { [field]: value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated division ${field}.`;
+    } catch (error) {
+      throw new import_nodejs_utils5.InternalServerError(`Failed to update division ${field}.`);
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new import_mongodb4.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils5.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+      );
+      delCachedData();
+      return "Successfully deleted division.";
+    } catch (error) {
+      throw new import_nodejs_utils5.InternalServerError("Failed to delete division.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateFieldById,
+    deleteById,
+    getByName
+  };
+}
+
+// src/controllers/division.controller.ts
+var import_nodejs_utils6 = require("@eeplatform/nodejs-utils");
+var import_joi4 = __toESM(require("joi"));
+function useDivisionController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById,
+    getByName: _getByName,
+    updateFieldById: _updateFieldById,
+    deleteById: _deleteById
+  } = useDivisionRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaDivision.validate(value);
+    if (error) {
+      next(new import_nodejs_utils6.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _add(value);
+      res.json({
+        message: "Successfully created division.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi4.default.object({
+      page: import_joi4.default.number().min(1).optional().allow("", null),
+      limit: import_joi4.default.number().min(1).optional().allow("", null),
+      search: import_joi4.default.string().optional().allow("", null),
+      status: import_joi4.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "active";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_nodejs_utils6.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_nodejs_utils6.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_nodejs_utils6.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAll({ page, limit, search, status });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi4.default.object({
+      id: import_joi4.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils6.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json({
+        message: "Successfully retrieved division.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByName(req, res, next) {
+    const name = req.params.name;
+    const validation = import_joi4.default.object({
+      name: import_joi4.default.string().required()
+    });
+    const { error } = validation.validate({ name });
+    if (error) {
+      next(new import_nodejs_utils6.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getByName(name);
+      res.json({
+        message: "Successfully retrieved division.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateField(req, res, next) {
+    const _id = req.params.id;
+    const { field, value } = req.body;
+    const validation = import_joi4.default.object({
+      _id: import_joi4.default.string().hex().required(),
+      field: import_joi4.default.string().valid("name", "director", "directorName").required(),
+      value: import_joi4.default.string().required()
+    });
+    const { error } = validation.validate({ _id, field, value });
+    if (error) {
+      next(new import_nodejs_utils6.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateFieldById({ _id, field, value });
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const _id = req.params.id;
+    const validation = import_joi4.default.object({
+      _id: import_joi4.default.string().hex().required()
+    });
+    const { error } = validation.validate({ _id });
+    if (error) {
+      next(new import_nodejs_utils6.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(_id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    getByName,
+    updateField,
+    deleteById
+  };
+}
+
+// src/models/school.model.ts
+var import_nodejs_utils7 = require("@eeplatform/nodejs-utils");
+var import_joi5 = __toESM(require("joi"));
+var import_mongodb5 = require("mongodb");
+var schemaSchool = import_joi5.default.object({
+  _id: import_joi5.default.string().hex().optional().allow(null, ""),
+  name: import_joi5.default.string().min(1).max(100).required(),
+  region: import_joi5.default.string().hex().optional().allow(null, ""),
+  regionName: import_joi5.default.string().min(1).max(100).optional().allow(null, ""),
+  division: import_joi5.default.string().hex().optional().allow(null, ""),
+  divisionName: import_joi5.default.string().min(1).max(100).optional().allow(null, ""),
+  principal: import_joi5.default.string().hex().optional().allow(null, ""),
+  principalName: import_joi5.default.string().min(1).max(100).optional().allow(null, ""),
+  createdAt: import_joi5.default.string().isoDate().optional(),
+  updatedAt: import_joi5.default.string().isoDate().optional(),
+  deletedAt: import_joi5.default.string().isoDate().optional().allow(null, "")
+});
+function modelSchool(value) {
+  const { error } = schemaSchool.validate(value);
+  if (error) {
+    throw new import_nodejs_utils7.BadRequestError(`Invalid sdo data: ${error.message}`);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = import_mongodb5.ObjectId.createFromTime(value._id);
+    } catch (error2) {
+      throw new Error("Invalid _id.");
+    }
+  }
+  return {
+    _id: value._id,
+    name: value.name,
+    region: value.region,
+    regionName: value.regionName ?? "",
+    division: value.division,
+    divisionName: value.divisionName ?? "",
+    principal: value.principal,
+    principalName: value.principalName ?? "",
+    createdAt: value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/school.repository.ts
+var import_nodejs_utils8 = require("@eeplatform/nodejs-utils");
+var import_mongodb6 = require("mongodb");
+function useSchoolRepo() {
+  const db = import_nodejs_utils8.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "deped.schools";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils8.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { name: 1 } },
+        { key: { createdAt: 1 } },
+        { key: { name: "text" } },
+        { key: { name: 1 }, unique: true, name: "unique_name" }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on schools.");
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils8.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils8.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = modelSchool(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils8.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils8.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils8.BadRequestError("School already exists.");
+        }
+        throw new Error("Failed to create school.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      deletedAt: { $in: ["", null] },
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: 1 };
+    const cacheKeyOptions = {
+      status,
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search) {
+      query.$text = { $search: search };
+      cacheKeyOptions.search = search;
+    }
+    const cacheKey = (0, import_nodejs_utils8.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_nodejs_utils8.logger.log({
+      level: "info",
+      message: `Cache key for getAll schools: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils8.logger.log({
+          level: "info",
+          message: `Cache hit for getAll schools: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils8.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils8.logger.log({
+          level: "info",
+          message: `Cache set for getAll schools: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils8.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll schools: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils8.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb6.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils8.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils8.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils8.logger.log({
+          level: "info",
+          message: `Cache hit for getById school: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils8.BadRequestError("School not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils8.logger.log({
+          level: "info",
+          message: `Cache set for school by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils8.logger.log({
+          level: "error",
+          message: `Failed to set cache for school by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils8.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils8.InternalServerError("Failed to get school.");
+      }
+    }
+  }
+  async function getByName(name) {
+    const cacheKey = (0, import_nodejs_utils8.makeCacheKey)(namespace_collection, { name });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils8.logger.log({
+          level: "info",
+          message: `Cache hit for getByName school: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        name,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils8.BadRequestError("School not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils8.logger.log({
+          level: "info",
+          message: `Cache set for school by name: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils8.logger.log({
+          level: "error",
+          message: `Failed to set cache for school by name: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils8.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils8.InternalServerError("Failed to get school.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["name"];
+    if (!allowedFields.includes(field)) {
+      throw new import_nodejs_utils8.BadRequestError(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new import_mongodb6.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils8.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id, deletedAt: { $in: ["", null] } },
+        { $set: { [field]: value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated school ${field}.`;
+    } catch (error) {
+      throw new import_nodejs_utils8.InternalServerError(`Failed to update school ${field}.`);
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new import_mongodb6.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils8.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+      );
+      delCachedData();
+      return "Successfully deleted school.";
+    } catch (error) {
+      throw new import_nodejs_utils8.InternalServerError("Failed to delete school.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateFieldById,
+    deleteById,
+    getByName
+  };
+}
+
+// src/controllers/school.controller.ts
+var import_nodejs_utils9 = require("@eeplatform/nodejs-utils");
+var import_joi6 = __toESM(require("joi"));
+function useSchoolController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById,
+    getByName: _getByName,
+    updateFieldById: _updateFieldById,
+    deleteById: _deleteById
+  } = useSchoolRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaSchool.validate(value);
+    if (error) {
+      next(new import_nodejs_utils9.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _add(value);
+      res.json({
+        message: "Successfully created school.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi6.default.object({
+      page: import_joi6.default.number().min(1).optional().allow("", null),
+      limit: import_joi6.default.number().min(1).optional().allow("", null),
+      search: import_joi6.default.string().optional().allow("", null),
+      status: import_joi6.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "active";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_nodejs_utils9.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_nodejs_utils9.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_nodejs_utils9.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAll({ page, limit, search, status });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi6.default.object({
+      id: import_joi6.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils9.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json({
+        message: "Successfully retrieved school.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByName(req, res, next) {
+    const name = req.params.name;
+    const validation = import_joi6.default.object({
+      name: import_joi6.default.string().required()
+    });
+    const { error } = validation.validate({ name });
+    if (error) {
+      next(new import_nodejs_utils9.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getByName(name);
+      res.json({
+        message: "Successfully retrieved school.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateField(req, res, next) {
+    const _id = req.params.id;
+    const { field, value } = req.body;
+    const validation = import_joi6.default.object({
+      _id: import_joi6.default.string().hex().required(),
+      field: import_joi6.default.string().valid("name", "director", "directorName").required(),
+      value: import_joi6.default.string().required()
+    });
+    const { error } = validation.validate({ _id, field, value });
+    if (error) {
+      next(new import_nodejs_utils9.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateFieldById({ _id, field, value });
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const _id = req.params.id;
+    const validation = import_joi6.default.object({
+      _id: import_joi6.default.string().hex().required()
+    });
+    const { error } = validation.validate({ _id });
+    if (error) {
+      next(new import_nodejs_utils9.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(_id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    getByName,
+    updateField,
+    deleteById
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  modelDivision,
+  modelRegion,
+  modelSchool,
+  schemaDivision,
+  schemaRegion,
+  schemaSchool,
+  useDivisionController,
+  useDivisionRepo,
+  useRegionController,
+  useRegionRepo,
+  useSchoolController,
+  useSchoolRepo
+});
+//# sourceMappingURL=index.js.map