@goweekdays/core 2.12.3 → 2.13.0

package/dist/index.mjs

@@ -11073,6 +11073,24 @@ function useOrgController() {
     companySearch: _companySearch
   } = useOrgRepo();
   const { addPilot: _addPilot } = useOrgService();
+  async function validOrg(req, res, next) {
+    const org = req.params.org ?? "";
+    const { error } = Joi49.string().hex().required().validate(org);
+    if (error) {
+      next(new BadRequestError53("Invalid organization ID."));
+      return;
+    }
+    try {
+      const organization = await _getById(org);
+      if (!organization) {
+        next(new BadRequestError53("Organization not found."));
+        return;
+      }
+      next();
+    } catch (error2) {
+      next(error2);
+    }
+  }
   async function add(req, res, next) {
     const value = req.body;
     const { error } = schemaOrgAdd.validate(value);
@@ -11246,6 +11264,7 @@ function useOrgController() {
     }
   }
   return {
+    validOrg,
     add,
     getOrgsByUserId,
     getByName,
@@ -13798,10 +13817,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.");
@@ -13811,7 +13830,7 @@ function useCounterRepo() {
     try {
       const res = await collection.updateOne(
         { type },
-        { $inc: { count: 1 } },
+        { $inc: { count: 1 }, $set: { updatedAt: /* @__PURE__ */ new Date() } },
         { session }
       );
       delCachedData();
@@ -17045,6 +17064,2349 @@ function useJobSummaryCtrl() {
     getByOrg
   };
 }
+
+// src/resources/finance-tax/tax.model.ts
+import { BadRequestError as BadRequestError80 } from "@goweekdays/utils";
+import Joi69 from "joi";
+import { ObjectId as ObjectId40 } from "mongodb";
+var taxDirections = ["input", "output", "withholding"];
+var schemaTax = Joi69.object({
+  org: Joi69.string().hex().required(),
+  name: Joi69.string().required(),
+  rate: Joi69.number().required(),
+  direction: Joi69.string().valid(...taxDirections).required()
+});
+var schemaTaxUpdate = Joi69.object({
+  name: Joi69.string().required(),
+  rate: Joi69.number().required(),
+  direction: Joi69.string().valid(...taxDirections).required()
+});
+function modelTax(data) {
+  const { error } = schemaTax.validate(data);
+  if (error) {
+    throw new BadRequestError80(`Invalid tax data: ${error.message}`);
+  }
+  try {
+    data.org = new ObjectId40(data.org);
+  } catch (error2) {
+    throw new BadRequestError80(`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
+import {
+  AppError as AppError39,
+  BadRequestError as BadRequestError81,
+  useAtlas as useAtlas36,
+  useCache as useCache27,
+  makeCacheKey as makeCacheKey24,
+  paginate as paginate21,
+  logger as logger41,
+  InternalServerError as InternalServerError36
+} from "@goweekdays/utils";
+import { ObjectId as ObjectId41 } from "mongodb";
+import Joi70 from "joi";
+function useTaxRepo() {
+  const db = useAtlas36.getDb();
+  if (!db) {
+    throw new BadRequestError81("Unable to connect to server.");
+  }
+  const namespace_collection = "finance.taxes";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache27(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      logger41.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger41.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) {
+      logger41.log({
+        level: "error",
+        message: error.message
+      });
+      throw new BadRequestError81(`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 ObjectId41(options.org);
+    } catch (error) {
+      throw new BadRequestError81("Invalid organization ID.");
+    }
+    if (options.search) {
+      query.$text = { $search: options.search };
+    }
+    const cacheKey = makeCacheKey24(namespace_collection, {
+      search: options.search,
+      page: options.page,
+      limit: options.limit,
+      status: options.status
+    });
+    logger41.log({
+      level: "info",
+      message: `Cache key for getAll taxes: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger41.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 = paginate21(items, options.page, options.limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        logger41.log({
+          level: "info",
+          message: `Cache set for getAll taxes: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger41.log({
+          level: "error",
+          message: `Failed to set cache for getAll taxes: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      logger41.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 ObjectId41(org);
+    } catch (error) {
+      throw new BadRequestError81("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 = makeCacheKey24(namespace_collection, cacheKeyOptions);
+      const cached = await getCache(
+        cacheKey
+      );
+      if (cached) {
+        logger41.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 = paginate21(items, page, limit, length);
+      setCache(cacheKey, data, 300).then(() => {
+        logger41.log({
+          level: "info",
+          message: `Cache set for getTaxesByOrg: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger41.log({
+          level: "error",
+          message: `Failed to set cache for getTaxesByOrg: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new InternalServerError36(
+        "Internal server error, failed to retrieve taxes."
+      );
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId41(_id);
+    } catch (error) {
+      throw new BadRequestError81("Invalid ID.");
+    }
+    const cacheKey = makeCacheKey24(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger41.log({
+          level: "info",
+          message: `Cache hit for getById tax: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({ _id });
+      if (!result) {
+        throw new BadRequestError81("Tax not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        logger41.log({
+          level: "info",
+          message: `Cache set for tax by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger41.log({
+          level: "error",
+          message: `Failed to set cache for tax by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError39) {
+        throw error;
+      } else {
+        throw new InternalServerError36("Failed to get tax.");
+      }
+    }
+  }
+  async function updateById(_id, options) {
+    const { error: errorId } = Joi70.string().hex().required().validate(String(_id));
+    if (errorId) {
+      throw new BadRequestError81("Invalid Tax ID.");
+    }
+    const { error } = schemaTaxUpdate.validate(options);
+    if (error) {
+      throw new BadRequestError81(`Invalid tax update data: ${error.message}`);
+    }
+    try {
+      _id = new ObjectId41(_id);
+    } catch (error2) {
+      throw new BadRequestError81("Invalid Tax ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return "Successfully updated tax.";
+    } catch (error2) {
+      throw new InternalServerError36("Failed to update tax.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId41(_id);
+    } catch (error) {
+      throw new BadRequestError81("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 InternalServerError36("Failed to delete tax.");
+    }
+  }
+  async function updateStatusById(_id, status2) {
+    try {
+      _id = new ObjectId41(_id);
+    } catch (error) {
+      throw new BadRequestError81("Invalid ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: status2,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new BadRequestError81("Tax not found.");
+      }
+      delCachedData();
+      return "Successfully updated tax status.";
+    } catch (error) {
+      if (error instanceof AppError39) {
+        throw error;
+      }
+      throw new InternalServerError36("Failed to update tax status.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getTaxesByOrg,
+    getById,
+    updateById,
+    deleteById,
+    updateStatusById
+  };
+}
+
+// src/resources/finance-tax/tax.controller.ts
+import Joi71 from "joi";
+import { BadRequestError as BadRequestError82, logger as logger42 } from "@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 BadRequestError82(error.message));
+      logger42.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 = Joi71.object({
+      org: Joi71.string().hex().required(),
+      page: Joi71.number().min(1).optional().allow("", null),
+      limit: Joi71.number().min(1).optional().allow("", null),
+      search: Joi71.string().optional().allow("", null),
+      status: Joi71.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 BadRequestError82("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new BadRequestError82("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new BadRequestError82(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 BadRequestError82("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new BadRequestError82("Invalid limit number."));
+      return;
+    }
+    const validation = Joi71.object({
+      org: Joi71.string().hex().required(),
+      page: Joi71.number().min(1).optional().allow("", null),
+      limit: Joi71.number().min(1).optional().allow("", null),
+      search: Joi71.string().optional().allow("", null),
+      status: Joi71.string().optional()
+    });
+    const { error } = validation.validate({ org, page, limit, search, status: status2 });
+    if (error) {
+      next(new BadRequestError82(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 = Joi71.object({
+      id: Joi71.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError82(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 } = Joi71.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new BadRequestError82("Invalid Tax ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaTaxUpdate.validate(payload);
+    if (error) {
+      next(new BadRequestError82(`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 BadRequestError82("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 = Joi71.object({
+      id: Joi71.string().hex().required(),
+      status: Joi71.string().required()
+    });
+    const { error } = validation.validate({ id, status: status2 });
+    if (error) {
+      next(new BadRequestError82(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
+import Joi72 from "joi";
+import { ObjectId as ObjectId42 } from "mongodb";
+var chartOfAccountTypes = [
+  "asset",
+  "liability",
+  "equity",
+  "income",
+  "expense"
+];
+var chartOfAccountNormalBalances = [
+  "debit",
+  "credit"
+];
+var schemaChartOfAccount = {
+  type: Joi72.string().valid(...chartOfAccountTypes).required(),
+  normalBalance: Joi72.string().valid(...chartOfAccountNormalBalances).required(),
+  parent: Joi72.string().hex().optional().allow("", null),
+  name: Joi72.string().required(),
+  code: Joi72.string().required(),
+  tax: Joi72.string().hex().optional().allow("", null)
+};
+var schemaChartOfAccountBase = Joi72.object({
+  ...schemaChartOfAccount,
+  org: Joi72.string().hex().required(),
+  isContra: Joi72.boolean().required()
+});
+var schemaChartOfAccountStd = Joi72.object({
+  ...schemaChartOfAccount,
+  org: Joi72.string().hex().required(),
+  isContra: Joi72.boolean().required(),
+  path: Joi72.string().required(),
+  parentName: Joi72.string().optional().allow("", null)
+});
+var schemaChartOfAccountUpdate = Joi72.object({
+  ...schemaChartOfAccount,
+  isContra: Joi72.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 ObjectId42(data.org);
+  } catch (error2) {
+    throw new Error(`Invalid org ID: ${data.org}`);
+  }
+  if (data.parent) {
+    try {
+      data.parent = new ObjectId42(data.parent);
+    } catch (error2) {
+      throw new Error(`Invalid parent ID: ${data.parent}`);
+    }
+  }
+  if (data.tax) {
+    try {
+      data.tax = new ObjectId42(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
+import {
+  AppError as AppError40,
+  BadRequestError as BadRequestError83,
+  useAtlas as useAtlas37,
+  useCache as useCache28,
+  makeCacheKey as makeCacheKey25,
+  paginate as paginate22,
+  logger as logger43,
+  InternalServerError as InternalServerError37
+} from "@goweekdays/utils";
+import { ObjectId as ObjectId43 } from "mongodb";
+import Joi73 from "joi";
+function useChartOfAccountRepo() {
+  const db = useAtlas37.getDb();
+  if (!db) {
+    throw new BadRequestError83("Unable to connect to server.");
+  }
+  const namespace_collection = "finance.accounts";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache28(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      logger43.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger43.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) {
+      logger43.log({
+        level: "error",
+        message: error.message
+      });
+      throw new BadRequestError83(
+        `Failed to create chart of account: ${error.message}`
+      );
+    }
+  }
+  async function getAll(options) {
+    const validation = Joi73.object({
+      org: Joi73.string().hex().required(),
+      page: Joi73.number().min(1).optional().allow("", null),
+      limit: Joi73.number().min(1).optional().allow("", null),
+      search: Joi73.string().optional().allow("", null),
+      status: Joi73.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(options);
+    if (error) {
+      throw new BadRequestError83(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 ObjectId43(options.org);
+    } catch (error2) {
+      throw new BadRequestError83("Invalid organization ID.");
+    }
+    if (options.search) {
+      query.$text = { $search: options.search };
+    }
+    const cacheKey = makeCacheKey25(namespace_collection, {
+      search: options.search,
+      page: options.page,
+      limit: options.limit,
+      status: options.status
+    });
+    logger43.log({
+      level: "info",
+      message: `Cache key for getAll chart of accounts: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger43.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 = paginate22(items, options.page, options.limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        logger43.log({
+          level: "info",
+          message: `Cache set for getAll chart of accounts: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger43.log({
+          level: "error",
+          message: `Failed to set cache for getAll chart of accounts: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      logger43.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 ObjectId43(org);
+    } catch (error) {
+      throw new BadRequestError83("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 = makeCacheKey25(namespace_collection, cacheKeyOptions);
+      const cached = await getCache(
+        cacheKey
+      );
+      if (cached) {
+        logger43.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 = paginate22(items, page, limit, length);
+      setCache(cacheKey, data, 300).then(() => {
+        logger43.log({
+          level: "info",
+          message: `Cache set for getByOrg: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger43.log({
+          level: "error",
+          message: `Failed to set cache for getByOrg: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new InternalServerError37(
+        "Internal server error, failed to retrieve chart of accounts."
+      );
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId43(_id);
+    } catch (error) {
+      throw new BadRequestError83("Invalid ID.");
+    }
+    const cacheKey = makeCacheKey25(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger43.log({
+          level: "info",
+          message: `Cache hit for getById chart of account: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({ _id });
+      if (!result) {
+        throw new BadRequestError83("Chart of account not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        logger43.log({
+          level: "info",
+          message: `Cache set for chart of account by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger43.log({
+          level: "error",
+          message: `Failed to set cache for chart of account by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError40) {
+        throw error;
+      } else {
+        throw new InternalServerError37("Failed to get chart of account.");
+      }
+    }
+  }
+  async function updateById(_id, options, session) {
+    try {
+      _id = new ObjectId43(_id);
+    } catch (error) {
+      throw new BadRequestError83("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 InternalServerError37("Failed to update chart of account.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId43(_id);
+    } catch (error) {
+      throw new BadRequestError83("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 InternalServerError37("Failed to archive chart of account.");
+    }
+  }
+  async function updateStatusById(_id, status2) {
+    try {
+      _id = new ObjectId43(_id);
+    } catch (error) {
+      throw new BadRequestError83("Invalid ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: status2,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new BadRequestError83("Chart of account not found.");
+      }
+      delCachedData();
+      return "Successfully updated chart of account status.";
+    } catch (error) {
+      if (error instanceof AppError40) {
+        throw error;
+      }
+      throw new InternalServerError37(
+        "Failed to update chart of account status."
+      );
+    }
+  }
+  async function countByPath(path) {
+    const { error } = Joi73.string().required().validate(path);
+    if (error) {
+      throw new BadRequestError83("Path is required and must be a string.");
+    }
+    try {
+      const count = await collection.countDocuments({
+        path: { $regex: `^${path}(-|$)` }
+      });
+      return count;
+    } catch (error2) {
+      throw new InternalServerError37(
+        "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
+import Joi75 from "joi";
+import { BadRequestError as BadRequestError85, logger as logger44 } from "@goweekdays/utils";
+
+// src/resources/finance-account/chart-of-account.service.ts
+import { BadRequestError as BadRequestError84, useAtlas as useAtlas38 } from "@goweekdays/utils";
+import Joi74 from "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 BadRequestError84(error.message);
+    }
+    const session = useAtlas38.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 BadRequestError84("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 } = Joi74.string().hex().required().validate(id);
+    if (errorId) {
+      throw new BadRequestError84("Invalid Chart of Account ID.");
+    }
+    const { error } = schemaChartOfAccountUpdate.validate(value);
+    if (error) {
+      throw new BadRequestError84(
+        `Invalid chart of account update data: ${error.message}`
+      );
+    }
+    const session = useAtlas38.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session.startTransaction();
+      const existingAccount = await _getById(id);
+      if (!existingAccount) {
+        throw new BadRequestError84("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 BadRequestError84("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 } = Joi74.string().hex().required().validate(id);
+    if (error) {
+      throw new BadRequestError84("Invalid Chart of Account ID.");
+    }
+    const session = useAtlas38.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session.startTransaction();
+      const existingAccount = await _getById(id);
+      if (!existingAccount) {
+        throw new BadRequestError84("Chart of Account not found.");
+      }
+      const childCount = await countByPath(existingAccount.path);
+      if (childCount > 1) {
+        throw new BadRequestError84(
+          "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 BadRequestError85(error.message));
+      logger44.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 = Joi75.object({
+      org: Joi75.string().hex().required(),
+      page: Joi75.number().min(1).optional().allow("", null),
+      limit: Joi75.number().min(1).optional().allow("", null),
+      search: Joi75.string().optional().allow("", null),
+      status: Joi75.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 BadRequestError85("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new BadRequestError85("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new BadRequestError85(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 BadRequestError85("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new BadRequestError85("Invalid limit number."));
+      return;
+    }
+    const validation = Joi75.object({
+      org: Joi75.string().hex().required(),
+      page: Joi75.number().min(1).optional().allow("", null),
+      limit: Joi75.number().min(1).optional().allow("", null),
+      search: Joi75.string().optional().allow("", null),
+      status: Joi75.string().optional()
+    });
+    const { error } = validation.validate({ org, page, limit, search, status: status2 });
+    if (error) {
+      next(new BadRequestError85(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 = Joi75.object({
+      id: Joi75.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError85(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 } = Joi75.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new BadRequestError85("Invalid Chart of Account ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaChartOfAccountUpdate.validate(payload);
+    if (error) {
+      next(new BadRequestError85(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 BadRequestError85("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 = Joi75.object({
+      id: Joi75.string().hex().required(),
+      status: Joi75.string().required()
+    });
+    const { error } = validation.validate({ id, status: status2 });
+    if (error) {
+      next(new BadRequestError85(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
+import { BadRequestError as BadRequestError86 } from "@goweekdays/utils";
+import Joi76 from "joi";
+import { ObjectId as ObjectId44 } from "mongodb";
+var journalEntryStatuses = [
+  "draft",
+  "posted",
+  "voided"
+];
+var journalEntryTypes = [
+  "general",
+  "sales",
+  "purchases",
+  "cash-receipts",
+  "cash-disbursements"
+];
+var schemaJournalEntryBase = {
+  org: Joi76.string().hex().required(),
+  book: Joi76.string().valid(...journalEntryTypes).required(),
+  date: Joi76.date().required(),
+  type: Joi76.string().required(),
+  description: Joi76.string().required(),
+  createdBy: Joi76.string().hex().required(),
+  metadata: Joi76.object({
+    customerId: Joi76.string().hex().optional().allow("", null),
+    supplierId: Joi76.string().hex().optional().allow("", null),
+    itemId: Joi76.string().hex().optional().allow("", null),
+    assetId: Joi76.string().hex().optional().allow("", null),
+    purchaseOrderId: Joi76.string().hex().optional().allow("", null),
+    salesOrderId: Joi76.string().hex().optional().allow("", null)
+  }).optional()
+};
+var schemaJournalEntryCtrl = Joi76.object(schemaJournalEntryBase);
+var schemaJournalEntryRepo = Joi76.object({
+  ...schemaJournalEntryBase,
+  id: Joi76.string().required(),
+  createdByName: Joi76.string().required(),
+  status: Joi76.string().valid(...journalEntryStatuses).required()
+});
+var schemaJournalEntryGetAll = Joi76.object({
+  org: Joi76.string().hex().required(),
+  page: Joi76.number().optional().allow("", null),
+  limit: Joi76.number().max(100).optional().allow("", null),
+  book: Joi76.string().required().allow("", null),
+  type: Joi76.string().optional().allow("", null),
+  search: Joi76.string().optional().allow("", null),
+  status: Joi76.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 ObjectId44(data.org);
+  } catch (error2) {
+    throw new BadRequestError86(`Invalid org ID: ${data.org}`);
+  }
+  try {
+    data.createdBy = new ObjectId44(data.createdBy);
+  } catch (error2) {
+    throw new BadRequestError86(`Invalid createdBy ID: ${data.createdBy}`);
+  }
+  const date = /* @__PURE__ */ new Date();
+  if (data.metadata) {
+    if (data.metadata.customerId) {
+      try {
+        data.metadata.customerId = new ObjectId44(data.metadata.customerId);
+      } catch (error2) {
+        throw new BadRequestError86(
+          `Invalid customer ID: ${data.metadata.customerId}`
+        );
+      }
+    }
+    if (data.metadata.supplierId) {
+      try {
+        data.metadata.supplierId = new ObjectId44(data.metadata.supplierId);
+      } catch (error2) {
+        throw new BadRequestError86(
+          `Invalid supplier ID: ${data.metadata.supplierId}`
+        );
+      }
+    }
+    if (data.metadata.itemId) {
+      try {
+        data.metadata.itemId = new ObjectId44(data.metadata.itemId);
+      } catch (error2) {
+        throw new BadRequestError86(`Invalid item ID: ${data.metadata.itemId}`);
+      }
+    }
+    if (data.metadata.assetId) {
+      try {
+        data.metadata.assetId = new ObjectId44(data.metadata.assetId);
+      } catch (error2) {
+        throw new BadRequestError86(`Invalid asset ID: ${data.metadata.assetId}`);
+      }
+    }
+    if (data.metadata.purchaseOrderId) {
+      try {
+        data.metadata.purchaseOrderId = new ObjectId44(
+          data.metadata.purchaseOrderId
+        );
+      } catch (error2) {
+        throw new BadRequestError86(
+          `Invalid purchase order ID: ${data.metadata.purchaseOrderId}`
+        );
+      }
+    }
+    if (data.metadata.salesOrderId) {
+      try {
+        data.metadata.salesOrderId = new ObjectId44(data.metadata.salesOrderId);
+      } catch (error2) {
+        throw new BadRequestError86(
+          `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
+import {
+  AppError as AppError41,
+  BadRequestError as BadRequestError87,
+  useAtlas as useAtlas39,
+  useCache as useCache29,
+  makeCacheKey as makeCacheKey26,
+  paginate as paginate23,
+  logger as logger45,
+  InternalServerError as InternalServerError38
+} from "@goweekdays/utils";
+import { ObjectId as ObjectId45 } from "mongodb";
+import Joi77 from "joi";
+function useJournalEntryRepo() {
+  const db = useAtlas39.getDb();
+  if (!db) {
+    throw new BadRequestError87("Unable to connect to server.");
+  }
+  const namespace_collection = "finance.journal.entries";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache29(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      logger45.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger45.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) {
+      logger45.log({
+        level: "error",
+        message: error.message
+      });
+      throw new BadRequestError87(
+        `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 BadRequestError87(`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 ObjectId45(options.org);
+      cacheKeyOptions.org = String(options.org);
+    } catch (error2) {
+      throw new BadRequestError87("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 = makeCacheKey26(namespace_collection, cacheKeyOptions);
+    logger45.log({
+      level: "info",
+      message: `Cache key for getAll journal entries: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger45.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 = paginate23(items, options.page, options.limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        logger45.log({
+          level: "info",
+          message: `Cache set for getAll journal entries: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger45.log({
+          level: "error",
+          message: `Failed to set cache for getAll journal entries: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      logger45.log({ level: "error", message: `${error2}` });
+      throw error2;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId45(_id);
+    } catch (error) {
+      throw new BadRequestError87("Invalid ID.");
+    }
+    const cacheKey = makeCacheKey26(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger45.log({
+          level: "info",
+          message: `Cache hit for getById journal entry: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({ _id });
+      if (!result) {
+        throw new BadRequestError87("Journal entry not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        logger45.log({
+          level: "info",
+          message: `Cache set for journal entry by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger45.log({
+          level: "error",
+          message: `Failed to set cache for journal entry by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError41) {
+        throw error;
+      } else {
+        throw new InternalServerError38("Failed to get journal entry.");
+      }
+    }
+  }
+  async function updateById(_id, options) {
+    const { error: errorId } = Joi77.string().hex().required().validate(String(_id));
+    if (errorId) {
+      throw new BadRequestError87("Invalid Journal Entry ID.");
+    }
+    const { error } = schemaJournalEntryRepo.validate(options);
+    if (error) {
+      throw new BadRequestError87(
+        `Invalid journal entry update data: ${error.message}`
+      );
+    }
+    try {
+      _id = new ObjectId45(_id);
+    } catch (error2) {
+      throw new BadRequestError87("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 InternalServerError38("Failed to update journal entry.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId45(_id);
+    } catch (error) {
+      throw new BadRequestError87("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 InternalServerError38("Failed to void journal entry.");
+    }
+  }
+  async function updateStatusById(_id, status2) {
+    try {
+      _id = new ObjectId45(_id);
+    } catch (error) {
+      throw new BadRequestError87("Invalid ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: status2,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new BadRequestError87("Journal entry not found.");
+      }
+      delCachedData();
+      return "Successfully updated journal entry status.";
+    } catch (error) {
+      if (error instanceof AppError41) {
+        throw error;
+      }
+      throw new InternalServerError38("Failed to update journal entry status.");
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById,
+    updateStatusById
+  };
+}
+
+// src/resources/finance-journal/finance.journal.entry.service.ts
+import Joi80 from "joi";
+
+// src/resources/finance-journal/finance.journal.line.model.ts
+import { BadRequestError as BadRequestError88 } from "@goweekdays/utils";
+import Joi78 from "joi";
+import { ObjectId as ObjectId46 } from "mongodb";
+var schemaJournalLineBase = {
+  org: Joi78.string().hex().required(),
+  account: Joi78.string().hex().required(),
+  debit: Joi78.number().min(0).required(),
+  credit: Joi78.number().min(0).required()
+};
+var schemaJournalLineCtrl = Joi78.object(schemaJournalLineBase);
+var schemaJournalLineRepo = Joi78.object({
+  ...schemaJournalLineBase,
+  journalEntry: Joi78.string().hex().required(),
+  accountName: Joi78.string().required()
+});
+function modelJournalLine(data) {
+  const { error } = schemaJournalLineRepo.validate(data);
+  if (error) {
+    throw new BadRequestError88(`Invalid journal line data: ${error.message}`);
+  }
+  try {
+    data.org = new ObjectId46(data.org);
+  } catch (error2) {
+    throw new BadRequestError88(`Invalid org ID: ${data.org}`);
+  }
+  try {
+    data.journalEntry = new ObjectId46(data.journalEntry);
+  } catch (error2) {
+    throw new BadRequestError88(`Invalid journal entry ID: ${data.journalEntry}`);
+  }
+  try {
+    data.account = new ObjectId46(data.account);
+  } catch (error2) {
+    throw new BadRequestError88(`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
+import {
+  AppError as AppError42,
+  BadRequestError as BadRequestError89,
+  useAtlas as useAtlas40,
+  useCache as useCache30,
+  makeCacheKey as makeCacheKey27,
+  paginate as paginate24,
+  logger as logger46,
+  InternalServerError as InternalServerError39
+} from "@goweekdays/utils";
+import { ObjectId as ObjectId47 } from "mongodb";
+import Joi79 from "joi";
+function useJournalLineRepo() {
+  const db = useAtlas40.getDb();
+  if (!db) {
+    throw new BadRequestError89("Unable to connect to server.");
+  }
+  const namespace_collection = "finance.journal.lines";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = useCache30(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      logger46.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger46.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) {
+      logger46.log({
+        level: "error",
+        message: error.message
+      });
+      throw new BadRequestError89(
+        `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 ObjectId47(options.org);
+    } catch (error) {
+      throw new BadRequestError89("Invalid organization ID.");
+    }
+    if (options.journalEntry) {
+      try {
+        query.journalEntry = new ObjectId47(options.journalEntry);
+      } catch (error) {
+        throw new BadRequestError89("Invalid journal entry ID.");
+      }
+    }
+    const cacheKey = makeCacheKey27(namespace_collection, {
+      org: String(options.org),
+      journalEntry: String(options.journalEntry ?? ""),
+      page: options.page,
+      limit: options.limit
+    });
+    logger46.log({
+      level: "info",
+      message: `Cache key for getAll journal lines: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger46.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 = paginate24(items, options.page, options.limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        logger46.log({
+          level: "info",
+          message: `Cache set for getAll journal lines: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger46.log({
+          level: "error",
+          message: `Failed to set cache for getAll journal lines: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      logger46.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId47(_id);
+    } catch (error) {
+      throw new BadRequestError89("Invalid ID.");
+    }
+    const cacheKey = makeCacheKey27(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger46.log({
+          level: "info",
+          message: `Cache hit for getById journal line: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({ _id });
+      if (!result) {
+        throw new BadRequestError89("Journal line not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        logger46.log({
+          level: "info",
+          message: `Cache set for journal line by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger46.log({
+          level: "error",
+          message: `Failed to set cache for journal line by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError42) {
+        throw error;
+      } else {
+        throw new InternalServerError39("Failed to get journal line.");
+      }
+    }
+  }
+  async function updateById(_id, options) {
+    const { error: errorId } = Joi79.string().hex().required().validate(String(_id));
+    if (errorId) {
+      throw new BadRequestError89("Invalid Journal Line ID.");
+    }
+    const { error } = schemaJournalLineRepo.validate(options);
+    if (error) {
+      throw new BadRequestError89(
+        `Invalid journal line update data: ${error.message}`
+      );
+    }
+    try {
+      _id = new ObjectId47(_id);
+    } catch (error2) {
+      throw new BadRequestError89("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 InternalServerError39("Failed to update journal line.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId47(_id);
+    } catch (error) {
+      throw new BadRequestError89("Invalid ID.");
+    }
+    try {
+      await collection.deleteOne({ _id }, { session });
+      delCachedData();
+      return "Successfully deleted journal line.";
+    } catch (error) {
+      throw new InternalServerError39("Failed to delete journal line.");
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/finance-journal/finance.journal.entry.service.ts
+import {
+  AppError as AppError43,
+  BadRequestError as BadRequestError90,
+  InternalServerError as InternalServerError40,
+  NotFoundError as NotFoundError6,
+  useAtlas as useAtlas41
+} from "@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 } = Joi80.object({
+      journalEntry: schemaJournalEntryCtrl.required(),
+      journalLines: Joi80.array().items(schemaJournalLineCtrl).min(1).required()
+    }).validate({ journalEntry: entry, journalLines: lines });
+    if (error) {
+      throw new BadRequestError90(`Invalid journal entry data: ${error.message}`);
+    }
+    const session = useAtlas41.getClient()?.startSession();
+    if (!session) {
+      throw new BadRequestError90("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 BadRequestError90(
+          `Total debit (${totalDebit}) must equal total credit (${totalCredit}).`
+        );
+      }
+      const user = await getUserById(entry.createdBy);
+      if (!user) {
+        throw new NotFoundError6("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 NotFoundError6(`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 AppError43) {
+        throw error2;
+      }
+      throw new InternalServerError40(
+        `Failed to create journal entry: ${error2.message}`
+      );
+    } finally {
+      session.endSession();
+    }
+  }
+  return {
+    add
+  };
+}
+
+// src/resources/finance-journal/finance.journal.entry.controller.ts
+import Joi81 from "joi";
+import { BadRequestError as BadRequestError91, logger as logger47 } from "@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 } = Joi81.object({
+      journalEntry: schemaJournalEntryCtrl.required(),
+      journalLines: Joi81.array().items(schemaJournalLineCtrl).min(1).required()
+    }).validate(value);
+    if (error) {
+      next(new BadRequestError91(error.message));
+      logger47.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 BadRequestError91("Invalid page number."));
+      return;
+    }
+    if (!isFinite(limit)) {
+      next(new BadRequestError91("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new BadRequestError91(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 = Joi81.object({
+      id: Joi81.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError91(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 } = Joi81.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new BadRequestError91("Invalid Journal Entry ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaJournalEntryCtrl.validate(payload);
+    if (error) {
+      next(
+        new BadRequestError91(
+          `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 BadRequestError91("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 = Joi81.object({
+      id: Joi81.string().hex().required(),
+      status: Joi81.string().required()
+    });
+    const { error } = validation.validate({ id, status: status2 });
+    if (error) {
+      next(new BadRequestError91(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
+import Joi82 from "joi";
+import { BadRequestError as BadRequestError92 } from "@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 = Joi82.object({
+      org: Joi82.string().hex().required(),
+      journalEntry: Joi82.string().hex().optional(),
+      page: Joi82.number().min(1).optional().allow("", null),
+      limit: Joi82.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 BadRequestError92("Invalid page number."));
+      return;
+    }
+    if (!isFinite(limit)) {
+      next(new BadRequestError92("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new BadRequestError92(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 = Joi82.object({
+      id: Joi82.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError92(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 } = Joi82.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new BadRequestError92("Invalid Journal Line ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaJournalLineCtrl.validate(payload);
+    if (error) {
+      next(
+        new BadRequestError92(
+          `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 BadRequestError92("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
+  };
+}
 export {
   ACCESS_TOKEN_EXPIRY,
   ACCESS_TOKEN_SECRET,
@@ -17087,12 +19449,17 @@ export {
   VERIFICATION_USER_INVITE_DURATION,
   XENDIT_BASE_URL,
   XENDIT_SECRET_KEY,
+  chartOfAccountNormalBalances,
+  chartOfAccountTypes,
   currencies,
   isDev,
   jobApplicationStatuses,
+  journalEntryStatuses,
+  journalEntryTypes,
   ledgerBillStatuses,
   ledgerBillTypes,
   modelApp,
+  modelChartOfAccount,
   modelJobApplication,
   modelJobPost,
   modelJobProfile,
@@ -17104,6 +19471,8 @@ export {
   modelJobStatusSetup,
   modelJobStatusTrans,
   modelJobSummary,
+  modelJournalEntry,
+  modelJournalLine,
   modelLedgerBill,
   modelMember,
   modelOption,
@@ -17115,6 +19484,7 @@ export {
   modelRole,
   modelSubscription,
   modelSubscriptionTransaction,
+  modelTax,
   modelUser,
   modelVerification,
   schemaApp,
@@ -17123,6 +19493,9 @@ export {
   schemaBuilding,
   schemaBuildingUnit,
   schemaCertification,
+  schemaChartOfAccountBase,
+  schemaChartOfAccountStd,
+  schemaChartOfAccountUpdate,
   schemaEducation,
   schemaGroup,
   schemaInviteMember,
@@ -17149,6 +19522,11 @@ export {
   schemaJobStatusTrans,
   schemaJobSummary,
   schemaJobSummaryInc,
+  schemaJournalEntryCtrl,
+  schemaJournalEntryGetAll,
+  schemaJournalEntryRepo,
+  schemaJournalLineCtrl,
+  schemaJournalLineRepo,
   schemaLanguage,
   schemaLedgerBill,
   schemaLedgerBillingSummary,
@@ -17179,11 +19557,14 @@ export {
   schemaSubscriptionSeats,
   schemaSubscriptionTransaction,
   schemaSubscriptionUpdate,
+  schemaTax,
+  schemaTaxUpdate,
   schemaUpdateOptions,
   schemaUser,
   schemaVerification,
   schemaVerificationOrgInvite,
   schemaWorkExp,
+  taxDirections,
   transactionSchema,
   useAppController,
   useAppRepo,
@@ -17196,6 +19577,8 @@ export {
   useBuildingUnitController,
   useBuildingUnitRepo,
   useBuildingUnitService,
+  useChartOfAccountController,
+  useChartOfAccountRepo,
   useCounterModel,
   useCounterRepo,
   useFileController,
@@ -17214,6 +19597,11 @@ export {
   useJobSummaryCtrl,
   useJobSummaryRepo,
   useJobSummarySvc,
+  useJournalEntryController,
+  useJournalEntryRepo,
+  useJournalEntryService,
+  useJournalLineController,
+  useJournalLineRepo,
   useLedgerBillingController,
   useLedgerBillingRepo,
   useMemberController,
@@ -17244,6 +19632,8 @@ export {
   useSubscriptionService,
   useSubscriptionTransactionController,
   useSubscriptionTransactionRepo,
+  useTaxController,
+  useTaxRepo,
   useUserController,
   useUserRepo,
   useUserService,