@eeplatform/core 1.7.2 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @eeplatform/core
 
+## 1.8.0
+
+### Minor Changes
+
+- de639da: PSGC mgmt - initial release
+
+## 1.7.4
+
+### Patch Changes
+
+- 8816b2d: Add optional cache clear params to role repo
+
+## 1.7.3
+
+### Patch Changes
+
+- 36493af: Add new services
+
 ## 1.7.2
 
 ### Patch Changes

package/dist/index.d.ts

@@ -281,7 +281,7 @@ declare function useRoleRepo(): {
     createIndex: () => Promise<void>;
     createTextIndex: () => Promise<void>;
     createUniqueIndex: () => Promise<void>;
-    addRole: (value: TRole, session?: ClientSession) => Promise<ObjectId>;
+    addRole: (value: TRole, session?: ClientSession, clearCache?: boolean) => Promise<ObjectId>;
     getRoles: ({ search, page, limit, sort, type, id, }?: {
         search?: string;
         page?: number;
@@ -300,6 +300,7 @@ declare function useRoleRepo(): {
     updateRole: (_id: string | ObjectId, value: TMiniRole, session?: ClientSession) => Promise<string>;
     deleteRole: (_id: ObjectId | string, session?: ClientSession) => Promise<string>;
     updatePermissionsById: (_id: string | ObjectId, permissions: TRole["permissions"], session?: ClientSession) => Promise<string>;
+    delCachedData: () => void;
 };
 
 declare function useRoleController(): {
@@ -873,6 +874,48 @@ declare function useUtilController(): {
 
 declare const transactionSchema: Joi.ObjectSchema<any>;
 
+type TPSGC = {
+    _id?: ObjectId;
+    code: number;
+    name: string;
+    type: string;
+};
+declare const schemaPSGC: Joi.ObjectSchema<any>;
+declare function modelPSGC(data: any): {
+    code: any;
+    name: any;
+    type: any;
+};
+
+declare function usePSGCRepo(): {
+    createIndexes: () => Promise<void>;
+    add: (value: TPSGC, session?: ClientSession) => Promise<ObjectId>;
+    getAll: ({ search, page, limit, sort, status, }?: {
+        search?: string | undefined;
+        page?: number | undefined;
+        limit?: number | undefined;
+        sort?: {} | undefined;
+        status?: string | undefined;
+    }) => Promise<Record<string, any> | {
+        items: any[];
+        pages: number;
+        pageRange: string;
+    }>;
+    getById: (_id: string | ObjectId) => Promise<TPSGC>;
+    updateFieldById: ({ _id, field, value }?: {
+        _id: string | ObjectId;
+        field: string;
+        value: string;
+    }, session?: ClientSession) => Promise<string>;
+    deleteById: (_id: string | ObjectId) => Promise<string>;
+    getByName: ({ name, cityMunicipality, code, type }?: {
+        name: string;
+        cityMunicipality?: boolean;
+        code?: number;
+        type?: string;
+    }) => Promise<TPSGC | null>;
+};
+
 declare const MONGO_URI: string;
 declare const MONGO_DB: string;
 declare const PORT: number;
@@ -912,4 +955,4 @@ declare const GEMINI_API_KEY: string;
 declare const ASSEMBLY_AI_API_KEY: string;
 declare const DOMAIN: string;
 
-export { ACCESS_TOKEN_EXPIRY, ACCESS_TOKEN_SECRET, APP_ACCOUNT, APP_MAIN, ASSEMBLY_AI_API_KEY, AudioFileData, AudioTranscriptionOptions, AudioTranscriptionResult, DEFAULT_USER_EMAIL, DEFAULT_USER_FIRST_NAME, DEFAULT_USER_LAST_NAME, DEFAULT_USER_PASSWORD, DOMAIN, GEMINI_API_KEY, MAILER_EMAIL, MAILER_PASSWORD, MAILER_TRANSPORT_HOST, MAILER_TRANSPORT_PORT, MAILER_TRANSPORT_SECURE, MAddress, MBuilding, MBuildingUnit, MFile, MMember, MONGO_DB, MONGO_URI, MOrg, MRole, MToken, MUser, MUserRole, MVerification, PAYPAL_API_URL, PAYPAL_CLIENT_ID, PAYPAL_CLIENT_SECRET, PORT, PhonemeMatchOptions, PhonemeMatchResult, REDIS_HOST, REDIS_PASSWORD, REDIS_PORT, REFRESH_TOKEN_EXPIRY, REFRESH_TOKEN_SECRET, SECRET_KEY, SPACES_ACCESS_KEY, SPACES_BUCKET, SPACES_ENDPOINT, SPACES_REGION, SPACES_SECRET_KEY, TAddress, TBuilding, TBuildingUnit, TCounter, TFile, TMember, TMiniRole, TOrg, TRole, TToken, TUser, TUserRole, TVerification, TVerificationMetadata, VERIFICATION_FORGET_PASSWORD_DURATION, VERIFICATION_USER_INVITE_DURATION, XENDIT_BASE_URL, XENDIT_SECRET_KEY, addressSchema, isDev, schemaBuilding, schemaBuildingUnit, schemaOrg, schemaUpdateOptions, transactionSchema, useAddressController, useAddressRepo, useAudioTranscriptionController, useAuthController, useAuthService, useBuildingController, useBuildingRepo, useBuildingService, useBuildingUnitController, useBuildingUnitRepo, useBuildingUnitService, useCounterModel, useCounterRepo, useFileController, useFileRepo, useFileService, useGeminiAiService, useGitHubService, useMemberController, useMemberRepo, useOrgController, useOrgRepo, useOrgService, useRoleController, useRoleRepo, useTokenRepo, useTranscribeService, useUserController, useUserRepo, useUserService, useUtilController, useVerificationController, useVerificationRepo, useVerificationService };
+export { ACCESS_TOKEN_EXPIRY, ACCESS_TOKEN_SECRET, APP_ACCOUNT, APP_MAIN, ASSEMBLY_AI_API_KEY, AudioFileData, AudioTranscriptionOptions, AudioTranscriptionResult, DEFAULT_USER_EMAIL, DEFAULT_USER_FIRST_NAME, DEFAULT_USER_LAST_NAME, DEFAULT_USER_PASSWORD, DOMAIN, GEMINI_API_KEY, MAILER_EMAIL, MAILER_PASSWORD, MAILER_TRANSPORT_HOST, MAILER_TRANSPORT_PORT, MAILER_TRANSPORT_SECURE, MAddress, MBuilding, MBuildingUnit, MFile, MMember, MONGO_DB, MONGO_URI, MOrg, MRole, MToken, MUser, MUserRole, MVerification, PAYPAL_API_URL, PAYPAL_CLIENT_ID, PAYPAL_CLIENT_SECRET, PORT, PhonemeMatchOptions, PhonemeMatchResult, REDIS_HOST, REDIS_PASSWORD, REDIS_PORT, REFRESH_TOKEN_EXPIRY, REFRESH_TOKEN_SECRET, SECRET_KEY, SPACES_ACCESS_KEY, SPACES_BUCKET, SPACES_ENDPOINT, SPACES_REGION, SPACES_SECRET_KEY, TAddress, TBuilding, TBuildingUnit, TCounter, TFile, TMember, TMiniRole, TOrg, TPSGC, TRole, TToken, TUser, TUserRole, TVerification, TVerificationMetadata, VERIFICATION_FORGET_PASSWORD_DURATION, VERIFICATION_USER_INVITE_DURATION, XENDIT_BASE_URL, XENDIT_SECRET_KEY, addressSchema, isDev, modelPSGC, schemaBuilding, schemaBuildingUnit, schemaOrg, schemaPSGC, schemaUpdateOptions, transactionSchema, useAddressController, useAddressRepo, useAudioTranscriptionController, useAuthController, useAuthService, useBuildingController, useBuildingRepo, useBuildingService, useBuildingUnitController, useBuildingUnitRepo, useBuildingUnitService, useCounterModel, useCounterRepo, useFileController, useFileRepo, useFileService, useGeminiAiService, useGitHubService, useMemberController, useMemberRepo, useOrgController, useOrgRepo, useOrgService, usePSGCRepo, useRoleController, useRoleRepo, useTokenRepo, useTranscribeService, useUserController, useUserRepo, useUserService, useUtilController, useVerificationController, useVerificationRepo, useVerificationService };

package/dist/index.js

@@ -80,9 +80,11 @@ __export(src_exports, {
   XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
   addressSchema: () => addressSchema,
   isDev: () => isDev,
+  modelPSGC: () => modelPSGC,
   schemaBuilding: () => schemaBuilding,
   schemaBuildingUnit: () => schemaBuildingUnit,
   schemaOrg: () => schemaOrg,
+  schemaPSGC: () => schemaPSGC,
   schemaUpdateOptions: () => schemaUpdateOptions,
   transactionSchema: () => transactionSchema,
   useAddressController: () => useAddressController,
@@ -108,6 +110,7 @@ __export(src_exports, {
   useOrgController: () => useOrgController,
   useOrgRepo: () => useOrgRepo,
   useOrgService: () => useOrgService,
+  usePSGCRepo: () => usePSGCRepo,
   useRoleController: () => useRoleController,
   useRoleRepo: () => useRoleRepo,
   useTokenRepo: () => useTokenRepo,
@@ -2221,11 +2224,13 @@ function useRoleRepo() {
       throw new import_nodejs_utils10.InternalServerError("Failed to create unique index on role.");
     }
   }
-  async function addRole(value, session) {
+  async function addRole(value, session, clearCache = true) {
     value = new MRole(value);
     try {
       const res = await collection.insertOne(value, { session });
-      delCachedData();
+      if (clearCache) {
+        delCachedData();
+      }
       return res.insertedId;
     } catch (error) {
       import_nodejs_utils10.logger.log({ level: "error", message: `${error}` });
@@ -2498,7 +2503,8 @@ function useRoleRepo() {
     getRoleByName,
     updateRole,
     deleteRole,
-    updatePermissionsById
+    updatePermissionsById,
+    delCachedData
   };
 }
 
@@ -3875,6 +3881,7 @@ function useRoleController() {
 // src/resources/file/file.service.ts
 var import_nodejs_utils19 = require("@eeplatform/nodejs-utils");
 var import_node_cron = __toESM(require("node-cron"));
+var fs = __toESM(require("fs"));
 function useFileService() {
   const {
     createFile: _createFile,
@@ -3898,12 +3905,23 @@ function useFileService() {
     };
     try {
       const id = await _createFile(file, session);
+      const fileBuffer = value.buffer || await fs.promises.readFile(value.path);
       await s3.uploadObject({
         key: id,
-        body: value.buffer,
+        body: fileBuffer,
         contentType: value.mimetype
       });
       await session?.commitTransaction();
+      if (value.path) {
+        try {
+          await fs.promises.unlink(value.path);
+        } catch (cleanupError) {
+          console.error(
+            `Failed to cleanup temporary file ${value.path}:`,
+            cleanupError
+          );
+        }
+      }
       return id;
     } catch (error) {
       await session?.abortTransaction();
@@ -6257,7 +6275,7 @@ function useGitHubService() {
       const octokit = new import_rest.Octokit({ auth: githubToken });
       const { owner, repo } = parseRepoUrl(repoUrl);
       await checkAdminPermission(owner, repo, octokit);
-      const lines = keyValues.split(/[\n\r\s\t]+/).map((l) => l.trim()).filter(Boolean);
+      const lines = keyValues.split(";").map((l) => l.trim()).filter(Boolean);
       for (const line of lines) {
         const equalIndex = line.indexOf("=");
         if (equalIndex === -1)
@@ -6873,7 +6891,7 @@ function useUtilController() {
           availableEndpoints: [
             "POST /github/variables - Set GitHub environment variables or secrets"
           ],
-          keyValueFormat: "KEY=value pairs separated by newlines, spaces, or tabs"
+          keyValueFormat: "KEY=value pairs separated by semicolons"
         }
       });
     } catch (error) {
@@ -6927,14 +6945,14 @@ function useUtilController() {
         );
         return;
       }
-      const lines = keyValues.split(/[\n\r\s\t]+/).map((l) => l.trim()).filter(Boolean);
+      const lines = keyValues.split(";").map((l) => l.trim()).filter(Boolean);
       const invalidLines = lines.filter(
         (line) => !line.includes("=") || line.indexOf("=") === -1
       );
       if (invalidLines.length > 0) {
         next(
           new import_nodejs_utils38.BadRequestError(
-            "Invalid key-value format. Each pair should be in format: KEY=value. Pairs can be separated by newlines, spaces, or tabs."
+            "Invalid key-value format. Each pair should be in format: KEY=value. Pairs should be separated by semicolons."
           )
         );
         return;
@@ -7007,6 +7025,288 @@ var transactionSchema = import_joi17.default.object({
   updatedAt: import_joi17.default.string().optional().allow("", null),
   deletedAt: import_joi17.default.string().optional().allow("", null)
 });
+
+// src/resources/phillipine-std-geo-code/psgc.model.ts
+var import_joi18 = __toESM(require("joi"));
+var schemaPSGC = import_joi18.default.object({
+  code: import_joi18.default.number().required(),
+  name: import_joi18.default.string().required(),
+  type: import_joi18.default.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
+var import_nodejs_utils39 = require("@eeplatform/nodejs-utils");
+var import_mongodb21 = require("mongodb");
+function usePSGCRepo() {
+  const db = import_nodejs_utils39.useAtlas.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 } = (0, import_nodejs_utils39.useCache)(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(() => {
+      import_nodejs_utils39.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils39.logger.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) {
+      import_nodejs_utils39.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils39.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils39.BadRequestError("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 = (0, import_nodejs_utils39.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_nodejs_utils39.logger.log({
+      level: "info",
+      message: `Cache key for getAll PSGC: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils39.logger.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 = (0, import_nodejs_utils39.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils39.logger.log({
+          level: "info",
+          message: `Cache set for getAll PSGC: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils39.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll PSGC: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils39.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb21.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils39.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils39.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils39.logger.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 import_nodejs_utils39.BadRequestError("Region not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils39.logger.log({
+          level: "info",
+          message: `Cache set for PSGC by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils39.logger.log({
+          level: "error",
+          message: `Failed to set cache for PSGC by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils39.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils39.InternalServerError("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 = (0, import_nodejs_utils39.makeCacheKey)(namespace_collection, { name });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils39.logger.log({
+          level: "info",
+          message: `Cache hit for getByName PSGC: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne(query);
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils39.logger.log({
+          level: "info",
+          message: `Cache set for PSGC by name: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils39.logger.log({
+          level: "error",
+          message: `Failed to set cache for PSGC by name: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils39.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils39.InternalServerError("Failed to get PSGC.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["name"];
+    if (!allowedFields.includes(field)) {
+      throw new import_nodejs_utils39.BadRequestError(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new import_mongodb21.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils39.BadRequestError("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 import_nodejs_utils39.InternalServerError(`Failed to update PSGC ${field}.`);
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new import_mongodb21.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils39.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+      );
+      delCachedData();
+      return "Successfully deleted PSGC.";
+    } catch (error) {
+      throw new import_nodejs_utils39.InternalServerError("Failed to delete PSGC.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateFieldById,
+    deleteById,
+    getByName
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCESS_TOKEN_EXPIRY,
@@ -7059,9 +7359,11 @@ var transactionSchema = import_joi17.default.object({
   XENDIT_SECRET_KEY,
   addressSchema,
   isDev,
+  modelPSGC,
   schemaBuilding,
   schemaBuildingUnit,
   schemaOrg,
+  schemaPSGC,
   schemaUpdateOptions,
   transactionSchema,
   useAddressController,
@@ -7087,6 +7389,7 @@ var transactionSchema = import_joi17.default.object({
   useOrgController,
   useOrgRepo,
   useOrgService,
+  usePSGCRepo,
   useRoleController,
   useRoleRepo,
   useTokenRepo,