@goweekdays/core 2.15.0 → 2.15.2

package/dist/index.js

@@ -102,6 +102,7 @@ __export(src_exports, {
   modelJobSummary: () => modelJobSummary,
   modelJournal: () => modelJournal,
   modelJournalLine: () => modelJournalLine,
+  modelJournalTransaction: () => modelJournalTransaction,
   modelLedgerBill: () => modelLedgerBill,
   modelMember: () => modelMember,
   modelOption: () => modelOption,
@@ -171,6 +172,11 @@ __export(src_exports, {
   schemaJournalLineRepo: () => schemaJournalLineRepo,
   schemaJournalRepo: () => schemaJournalRepo,
   schemaJournalRepoUpdate: () => schemaJournalRepoUpdate,
+  schemaJournalTransactionAccount: () => schemaJournalTransactionAccount,
+  schemaJournalTransactionCtrl: () => schemaJournalTransactionCtrl,
+  schemaJournalTransactionCtrlUpdate: () => schemaJournalTransactionCtrlUpdate,
+  schemaJournalTransactionGetAll: () => schemaJournalTransactionGetAll,
+  schemaJournalTransactionRepo: () => schemaJournalTransactionRepo,
   schemaLanguage: () => schemaLanguage,
   schemaLedgerBill: () => schemaLedgerBill,
   schemaLedgerBillingSummary: () => schemaLedgerBillingSummary,
@@ -252,6 +258,9 @@ __export(src_exports, {
   useJournalLineRepo: () => useJournalLineRepo,
   useJournalRepo: () => useJournalRepo,
   useJournalService: () => useJournalService,
+  useJournalTransactionController: () => useJournalTransactionController,
+  useJournalTransactionRepo: () => useJournalTransactionRepo,
+  useJournalTransactionService: () => useJournalTransactionService,
   useLedgerBillingController: () => useLedgerBillingController,
   useLedgerBillingRepo: () => useLedgerBillingRepo,
   useMemberController: () => useMemberController,
@@ -18347,7 +18356,8 @@ function useChartOfAccountRepo() {
         { 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" }
+        { key: { code: 1, org: 1 }, unique: true, name: "unique_code_per_org" },
+        { key: { name: "text", code: "text" }, name: "text_search" }
       ]);
     } catch (error) {
       throw new Error("Failed to create index on chart of account.");
@@ -19145,7 +19155,12 @@ function useAccountBalanceRepo() {
         { key: { account: 1 } },
         { key: { "period.fiscalYear": 1 } },
         {
-          key: { org: 1, account: 1, "period.fiscalYear": 1, "period.month": 1 },
+          key: {
+            org: 1,
+            account: 1,
+            "period.fiscalYear": 1,
+            "period.month": 1
+          },
           unique: true,
           name: "unique_balance_per_account_month"
         }
@@ -19320,9 +19335,7 @@ function useAccountBalanceRepo() {
       if (error instanceof import_utils99.AppError) {
         throw error;
       }
-      throw new import_utils99.InternalServerError(
-        "Failed to get account balance."
-      );
+      throw new import_utils99.InternalServerError("Failed to get account balance.");
     }
   }
   async function getYearBalancesByAccount(options) {
@@ -19347,9 +19360,7 @@ function useAccountBalanceRepo() {
       if (error instanceof import_utils99.AppError) {
         throw error;
       }
-      throw new import_utils99.InternalServerError(
-        "Failed to get account balances by year."
-      );
+      throw new import_utils99.InternalServerError("Failed to get account balances by year.");
     }
   }
   async function updateById(account, org, fiscalYear, month, options, session) {
@@ -19435,7 +19446,7 @@ var journalTypes = [
 var schemaJournalBase = {
   date: import_joi83.default.date().required(),
   type: import_joi83.default.string().allow(...journalTypes).required(),
-  transaction: import_joi83.default.string().required(),
+  transaction: import_joi83.default.string().hex().required(),
   customer: import_joi83.default.string().hex().optional().allow("", null),
   description: import_joi83.default.string().required(),
   invoiceNumber: import_joi83.default.string().optional().allow("", null)
@@ -19452,6 +19463,7 @@ var schemaJournalRepo = import_joi83.default.object({
   id: import_joi83.default.string().required(),
   createdBy: import_joi83.default.string().hex().required(),
   createdByName: import_joi83.default.string().required(),
+  transactionName: import_joi83.default.string().required(),
   customerName: import_joi83.default.string().optional().allow("", null),
   status: import_joi83.default.string().valid(...JournalStatuses).required(),
   reversedEntry: import_joi83.default.string().hex().optional().allow("", null),
@@ -19463,6 +19475,7 @@ var schemaJournalRepoUpdate = import_joi83.default.object({
   date: import_joi83.default.date().optional().allow("", null),
   type: import_joi83.default.string().allow(...journalTypes).optional().allow("", null),
   transaction: import_joi83.default.string().optional().allow("", null),
+  transactionName: import_joi83.default.string().optional().allow("", null),
   description: import_joi83.default.string().optional().allow("", null),
   status: import_joi83.default.string().valid(...JournalStatuses).optional().allow("", null),
   customerName: import_joi83.default.string().optional().allow("", null),
@@ -19491,6 +19504,11 @@ function modelJournal(data) {
   } catch (error2) {
     throw new import_utils100.BadRequestError(`Invalid org ID: ${data.org}`);
   }
+  try {
+    data.transaction = new import_mongodb50.ObjectId(data.transaction);
+  } catch (error2) {
+    throw new import_utils100.BadRequestError(`Invalid transaction ID: ${data.transaction}`);
+  }
   try {
     data.createdBy = new import_mongodb50.ObjectId(data.createdBy);
   } catch (error2) {
@@ -19535,6 +19553,7 @@ function modelJournal(data) {
     org: data.org,
     type: data.type,
     transaction: data.transaction,
+    transactionName: data.transactionName ?? "",
     date,
     invoiceNumber: data.invoiceNumber ?? "",
     customer: data.customer ?? "",
@@ -19831,6 +19850,24 @@ function useJournalRepo() {
       throw new import_utils101.InternalServerError("Failed to update journal status.");
     }
   }
+  async function existsByTransactionId(org, transactionId) {
+    try {
+      org = new import_mongodb51.ObjectId(org);
+    } catch {
+      throw new import_utils101.BadRequestError("Invalid org ID.");
+    }
+    try {
+      transactionId = new import_mongodb51.ObjectId(transactionId);
+    } catch {
+      throw new import_utils101.BadRequestError("Invalid transaction ID.");
+    }
+    const count = await repo.collection.countDocuments({
+      org,
+      transaction: transactionId,
+      status: { $ne: "voided" }
+    });
+    return count > 0;
+  }
   return {
     createIndexes,
     delCachedData: repo.delCachedData,
@@ -19839,12 +19876,13 @@ function useJournalRepo() {
     getById,
     updateById,
     deleteById,
-    updateStatusById
+    updateStatusById,
+    existsByTransactionId
   };
 }
 
 // src/resources/finance-journal/finance.journal.service.ts
-var import_joi90 = __toESM(require("joi"));
+var import_joi93 = __toESM(require("joi"));
 
 // src/resources/finance-journal-line/finance.journal.line.model.ts
 var import_utils102 = require("@goweekdays/utils");
@@ -20175,6 +20213,23 @@ function useJournalLineRepo() {
       throw new import_utils103.InternalServerError("Failed to delete journal line.");
     }
   }
+  async function updateBalanceById(_id, balance, session) {
+    try {
+      _id = new import_mongodb53.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils103.BadRequestError("Invalid Journal Line ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { balance, updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      delCachedData();
+    } catch (error) {
+      throw new import_utils103.InternalServerError("Failed to update journal line balance.");
+    }
+  }
   async function updateStatusByJournal(journalEntry, status2, session) {
     const validation = import_joi86.default.object({
       journalEntry: import_joi86.default.string().hex().required(),
@@ -20215,13 +20270,14 @@ function useJournalLineRepo() {
     getById,
     getByEntry,
     updateById,
+    updateBalanceById,
     deleteById,
     updateStatusByJournal
   };
 }
 
 // src/resources/finance-journal/finance.journal.service.ts
-var import_utils108 = require("@goweekdays/utils");
+var import_utils112 = require("@goweekdays/utils");
 
 // src/resources/finance-journal/finance.journal.util.ts
 var import_utils104 = require("@goweekdays/utils");
@@ -20629,6 +20685,529 @@ function useJournalLogRepo() {
 var import_joi89 = __toESM(require("joi"));
 var import_utils107 = require("@goweekdays/utils");
 
+// src/resources/finance-journal-transaction/finance.journal.transaction.model.ts
+var import_utils108 = require("@goweekdays/utils");
+var import_joi90 = __toESM(require("joi"));
+var import_mongodb56 = require("mongodb");
+var schemaJournalTransactionAccount = import_joi90.default.object({
+  title: import_joi90.default.string().required(),
+  value: import_joi90.default.string().hex().required()
+});
+var schemaJournalTransactionBase = {
+  type: import_joi90.default.string().valid(...journalTypes).required(),
+  code: import_joi90.default.string().required(),
+  title: import_joi90.default.string().required(),
+  debits: import_joi90.default.array().items(schemaJournalTransactionAccount).min(1).required(),
+  credits: import_joi90.default.array().items(schemaJournalTransactionAccount).min(1).required(),
+  template: import_joi90.default.boolean().required(),
+  description: import_joi90.default.string().optional().allow("", null)
+};
+var schemaJournalTransactionCtrl = import_joi90.default.object({
+  ...schemaJournalTransactionBase,
+  org: import_joi90.default.string().hex().required(),
+  createdBy: import_joi90.default.string().hex().required()
+});
+var schemaJournalTransactionCtrlUpdate = import_joi90.default.object({
+  code: import_joi90.default.string().optional(),
+  title: import_joi90.default.string().optional(),
+  debits: import_joi90.default.array().items(schemaJournalTransactionAccount).min(1).optional(),
+  credits: import_joi90.default.array().items(schemaJournalTransactionAccount).min(1).optional(),
+  template: import_joi90.default.boolean().optional(),
+  description: import_joi90.default.string().optional().allow("", null)
+});
+var schemaJournalTransactionRepo = import_joi90.default.object({
+  ...schemaJournalTransactionBase,
+  org: import_joi90.default.string().hex().required(),
+  createdBy: import_joi90.default.string().hex().required(),
+  createdByName: import_joi90.default.string().optional().allow("", null)
+});
+var schemaJournalTransactionGetAll = import_joi90.default.object({
+  org: import_joi90.default.string().hex().required(),
+  type: import_joi90.default.string().optional().allow("", null),
+  search: import_joi90.default.string().optional().allow("", null),
+  page: import_joi90.default.number().optional().allow("", null),
+  limit: import_joi90.default.number().max(100).optional().allow("", null)
+});
+function modelJournalTransaction(data) {
+  const { error } = schemaJournalTransactionRepo.validate(data);
+  if (error) {
+    throw new import_utils108.BadRequestError(
+      `Invalid journal transaction data: ${error.message}`
+    );
+  }
+  try {
+    data.org = new import_mongodb56.ObjectId(data.org);
+  } catch (error2) {
+    throw new import_utils108.BadRequestError(`Invalid org ID: ${data.org}`);
+  }
+  try {
+    data.createdBy = new import_mongodb56.ObjectId(data.createdBy);
+  } catch (error2) {
+    throw new import_utils108.BadRequestError(`Invalid createdBy ID: ${data.createdBy}`);
+  }
+  for (let i = 0; i < data.debits.length; i++) {
+    try {
+      data.debits[i].value = new import_mongodb56.ObjectId(data.debits[i].value);
+    } catch (error2) {
+      throw new import_utils108.BadRequestError(`Invalid debit account ID at index ${i}`);
+    }
+  }
+  for (let i = 0; i < data.credits.length; i++) {
+    try {
+      data.credits[i].value = new import_mongodb56.ObjectId(data.credits[i].value);
+    } catch (error2) {
+      throw new import_utils108.BadRequestError(`Invalid credit account ID at index ${i}`);
+    }
+  }
+  const now = /* @__PURE__ */ new Date();
+  return {
+    _id: data._id,
+    org: data.org,
+    type: data.type,
+    code: data.code,
+    title: data.title,
+    debits: data.debits,
+    credits: data.credits,
+    template: data.template ?? false,
+    description: data.description ?? "",
+    createdBy: data.createdBy,
+    createdByName: data.createdByName ?? "",
+    createdAt: data.createdAt ?? now,
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/finance-journal-transaction/finance.journal.transaction.repository.ts
+var import_utils109 = require("@goweekdays/utils");
+var import_mongodb57 = require("mongodb");
+function useJournalTransactionRepo() {
+  const namespace_collection = "finance.journal.transactions";
+  const repo = (0, import_utils109.useRepo)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { org: 1, type: 1, _id: 1 } },
+        { key: { org: 1 } },
+        { key: { type: 1 } },
+        { key: { code: 1 } },
+        { key: { org: 1, type: 1 } },
+        {
+          key: {
+            title: "text",
+            code: "text",
+            description: "text"
+          }
+        },
+        {
+          key: { org: 1, type: 1, code: 1 },
+          unique: true,
+          name: "unique_org_type_code"
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on journal transactions.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelJournalTransaction(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_utils109.logger.log({ level: "error", message: error.message });
+      throw new import_utils109.BadRequestError(
+        `Failed to create journal transaction: ${error.message}`
+      );
+    }
+  }
+  async function getAll(options) {
+    options.page = options.page && options.page > 0 ? options.page - 1 : 0;
+    options.limit = options.limit ?? 10;
+    options.search = options.search ?? "";
+    const { error } = schemaJournalTransactionGetAll.validate(options);
+    if (error) {
+      throw new import_utils109.BadRequestError(`Invalid query parameters: ${error.message}`);
+    }
+    const query = {};
+    const cacheKeyOptions = {
+      page: options.page,
+      limit: options.limit
+    };
+    try {
+      query.org = new import_mongodb57.ObjectId(options.org);
+      cacheKeyOptions.org = String(options.org);
+    } catch (error2) {
+      throw new import_utils109.BadRequestError("Invalid organization ID.");
+    }
+    if (options.type) {
+      query.type = options.type;
+      cacheKeyOptions.type = options.type;
+    }
+    if (options.search) {
+      query.$text = { $search: options.search };
+      cacheKeyOptions.search = options.search;
+    }
+    const cacheKey = (0, import_utils109.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_utils109.logger.log({
+      level: "info",
+      message: `Cache key for getAll journal transactions: ${cacheKey}`
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_utils109.logger.log({
+          level: "info",
+          message: `Cache hit for getAll journal transactions: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await repo.collection.aggregate([
+        { $match: query },
+        { $sort: { title: 1 } },
+        { $skip: options.page * options.limit },
+        { $limit: options.limit }
+      ]).toArray();
+      const length = await repo.collection.countDocuments(query);
+      const data = (0, import_utils109.paginate)(items, options.page, options.limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        import_utils109.logger.log({
+          level: "info",
+          message: `Cache set for getAll journal transactions: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils109.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll journal transactions: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      import_utils109.logger.log({ level: "error", message: `${error2}` });
+      throw error2;
+    }
+  }
+  async function getByOrgTypeId(options) {
+    try {
+      options._id = new import_mongodb57.ObjectId(options._id);
+    } catch (error) {
+      throw new import_utils109.BadRequestError("Invalid ID.");
+    }
+    try {
+      options.org = new import_mongodb57.ObjectId(options.org);
+    } catch (error) {
+      throw new import_utils109.BadRequestError("Invalid organization ID.");
+    }
+    const cacheKey = (0, import_utils109.makeCacheKey)(namespace_collection, {
+      org: String(options.org),
+      type: options.type,
+      _id: String(options._id),
+      tag: "org_type_id"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_utils109.logger.log({
+          level: "info",
+          message: `Cache hit for get by org + type + id journal transaction: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await repo.collection.findOne({
+        _id: options._id,
+        org: options.org,
+        type: options.type
+      });
+      repo.setCache(cacheKey, result, 300).then(() => {
+        import_utils109.logger.log({
+          level: "info",
+          message: `Cache set for journal transaction by org + type + id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils109.logger.log({
+          level: "error",
+          message: `Failed to set cache for journal transaction by org + type + id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils109.AppError) {
+        throw error;
+      } else {
+        throw new import_utils109.InternalServerError("Failed to get journal transaction.");
+      }
+    }
+  }
+  async function updateById(_id, options, session) {
+    const { error } = schemaJournalTransactionCtrlUpdate.validate(options);
+    if (error) {
+      throw new import_utils109.BadRequestError(
+        `Invalid journal transaction update data: ${error.message}`
+      );
+    }
+    try {
+      _id = new import_mongodb57.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils109.BadRequestError("Invalid journal transaction ID.");
+    }
+    if (options.debits) {
+      for (let i = 0; i < options.debits.length; i++) {
+        try {
+          options.debits[i].value = new import_mongodb57.ObjectId(options.debits[i].value);
+        } catch (error2) {
+          throw new import_utils109.BadRequestError(`Invalid debit account ID at index ${i}`);
+        }
+      }
+    }
+    if (options.credits) {
+      for (let i = 0; i < options.credits.length; i++) {
+        try {
+          options.credits[i].value = new import_mongodb57.ObjectId(options.credits[i].value);
+        } catch (error2) {
+          throw new import_utils109.BadRequestError(`Invalid credit account ID at index ${i}`);
+        }
+      }
+    }
+    try {
+      await repo.collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      repo.delCachedData();
+      return "Successfully updated journal transaction.";
+    } catch (error2) {
+      throw new import_utils109.InternalServerError("Failed to update journal transaction.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb57.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils109.BadRequestError("Invalid ID.");
+    }
+    try {
+      await repo.collection.deleteOne({ _id }, { session });
+      repo.delCachedData();
+      return "Successfully deleted journal transaction.";
+    } catch (error) {
+      throw new import_utils109.InternalServerError("Failed to delete journal transaction.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getByOrgTypeId,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/finance-journal-transaction/finance.journal.transaction.service.ts
+var import_utils110 = require("@goweekdays/utils");
+var import_joi91 = __toESM(require("joi"));
+function validateNoDuplicateAccounts(debits, credits) {
+  const debitIds = debits.map((d) => String(d.value));
+  const creditIds = credits.map((c) => String(c.value));
+  const debitSet = new Set(debitIds);
+  if (debitSet.size !== debitIds.length) {
+    throw new import_utils110.BadRequestError("Duplicate accounts found in debits.");
+  }
+  const creditSet = new Set(creditIds);
+  if (creditSet.size !== creditIds.length) {
+    throw new import_utils110.BadRequestError("Duplicate accounts found in credits.");
+  }
+}
+function useJournalTransactionService() {
+  const {
+    add: _add,
+    updateById: _updateById,
+    getByOrgTypeId
+  } = useJournalTransactionRepo();
+  const { getUserById } = useUserRepo();
+  async function add(value) {
+    const { error } = schemaJournalTransactionCtrl.validate(value);
+    if (error) {
+      throw new import_utils110.BadRequestError(
+        `Invalid journal transaction data: ${error.message}`
+      );
+    }
+    validateNoDuplicateAccounts(value.debits, value.credits);
+    const user = await getUserById(value.createdBy);
+    if (!user) {
+      throw new import_utils110.NotFoundError("User not found.");
+    }
+    value.createdByName = `${user.firstName} ${user.lastName}`;
+    try {
+      const id = await _add(value);
+      return id;
+    } catch (error2) {
+      if (error2 instanceof import_utils110.AppError) {
+        throw error2;
+      }
+      throw new import_utils110.InternalServerError(
+        `Failed to create journal transaction: ${error2.message}`
+      );
+    }
+  }
+  async function updateById(org, type, _id, options) {
+    const { error: idError } = import_joi91.default.string().hex().required().validate(_id);
+    if (idError) {
+      throw new import_utils110.BadRequestError("Invalid journal transaction ID.");
+    }
+    const { error } = schemaJournalTransactionCtrlUpdate.validate(options);
+    if (error) {
+      throw new import_utils110.BadRequestError(`Invalid update data: ${error.message}`);
+    }
+    const existing = await getByOrgTypeId({ org, type, _id });
+    if (!existing) {
+      throw new import_utils110.NotFoundError("Journal transaction not found.");
+    }
+    const debits = options.debits ?? existing.debits;
+    const credits = options.credits ?? existing.credits;
+    validateNoDuplicateAccounts(debits, credits);
+    try {
+      return await _updateById(_id, options);
+    } catch (error2) {
+      if (error2 instanceof import_utils110.AppError) {
+        throw error2;
+      }
+      throw new import_utils110.InternalServerError(
+        `Failed to update journal transaction: ${error2.message}`
+      );
+    }
+  }
+  return {
+    add,
+    updateById
+  };
+}
+
+// src/resources/finance-journal-transaction/finance.journal.transaction.controller.ts
+var import_joi92 = __toESM(require("joi"));
+var import_utils111 = require("@goweekdays/utils");
+function useJournalTransactionController() {
+  const {
+    getAll: _getAll,
+    getByOrgTypeId: _getByOrgTypeId,
+    deleteById: _deleteById
+  } = useJournalTransactionRepo();
+  const { add: _add, updateById: _updateById } = useJournalTransactionService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaJournalTransactionCtrl.validate(value);
+    if (error) {
+      next(new import_utils111.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _add(value);
+      res.json({ message: "Journal transaction created successfully.", id });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const org = req.params.org ?? "";
+    const type = req.params.type ?? "";
+    const search = req.query.search ?? "";
+    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 { error } = schemaJournalTransactionGetAll.validate({
+      ...req.params,
+      ...req.query
+    });
+    if (!isFinite(page)) {
+      next(new import_utils111.BadRequestError("Invalid page number."));
+      return;
+    }
+    if (!isFinite(limit)) {
+      next(new import_utils111.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_utils111.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAll({ org, type, search, page, limit });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByOrgTypeId(req, res, next) {
+    const { error } = import_joi92.default.object({
+      org: import_joi92.default.string().hex().required(),
+      type: import_joi92.default.string().required(),
+      id: import_joi92.default.string().hex().required()
+    }).validate(req.params);
+    if (error) {
+      next(new import_utils111.BadRequestError(error.message));
+      return;
+    }
+    const _id = req.params.id;
+    const org = req.params.org;
+    const type = req.params.type;
+    try {
+      const data = await _getByOrgTypeId({ org, type, _id });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const value = req.body;
+    const { error } = import_joi92.default.object({
+      id: import_joi92.default.string().hex().required(),
+      org: import_joi92.default.string().hex().required(),
+      type: import_joi92.default.string().allow(...journalTypes).required()
+    }).concat(schemaJournalTransactionCtrlUpdate).validate({ ...req.params, ...value });
+    if (error) {
+      next(new import_utils111.BadRequestError(error.message));
+      return;
+    }
+    const id = req.params.id ?? "";
+    const org = req.params.org ?? "";
+    const type = req.params.type ?? "";
+    try {
+      const message = await _updateById(org, type, id, value);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const { error } = import_joi92.default.object({
+      id: import_joi92.default.string().hex().required()
+    }).validate({ id });
+    if (error) {
+      next(new import_utils111.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getByOrgTypeId,
+    updateById,
+    deleteById
+  };
+}
+
 // src/resources/finance-journal/finance.journal.service.ts
 function useJournalService() {
   const {
@@ -20638,10 +21217,12 @@ function useJournalService() {
     updateById: _updateById,
     delCachedData: delJournalCache
   } = useJournalRepo();
+  const { getByOrgTypeId: getJournalTransaction } = useJournalTransactionRepo();
   const {
     add: addLine,
     getByEntry: getJournalLinesByEntry,
     updateById: updateJournalLineById,
+    updateBalanceById: updateJournalLineBalance,
     deleteById: deleteJournalLineById
   } = useJournalLineRepo();
   const { getUserById } = useUserRepo();
@@ -20655,21 +21236,21 @@ function useJournalService() {
   const { add: addJournalLog } = useJournalLogRepo();
   const { getById: getCustomerById } = useCustomerRepo();
   async function add(entry, lines) {
-    const { error } = import_joi90.default.object({
+    const { error } = import_joi93.default.object({
       journalEntry: schemaJournalCtrl.required(),
-      journalLines: import_joi90.default.array().items(schemaJournalLineCtrl).min(1).required()
+      journalLines: import_joi93.default.array().items(schemaJournalLineCtrl).min(1).required()
     }).validate({
       journalEntry: entry,
       journalLines: lines
     });
     if (error) {
-      throw new import_utils108.BadRequestError(
+      throw new import_utils112.BadRequestError(
         `Invalid general journal data: ${error.message}`
       );
     }
-    const session = import_utils108.useAtlas.getClient()?.startSession();
+    const session = import_utils112.useAtlas.getClient()?.startSession();
     if (!session) {
-      throw new import_utils108.BadRequestError("Unable to start database session.");
+      throw new import_utils112.BadRequestError("Unable to start database session.");
     }
     try {
       session.startTransaction();
@@ -20684,16 +21265,25 @@ function useJournalService() {
       await validateJournalLines(lines);
       const user = await getUserById(entry.createdBy);
       if (!user) {
-        throw new import_utils108.NotFoundError("User not found.");
+        throw new import_utils112.NotFoundError("User not found.");
       }
       entry.createdByName = `${user.firstName} ${user.lastName}`;
       if (entry.customer) {
         const customer = await getCustomerById(String(entry.customer));
         if (!customer) {
-          throw new import_utils108.NotFoundError("Customer not found.");
+          throw new import_utils112.NotFoundError("Customer not found.");
         }
         entry.customerName = `${customer.firstName} ${customer.lastName}`;
       }
+      const journalTx = await getJournalTransaction({
+        org: String(entry.org),
+        type: entry.type,
+        _id: String(entry.transaction)
+      });
+      if (!journalTx) {
+        throw new import_utils112.NotFoundError("Transaction not found.");
+      }
+      entry.transactionName = journalTx.title;
       entry.status = "draft";
       const entryId = await _add(entry, session);
       for (const line of lines) {
@@ -20701,7 +21291,7 @@ function useJournalService() {
         line.journalEntry = entryId.toString();
         const account = await getAccountById(String(line.account));
         if (!account) {
-          throw new import_utils108.NotFoundError(`Account not found: ${line.account}`);
+          throw new import_utils112.NotFoundError(`Account not found: ${line.account}`);
         }
         line.accountName = account.name;
         line.accountCode = account.code;
@@ -20733,10 +21323,10 @@ function useJournalService() {
       return "Journal entry created successfully.";
     } catch (error2) {
       await session.abortTransaction();
-      if (error2 instanceof import_utils108.AppError) {
+      if (error2 instanceof import_utils112.AppError) {
         throw error2;
       }
-      throw new import_utils108.InternalServerError(
+      throw new import_utils112.InternalServerError(
         `Failed to create general journal: ${error2.message}`
       );
     } finally {
@@ -20750,18 +21340,19 @@ function useJournalService() {
     getYearBalancesByAccount,
     updateById: updateAccountBalance
   } = useAccountBalanceRepo();
+  const { getByOrg: getBusinessProfileByOrg } = useBusinessProfileRepo();
   async function updateStatusById(_id, status2, user) {
-    const validation = import_joi90.default.object({
-      _id: import_joi90.default.string().hex().required(),
-      status: import_joi90.default.string().valid("posted", "voided").required()
+    const validation = import_joi93.default.object({
+      _id: import_joi93.default.string().hex().required(),
+      status: import_joi93.default.string().valid("posted", "voided").required()
     });
     const { error } = validation.validate({ _id, status: status2 });
     if (error) {
-      throw new import_utils108.BadRequestError(`Invalid input: ${error.message}`);
+      throw new import_utils112.BadRequestError(`Invalid input: ${error.message}`);
     }
-    const session = import_utils108.useAtlas.getClient()?.startSession();
+    const session = import_utils112.useAtlas.getClient()?.startSession();
     if (!session) {
-      throw new import_utils108.BadRequestError("Unable to start database session.");
+      throw new import_utils112.BadRequestError("Unable to start database session.");
     }
     try {
       let computeClosingBalance2 = function(openingDebit, openingCredit, movementDebit, movementCredit) {
@@ -20775,18 +21366,18 @@ function useJournalService() {
       var computeClosingBalance = computeClosingBalance2;
       const journalEntry = await getJournalById(_id);
       if (!journalEntry) {
-        throw new import_utils108.NotFoundError("Journal entry not found.");
+        throw new import_utils112.NotFoundError("Journal entry not found.");
       }
       if (journalEntry.status === "voided") {
-        throw new import_utils108.BadRequestError("Cannot update a voided general journal.");
+        throw new import_utils112.BadRequestError("Cannot update a voided general journal.");
       }
       if (journalEntry.status === "posted" && status2 === "draft") {
-        throw new import_utils108.BadRequestError(
+        throw new import_utils112.BadRequestError(
           "Cannot revert a posted general journal to draft."
         );
       }
       if (status2 === "voided" && journalEntry.reversalDraft) {
-        throw new import_utils108.BadRequestError(
+        throw new import_utils112.BadRequestError(
           "Cannot void a general journal with an existing reversal draft."
         );
       }
@@ -20808,9 +21399,17 @@ function useJournalService() {
       if (status2 === "posted") {
         await updateStatusByJournal(_id, status2, session);
         await _updateStatusById(_id, status2, session);
+        const businessProfile = await getBusinessProfileByOrg(
+          String(journalEntry.org)
+        );
+        if (!businessProfile) {
+          throw new import_utils112.NotFoundError(
+            "Business profile not found for organization."
+          );
+        }
         const linesToPost = await getJournalLinesByEntry(_id);
         const journalDate = new Date(journalEntry.date);
-        const fiscalYear = journalDate.getFullYear();
+        const fiscalYear = Number(businessProfile.currentFiscalYear);
         const month = journalDate.toLocaleString("en-US", { month: "long" });
         for (const line of linesToPost) {
           const existingBalance = await getAccountBalance({
@@ -20833,9 +21432,16 @@ function useJournalService() {
               String(journalEntry.org),
               fiscalYear,
               month,
-              { movementDebit, movementCredit, closingDebit, closingCredit, netBalance },
+              {
+                movementDebit,
+                movementCredit,
+                closingDebit,
+                closingCredit,
+                netBalance
+              },
               session
             );
+            await updateJournalLineBalance(String(line._id), netBalance, session);
           } else {
             const allYearBalances = await getYearBalancesByAccount({
               account: String(line.account),
@@ -20843,7 +21449,9 @@ function useJournalService() {
               fiscalYear
             });
             const currentMonthIdx = MONTHS.indexOf(month);
-            const previousRecord = allYearBalances.filter((r) => MONTHS.indexOf(r.period.month) < currentMonthIdx).sort((a, b) => MONTHS.indexOf(b.period.month) - MONTHS.indexOf(a.period.month))[0];
+            const previousRecord = allYearBalances.filter((r) => MONTHS.indexOf(r.period.month) < currentMonthIdx).sort(
+              (a, b) => MONTHS.indexOf(b.period.month) - MONTHS.indexOf(a.period.month)
+            )[0];
             const openingDebit = previousRecord?.closingDebit ?? 0;
             const openingCredit = previousRecord?.closingCredit ?? 0;
             const movementDebit = line.debit || 0;
@@ -20872,6 +21480,7 @@ function useJournalService() {
               },
               session
             );
+            await updateJournalLineBalance(String(line._id), netBalance, session);
           }
         }
         await addJournalLog(
@@ -20886,7 +21495,7 @@ function useJournalService() {
         if (journalEntry.reversedEntry) {
           const userData = await getUserById(user);
           if (!userData) {
-            throw new import_utils108.NotFoundError("User not found.");
+            throw new import_utils112.NotFoundError("User not found.");
           }
           await _updateById(
             journalEntry.reversedEntry,
@@ -20898,6 +21507,7 @@ function useJournalService() {
             },
             session
           );
+          await updateStatusByJournal(String(journalEntry.reversedEntry), "voided", session);
           await addJournalLog(
             {
               journalId: String(journalEntry._id),
@@ -20914,7 +21524,7 @@ function useJournalService() {
         const counterName = `${journalEntry.org.toString()}-general-journal`;
         const counter = await getCounterByType(counterName);
         if (!counter) {
-          throw new import_utils108.NotFoundError("Counter not found for general journal.");
+          throw new import_utils112.NotFoundError("Counter not found for general journal.");
         }
         const date = /* @__PURE__ */ new Date();
         const entryNumber = counter ? counter.count + 1 : 1;
@@ -20923,7 +21533,8 @@ function useJournalService() {
           org: String(journalEntry.org),
           id: entryNumber.toString().padStart(6, "0"),
           type: journalEntry.type,
-          transaction: journalEntry.transaction,
+          transaction: String(journalEntry.transaction),
+          transactionName: journalEntry.transactionName,
           date,
           description: `Reversal of ${getPrefixByType(journalEntry.type)}-${journalEntry.id}`,
           createdBy: String(journalEntry.createdBy),
@@ -20942,7 +21553,7 @@ function useJournalService() {
         );
         const lines = await getJournalLinesByEntry(String(journalEntry._id));
         if (lines && lines.length === 0) {
-          throw new import_utils108.NotFoundError("Journal lines not found for reversal.");
+          throw new import_utils112.NotFoundError("Journal lines not found for reversal.");
         }
         const reversedLines = [];
         for (const line of lines) {
@@ -20987,10 +21598,10 @@ function useJournalService() {
       return "Journal entry status updated successfully.";
     } catch (error2) {
       await session.abortTransaction();
-      if (error2 instanceof import_utils108.AppError) {
+      if (error2 instanceof import_utils112.AppError) {
         throw error2;
       }
-      throw new import_utils108.InternalServerError(
+      throw new import_utils112.InternalServerError(
         `Failed to update general journal status: ${error2.message}`
       );
     } finally {
@@ -20998,11 +21609,11 @@ function useJournalService() {
     }
   }
   async function updateById(id, entry, lines, user) {
-    const { error } = import_joi90.default.object({
-      id: import_joi90.default.string().hex().required(),
+    const { error } = import_joi93.default.object({
+      id: import_joi93.default.string().hex().required(),
       journalEntry: schemaJournalCtrlUpdate.required(),
-      journalLines: import_joi90.default.array().items(schemaJournalLineCtrlUpdate).min(1).required(),
-      user: import_joi90.default.string().hex().required()
+      journalLines: import_joi93.default.array().items(schemaJournalLineCtrlUpdate).min(1).required(),
+      user: import_joi93.default.string().hex().required()
     }).validate({
       id,
       journalEntry: entry,
@@ -21010,13 +21621,13 @@ function useJournalService() {
       user
     });
     if (error) {
-      throw new import_utils108.BadRequestError(
+      throw new import_utils112.BadRequestError(
         `Invalid general journal data: ${error.message}`
       );
     }
-    const session = import_utils108.useAtlas.getClient()?.startSession();
+    const session = import_utils112.useAtlas.getClient()?.startSession();
     if (!session) {
-      throw new import_utils108.BadRequestError("Unable to start database session.");
+      throw new import_utils112.BadRequestError("Unable to start database session.");
     }
     try {
       let hasLineChanged2 = function(existing, incoming) {
@@ -21026,24 +21637,37 @@ function useJournalService() {
       session.startTransaction();
       const existingEntry = await getJournalById(id);
       if (!existingEntry) {
-        throw new import_utils108.NotFoundError("Journal entry not found.");
+        throw new import_utils112.NotFoundError("Journal entry not found.");
       }
       if (existingEntry.status !== "draft") {
-        throw new import_utils108.BadRequestError("Only draft journal entries can be updated.");
+        throw new import_utils112.BadRequestError("Only draft journal entries can be updated.");
       }
       const updatedBy = await getUserById(user);
       if (!updatedBy) {
-        throw new import_utils108.NotFoundError("User not found.");
+        throw new import_utils112.NotFoundError("User not found.");
       }
       await validateJournalLines(lines);
-      const headerChanged = new Date(existingEntry.date).getTime() !== new Date(entry.date).getTime() || existingEntry.description !== entry.description || String(existingEntry.customer || "") !== String(entry.customer || "") || existingEntry.transaction !== entry.transaction;
+      const headerChanged = new Date(existingEntry.date).getTime() !== new Date(entry.date).getTime() || existingEntry.description !== entry.description || String(existingEntry.customer || "") !== String(entry.customer || "") || String(existingEntry.transaction) !== String(entry.transaction);
       if (entry.customer && String(entry.customer) !== String(existingEntry.customer)) {
         const customer = await getCustomerById(String(entry.customer));
         if (!customer) {
-          throw new import_utils108.NotFoundError("Customer not found.");
+          throw new import_utils112.NotFoundError("Customer not found.");
         }
         entry.customerName = `${customer.firstName} ${customer.lastName}`;
       }
+      if (String(existingEntry.transaction) !== String(entry.transaction)) {
+        const journalTx = await getJournalTransaction({
+          org: String(existingEntry.org),
+          type: entry.type,
+          _id: String(entry.transaction)
+        });
+        if (!journalTx) {
+          throw new import_utils112.NotFoundError("Transaction not found.");
+        }
+        entry.transactionName = journalTx.title;
+      } else {
+        entry.transactionName = existingEntry.transactionName;
+      }
       const existingLines = await getJournalLinesByEntry(id);
       const existingLineMap = new Map(
         existingLines.map((line) => [String(line._id), line])
@@ -21058,7 +21682,7 @@ function useJournalService() {
         (existingId) => !incomingIds.has(existingId)
       );
       if (existingLines.length > 0 && removedLineIds.length === existingLines.length && lines.length > 0) {
-        throw new import_utils108.BadRequestError(
+        throw new import_utils112.BadRequestError(
           "All journal lines marked for deletion. Identity mismatch suspected."
         );
       }
@@ -21076,7 +21700,7 @@ function useJournalService() {
       const newLines = lines.filter((line) => !line._id);
       const nothingChanged = !headerChanged && removedLineIds.length === 0 && updatedLines.length === 0 && newLines.length === 0;
       if (nothingChanged) {
-        throw new import_utils108.BadRequestError("No changes detected.");
+        throw new import_utils112.BadRequestError("No changes detected.");
       }
       for (const lineId of removedLineIds) {
         await deleteJournalLineById(lineId, session);
@@ -21091,7 +21715,7 @@ function useJournalService() {
         if (existing && String(existing.account) !== String(line.account)) {
           const account = await getAccountById(String(line.account));
           if (!account) {
-            throw new import_utils108.NotFoundError(`Account not found: ${line.account}`);
+            throw new import_utils112.NotFoundError(`Account not found: ${line.account}`);
           }
           updatePayload.accountName = account.name;
           updatePayload.accountCode = account.code;
@@ -21101,7 +21725,7 @@ function useJournalService() {
       for (const line of newLines) {
         const account = await getAccountById(String(line.account));
         if (!account) {
-          throw new import_utils108.NotFoundError(`Account not found: ${line.account}`);
+          throw new import_utils112.NotFoundError(`Account not found: ${line.account}`);
         }
         await addLine(
           {
@@ -21186,10 +21810,10 @@ function useJournalService() {
       return "Journal entry updated successfully.";
     } catch (error2) {
       await session.abortTransaction();
-      if (error2 instanceof import_utils108.AppError) {
+      if (error2 instanceof import_utils112.AppError) {
         throw error2;
       }
-      throw new import_utils108.InternalServerError(
+      throw new import_utils112.InternalServerError(
         `Failed to update general journal: ${error2.message}`
       );
     } finally {
@@ -21204,8 +21828,8 @@ function useJournalService() {
 }
 
 // src/resources/finance-journal/finance.journal.controller.ts
-var import_joi91 = __toESM(require("joi"));
-var import_utils109 = require("@goweekdays/utils");
+var import_joi94 = __toESM(require("joi"));
+var import_utils113 = require("@goweekdays/utils");
 function useJournalController() {
   const {
     getAll: _getAll,
@@ -21219,13 +21843,13 @@ function useJournalController() {
   } = useJournalService();
   async function add(req, res, next) {
     const value = req.body;
-    const { error } = import_joi91.default.object({
+    const { error } = import_joi94.default.object({
       journalEntry: schemaJournalCtrl.required(),
-      journalLines: import_joi91.default.array().items(schemaJournalLineCtrl).min(1).required()
+      journalLines: import_joi94.default.array().items(schemaJournalLineCtrl).min(1).required()
     }).validate(value);
     if (error) {
-      next(new import_utils109.BadRequestError(error.message));
-      import_utils109.logger.info(`Controller: ${error.message}`);
+      next(new import_utils113.BadRequestError(error.message));
+      import_utils113.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -21246,15 +21870,15 @@ function useJournalController() {
     const search = req.query.search ?? "";
     const status2 = req.query.status ?? "all";
     if (!isFinite(page)) {
-      next(new import_utils109.BadRequestError("Invalid page number."));
+      next(new import_utils113.BadRequestError("Invalid page number."));
       return;
     }
     if (!isFinite(limit)) {
-      next(new import_utils109.BadRequestError("Invalid limit number."));
+      next(new import_utils113.BadRequestError("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new import_utils109.BadRequestError(error.message));
+      next(new import_utils113.BadRequestError(error.message));
       return;
     }
     try {
@@ -21274,12 +21898,12 @@ function useJournalController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi91.default.object({
-      id: import_joi91.default.string().hex().required()
+    const validation = import_joi94.default.object({
+      id: import_joi94.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils109.BadRequestError(error.message));
+      next(new import_utils113.BadRequestError(error.message));
       return;
     }
     try {
@@ -21294,15 +21918,15 @@ function useJournalController() {
     const value = req.body;
     const id = req.params.id ?? "";
     const user = req.cookies.user;
-    const { error } = import_joi91.default.object({
-      id: import_joi91.default.string().hex().required(),
+    const { error } = import_joi94.default.object({
+      id: import_joi94.default.string().hex().required(),
       journalEntry: schemaJournalCtrlUpdate.required(),
-      journalLines: import_joi91.default.array().items(schemaJournalLineCtrlUpdate).min(1).required(),
-      user: import_joi91.default.string().hex().required()
+      journalLines: import_joi94.default.array().items(schemaJournalLineCtrlUpdate).min(1).required(),
+      user: import_joi94.default.string().hex().required()
     }).validate({ id, user, ...value });
     if (error) {
-      next(new import_utils109.BadRequestError(error.message));
-      import_utils109.logger.info(`Controller: ${error.message}`);
+      next(new import_utils113.BadRequestError(error.message));
+      import_utils113.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -21321,7 +21945,7 @@ function useJournalController() {
   async function deleteById(req, res, next) {
     const id = req.params.id;
     if (!id) {
-      next(new import_utils109.BadRequestError("Journal Entry ID is required."));
+      next(new import_utils113.BadRequestError("Journal Entry ID is required."));
       return;
     }
     try {
@@ -21336,14 +21960,14 @@ function useJournalController() {
     const id = req.params.id;
     const status2 = req.params.status;
     const user = req.cookies.user;
-    const validation = import_joi91.default.object({
-      id: import_joi91.default.string().hex().required(),
-      status: import_joi91.default.string().required(),
-      user: import_joi91.default.string().hex().required()
+    const validation = import_joi94.default.object({
+      id: import_joi94.default.string().hex().required(),
+      status: import_joi94.default.string().required(),
+      user: import_joi94.default.string().hex().required()
     });
     const { error } = validation.validate({ id, status: status2, user });
     if (error) {
-      next(new import_utils109.BadRequestError(error.message));
+      next(new import_utils113.BadRequestError(error.message));
       return;
     }
     try {
@@ -21365,8 +21989,8 @@ function useJournalController() {
 }
 
 // src/resources/finance-journal-line/finance.journal.line.controller.ts
-var import_joi92 = __toESM(require("joi"));
-var import_utils110 = require("@goweekdays/utils");
+var import_joi95 = __toESM(require("joi"));
+var import_utils114 = require("@goweekdays/utils");
 function useJournalLineController() {
   const {
     getAll: _getAll,
@@ -21377,14 +22001,14 @@ function useJournalLineController() {
   } = useJournalLineRepo();
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi92.default.object({
-      org: import_joi92.default.string().hex().required(),
-      JournalGeneral: import_joi92.default.string().hex().optional(),
-      page: import_joi92.default.number().min(1).optional().allow("", null),
-      limit: import_joi92.default.number().min(1).optional().allow("", null),
-      account: import_joi92.default.string().hex().optional().allow("", null),
-      search: import_joi92.default.string().optional().allow("", null),
-      status: import_joi92.default.string().valid("draft", "posted").optional().allow("", null)
+    const validation = import_joi95.default.object({
+      org: import_joi95.default.string().hex().required(),
+      JournalGeneral: import_joi95.default.string().hex().optional(),
+      page: import_joi95.default.number().min(1).optional().allow("", null),
+      limit: import_joi95.default.number().min(1).optional().allow("", null),
+      account: import_joi95.default.string().hex().optional().allow("", null),
+      search: import_joi95.default.string().optional().allow("", null),
+      status: import_joi95.default.string().valid("draft", "posted").optional().allow("", null)
     });
     const org = req.params.org ?? "";
     const JournalGeneral = req.query.JournalGeneral;
@@ -21400,15 +22024,15 @@ function useJournalLineController() {
       account
     });
     if (!isFinite(page)) {
-      next(new import_utils110.BadRequestError("Invalid page number."));
+      next(new import_utils114.BadRequestError("Invalid page number."));
       return;
     }
     if (!isFinite(limit)) {
-      next(new import_utils110.BadRequestError("Invalid limit number."));
+      next(new import_utils114.BadRequestError("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new import_utils110.BadRequestError(error.message));
+      next(new import_utils114.BadRequestError(error.message));
       return;
     }
     try {
@@ -21429,12 +22053,12 @@ function useJournalLineController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi92.default.object({
-      id: import_joi92.default.string().hex().required()
+    const validation = import_joi95.default.object({
+      id: import_joi95.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils110.BadRequestError(error.message));
+      next(new import_utils114.BadRequestError(error.message));
       return;
     }
     try {
@@ -21524,6 +22148,7 @@ function useJournalLineController() {
   modelJobSummary,
   modelJournal,
   modelJournalLine,
+  modelJournalTransaction,
   modelLedgerBill,
   modelMember,
   modelOption,
@@ -21593,6 +22218,11 @@ function useJournalLineController() {
   schemaJournalLineRepo,
   schemaJournalRepo,
   schemaJournalRepoUpdate,
+  schemaJournalTransactionAccount,
+  schemaJournalTransactionCtrl,
+  schemaJournalTransactionCtrlUpdate,
+  schemaJournalTransactionGetAll,
+  schemaJournalTransactionRepo,
   schemaLanguage,
   schemaLedgerBill,
   schemaLedgerBillingSummary,
@@ -21674,6 +22304,9 @@ function useJournalLineController() {
   useJournalLineRepo,
   useJournalRepo,
   useJournalService,
+  useJournalTransactionController,
+  useJournalTransactionRepo,
+  useJournalTransactionService,
   useLedgerBillingController,
   useLedgerBillingRepo,
   useMemberController,