@eeplatform/core 1.7.4 → 1.8.0

package/dist/index.mjs

@@ -7039,6 +7039,297 @@ var transactionSchema = Joi17.object({
   updatedAt: Joi17.string().optional().allow("", null),
   deletedAt: Joi17.string().optional().allow("", null)
 });
+
+// src/resources/phillipine-std-geo-code/psgc.model.ts
+import Joi18 from "joi";
+var schemaPSGC = Joi18.object({
+  code: Joi18.number().required(),
+  name: Joi18.string().required(),
+  type: Joi18.string().valid("Reg", "Prov", "City", "Mun", "Bgy").required()
+});
+function modelPSGC(data) {
+  const { error } = schemaPSGC.validate(data);
+  if (error) {
+    throw new Error(`Invalid PSGC data: ${error.message}`);
+  }
+  return {
+    code: data.code,
+    name: data.name,
+    type: data.type
+  };
+}
+
+// src/resources/phillipine-std-geo-code/psgc.repository.ts
+import {
+  AppError as AppError14,
+  BadRequestError as BadRequestError34,
+  InternalServerError as InternalServerError20,
+  logger as logger19,
+  makeCacheKey as makeCacheKey13,
+  paginate as paginate8,
+  useAtlas as useAtlas18,
+  useCache as useCache14
+} from "@eeplatform/nodejs-utils";
+import { ObjectId as ObjectId21 } from "mongodb";
+function usePSGCRepo() {
+  const db = useAtlas18.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "philippine.standard.geographic.codes";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache14(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { name: 1 } },
+        { key: { name: "text" } },
+        { key: { code: 1 }, unique: true, name: "unique_code" }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on PSGC.");
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      logger19.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger19.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = modelPSGC(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      logger19.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError14) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new BadRequestError34("Region already exists.");
+        }
+        throw new Error("Failed to create PSGC.");
+      }
+    }
+  }
+  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 = makeCacheKey13(namespace_collection, cacheKeyOptions);
+    logger19.log({
+      level: "info",
+      message: `Cache key for getAll PSGC: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger19.log({
+          level: "info",
+          message: `Cache hit for getAll PSGC: ${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 = paginate8(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        logger19.log({
+          level: "info",
+          message: `Cache set for getAll PSGC: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger19.log({
+          level: "error",
+          message: `Failed to set cache for getAll PSGC: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      logger19.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId21(_id);
+    } catch (error) {
+      throw new BadRequestError34("Invalid ID.");
+    }
+    const cacheKey = makeCacheKey13(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger19.log({
+          level: "info",
+          message: `Cache hit for getById PSGC: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new BadRequestError34("Region not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        logger19.log({
+          level: "info",
+          message: `Cache set for PSGC by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger19.log({
+          level: "error",
+          message: `Failed to set cache for PSGC by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError14) {
+        throw error;
+      } else {
+        throw new InternalServerError20("Failed to get PSGC.");
+      }
+    }
+  }
+  async function getByName({ name, cityMunicipality = false, code = 0, type = "" } = {}) {
+    const query = { $text: { $search: name } };
+    const cacheKeyOptions = { name };
+    if (cityMunicipality) {
+      query.type = { $in: ["City", "Mun"] };
+      cacheKeyOptions.type = cityMunicipality;
+    }
+    if (type && !cityMunicipality) {
+      query.type = type;
+      cacheKeyOptions.type = type;
+    }
+    if (code) {
+      query.code = { $gt: code };
+      if (cityMunicipality) {
+        query.code.$lt = code + 1e6;
+      }
+      cacheKeyOptions.code = code;
+    }
+    const cacheKey = makeCacheKey13(namespace_collection, { name });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger19.log({
+          level: "info",
+          message: `Cache hit for getByName PSGC: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne(query);
+      setCache(cacheKey, result, 300).then(() => {
+        logger19.log({
+          level: "info",
+          message: `Cache set for PSGC by name: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger19.log({
+          level: "error",
+          message: `Failed to set cache for PSGC by name: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError14) {
+        throw error;
+      } else {
+        throw new InternalServerError20("Failed to get PSGC.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["name"];
+    if (!allowedFields.includes(field)) {
+      throw new BadRequestError34(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new ObjectId21(_id);
+    } catch (error) {
+      throw new BadRequestError34("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id, deletedAt: { $in: ["", null] } },
+        { $set: { [field]: value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated PSGC ${field}.`;
+    } catch (error) {
+      throw new InternalServerError20(`Failed to update PSGC ${field}.`);
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new ObjectId21(_id);
+    } catch (error) {
+      throw new BadRequestError34("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+      );
+      delCachedData();
+      return "Successfully deleted PSGC.";
+    } catch (error) {
+      throw new InternalServerError20("Failed to delete PSGC.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateFieldById,
+    deleteById,
+    getByName
+  };
+}
 export {
   ACCESS_TOKEN_EXPIRY,
   ACCESS_TOKEN_SECRET,
@@ -7090,9 +7381,11 @@ export {
   XENDIT_SECRET_KEY,
   addressSchema,
   isDev,
+  modelPSGC,
   schemaBuilding,
   schemaBuildingUnit,
   schemaOrg,
+  schemaPSGC,
   schemaUpdateOptions,
   transactionSchema,
   useAddressController,
@@ -7118,6 +7411,7 @@ export {
   useOrgController,
   useOrgRepo,
   useOrgService,
+  usePSGCRepo,
   useRoleController,
   useRoleRepo,
   useTokenRepo,