@goweekdays/core 2.11.17 → 2.11.19

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @goweekdays/core
 
+## 2.11.19
+
+### Patch Changes
+
+- dc8a6a1: Add getById and updateStatusById for job applications
+
+## 2.11.18
+
+### Patch Changes
+
+- 0574284: Fix query return value
+
 ## 2.11.17
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1163,7 +1163,7 @@ type TJobPost = {
     _id?: ObjectId;
     org: ObjectId | string;
     orgName?: string;
-    company: ObjectId;
+    company: ObjectId | string;
     companyName?: string;
     title: string;
     setup: string;
@@ -1276,6 +1276,63 @@ declare function useLedgerBillingController(): {
     getSummary: (req: Request, res: Response, next: NextFunction) => Promise<void>;
 };
 
+type TJobApplicationMetadata = {
+    resume?: string;
+    resumeUrl?: string;
+    portfolio?: string;
+    portfolioUrl?: string;
+    coverLetter?: string;
+    coverLetterUrl?: string;
+};
+type TJobApplication = {
+    _id?: ObjectId;
+    post: ObjectId | string;
+    jobTitle?: string;
+    company?: ObjectId | string;
+    companyName?: string;
+    location?: string;
+    user: ObjectId | string;
+    name: string;
+    email: string;
+    contact?: string;
+    metadata?: TJobApplicationMetadata;
+    status?: string;
+    createdAt?: Date | String;
+    updatedAt?: Date | String;
+    deletedAt?: Date | String;
+};
+declare const jobApplicationStatuses: string[];
+declare const schemaJobApplication: Joi.ObjectSchema<any>;
+declare function modelJobApplication(data: TJobApplication): TJobApplication;
+
+declare function useJobApplicationRepo(): {
+    createIndexes: () => Promise<string>;
+    delCachedData: () => void;
+    add: (data: TJobApplication) => Promise<ObjectId>;
+    getAll: ({ page, limit, search, status, }?: {
+        page?: number | undefined;
+        limit?: number | undefined;
+        search?: string | undefined;
+        status?: string | undefined;
+    }) => Promise<{
+        items: any[];
+        pages: number;
+        pageRange: string;
+    } | {
+        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;
 declare const MONGO_DB: string;
 declare const PORT: number;
@@ -1315,4 +1372,4 @@ declare const XENDIT_BASE_URL: string;
 declare const DOMAIN: string;
 declare const APP_ORG: string;
 
-export { ACCESS_TOKEN_EXPIRY, ACCESS_TOKEN_SECRET, APP_ACCOUNT, APP_MAIN, APP_ORG, DEFAULT_USER_EMAIL, DEFAULT_USER_FIRST_NAME, DEFAULT_USER_LAST_NAME, DEFAULT_USER_PASSWORD, DOMAIN, MAILER_EMAIL, MAILER_PASSWORD, MAILER_TRANSPORT_HOST, MAILER_TRANSPORT_PORT, MAILER_TRANSPORT_SECURE, MBuilding, MBuildingUnit, MFile, MONGO_DB, MONGO_URI, PAYPAL_API_URL, PAYPAL_CLIENT_ID, PAYPAL_CLIENT_SECRET, PAYPAL_WEBHOOK_ID, PORT, PaypalWebhookHeaders, 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, TApp, TBuilding, TBuildingUnit, TCounter, TFile, TJobPost, TLedgerBill, TMember, TOrg, TPermission, TPermissionGroup, TPlan, TPromo, TRole, TSubscribe, TSubscription, TSubscriptionTransaction, TUser, TVerification, TVerificationMetadata, VERIFICATION_FORGET_PASSWORD_DURATION, VERIFICATION_USER_INVITE_DURATION, XENDIT_BASE_URL, XENDIT_SECRET_KEY, currencies, isDev, ledgerBillStatuses, ledgerBillTypes, modelApp, modelJobPost, modelLedgerBill, modelMember, modelOrg, modelPermission, modelPermissionGroup, modelPlan, modelPromo, modelRole, modelSubscription, modelSubscriptionTransaction, modelUser, modelVerification, schemaApp, schemaAppUpdate, schemaBuilding, schemaBuildingUnit, schemaInviteMember, schemaJobPost, schemaJobPostUpdate, schemaLedgerBill, schemaLedgerBillingSummary, schemaMember, schemaMemberRole, schemaMemberStatus, schemaOrg, schemaOrgAdd, schemaOrgPilot, schemaOrgUpdate, schemaPermission, schemaPermissionGroup, schemaPermissionGroupUpdate, schemaPermissionUpdate, schemaPlan, schemaPromo, schemaRole, schemaRoleUpdate, schemaSubscribe, schemaSubscription, schemaSubscriptionCompute, schemaSubscriptionPromoCode, schemaSubscriptionSeats, schemaSubscriptionTransaction, schemaSubscriptionUpdate, schemaUpdateOptions, schemaUser, schemaVerification, schemaVerificationOrgInvite, transactionSchema, useAppController, useAppRepo, useAppService, useAuthController, useAuthService, useBuildingController, useBuildingRepo, useBuildingService, useBuildingUnitController, useBuildingUnitRepo, useBuildingUnitService, useCounterModel, useCounterRepo, useFileController, useFileRepo, useFileService, useGitHubService, useJobPostController, useJobPostRepo, useJobPostService, useLedgerBillingController, useLedgerBillingRepo, useMemberController, useMemberRepo, useOrgController, useOrgRepo, useOrgService, usePaypalService, usePermissionController, usePermissionGroupController, usePermissionGroupRepo, usePermissionGroupService, usePermissionRepo, usePermissionService, usePlanController, usePlanRepo, usePlanService, usePromoController, usePromoRepo, usePromoUsageRepo, useRoleController, useRoleRepo, useRoleService, useSubscriptionController, useSubscriptionRepo, useSubscriptionService, useSubscriptionTransactionController, useSubscriptionTransactionRepo, useUserController, useUserRepo, useUserService, useUtilController, useVerificationController, useVerificationRepo, useVerificationService };
+export { ACCESS_TOKEN_EXPIRY, ACCESS_TOKEN_SECRET, APP_ACCOUNT, APP_MAIN, APP_ORG, DEFAULT_USER_EMAIL, DEFAULT_USER_FIRST_NAME, DEFAULT_USER_LAST_NAME, DEFAULT_USER_PASSWORD, DOMAIN, MAILER_EMAIL, MAILER_PASSWORD, MAILER_TRANSPORT_HOST, MAILER_TRANSPORT_PORT, MAILER_TRANSPORT_SECURE, MBuilding, MBuildingUnit, MFile, MONGO_DB, MONGO_URI, PAYPAL_API_URL, PAYPAL_CLIENT_ID, PAYPAL_CLIENT_SECRET, PAYPAL_WEBHOOK_ID, PORT, PaypalWebhookHeaders, 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, TApp, TBuilding, TBuildingUnit, TCounter, TFile, TJobApplication, TJobApplicationMetadata, TJobPost, TLedgerBill, TMember, TOrg, TPermission, TPermissionGroup, TPlan, TPromo, TRole, TSubscribe, TSubscription, TSubscriptionTransaction, TUser, TVerification, TVerificationMetadata, VERIFICATION_FORGET_PASSWORD_DURATION, VERIFICATION_USER_INVITE_DURATION, XENDIT_BASE_URL, XENDIT_SECRET_KEY, currencies, isDev, jobApplicationStatuses, ledgerBillStatuses, ledgerBillTypes, modelApp, modelJobApplication, modelJobPost, modelLedgerBill, modelMember, modelOrg, modelPermission, modelPermissionGroup, modelPlan, modelPromo, modelRole, modelSubscription, modelSubscriptionTransaction, modelUser, modelVerification, schemaApp, schemaAppUpdate, schemaBuilding, schemaBuildingUnit, schemaInviteMember, schemaJobApplication, schemaJobPost, schemaJobPostUpdate, schemaLedgerBill, schemaLedgerBillingSummary, schemaMember, schemaMemberRole, schemaMemberStatus, schemaOrg, schemaOrgAdd, schemaOrgPilot, schemaOrgUpdate, schemaPermission, schemaPermissionGroup, schemaPermissionGroupUpdate, schemaPermissionUpdate, schemaPlan, schemaPromo, schemaRole, schemaRoleUpdate, schemaSubscribe, schemaSubscription, schemaSubscriptionCompute, schemaSubscriptionPromoCode, schemaSubscriptionSeats, schemaSubscriptionTransaction, schemaSubscriptionUpdate, schemaUpdateOptions, schemaUser, schemaVerification, schemaVerificationOrgInvite, transactionSchema, useAppController, useAppRepo, useAppService, useAuthController, useAuthService, useBuildingController, useBuildingRepo, useBuildingService, useBuildingUnitController, useBuildingUnitRepo, useBuildingUnitService, useCounterModel, useCounterRepo, useFileController, useFileRepo, useFileService, useGitHubService, useJobApplicationController, useJobApplicationRepo, useJobPostController, useJobPostRepo, useJobPostService, useLedgerBillingController, useLedgerBillingRepo, useMemberController, useMemberRepo, useOrgController, useOrgRepo, useOrgService, usePaypalService, usePermissionController, usePermissionGroupController, usePermissionGroupRepo, usePermissionGroupService, usePermissionRepo, usePermissionService, usePlanController, usePlanRepo, usePlanService, usePromoController, usePromoRepo, usePromoUsageRepo, useRoleController, useRoleRepo, useRoleService, useSubscriptionController, useSubscriptionRepo, useSubscriptionService, useSubscriptionTransactionController, useSubscriptionTransactionRepo, useUserController, useUserRepo, useUserService, useUtilController, useVerificationController, useVerificationRepo, useVerificationService };

package/dist/index.js

@@ -72,9 +72,11 @@ __export(src_exports, {
   XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
   currencies: () => currencies,
   isDev: () => isDev,
+  jobApplicationStatuses: () => jobApplicationStatuses,
   ledgerBillStatuses: () => ledgerBillStatuses,
   ledgerBillTypes: () => ledgerBillTypes,
   modelApp: () => modelApp,
+  modelJobApplication: () => modelJobApplication,
   modelJobPost: () => modelJobPost,
   modelLedgerBill: () => modelLedgerBill,
   modelMember: () => modelMember,
@@ -93,6 +95,7 @@ __export(src_exports, {
   schemaBuilding: () => schemaBuilding,
   schemaBuildingUnit: () => schemaBuildingUnit,
   schemaInviteMember: () => schemaInviteMember,
+  schemaJobApplication: () => schemaJobApplication,
   schemaJobPost: () => schemaJobPost,
   schemaJobPostUpdate: () => schemaJobPostUpdate,
   schemaLedgerBill: () => schemaLedgerBill,
@@ -141,6 +144,8 @@ __export(src_exports, {
   useFileRepo: () => useFileRepo,
   useFileService: () => useFileService,
   useGitHubService: () => useGitHubService,
+  useJobApplicationController: () => useJobApplicationController,
+  useJobApplicationRepo: () => useJobApplicationRepo,
   useJobPostController: () => useJobPostController,
   useJobPostRepo: () => useJobPostRepo,
   useJobPostService: () => useJobPostService,
@@ -12974,10 +12979,12 @@ function modelJobPost(value) {
   } catch (error2) {
     throw new import_utils66.BadRequestError("Invalid Org ID");
   }
-  try {
-    value.company = new import_mongodb29.ObjectId(value.company);
-  } catch (error2) {
-    throw new import_utils66.BadRequestError("Invalid Company ID");
+  if (value.company && typeof value.company === "string" && value.company.length === 24) {
+    try {
+      value.company = new import_mongodb29.ObjectId(value.company);
+    } catch (error2) {
+      throw new import_utils66.BadRequestError("Invalid Company ID");
+    }
   }
   return {
     _id: value._id,
@@ -13102,7 +13109,11 @@ function useJobPostRepo() {
         {
           $project: {
             _id: 1,
+            org: 1,
             orgName: 1,
+            company: 1,
+            companyName: 1,
+            description: 1,
             minSalary: 1,
             maxSalary: 1,
             currency: 1,
@@ -13896,6 +13907,463 @@ function useJobPostController() {
     getCurrencies
   };
 }
+
+// src/resources/job-applications/job.applications.model.ts
+var import_utils72 = require("@goweekdays/utils");
+var import_joi54 = __toESM(require("joi"));
+var import_mongodb32 = require("mongodb");
+var jobApplicationStatuses = [
+  "new",
+  "shortlisted",
+  "interview-scheduled",
+  "interviewed",
+  "offer-extended",
+  "hired",
+  "on-hold",
+  "withdrawn",
+  "rejected",
+  // Agency specific
+  "contacted",
+  "endorsed",
+  "client-interested",
+  "pooled",
+  // HR specific
+  "under-review",
+  "for-approval"
+];
+var schemaJobApplication = import_joi54.default.object({
+  post: import_joi54.default.string().required(),
+  jobTitle: import_joi54.default.string().optional().allow(""),
+  company: import_joi54.default.string().hex().optional().allow(""),
+  companyName: import_joi54.default.string().optional().allow(""),
+  location: import_joi54.default.string().optional().allow(""),
+  user: import_joi54.default.string().required(),
+  name: import_joi54.default.string().required(),
+  email: import_joi54.default.string().email().required(),
+  contact: import_joi54.default.string().optional().allow(""),
+  metadata: import_joi54.default.object({
+    resume: import_joi54.default.string().optional().allow(""),
+    resumeUrl: import_joi54.default.string().uri().optional().allow(""),
+    portfolio: import_joi54.default.string().optional().allow(""),
+    portfolioUrl: import_joi54.default.string().uri().optional().allow(""),
+    coverLetter: import_joi54.default.string().optional().allow(""),
+    coverLetterUrl: import_joi54.default.string().uri().optional().allow("")
+  }).optional()
+});
+function modelJobApplication(data) {
+  const { error } = schemaJobApplication.validate(data);
+  if (error) {
+    throw new import_utils72.BadRequestError(`Invalid job application data: ${error.message}`);
+  }
+  if (data._id && typeof data._id === "string") {
+    try {
+      data._id = new import_mongodb32.ObjectId(data._id);
+    } catch (error2) {
+      throw new import_utils72.BadRequestError(`Invalid job application _id: ${data._id}`);
+    }
+  }
+  try {
+    data.post = new import_mongodb32.ObjectId(data.post);
+  } 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);
+    } catch (error2) {
+      throw new import_utils72.BadRequestError(
+        `Invalid job application company id: ${data.company}`
+      );
+    }
+  }
+  return {
+    _id: data._id,
+    post: data.post,
+    jobTitle: data.jobTitle,
+    company: data.company,
+    companyName: data.companyName ?? "",
+    location: data.location ?? "",
+    user: data.user,
+    name: data.name,
+    email: data.email,
+    contact: data.contact ?? "",
+    metadata: data.metadata ?? {},
+    status: data.status ?? "new",
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? "",
+    deletedAt: data.deletedAt ?? ""
+  };
+}
+
+// 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) {
+    throw new import_utils73.BadRequestError("Unable to connect to server.");
+  }
+  const namespace_collection = "job.applications";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils73.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils73.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils73.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { jobTitle: 1 } },
+        { key: { company: 1 } },
+        { key: { companyName: 1 } },
+        { key: { location: 1 } },
+        { key: { user: 1 } },
+        { key: { email: 1 } },
+        {
+          key: {
+            jobTitle: "text",
+            company: "text",
+            companyName: "text",
+            location: "text",
+            name: "text"
+          },
+          name: "job_application_text_search"
+        }
+      ]);
+      return "Successfully created job application indexes.";
+    } catch (error) {
+      throw new import_utils73.BadRequestError("Failed to create job application indexes.");
+    }
+  }
+  async function add(data) {
+    const { error } = schemaJobApplication.validate(data);
+    if (error) {
+      throw new import_utils73.BadRequestError(
+        `Invalid job application data: ${error.message}`
+      );
+    }
+    try {
+      data = modelJobApplication(data);
+      const res = await collection.insertOne(data);
+      delCachedData();
+      return res.insertedId;
+    } catch (error2) {
+      if (error2 instanceof import_utils73.AppError) {
+        throw error2;
+      }
+      throw new import_utils73.BadRequestError(
+        `Failed to create job application: ${error2.message}`
+      );
+    }
+  }
+  async function getAll({
+    page = 1,
+    limit = 10,
+    search = "",
+    status = "new"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { status };
+    const cacheKeyOptions = {
+      page,
+      limit,
+      status,
+      tag: "getAll"
+    };
+    if (search) {
+      query.$text = { $search: search };
+      cacheKeyOptions.search = search;
+    }
+    const cacheKey = (0, import_utils73.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils73.paginate)(items, page, limit, length);
+      setCache(cacheKey, data).then(() => {
+        import_utils73.logger.log({
+          level: "info",
+          message: `Cache set for getAll job applications: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils73.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll job applications: ${cacheKey}, error: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      if (error instanceof import_utils73.AppError) {
+        throw error;
+      }
+      throw new import_utils73.BadRequestError(
+        `Failed to get job applications: ${error.message}`
+      );
+    }
+  }
+  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,
+    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");
+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,
+    getById: _getById
+  } = useJobApplicationRepo();
+  async function add(req, res, next) {
+    const { error } = schemaJobApplication.validate(req.body);
+    if (error) {
+      next(
+        new import_utils75.BadRequestError(`Invalid job application data: ${error.message}`)
+      );
+      return;
+    }
+    try {
+      const message = await _add(req.body);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      if (error2 instanceof import_utils75.AppError) {
+        next(error2);
+        return;
+      }
+      next(
+        new import_utils75.BadRequestError(
+          `Failed to create job application: ${error2.message}`
+        )
+      );
+    }
+  }
+  async function getAll(req, res, next) {
+    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_utils75.BadRequestError(`Invalid query parameters: ${error.message}`));
+      return;
+    }
+    const page = req.query.page ? parseInt(req.query.page) : 1;
+    const limit = req.query.limit ? parseInt(req.query.limit) : 10;
+    const search = req.query.search ? req.query.search : "";
+    const status = req.query.status ? req.query.status : "new";
+    try {
+      const data = await _getAll({ page, limit, search, status });
+      res.json(data);
+      return;
+    } catch (error2) {
+      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_utils75.BadRequestError(
+          `Failed to update job application status: ${error2.message}`
+        )
+      );
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateStatusById
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCESS_TOKEN_EXPIRY,
@@ -13940,9 +14408,11 @@ function useJobPostController() {
   XENDIT_SECRET_KEY,
   currencies,
   isDev,
+  jobApplicationStatuses,
   ledgerBillStatuses,
   ledgerBillTypes,
   modelApp,
+  modelJobApplication,
   modelJobPost,
   modelLedgerBill,
   modelMember,
@@ -13961,6 +14431,7 @@ function useJobPostController() {
   schemaBuilding,
   schemaBuildingUnit,
   schemaInviteMember,
+  schemaJobApplication,
   schemaJobPost,
   schemaJobPostUpdate,
   schemaLedgerBill,
@@ -14009,6 +14480,8 @@ function useJobPostController() {
   useFileRepo,
   useFileService,
   useGitHubService,
+  useJobApplicationController,
+  useJobApplicationRepo,
   useJobPostController,
   useJobPostRepo,
   useJobPostService,