@goweekdays/core 2.12.3 → 2.13.0

package/dist/index.js

@@ -71,12 +71,17 @@ __export(src_exports, {
   VERIFICATION_USER_INVITE_DURATION: () => VERIFICATION_USER_INVITE_DURATION,
   XENDIT_BASE_URL: () => XENDIT_BASE_URL,
   XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
+  chartOfAccountNormalBalances: () => chartOfAccountNormalBalances,
+  chartOfAccountTypes: () => chartOfAccountTypes,
   currencies: () => currencies,
   isDev: () => isDev,
   jobApplicationStatuses: () => jobApplicationStatuses,
+  journalEntryStatuses: () => journalEntryStatuses,
+  journalEntryTypes: () => journalEntryTypes,
   ledgerBillStatuses: () => ledgerBillStatuses,
   ledgerBillTypes: () => ledgerBillTypes,
   modelApp: () => modelApp,
+  modelChartOfAccount: () => modelChartOfAccount,
   modelJobApplication: () => modelJobApplication,
   modelJobPost: () => modelJobPost,
   modelJobProfile: () => modelJobProfile,
@@ -88,6 +93,8 @@ __export(src_exports, {
   modelJobStatusSetup: () => modelJobStatusSetup,
   modelJobStatusTrans: () => modelJobStatusTrans,
   modelJobSummary: () => modelJobSummary,
+  modelJournalEntry: () => modelJournalEntry,
+  modelJournalLine: () => modelJournalLine,
   modelLedgerBill: () => modelLedgerBill,
   modelMember: () => modelMember,
   modelOption: () => modelOption,
@@ -99,6 +106,7 @@ __export(src_exports, {
   modelRole: () => modelRole,
   modelSubscription: () => modelSubscription,
   modelSubscriptionTransaction: () => modelSubscriptionTransaction,
+  modelTax: () => modelTax,
   modelUser: () => modelUser,
   modelVerification: () => modelVerification,
   schemaApp: () => schemaApp,
@@ -107,6 +115,9 @@ __export(src_exports, {
   schemaBuilding: () => schemaBuilding,
   schemaBuildingUnit: () => schemaBuildingUnit,
   schemaCertification: () => schemaCertification,
+  schemaChartOfAccountBase: () => schemaChartOfAccountBase,
+  schemaChartOfAccountStd: () => schemaChartOfAccountStd,
+  schemaChartOfAccountUpdate: () => schemaChartOfAccountUpdate,
   schemaEducation: () => schemaEducation,
   schemaGroup: () => schemaGroup,
   schemaInviteMember: () => schemaInviteMember,
@@ -133,6 +144,11 @@ __export(src_exports, {
   schemaJobStatusTrans: () => schemaJobStatusTrans,
   schemaJobSummary: () => schemaJobSummary,
   schemaJobSummaryInc: () => schemaJobSummaryInc,
+  schemaJournalEntryCtrl: () => schemaJournalEntryCtrl,
+  schemaJournalEntryGetAll: () => schemaJournalEntryGetAll,
+  schemaJournalEntryRepo: () => schemaJournalEntryRepo,
+  schemaJournalLineCtrl: () => schemaJournalLineCtrl,
+  schemaJournalLineRepo: () => schemaJournalLineRepo,
   schemaLanguage: () => schemaLanguage,
   schemaLedgerBill: () => schemaLedgerBill,
   schemaLedgerBillingSummary: () => schemaLedgerBillingSummary,
@@ -163,11 +179,14 @@ __export(src_exports, {
   schemaSubscriptionSeats: () => schemaSubscriptionSeats,
   schemaSubscriptionTransaction: () => schemaSubscriptionTransaction,
   schemaSubscriptionUpdate: () => schemaSubscriptionUpdate,
+  schemaTax: () => schemaTax,
+  schemaTaxUpdate: () => schemaTaxUpdate,
   schemaUpdateOptions: () => schemaUpdateOptions,
   schemaUser: () => schemaUser,
   schemaVerification: () => schemaVerification,
   schemaVerificationOrgInvite: () => schemaVerificationOrgInvite,
   schemaWorkExp: () => schemaWorkExp,
+  taxDirections: () => taxDirections,
   transactionSchema: () => transactionSchema,
   useAppController: () => useAppController,
   useAppRepo: () => useAppRepo,
@@ -180,6 +199,8 @@ __export(src_exports, {
   useBuildingUnitController: () => useBuildingUnitController,
   useBuildingUnitRepo: () => useBuildingUnitRepo,
   useBuildingUnitService: () => useBuildingUnitService,
+  useChartOfAccountController: () => useChartOfAccountController,
+  useChartOfAccountRepo: () => useChartOfAccountRepo,
   useCounterModel: () => useCounterModel,
   useCounterRepo: () => useCounterRepo,
   useFileController: () => useFileController,
@@ -198,6 +219,11 @@ __export(src_exports, {
   useJobSummaryCtrl: () => useJobSummaryCtrl,
   useJobSummaryRepo: () => useJobSummaryRepo,
   useJobSummarySvc: () => useJobSummarySvc,
+  useJournalEntryController: () => useJournalEntryController,
+  useJournalEntryRepo: () => useJournalEntryRepo,
+  useJournalEntryService: () => useJournalEntryService,
+  useJournalLineController: () => useJournalLineController,
+  useJournalLineRepo: () => useJournalLineRepo,
   useLedgerBillingController: () => useLedgerBillingController,
   useLedgerBillingRepo: () => useLedgerBillingRepo,
   useMemberController: () => useMemberController,
@@ -228,6 +254,8 @@ __export(src_exports, {
   useSubscriptionService: () => useSubscriptionService,
   useSubscriptionTransactionController: () => useSubscriptionTransactionController,
   useSubscriptionTransactionRepo: () => useSubscriptionTransactionRepo,
+  useTaxController: () => useTaxController,
+  useTaxRepo: () => useTaxRepo,
   useUserController: () => useUserController,
   useUserRepo: () => useUserRepo,
   useUserService: () => useUserService,
@@ -11094,6 +11122,24 @@ function useOrgController() {
     companySearch: _companySearch
   } = useOrgRepo();
   const { addPilot: _addPilot } = useOrgService();
+  async function validOrg(req, res, next) {
+    const org = req.params.org ?? "";
+    const { error } = import_joi49.default.string().hex().required().validate(org);
+    if (error) {
+      next(new import_utils57.BadRequestError("Invalid organization ID."));
+      return;
+    }
+    try {
+      const organization = await _getById(org);
+      if (!organization) {
+        next(new import_utils57.BadRequestError("Organization not found."));
+        return;
+      }
+      next();
+    } catch (error2) {
+      next(error2);
+    }
+  }
   async function add(req, res, next) {
     const value = req.body;
     const { error } = schemaOrgAdd.validate(value);
@@ -11267,6 +11313,7 @@ function useOrgController() {
     }
   }
   return {
+    validOrg,
     add,
     getOrgsByUserId,
     getByName,
@@ -13797,10 +13844,10 @@ function useCounterRepo() {
       throw new Error("Failed to create index.");
     }
   }
-  async function add(type) {
+  async function add(type, session) {
     try {
       const value = createCounter({ type });
-      await collection.insertOne(value);
+      await collection.insertOne(value, { session });
       delCachedData();
     } catch (error) {
       throw new Error("Failed to add counter.");
@@ -13810,7 +13857,7 @@ function useCounterRepo() {
     try {
       const res = await collection.updateOne(
         { type },
-        { $inc: { count: 1 } },
+        { $inc: { count: 1 }, $set: { updatedAt: /* @__PURE__ */ new Date() } },
         { session }
       );
       delCachedData();
@@ -17004,6 +17051,2307 @@ function useJobSummaryCtrl() {
     getByOrg
   };
 }
+
+// src/resources/finance-tax/tax.model.ts
+var import_utils87 = require("@goweekdays/utils");
+var import_joi69 = __toESM(require("joi"));
+var import_mongodb40 = require("mongodb");
+var taxDirections = ["input", "output", "withholding"];
+var schemaTax = import_joi69.default.object({
+  org: import_joi69.default.string().hex().required(),
+  name: import_joi69.default.string().required(),
+  rate: import_joi69.default.number().required(),
+  direction: import_joi69.default.string().valid(...taxDirections).required()
+});
+var schemaTaxUpdate = import_joi69.default.object({
+  name: import_joi69.default.string().required(),
+  rate: import_joi69.default.number().required(),
+  direction: import_joi69.default.string().valid(...taxDirections).required()
+});
+function modelTax(data) {
+  const { error } = schemaTax.validate(data);
+  if (error) {
+    throw new import_utils87.BadRequestError(`Invalid tax data: ${error.message}`);
+  }
+  try {
+    data.org = new import_mongodb40.ObjectId(data.org);
+  } catch (error2) {
+    throw new import_utils87.BadRequestError(`Invalid org ID: ${data.org}`);
+  }
+  return {
+    _id: data._id,
+    org: data.org,
+    name: data.name,
+    rate: data.rate,
+    direction: data.direction,
+    status: data.status ?? "active",
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/finance-tax/tax.repository.ts
+var import_utils88 = require("@goweekdays/utils");
+var import_mongodb41 = require("mongodb");
+var import_joi70 = __toESM(require("joi"));
+function useTaxRepo() {
+  const db = import_utils88.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils88.BadRequestError("Unable to connect to server.");
+  }
+  const namespace_collection = "finance.taxes";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils88.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils88.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils88.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { name: 1 } },
+        { key: { org: 1 } },
+        {
+          key: { name: 1, org: 1 },
+          partialFilterExpression: { status: "active" },
+          unique: true,
+          name: "unique_name_per_org"
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on tax.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelTax(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_utils88.logger.log({
+        level: "error",
+        message: error.message
+      });
+      throw new import_utils88.BadRequestError(`Failed to create tax: ${error.message}`);
+    }
+  }
+  async function getAll(options) {
+    options.page = options.page && options.page > 0 ? options.page - 1 : 0;
+    options.status = options.status ?? "active";
+    options.limit = options.limit ?? 10;
+    const query = { status: options.status };
+    try {
+      query.org = new import_mongodb41.ObjectId(options.org);
+    } catch (error) {
+      throw new import_utils88.BadRequestError("Invalid organization ID.");
+    }
+    if (options.search) {
+      query.$text = { $search: options.search };
+    }
+    const cacheKey = (0, import_utils88.makeCacheKey)(namespace_collection, {
+      search: options.search,
+      page: options.page,
+      limit: options.limit,
+      status: options.status
+    });
+    import_utils88.logger.log({
+      level: "info",
+      message: `Cache key for getAll taxes: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils88.logger.log({
+          level: "info",
+          message: `Cache hit for getAll taxes: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: options.page * options.limit },
+        { $limit: options.limit },
+        {
+          $project: {
+            _id: 1,
+            org: 1,
+            name: 1,
+            rate: 1,
+            direction: 1,
+            status: 1,
+            createdAt: 1
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils88.paginate)(items, options.page, options.limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_utils88.logger.log({
+          level: "info",
+          message: `Cache set for getAll taxes: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils88.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll taxes: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_utils88.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getTaxesByOrg({ search = "", page = 1, limit = 10, org = "", status: status2 = "active" } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    try {
+      org = new import_mongodb41.ObjectId(org);
+    } catch (error) {
+      throw new import_utils88.BadRequestError("Invalid organization ID.");
+    }
+    const query = { org, status: status2 };
+    const cacheKeyOptions = {
+      org: String(org),
+      status: status2,
+      limit,
+      page
+    };
+    if (search) {
+      cacheKeyOptions.search = search;
+      query.$text = { $search: search };
+    }
+    try {
+      const cacheKey = (0, import_utils88.makeCacheKey)(namespace_collection, cacheKeyOptions);
+      const cached = await getCache(
+        cacheKey
+      );
+      if (cached) {
+        import_utils88.logger.log({
+          level: "info",
+          message: `Cache hit for getTaxesByOrg : ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit },
+        {
+          $project: {
+            _id: 1,
+            name: 1,
+            rate: 1,
+            direction: 1,
+            status: 1,
+            createdAt: 1
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils88.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 300).then(() => {
+        import_utils88.logger.log({
+          level: "info",
+          message: `Cache set for getTaxesByOrg: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils88.logger.log({
+          level: "error",
+          message: `Failed to set cache for getTaxesByOrg: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new import_utils88.InternalServerError(
+        "Internal server error, failed to retrieve taxes."
+      );
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb41.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils88.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_utils88.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils88.logger.log({
+          level: "info",
+          message: `Cache hit for getById tax: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({ _id });
+      if (!result) {
+        throw new import_utils88.BadRequestError("Tax not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_utils88.logger.log({
+          level: "info",
+          message: `Cache set for tax by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils88.logger.log({
+          level: "error",
+          message: `Failed to set cache for tax by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils88.AppError) {
+        throw error;
+      } else {
+        throw new import_utils88.InternalServerError("Failed to get tax.");
+      }
+    }
+  }
+  async function updateById(_id, options) {
+    const { error: errorId } = import_joi70.default.string().hex().required().validate(String(_id));
+    if (errorId) {
+      throw new import_utils88.BadRequestError("Invalid Tax ID.");
+    }
+    const { error } = schemaTaxUpdate.validate(options);
+    if (error) {
+      throw new import_utils88.BadRequestError(`Invalid tax update data: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb41.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils88.BadRequestError("Invalid Tax ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return "Successfully updated tax.";
+    } catch (error2) {
+      throw new import_utils88.InternalServerError("Failed to update tax.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb41.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils88.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: "deleted",
+            updatedAt: /* @__PURE__ */ new Date(),
+            deletedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { session }
+      );
+      delCachedData();
+      return "Successfully deleted tax.";
+    } catch (error) {
+      throw new import_utils88.InternalServerError("Failed to delete tax.");
+    }
+  }
+  async function updateStatusById(_id, status2) {
+    try {
+      _id = new import_mongodb41.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils88.BadRequestError("Invalid ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: status2,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new import_utils88.BadRequestError("Tax not found.");
+      }
+      delCachedData();
+      return "Successfully updated tax status.";
+    } catch (error) {
+      if (error instanceof import_utils88.AppError) {
+        throw error;
+      }
+      throw new import_utils88.InternalServerError("Failed to update tax status.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getTaxesByOrg,
+    getById,
+    updateById,
+    deleteById,
+    updateStatusById
+  };
+}
+
+// src/resources/finance-tax/tax.controller.ts
+var import_joi71 = __toESM(require("joi"));
+var import_utils89 = require("@goweekdays/utils");
+function useTaxController() {
+  const {
+    getAll: _getAll,
+    getTaxesByOrg: _getTaxesByOrg,
+    getById: _getById,
+    updateById: _updateById,
+    deleteById: _deleteById,
+    updateStatusById: _updateStatusById,
+    add: _add
+  } = useTaxRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaTax.validate(value);
+    if (error) {
+      next(new import_utils89.BadRequestError(error.message));
+      import_utils89.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const message = await _add(value);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi71.default.object({
+      org: import_joi71.default.string().hex().required(),
+      page: import_joi71.default.number().min(1).optional().allow("", null),
+      limit: import_joi71.default.number().min(1).optional().allow("", null),
+      search: import_joi71.default.string().optional().allow("", null),
+      status: import_joi71.default.string().optional()
+    });
+    const org = req.params.org ?? "";
+    const { error } = validation.validate({ ...query, org });
+    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 status2 = req.query.status ?? "active";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_utils89.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_utils89.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_utils89.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const taxes = await _getAll({ org, page, limit, search, status: status2 });
+      res.json(taxes);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getTaxesByOrg(req, res, next) {
+    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 status2 = req.query.status ?? "active";
+    const org = req.params.org ?? "";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_utils89.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_utils89.BadRequestError("Invalid limit number."));
+      return;
+    }
+    const validation = import_joi71.default.object({
+      org: import_joi71.default.string().hex().required(),
+      page: import_joi71.default.number().min(1).optional().allow("", null),
+      limit: import_joi71.default.number().min(1).optional().allow("", null),
+      search: import_joi71.default.string().optional().allow("", null),
+      status: import_joi71.default.string().optional()
+    });
+    const { error } = validation.validate({ org, page, limit, search, status: status2 });
+    if (error) {
+      next(new import_utils89.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const taxes = await _getTaxesByOrg({ org, page, limit, search, status: status2 });
+      res.json(taxes);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi71.default.object({
+      id: import_joi71.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_utils89.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const tax = await _getById(id);
+      res.json(tax);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const _id = req.params.id ?? "";
+    const { error: errorId } = import_joi71.default.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new import_utils89.BadRequestError("Invalid Tax ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaTaxUpdate.validate(payload);
+    if (error) {
+      next(new import_utils89.BadRequestError(`Invalid tax update data: ${error.message}`));
+      return;
+    }
+    try {
+      const message = await _updateById(_id, payload);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    if (!id) {
+      next(new import_utils89.BadRequestError("Tax ID is required."));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function updateStatusById(req, res, next) {
+    const id = req.params.id;
+    const status2 = req.params.status;
+    const validation = import_joi71.default.object({
+      id: import_joi71.default.string().hex().required(),
+      status: import_joi71.default.string().required()
+    });
+    const { error } = validation.validate({ id, status: status2 });
+    if (error) {
+      next(new import_utils89.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateStatusById(id, status2);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getTaxesByOrg,
+    getById,
+    updateById,
+    deleteById,
+    updateStatusById
+  };
+}
+
+// src/resources/finance-account/chart-of-account.model.ts
+var import_joi72 = __toESM(require("joi"));
+var import_mongodb42 = require("mongodb");
+var chartOfAccountTypes = [
+  "asset",
+  "liability",
+  "equity",
+  "income",
+  "expense"
+];
+var chartOfAccountNormalBalances = [
+  "debit",
+  "credit"
+];
+var schemaChartOfAccount = {
+  type: import_joi72.default.string().valid(...chartOfAccountTypes).required(),
+  normalBalance: import_joi72.default.string().valid(...chartOfAccountNormalBalances).required(),
+  parent: import_joi72.default.string().hex().optional().allow("", null),
+  name: import_joi72.default.string().required(),
+  code: import_joi72.default.string().required(),
+  tax: import_joi72.default.string().hex().optional().allow("", null)
+};
+var schemaChartOfAccountBase = import_joi72.default.object({
+  ...schemaChartOfAccount,
+  org: import_joi72.default.string().hex().required(),
+  isContra: import_joi72.default.boolean().required()
+});
+var schemaChartOfAccountStd = import_joi72.default.object({
+  ...schemaChartOfAccount,
+  org: import_joi72.default.string().hex().required(),
+  isContra: import_joi72.default.boolean().required(),
+  path: import_joi72.default.string().required(),
+  parentName: import_joi72.default.string().optional().allow("", null)
+});
+var schemaChartOfAccountUpdate = import_joi72.default.object({
+  ...schemaChartOfAccount,
+  isContra: import_joi72.default.boolean().required()
+});
+function modelChartOfAccount(data) {
+  const { error } = schemaChartOfAccountStd.validate(data);
+  if (error) {
+    throw new Error(`Invalid chart of account data: ${error.message}`);
+  }
+  try {
+    data.org = new import_mongodb42.ObjectId(data.org);
+  } catch (error2) {
+    throw new Error(`Invalid org ID: ${data.org}`);
+  }
+  if (data.parent) {
+    try {
+      data.parent = new import_mongodb42.ObjectId(data.parent);
+    } catch (error2) {
+      throw new Error(`Invalid parent ID: ${data.parent}`);
+    }
+  }
+  if (data.tax) {
+    try {
+      data.tax = new import_mongodb42.ObjectId(data.tax);
+    } catch (error2) {
+      throw new Error(`Invalid tax ID: ${data.tax}`);
+    }
+  }
+  return {
+    _id: data._id,
+    org: data.org,
+    type: data.type,
+    normalBalance: data.normalBalance,
+    parent: data.parent,
+    parentName: data.parentName ?? "",
+    path: data.path,
+    name: data.name,
+    code: data.code,
+    tax: data.tax,
+    isContra: data.isContra,
+    status: data.status ?? "active",
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/finance-account/chart-of-account.repository.ts
+var import_utils90 = require("@goweekdays/utils");
+var import_mongodb43 = require("mongodb");
+var import_joi73 = __toESM(require("joi"));
+function useChartOfAccountRepo() {
+  const db = import_utils90.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils90.BadRequestError("Unable to connect to server.");
+  }
+  const namespace_collection = "finance.accounts";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils90.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils90.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils90.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { name: 1 } },
+        { key: { org: 1 } },
+        { key: { code: 1 } },
+        { key: { path: 1 } },
+        { key: { name: 1, org: 1 }, unique: true, name: "unique_name_per_org" },
+        { key: { code: 1, org: 1 }, unique: true, name: "unique_code_per_org" }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on chart of account.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelChartOfAccount(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_utils90.logger.log({
+        level: "error",
+        message: error.message
+      });
+      throw new import_utils90.BadRequestError(
+        `Failed to create chart of account: ${error.message}`
+      );
+    }
+  }
+  async function getAll(options) {
+    const validation = import_joi73.default.object({
+      org: import_joi73.default.string().hex().required(),
+      page: import_joi73.default.number().min(1).optional().allow("", null),
+      limit: import_joi73.default.number().min(1).optional().allow("", null),
+      search: import_joi73.default.string().optional().allow("", null),
+      status: import_joi73.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(options);
+    if (error) {
+      throw new import_utils90.BadRequestError(error.message);
+    }
+    options.page = options.page && options.page > 0 ? options.page - 1 : 0;
+    options.status = options.status ?? "active";
+    options.limit = options.limit ?? 10;
+    const query = { status: options.status };
+    try {
+      query.org = new import_mongodb43.ObjectId(options.org);
+    } catch (error2) {
+      throw new import_utils90.BadRequestError("Invalid organization ID.");
+    }
+    if (options.search) {
+      query.$text = { $search: options.search };
+    }
+    const cacheKey = (0, import_utils90.makeCacheKey)(namespace_collection, {
+      search: options.search,
+      page: options.page,
+      limit: options.limit,
+      status: options.status
+    });
+    import_utils90.logger.log({
+      level: "info",
+      message: `Cache key for getAll chart of accounts: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache hit for getAll chart of accounts: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: { path: 1 } },
+        { $skip: options.page * options.limit },
+        { $limit: options.limit },
+        {
+          $project: {
+            _id: 1,
+            type: 1,
+            normalBalance: 1,
+            parent: 1,
+            parentName: 1,
+            path: 1,
+            name: 1,
+            code: 1,
+            tax: 1,
+            status: 1
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils90.paginate)(items, options.page, options.limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache set for getAll chart of accounts: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils90.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll chart of accounts: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      import_utils90.logger.log({ level: "error", message: `${error2}` });
+      throw error2;
+    }
+  }
+  async function getByOrg({ search = "", page = 1, limit = 10, org = "", status: status2 = "active" } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    try {
+      org = new import_mongodb43.ObjectId(org);
+    } catch (error) {
+      throw new import_utils90.BadRequestError("Invalid organization ID.");
+    }
+    const query = { org, status: status2 };
+    const cacheKeyOptions = {
+      org: String(org),
+      status: status2,
+      limit,
+      page
+    };
+    if (search) {
+      cacheKeyOptions.search = search;
+      query.$text = { $search: search };
+    }
+    try {
+      const cacheKey = (0, import_utils90.makeCacheKey)(namespace_collection, cacheKeyOptions);
+      const cached = await getCache(
+        cacheKey
+      );
+      if (cached) {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache hit for getByOrg: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit },
+        {
+          $project: {
+            _id: 1,
+            org: 1,
+            type: 1,
+            normalBalance: 1,
+            parent: 1,
+            name: 1,
+            code: 1,
+            tax: 1,
+            status: 1,
+            createdAt: 1,
+            updatedAt: 1
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils90.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 300).then(() => {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache set for getByOrg: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils90.logger.log({
+          level: "error",
+          message: `Failed to set cache for getByOrg: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new import_utils90.InternalServerError(
+        "Internal server error, failed to retrieve chart of accounts."
+      );
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb43.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils90.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_utils90.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache hit for getById chart of account: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({ _id });
+      if (!result) {
+        throw new import_utils90.BadRequestError("Chart of account not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache set for chart of account by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils90.logger.log({
+          level: "error",
+          message: `Failed to set cache for chart of account by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils90.AppError) {
+        throw error;
+      } else {
+        throw new import_utils90.InternalServerError("Failed to get chart of account.");
+      }
+    }
+  }
+  async function updateById(_id, options, session) {
+    try {
+      _id = new import_mongodb43.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils90.BadRequestError("Invalid Chart of Account ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return "Successfully updated chart of account.";
+    } catch (error) {
+      throw new import_utils90.InternalServerError("Failed to update chart of account.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb43.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils90.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: "archived",
+            updatedAt: /* @__PURE__ */ new Date(),
+            deletedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { session }
+      );
+      delCachedData();
+      return "Successfully archived chart of account.";
+    } catch (error) {
+      throw new import_utils90.InternalServerError("Failed to archive chart of account.");
+    }
+  }
+  async function updateStatusById(_id, status2) {
+    try {
+      _id = new import_mongodb43.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils90.BadRequestError("Invalid ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: status2,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new import_utils90.BadRequestError("Chart of account not found.");
+      }
+      delCachedData();
+      return "Successfully updated chart of account status.";
+    } catch (error) {
+      if (error instanceof import_utils90.AppError) {
+        throw error;
+      }
+      throw new import_utils90.InternalServerError(
+        "Failed to update chart of account status."
+      );
+    }
+  }
+  async function countByPath(path) {
+    const { error } = import_joi73.default.string().required().validate(path);
+    if (error) {
+      throw new import_utils90.BadRequestError("Path is required and must be a string.");
+    }
+    try {
+      const count = await collection.countDocuments({
+        path: { $regex: `^${path}(-|$)` }
+      });
+      return count;
+    } catch (error2) {
+      throw new import_utils90.InternalServerError(
+        "Failed to count chart of accounts by path."
+      );
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getByOrg,
+    getById,
+    updateById,
+    deleteById,
+    updateStatusById,
+    countByPath
+  };
+}
+
+// src/resources/finance-account/chart-of-account.controller.ts
+var import_joi75 = __toESM(require("joi"));
+var import_utils92 = require("@goweekdays/utils");
+
+// src/resources/finance-account/chart-of-account.service.ts
+var import_utils91 = require("@goweekdays/utils");
+var import_joi74 = __toESM(require("joi"));
+function useChartOfAccountService() {
+  const {
+    add: _add,
+    getById: _getById,
+    updateById: _updateById,
+    deleteById: _deleteById,
+    countByPath
+  } = useChartOfAccountRepo();
+  async function add(value) {
+    const { error } = schemaChartOfAccountBase.validate(value);
+    if (error) {
+      throw new import_utils91.BadRequestError(error.message);
+    }
+    const session = import_utils91.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session.startTransaction();
+      const data = {
+        org: value.org,
+        name: value.name,
+        code: value.code,
+        type: value.type,
+        normalBalance: value.normalBalance,
+        parent: value.parent,
+        path: value.code,
+        tax: value.tax,
+        isContra: value.isContra
+      };
+      let parentAccount = null;
+      if (value.parent) {
+        parentAccount = await _getById(value.parent);
+        if (!parentAccount) {
+          throw new import_utils91.BadRequestError("Parent account not found.");
+        }
+        data.path = `${parentAccount.path}-${data.code}`;
+        data.parentName = parentAccount.name;
+        data.type = parentAccount.type;
+        data.normalBalance = parentAccount.normalBalance;
+      }
+      const message = await _add(data, session);
+      await session.commitTransaction();
+      return message;
+    } catch (error2) {
+      await session.abortTransaction();
+      throw error2;
+    } finally {
+      session.endSession();
+    }
+  }
+  async function updateById(id, value) {
+    const { error: errorId } = import_joi74.default.string().hex().required().validate(id);
+    if (errorId) {
+      throw new import_utils91.BadRequestError("Invalid Chart of Account ID.");
+    }
+    const { error } = schemaChartOfAccountUpdate.validate(value);
+    if (error) {
+      throw new import_utils91.BadRequestError(
+        `Invalid chart of account update data: ${error.message}`
+      );
+    }
+    const session = import_utils91.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session.startTransaction();
+      const existingAccount = await _getById(id);
+      if (!existingAccount) {
+        throw new import_utils91.BadRequestError("Chart of Account not found.");
+      }
+      const updatedData = {
+        org: existingAccount.org,
+        name: value.name,
+        code: value.code,
+        type: value.type,
+        normalBalance: value.normalBalance,
+        parent: value.parent ?? "",
+        parentName: "",
+        tax: value.tax,
+        path: existingAccount.path,
+        isContra: value.isContra
+      };
+      if (value.parent) {
+        const parentAccount = await _getById(value.parent);
+        if (!parentAccount) {
+          throw new import_utils91.BadRequestError("Parent account not found.");
+        }
+        updatedData.path = `${parentAccount.path}-${value.code}`;
+        updatedData.parentName = parentAccount.name;
+        updatedData.type = parentAccount.type;
+        updatedData.normalBalance = parentAccount.normalBalance;
+      } else {
+        updatedData.path = value.code;
+        updatedData.parentName = "";
+      }
+      const message = await _updateById(id, updatedData, session);
+      await session.commitTransaction();
+      return message;
+    } catch (error2) {
+      await session.abortTransaction();
+      throw error2;
+    } finally {
+      session.endSession();
+    }
+  }
+  async function deleteById(id) {
+    const { error } = import_joi74.default.string().hex().required().validate(id);
+    if (error) {
+      throw new import_utils91.BadRequestError("Invalid Chart of Account ID.");
+    }
+    const session = import_utils91.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session.startTransaction();
+      const existingAccount = await _getById(id);
+      if (!existingAccount) {
+        throw new import_utils91.BadRequestError("Chart of Account not found.");
+      }
+      const childCount = await countByPath(existingAccount.path);
+      if (childCount > 1) {
+        throw new import_utils91.BadRequestError(
+          "Cannot delete account with child accounts. Please delete child accounts first."
+        );
+      }
+      const message = await _deleteById(id, session);
+      await session.commitTransaction();
+      return message;
+    } catch (error2) {
+      await session.abortTransaction();
+      throw error2;
+    } finally {
+      session.endSession();
+    }
+  }
+  return {
+    add,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/finance-account/chart-of-account.controller.ts
+function useChartOfAccountController() {
+  const {
+    getAll: _getAll,
+    getByOrg: _getByOrg,
+    getById: _getById,
+    updateStatusById: _updateStatusById
+  } = useChartOfAccountRepo();
+  const {
+    add: _add,
+    updateById: _updateById,
+    deleteById: _deleteById
+  } = useChartOfAccountService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaChartOfAccountBase.validate(value);
+    if (error) {
+      next(new import_utils92.BadRequestError(error.message));
+      import_utils92.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const message = await _add(value);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi75.default.object({
+      org: import_joi75.default.string().hex().required(),
+      page: import_joi75.default.number().min(1).optional().allow("", null),
+      limit: import_joi75.default.number().min(1).optional().allow("", null),
+      search: import_joi75.default.string().optional().allow("", null),
+      status: import_joi75.default.string().optional().allow("", null)
+    });
+    const org = req.params.org ?? "";
+    const { error } = validation.validate({ ...query, org });
+    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 status2 = req.query.status ?? "active";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_utils92.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_utils92.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const accounts = await _getAll({ org, page, limit, search, status: status2 });
+      res.json(accounts);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByOrg(req, res, next) {
+    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 status2 = req.query.status ?? "active";
+    const org = req.params.org ?? "";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_utils92.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_utils92.BadRequestError("Invalid limit number."));
+      return;
+    }
+    const validation = import_joi75.default.object({
+      org: import_joi75.default.string().hex().required(),
+      page: import_joi75.default.number().min(1).optional().allow("", null),
+      limit: import_joi75.default.number().min(1).optional().allow("", null),
+      search: import_joi75.default.string().optional().allow("", null),
+      status: import_joi75.default.string().optional()
+    });
+    const { error } = validation.validate({ org, page, limit, search, status: status2 });
+    if (error) {
+      next(new import_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const accounts = await _getByOrg({ org, page, limit, search, status: status2 });
+      res.json(accounts);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi75.default.object({
+      id: import_joi75.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const account = await _getById(id);
+      res.json(account);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const _id = req.params.id;
+    const { error: errorId } = import_joi75.default.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new import_utils92.BadRequestError("Invalid Chart of Account ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaChartOfAccountUpdate.validate(payload);
+    if (error) {
+      next(new import_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateById(_id, payload);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    if (!id) {
+      next(new import_utils92.BadRequestError("Chart of Account ID is required."));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function updateStatusById(req, res, next) {
+    const id = req.params.id;
+    const status2 = req.params.status;
+    const validation = import_joi75.default.object({
+      id: import_joi75.default.string().hex().required(),
+      status: import_joi75.default.string().required()
+    });
+    const { error } = validation.validate({ id, status: status2 });
+    if (error) {
+      next(new import_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateStatusById(id, status2);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getByOrg,
+    getById,
+    updateById,
+    deleteById,
+    updateStatusById
+  };
+}
+
+// src/resources/finance-journal/finance.journal.entry.model.ts
+var import_utils93 = require("@goweekdays/utils");
+var import_joi76 = __toESM(require("joi"));
+var import_mongodb44 = require("mongodb");
+var journalEntryStatuses = [
+  "draft",
+  "posted",
+  "voided"
+];
+var journalEntryTypes = [
+  "general",
+  "sales",
+  "purchases",
+  "cash-receipts",
+  "cash-disbursements"
+];
+var schemaJournalEntryBase = {
+  org: import_joi76.default.string().hex().required(),
+  book: import_joi76.default.string().valid(...journalEntryTypes).required(),
+  date: import_joi76.default.date().required(),
+  type: import_joi76.default.string().required(),
+  description: import_joi76.default.string().required(),
+  createdBy: import_joi76.default.string().hex().required(),
+  metadata: import_joi76.default.object({
+    customerId: import_joi76.default.string().hex().optional().allow("", null),
+    supplierId: import_joi76.default.string().hex().optional().allow("", null),
+    itemId: import_joi76.default.string().hex().optional().allow("", null),
+    assetId: import_joi76.default.string().hex().optional().allow("", null),
+    purchaseOrderId: import_joi76.default.string().hex().optional().allow("", null),
+    salesOrderId: import_joi76.default.string().hex().optional().allow("", null)
+  }).optional()
+};
+var schemaJournalEntryCtrl = import_joi76.default.object(schemaJournalEntryBase);
+var schemaJournalEntryRepo = import_joi76.default.object({
+  ...schemaJournalEntryBase,
+  id: import_joi76.default.string().required(),
+  createdByName: import_joi76.default.string().required(),
+  status: import_joi76.default.string().valid(...journalEntryStatuses).required()
+});
+var schemaJournalEntryGetAll = import_joi76.default.object({
+  org: import_joi76.default.string().hex().required(),
+  page: import_joi76.default.number().optional().allow("", null),
+  limit: import_joi76.default.number().max(100).optional().allow("", null),
+  book: import_joi76.default.string().required().allow("", null),
+  type: import_joi76.default.string().optional().allow("", null),
+  search: import_joi76.default.string().optional().allow("", null),
+  status: import_joi76.default.string().optional().allow("", null)
+});
+function modelJournalEntry(data) {
+  const { error } = schemaJournalEntryRepo.validate(data);
+  if (error) {
+    throw new Error(`Invalid journal entry data: ${error.message}`);
+  }
+  try {
+    data.org = new import_mongodb44.ObjectId(data.org);
+  } catch (error2) {
+    throw new import_utils93.BadRequestError(`Invalid org ID: ${data.org}`);
+  }
+  try {
+    data.createdBy = new import_mongodb44.ObjectId(data.createdBy);
+  } catch (error2) {
+    throw new import_utils93.BadRequestError(`Invalid createdBy ID: ${data.createdBy}`);
+  }
+  const date = /* @__PURE__ */ new Date();
+  if (data.metadata) {
+    if (data.metadata.customerId) {
+      try {
+        data.metadata.customerId = new import_mongodb44.ObjectId(data.metadata.customerId);
+      } catch (error2) {
+        throw new import_utils93.BadRequestError(
+          `Invalid customer ID: ${data.metadata.customerId}`
+        );
+      }
+    }
+    if (data.metadata.supplierId) {
+      try {
+        data.metadata.supplierId = new import_mongodb44.ObjectId(data.metadata.supplierId);
+      } catch (error2) {
+        throw new import_utils93.BadRequestError(
+          `Invalid supplier ID: ${data.metadata.supplierId}`
+        );
+      }
+    }
+    if (data.metadata.itemId) {
+      try {
+        data.metadata.itemId = new import_mongodb44.ObjectId(data.metadata.itemId);
+      } catch (error2) {
+        throw new import_utils93.BadRequestError(`Invalid item ID: ${data.metadata.itemId}`);
+      }
+    }
+    if (data.metadata.assetId) {
+      try {
+        data.metadata.assetId = new import_mongodb44.ObjectId(data.metadata.assetId);
+      } catch (error2) {
+        throw new import_utils93.BadRequestError(`Invalid asset ID: ${data.metadata.assetId}`);
+      }
+    }
+    if (data.metadata.purchaseOrderId) {
+      try {
+        data.metadata.purchaseOrderId = new import_mongodb44.ObjectId(
+          data.metadata.purchaseOrderId
+        );
+      } catch (error2) {
+        throw new import_utils93.BadRequestError(
+          `Invalid purchase order ID: ${data.metadata.purchaseOrderId}`
+        );
+      }
+    }
+    if (data.metadata.salesOrderId) {
+      try {
+        data.metadata.salesOrderId = new import_mongodb44.ObjectId(data.metadata.salesOrderId);
+      } catch (error2) {
+        throw new import_utils93.BadRequestError(
+          `Invalid sales order ID: ${data.metadata.salesOrderId}`
+        );
+      }
+    }
+  }
+  return {
+    _id: data._id,
+    id: data.id,
+    org: data.org,
+    type: data.type,
+    date,
+    book: data.book,
+    description: data.description,
+    metadata: data.metadata ?? {
+      customerId: "",
+      supplierId: "",
+      itemId: "",
+      assetId: "",
+      purchaseOrderId: "",
+      salesOrderId: ""
+    },
+    status: data.status,
+    postedAt: data.postedAt ?? "",
+    createdBy: data.createdBy,
+    createdByName: data.createdByName,
+    createdAt: data.createdAt ?? date,
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/finance-journal/finance.journal.entry.repository.ts
+var import_utils94 = require("@goweekdays/utils");
+var import_mongodb45 = require("mongodb");
+var import_joi77 = __toESM(require("joi"));
+function useJournalEntryRepo() {
+  const db = import_utils94.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils94.BadRequestError("Unable to connect to server.");
+  }
+  const namespace_collection = "finance.journal.entries";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils94.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils94.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils94.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = modelJournalEntry(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_utils94.logger.log({
+        level: "error",
+        message: error.message
+      });
+      throw new import_utils94.BadRequestError(
+        `Failed to create journal entry: ${error.message}`
+      );
+    }
+  }
+  async function getAll(options) {
+    options.page = options.page && options.page > 0 ? options.page - 1 : 0;
+    options.status = options.status ?? "posted";
+    options.limit = options.limit ?? 10;
+    options.book = options.book ?? "general";
+    const { error } = schemaJournalEntryGetAll.validate(options);
+    if (error) {
+      throw new import_utils94.BadRequestError(`Invalid query parameters: ${error.message}`);
+    }
+    const query = {
+      status: options.status,
+      book: options.book
+    };
+    const cacheKeyOptions = {
+      page: options.page,
+      limit: options.limit,
+      book: options.book,
+      status: options.status
+    };
+    try {
+      query.org = new import_mongodb45.ObjectId(options.org);
+      cacheKeyOptions.org = String(options.org);
+    } catch (error2) {
+      throw new import_utils94.BadRequestError("Invalid organization ID.");
+    }
+    if (options.search) {
+      query.$text = { $search: options.search };
+      cacheKeyOptions.search = options.search;
+    }
+    if (options.type) {
+      query.type = options.type;
+      cacheKeyOptions.type = options.type;
+    }
+    const cacheKey = (0, import_utils94.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_utils94.logger.log({
+      level: "info",
+      message: `Cache key for getAll journal entries: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils94.logger.log({
+          level: "info",
+          message: `Cache hit for getAll journal entries: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: options.page * options.limit },
+        { $limit: options.limit },
+        {
+          $lookup: {
+            from: "finance.journal.lines",
+            let: { journalId: "$_id" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: { $eq: ["$journalEntry", "$$journalId"] }
+                }
+              },
+              {
+                $sort: { debit: -1 }
+              }
+            ],
+            as: "lines"
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils94.paginate)(items, options.page, options.limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_utils94.logger.log({
+          level: "info",
+          message: `Cache set for getAll journal entries: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils94.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll journal entries: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      import_utils94.logger.log({ level: "error", message: `${error2}` });
+      throw error2;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb45.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils94.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_utils94.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils94.logger.log({
+          level: "info",
+          message: `Cache hit for getById journal entry: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({ _id });
+      if (!result) {
+        throw new import_utils94.BadRequestError("Journal entry not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_utils94.logger.log({
+          level: "info",
+          message: `Cache set for journal entry by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils94.logger.log({
+          level: "error",
+          message: `Failed to set cache for journal entry by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils94.AppError) {
+        throw error;
+      } else {
+        throw new import_utils94.InternalServerError("Failed to get journal entry.");
+      }
+    }
+  }
+  async function updateById(_id, options) {
+    const { error: errorId } = import_joi77.default.string().hex().required().validate(String(_id));
+    if (errorId) {
+      throw new import_utils94.BadRequestError("Invalid Journal Entry ID.");
+    }
+    const { error } = schemaJournalEntryRepo.validate(options);
+    if (error) {
+      throw new import_utils94.BadRequestError(
+        `Invalid journal entry update data: ${error.message}`
+      );
+    }
+    try {
+      _id = new import_mongodb45.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils94.BadRequestError("Invalid Journal Entry ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return "Successfully updated journal entry.";
+    } catch (error2) {
+      throw new import_utils94.InternalServerError("Failed to update journal entry.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb45.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils94.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: "voided",
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { session }
+      );
+      delCachedData();
+      return "Successfully voided journal entry.";
+    } catch (error) {
+      throw new import_utils94.InternalServerError("Failed to void journal entry.");
+    }
+  }
+  async function updateStatusById(_id, status2) {
+    try {
+      _id = new import_mongodb45.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils94.BadRequestError("Invalid ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: status2,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new import_utils94.BadRequestError("Journal entry not found.");
+      }
+      delCachedData();
+      return "Successfully updated journal entry status.";
+    } catch (error) {
+      if (error instanceof import_utils94.AppError) {
+        throw error;
+      }
+      throw new import_utils94.InternalServerError("Failed to update journal entry status.");
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById,
+    updateStatusById
+  };
+}
+
+// src/resources/finance-journal/finance.journal.entry.service.ts
+var import_joi80 = __toESM(require("joi"));
+
+// src/resources/finance-journal/finance.journal.line.model.ts
+var import_utils95 = require("@goweekdays/utils");
+var import_joi78 = __toESM(require("joi"));
+var import_mongodb46 = require("mongodb");
+var schemaJournalLineBase = {
+  org: import_joi78.default.string().hex().required(),
+  account: import_joi78.default.string().hex().required(),
+  debit: import_joi78.default.number().min(0).required(),
+  credit: import_joi78.default.number().min(0).required()
+};
+var schemaJournalLineCtrl = import_joi78.default.object(schemaJournalLineBase);
+var schemaJournalLineRepo = import_joi78.default.object({
+  ...schemaJournalLineBase,
+  journalEntry: import_joi78.default.string().hex().required(),
+  accountName: import_joi78.default.string().required()
+});
+function modelJournalLine(data) {
+  const { error } = schemaJournalLineRepo.validate(data);
+  if (error) {
+    throw new import_utils95.BadRequestError(`Invalid journal line data: ${error.message}`);
+  }
+  try {
+    data.org = new import_mongodb46.ObjectId(data.org);
+  } catch (error2) {
+    throw new import_utils95.BadRequestError(`Invalid org ID: ${data.org}`);
+  }
+  try {
+    data.journalEntry = new import_mongodb46.ObjectId(data.journalEntry);
+  } catch (error2) {
+    throw new import_utils95.BadRequestError(`Invalid journal entry ID: ${data.journalEntry}`);
+  }
+  try {
+    data.account = new import_mongodb46.ObjectId(data.account);
+  } catch (error2) {
+    throw new import_utils95.BadRequestError(`Invalid account ID: ${data.account}`);
+  }
+  return {
+    _id: data._id,
+    org: data.org,
+    journalEntry: data.journalEntry,
+    account: data.account,
+    accountName: data.accountName,
+    debit: data.debit,
+    credit: data.credit,
+    postReference: data.postReference ?? "",
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/finance-journal/finance.journal.line.repository.ts
+var import_utils96 = require("@goweekdays/utils");
+var import_mongodb47 = require("mongodb");
+var import_joi79 = __toESM(require("joi"));
+function useJournalLineRepo() {
+  const db = import_utils96.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils96.BadRequestError("Unable to connect to server.");
+  }
+  const namespace_collection = "finance.journal.lines";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils96.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils96.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils96.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = modelJournalLine(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_utils96.logger.log({
+        level: "error",
+        message: error.message
+      });
+      throw new import_utils96.BadRequestError(
+        `Failed to create journal line: ${error.message}`
+      );
+    }
+  }
+  async function getAll(options) {
+    options.page = options.page && options.page > 0 ? options.page - 1 : 0;
+    options.limit = options.limit ?? 10;
+    const query = {};
+    try {
+      query.org = new import_mongodb47.ObjectId(options.org);
+    } catch (error) {
+      throw new import_utils96.BadRequestError("Invalid organization ID.");
+    }
+    if (options.journalEntry) {
+      try {
+        query.journalEntry = new import_mongodb47.ObjectId(options.journalEntry);
+      } catch (error) {
+        throw new import_utils96.BadRequestError("Invalid journal entry ID.");
+      }
+    }
+    const cacheKey = (0, import_utils96.makeCacheKey)(namespace_collection, {
+      org: String(options.org),
+      journalEntry: String(options.journalEntry ?? ""),
+      page: options.page,
+      limit: options.limit
+    });
+    import_utils96.logger.log({
+      level: "info",
+      message: `Cache key for getAll journal lines: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils96.logger.log({
+          level: "info",
+          message: `Cache hit for getAll journal lines: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: options.page * options.limit },
+        { $limit: options.limit },
+        {
+          $project: {
+            _id: 1,
+            org: 1,
+            journalEntry: 1,
+            account: 1,
+            debit: 1,
+            credit: 1,
+            description: 1,
+            createdAt: 1
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils96.paginate)(items, options.page, options.limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_utils96.logger.log({
+          level: "info",
+          message: `Cache set for getAll journal lines: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils96.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll journal lines: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_utils96.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb47.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils96.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_utils96.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils96.logger.log({
+          level: "info",
+          message: `Cache hit for getById journal line: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({ _id });
+      if (!result) {
+        throw new import_utils96.BadRequestError("Journal line not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_utils96.logger.log({
+          level: "info",
+          message: `Cache set for journal line by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils96.logger.log({
+          level: "error",
+          message: `Failed to set cache for journal line by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils96.AppError) {
+        throw error;
+      } else {
+        throw new import_utils96.InternalServerError("Failed to get journal line.");
+      }
+    }
+  }
+  async function updateById(_id, options) {
+    const { error: errorId } = import_joi79.default.string().hex().required().validate(String(_id));
+    if (errorId) {
+      throw new import_utils96.BadRequestError("Invalid Journal Line ID.");
+    }
+    const { error } = schemaJournalLineRepo.validate(options);
+    if (error) {
+      throw new import_utils96.BadRequestError(
+        `Invalid journal line update data: ${error.message}`
+      );
+    }
+    try {
+      _id = new import_mongodb47.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils96.BadRequestError("Invalid Journal Line ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return "Successfully updated journal line.";
+    } catch (error2) {
+      throw new import_utils96.InternalServerError("Failed to update journal line.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb47.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils96.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.deleteOne({ _id }, { session });
+      delCachedData();
+      return "Successfully deleted journal line.";
+    } catch (error) {
+      throw new import_utils96.InternalServerError("Failed to delete journal line.");
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/finance-journal/finance.journal.entry.service.ts
+var import_utils97 = require("@goweekdays/utils");
+function useJournalEntryService() {
+  const { add: _add } = useJournalEntryRepo();
+  const { add: addLine } = useJournalLineRepo();
+  const { getUserById } = useUserRepo();
+  const { getById: getAccountById } = useChartOfAccountRepo();
+  const {
+    getByType: getCounterByType,
+    add: addCounter,
+    incrementByType
+  } = useCounterRepo();
+  async function add(entry, lines) {
+    const { error } = import_joi80.default.object({
+      journalEntry: schemaJournalEntryCtrl.required(),
+      journalLines: import_joi80.default.array().items(schemaJournalLineCtrl).min(1).required()
+    }).validate({ journalEntry: entry, journalLines: lines });
+    if (error) {
+      throw new import_utils97.BadRequestError(`Invalid journal entry data: ${error.message}`);
+    }
+    const session = import_utils97.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new import_utils97.BadRequestError("Unable to start database session.");
+    }
+    try {
+      session.startTransaction();
+      const counterName = `${entry.org.toString()}.journal.entry.${entry.book}`;
+      const counter = await getCounterByType(counterName);
+      if (!counter) {
+        await addCounter(counterName, session);
+      }
+      const entryNumber = counter ? counter.count + 1 : 1;
+      entry.id = entryNumber.toString().padStart(6, "0");
+      await incrementByType(counterName, session);
+      const totalDebit = lines.reduce((sum, line) => sum + line.debit, 0);
+      const totalCredit = lines.reduce((sum, line) => sum + line.credit, 0);
+      if (totalDebit !== totalCredit) {
+        throw new import_utils97.BadRequestError(
+          `Total debit (${totalDebit}) must equal total credit (${totalCredit}).`
+        );
+      }
+      const user = await getUserById(entry.createdBy);
+      if (!user) {
+        throw new import_utils97.NotFoundError("User not found.");
+      }
+      entry.createdByName = `${user.firstName} ${user.lastName}`;
+      entry.status = "draft";
+      const entryId = await _add(entry, session);
+      for (const line of lines) {
+        line.journalEntry = entryId.toString();
+        const account = await getAccountById(String(line.account));
+        if (!account) {
+          throw new import_utils97.NotFoundError(`Account not found: ${line.account}`);
+        }
+        line.accountName = account.name;
+        await addLine(line, session);
+      }
+      await session.commitTransaction();
+      return "Journal entry created successfully.";
+    } catch (error2) {
+      await session.abortTransaction();
+      if (error2 instanceof import_utils97.AppError) {
+        throw error2;
+      }
+      throw new import_utils97.InternalServerError(
+        `Failed to create journal entry: ${error2.message}`
+      );
+    } finally {
+      session.endSession();
+    }
+  }
+  return {
+    add
+  };
+}
+
+// src/resources/finance-journal/finance.journal.entry.controller.ts
+var import_joi81 = __toESM(require("joi"));
+var import_utils98 = require("@goweekdays/utils");
+function useJournalEntryController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    updateById: _updateById,
+    deleteById: _deleteById,
+    updateStatusById: _updateStatusById
+  } = useJournalEntryRepo();
+  const { add: _add } = useJournalEntryService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = import_joi81.default.object({
+      journalEntry: schemaJournalEntryCtrl.required(),
+      journalLines: import_joi81.default.array().items(schemaJournalLineCtrl).min(1).required()
+    }).validate(value);
+    if (error) {
+      next(new import_utils98.BadRequestError(error.message));
+      import_utils98.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const message = await _add(value.journalEntry, value.journalLines);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const org = req.params.org ?? "";
+    const { error } = schemaJournalEntryGetAll.validate({ ...query, org });
+    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 book = req.query.book ?? "general";
+    const type = req.query.type ?? "";
+    const search = req.query.search ?? "";
+    const status2 = req.query.status ?? "posted";
+    if (!isFinite(page)) {
+      next(new import_utils98.BadRequestError("Invalid page number."));
+      return;
+    }
+    if (!isFinite(limit)) {
+      next(new import_utils98.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_utils98.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const entries = await _getAll({
+        org,
+        page,
+        limit,
+        book,
+        type,
+        search,
+        status: status2
+      });
+      res.json(entries);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi81.default.object({
+      id: import_joi81.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_utils98.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const entry = await _getById(id);
+      res.json(entry);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const _id = req.params.id ?? "";
+    const { error: errorId } = import_joi81.default.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new import_utils98.BadRequestError("Invalid Journal Entry ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaJournalEntryCtrl.validate(payload);
+    if (error) {
+      next(
+        new import_utils98.BadRequestError(
+          `Invalid journal entry update data: ${error.message}`
+        )
+      );
+      return;
+    }
+    try {
+      const message = await _updateById(_id, payload);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    if (!id) {
+      next(new import_utils98.BadRequestError("Journal Entry ID is required."));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function updateStatusById(req, res, next) {
+    const id = req.params.id;
+    const status2 = req.params.status;
+    const validation = import_joi81.default.object({
+      id: import_joi81.default.string().hex().required(),
+      status: import_joi81.default.string().required()
+    });
+    const { error } = validation.validate({ id, status: status2 });
+    if (error) {
+      next(new import_utils98.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateStatusById(id, status2);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById,
+    updateStatusById
+  };
+}
+
+// src/resources/finance-journal/finance.journal.line.controller.ts
+var import_joi82 = __toESM(require("joi"));
+var import_utils99 = require("@goweekdays/utils");
+function useJournalLineController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    updateById: _updateById,
+    deleteById: _deleteById,
+    add: _add
+  } = useJournalLineRepo();
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi82.default.object({
+      org: import_joi82.default.string().hex().required(),
+      journalEntry: import_joi82.default.string().hex().optional(),
+      page: import_joi82.default.number().min(1).optional().allow("", null),
+      limit: import_joi82.default.number().min(1).optional().allow("", null)
+    });
+    const org = req.params.org ?? "";
+    const journalEntry = req.query.journalEntry;
+    const { error } = validation.validate({ ...query, org, journalEntry });
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    if (!isFinite(page)) {
+      next(new import_utils99.BadRequestError("Invalid page number."));
+      return;
+    }
+    if (!isFinite(limit)) {
+      next(new import_utils99.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_utils99.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const lines = await _getAll({ org, journalEntry, page, limit });
+      res.json(lines);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi82.default.object({
+      id: import_joi82.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_utils99.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const line = await _getById(id);
+      res.json(line);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const _id = req.params.id ?? "";
+    const { error: errorId } = import_joi82.default.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new import_utils99.BadRequestError("Invalid Journal Line ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaJournalLineCtrl.validate(payload);
+    if (error) {
+      next(
+        new import_utils99.BadRequestError(
+          `Invalid journal line update data: ${error.message}`
+        )
+      );
+      return;
+    }
+    try {
+      const message = await _updateById(_id, payload);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    if (!id) {
+      next(new import_utils99.BadRequestError("Journal Line ID is required."));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  return {
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCESS_TOKEN_EXPIRY,
@@ -17047,12 +19395,17 @@ function useJobSummaryCtrl() {
   VERIFICATION_USER_INVITE_DURATION,
   XENDIT_BASE_URL,
   XENDIT_SECRET_KEY,
+  chartOfAccountNormalBalances,
+  chartOfAccountTypes,
   currencies,
   isDev,
   jobApplicationStatuses,
+  journalEntryStatuses,
+  journalEntryTypes,
   ledgerBillStatuses,
   ledgerBillTypes,
   modelApp,
+  modelChartOfAccount,
   modelJobApplication,
   modelJobPost,
   modelJobProfile,
@@ -17064,6 +19417,8 @@ function useJobSummaryCtrl() {
   modelJobStatusSetup,
   modelJobStatusTrans,
   modelJobSummary,
+  modelJournalEntry,
+  modelJournalLine,
   modelLedgerBill,
   modelMember,
   modelOption,
@@ -17075,6 +19430,7 @@ function useJobSummaryCtrl() {
   modelRole,
   modelSubscription,
   modelSubscriptionTransaction,
+  modelTax,
   modelUser,
   modelVerification,
   schemaApp,
@@ -17083,6 +19439,9 @@ function useJobSummaryCtrl() {
   schemaBuilding,
   schemaBuildingUnit,
   schemaCertification,
+  schemaChartOfAccountBase,
+  schemaChartOfAccountStd,
+  schemaChartOfAccountUpdate,
   schemaEducation,
   schemaGroup,
   schemaInviteMember,
@@ -17109,6 +19468,11 @@ function useJobSummaryCtrl() {
   schemaJobStatusTrans,
   schemaJobSummary,
   schemaJobSummaryInc,
+  schemaJournalEntryCtrl,
+  schemaJournalEntryGetAll,
+  schemaJournalEntryRepo,
+  schemaJournalLineCtrl,
+  schemaJournalLineRepo,
   schemaLanguage,
   schemaLedgerBill,
   schemaLedgerBillingSummary,
@@ -17139,11 +19503,14 @@ function useJobSummaryCtrl() {
   schemaSubscriptionSeats,
   schemaSubscriptionTransaction,
   schemaSubscriptionUpdate,
+  schemaTax,
+  schemaTaxUpdate,
   schemaUpdateOptions,
   schemaUser,
   schemaVerification,
   schemaVerificationOrgInvite,
   schemaWorkExp,
+  taxDirections,
   transactionSchema,
   useAppController,
   useAppRepo,
@@ -17156,6 +19523,8 @@ function useJobSummaryCtrl() {
   useBuildingUnitController,
   useBuildingUnitRepo,
   useBuildingUnitService,
+  useChartOfAccountController,
+  useChartOfAccountRepo,
   useCounterModel,
   useCounterRepo,
   useFileController,
@@ -17174,6 +19543,11 @@ function useJobSummaryCtrl() {
   useJobSummaryCtrl,
   useJobSummaryRepo,
   useJobSummarySvc,
+  useJournalEntryController,
+  useJournalEntryRepo,
+  useJournalEntryService,
+  useJournalLineController,
+  useJournalLineRepo,
   useLedgerBillingController,
   useLedgerBillingRepo,
   useMemberController,
@@ -17204,6 +19578,8 @@ function useJobSummaryCtrl() {
   useSubscriptionService,
   useSubscriptionTransactionController,
   useSubscriptionTransactionRepo,
+  useTaxController,
+  useTaxRepo,
   useUserController,
   useUserRepo,
   useUserService,