@goweekdays/core 2.11.18 → 2.11.19

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @goweekdays/core
 
+## 2.11.19
+
+### Patch Changes
+
+- dc8a6a1: Add getById and updateStatusById for job applications
+
 ## 2.11.18
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1308,7 +1308,7 @@ declare function modelJobApplication(data: TJobApplication): TJobApplication;
 declare function useJobApplicationRepo(): {
     createIndexes: () => Promise<string>;
     delCachedData: () => void;
-    add: (data: TJobApplication) => Promise<bson.ObjectId>;
+    add: (data: TJobApplication) => Promise<ObjectId>;
     getAll: ({ page, limit, search, status, }?: {
         page?: number | undefined;
         limit?: number | undefined;
@@ -1322,11 +1322,15 @@ declare function useJobApplicationRepo(): {
         data: TJobApplication[];
         total: number;
     }>;
+    getById: (_id: string | ObjectId) => Promise<mongodb.WithId<bson.Document> | TJobApplication | null>;
+    updateStatusById: (_id: string | ObjectId, status: string, session?: ClientSession) => Promise<string>;
 };
 
 declare function useJobApplicationController(): {
     add: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     getAll: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    updateStatusById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
 };
 
 declare const MONGO_URI: string;

package/dist/index.js

@@ -13967,6 +13967,11 @@ function modelJobApplication(data) {
   } catch (error2) {
     throw new import_utils72.BadRequestError(`Invalid job application post id: ${data.post}`);
   }
+  try {
+    data.user = new import_mongodb32.ObjectId(data.user);
+  } catch (error2) {
+    throw new import_utils72.BadRequestError(`Invalid job application user id: ${data.user}`);
+  }
   if (data.company && typeof data.company === "string") {
     try {
       data.company = new import_mongodb32.ObjectId(data.company);
@@ -13997,6 +14002,8 @@ function modelJobApplication(data) {
 
 // src/resources/job-applications/job.application.repository.ts
 var import_utils73 = require("@goweekdays/utils");
+var import_mongodb33 = require("mongodb");
+var import_joi55 = __toESM(require("joi"));
 function useJobApplicationRepo() {
   const db = import_utils73.useAtlas.getDb();
   if (!db) {
@@ -14116,24 +14123,142 @@ function useJobApplicationRepo() {
       );
     }
   }
+  async function getById(_id) {
+    const { error } = import_joi55.default.string().hex().length(24).validate(_id);
+    if (error) {
+      throw new import_utils73.BadRequestError(`Invalid job application id: ${_id}`);
+    }
+    try {
+      _id = new import_mongodb33.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils73.BadRequestError(`Invalid job application id: ${_id}`);
+    }
+    try {
+      const cacheKey = (0, import_utils73.makeCacheKey)(namespace_collection, {
+        _id,
+        tag: "getById"
+      });
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
+      }
+      const data = await collection.findOne({ _id });
+      setCache(cacheKey, data).then(() => {
+        import_utils73.logger.log({
+          level: "info",
+          message: `Cache set for getById job application: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils73.logger.log({
+          level: "error",
+          message: `Failed to set cache for getById job application: ${cacheKey}, error: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      if (error2 instanceof import_utils73.AppError) {
+        throw error2;
+      }
+      throw new import_utils73.BadRequestError(
+        `Failed to get job application: ${error2.message}`
+      );
+    }
+  }
+  async function updateStatusById(_id, status, session) {
+    const { error } = import_joi55.default.object({
+      _id: import_joi55.default.string().hex().length(24).required(),
+      status: import_joi55.default.string().valid(...jobApplicationStatuses).required()
+    }).validate({ _id, status });
+    if (error) {
+      throw new import_utils73.BadRequestError(`Invalid job application id: ${_id}`);
+    }
+    try {
+      _id = new import_mongodb33.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils73.BadRequestError(`Invalid job application id: ${_id}`);
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { status, updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      delCachedData();
+      return "Successfully updated job application status.";
+    } catch (error2) {
+      if (error2 instanceof import_utils73.AppError) {
+        throw error2;
+      }
+      throw new import_utils73.BadRequestError(
+        `Failed to update job application status: ${error2.message}`
+      );
+    }
+  }
   return {
     createIndexes,
     delCachedData,
     add,
-    getAll
+    getAll,
+    getById,
+    updateStatusById
   };
 }
 
 // src/resources/job-applications/job.application.controller.ts
+var import_utils75 = require("@goweekdays/utils");
+var import_joi57 = __toESM(require("joi"));
+
+// src/resources/job-applications/job.application.service.ts
+var import_joi56 = __toESM(require("joi"));
 var import_utils74 = require("@goweekdays/utils");
-var import_joi55 = __toESM(require("joi"));
+function useJobApplicationService() {
+  const { getById, updateStatusById: _updateStatusById } = useJobApplicationRepo();
+  async function updateStatusById(id, status) {
+    const { error } = import_joi56.default.object({
+      id: import_joi56.default.string().hex().length(24).required(),
+      status: import_joi56.default.string().valid(...jobApplicationStatuses).required()
+    }).validate({ id, status });
+    if (error) {
+      throw new import_utils74.BadRequestError(`Invalid parameters: ${error.message}`);
+    }
+    try {
+      const application = await getById(id);
+      if (!application) {
+        throw new import_utils74.BadRequestError(`Job application not found with id: ${id}`);
+      }
+      if (application.status === status) {
+        throw new import_utils74.BadRequestError(
+          `Job application already has status: ${status}`
+        );
+      }
+      await _updateStatusById(id, status);
+      return `Successfully updated job application status to: ${status}`;
+    } catch (error2) {
+      if (error2 instanceof import_utils74.AppError) {
+        throw error2;
+      }
+      throw new import_utils74.BadRequestError(
+        `Failed to update job application status: ${error2.message}`
+      );
+    }
+  }
+  return {
+    updateStatusById
+  };
+}
+
+// src/resources/job-applications/job.application.controller.ts
 function useJobApplicationController() {
-  const { add: _add, getAll: _getAll } = useJobApplicationRepo();
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById
+  } = useJobApplicationRepo();
   async function add(req, res, next) {
     const { error } = schemaJobApplication.validate(req.body);
     if (error) {
       next(
-        new import_utils74.BadRequestError(`Invalid job application data: ${error.message}`)
+        new import_utils75.BadRequestError(`Invalid job application data: ${error.message}`)
       );
       return;
     }
@@ -14142,27 +14267,27 @@ function useJobApplicationController() {
       res.json({ message });
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils74.AppError) {
+      if (error2 instanceof import_utils75.AppError) {
         next(error2);
         return;
       }
       next(
-        new import_utils74.BadRequestError(
+        new import_utils75.BadRequestError(
           `Failed to create job application: ${error2.message}`
         )
       );
     }
   }
   async function getAll(req, res, next) {
-    const validation = import_joi55.default.object({
-      page: import_joi55.default.number().integer().min(1).optional(),
-      limit: import_joi55.default.number().integer().min(1).max(100).optional(),
-      search: import_joi55.default.string().optional().allow(""),
-      status: import_joi55.default.string().valid(...jobApplicationStatuses).optional()
+    const validation = import_joi57.default.object({
+      page: import_joi57.default.number().integer().min(1).optional(),
+      limit: import_joi57.default.number().integer().min(1).max(100).optional(),
+      search: import_joi57.default.string().optional().allow(""),
+      status: import_joi57.default.string().valid(...jobApplicationStatuses).optional()
     });
     const { error } = validation.validate(req.query);
     if (error) {
-      next(new import_utils74.BadRequestError(`Invalid query parameters: ${error.message}`));
+      next(new import_utils75.BadRequestError(`Invalid query parameters: ${error.message}`));
       return;
     }
     const page = req.query.page ? parseInt(req.query.page) : 1;
@@ -14174,18 +14299,69 @@ function useJobApplicationController() {
       res.json(data);
       return;
     } catch (error2) {
-      if (error2 instanceof import_utils74.AppError) {
+      if (error2 instanceof import_utils75.AppError) {
+        next(error2);
+        return;
+      }
+      next(
+        new import_utils75.BadRequestError(`Failed to get job applications: ${error2.message}`)
+      );
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id ?? "";
+    const { error } = import_joi57.default.string().hex().length(24).required().validate(id);
+    if (error) {
+      next(new import_utils75.BadRequestError(`Invalid job application id: ${id}`));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      if (error2 instanceof import_utils75.AppError) {
+        next(error2);
+        return;
+      }
+      next(
+        new import_utils75.BadRequestError(`Failed to get job application: ${error2.message}`)
+      );
+    }
+  }
+  const { updateStatusById: _updateStatusById } = useJobApplicationService();
+  async function updateStatusById(req, res, next) {
+    const id = req.params.id ?? "";
+    const status = req.body.status ?? "";
+    const { error } = import_joi57.default.object({
+      id: import_joi57.default.string().hex().length(24).required(),
+      status: import_joi57.default.string().valid(...jobApplicationStatuses).required()
+    }).validate({ id, status });
+    if (error) {
+      next(new import_utils75.BadRequestError(`Invalid parameters: ${error.message}`));
+      return;
+    }
+    try {
+      const message = await _updateStatusById(id, status);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      if (error2 instanceof import_utils75.AppError) {
         next(error2);
         return;
       }
       next(
-        new import_utils74.BadRequestError(`Failed to get job applications: ${error2.message}`)
+        new import_utils75.BadRequestError(
+          `Failed to update job application status: ${error2.message}`
+        )
       );
     }
   }
   return {
     add,
-    getAll
+    getAll,
+    getById,
+    updateStatusById
   };
 }
 // Annotate the CommonJS export names for ESM import in node: