@goweekdays/core 2.15.6 → 2.15.8

package/dist/index.mjs

@@ -3465,6 +3465,11 @@ function useAppService() {
         name: "Finance",
         description: "Finance and billing services."
       },
+      {
+        code: "assets",
+        name: "Assets",
+        description: "Asset management and tracking."
+      },
       {
         code: "marketplace",
         name: "Marketplace",
@@ -22496,6 +22501,2567 @@ function useJournalLineController() {
     getById
   };
 }
+
+// src/resources/asset-item/asset.item.model.ts
+import { BadRequestError as BadRequestError108 } from "@goweekdays/utils";
+import Joi96 from "joi";
+import { ObjectId as ObjectId58 } from "mongodb";
+var assetItemCategories = [
+  "supply",
+  "tool",
+  "vehicle",
+  "facility",
+  "equipment"
+];
+var assetItemClasses = [
+  "consumable",
+  "semi_expendable",
+  "ppe"
+];
+var assetItemPurposes = ["internal", "for-sale", "for-rent"];
+var assetItemTrackingTypes = ["quantity", "individual"];
+var assetItemStatuses = ["active", "archived"];
+var schemaAssetItemBase = {
+  orgId: Joi96.string().hex().length(24).required(),
+  name: Joi96.string().required(),
+  sku: Joi96.string().optional().allow("", null).default(""),
+  price: Joi96.number().min(0).optional().allow("", null).default(0),
+  unit: Joi96.string().required(),
+  description: Joi96.string().optional().allow("", null),
+  assetCategory: Joi96.string().valid(...assetItemCategories).required(),
+  assetClass: Joi96.string().valid(...assetItemClasses).optional().allow("", null),
+  trackingType: Joi96.string().valid(...assetItemTrackingTypes).required(),
+  purpose: Joi96.string().valid(...assetItemPurposes).required(),
+  itemRefId: Joi96.string().hex().length(24).optional().allow("", null),
+  remarks: Joi96.string().optional().allow("", null),
+  departmentId: Joi96.string().hex().length(24).required(),
+  categoryId: Joi96.string().hex().length(24).optional().allow("", null),
+  subcategoryId: Joi96.string().hex().length(24).optional().allow("", null),
+  categoryPath: Joi96.string().optional().allow("", null),
+  brand: Joi96.string().optional().allow("", null),
+  tags: Joi96.array().items(
+    Joi96.object({
+      id: Joi96.string().required(),
+      name: Joi96.string().required()
+    })
+  ).optional().default([]),
+  quantityOnHand: Joi96.number().min(0).optional().default(0)
+};
+var schemaAssetItem = Joi96.object({
+  ...schemaAssetItemBase,
+  departmentName: Joi96.string().required(),
+  categoryName: Joi96.string().optional().allow("", null),
+  subcategoryName: Joi96.string().optional().allow("", null),
+  status: Joi96.string().valid(...assetItemStatuses).optional().allow("", null)
+});
+var schemaAssetItemCreate = Joi96.object({
+  ...schemaAssetItemBase,
+  tags: Joi96.array().items(
+    Joi96.object({
+      id: Joi96.string().required(),
+      name: Joi96.string().required()
+    })
+  ).optional().default([])
+}).custom((value, helpers) => {
+  if (value.subcategoryId && !value.categoryId) {
+    return helpers.error("any.custom", {
+      message: "categoryId is required when subcategoryId is provided."
+    });
+  }
+  return value;
+}, "subcategory-requires-category");
+var schemaAssetItemUpdate = Joi96.object({
+  name: Joi96.string().optional(),
+  description: Joi96.string().optional().allow("", null),
+  assetCategory: Joi96.string().valid(...assetItemCategories).optional(),
+  assetClass: Joi96.string().valid(...assetItemClasses).optional(),
+  brand: Joi96.string().optional().allow("", null),
+  sku: Joi96.string().optional().allow("", null),
+  price: Joi96.number().min(0).optional().allow("", null),
+  tags: Joi96.array().items(
+    Joi96.object({
+      id: Joi96.string().required(),
+      name: Joi96.string().required()
+    })
+  ).optional(),
+  quantityOnHand: Joi96.number().min(0).optional()
+});
+function modelAssetItem(data) {
+  const { error } = schemaAssetItem.validate(data);
+  if (error) {
+    throw new BadRequestError108(`Invalid asset item data: ${error.message}`);
+  }
+  try {
+    data.orgId = new ObjectId58(data.orgId);
+  } catch (error2) {
+    throw new BadRequestError108("Invalid orgId format.");
+  }
+  try {
+    data.departmentId = new ObjectId58(data.departmentId);
+  } catch (error2) {
+    throw new BadRequestError108("Invalid departmentId format.");
+  }
+  if (data.categoryId) {
+    try {
+      data.categoryId = new ObjectId58(data.categoryId);
+    } catch (error2) {
+      throw new BadRequestError108("Invalid categoryId format.");
+    }
+  }
+  if (data.subcategoryId) {
+    try {
+      data.subcategoryId = new ObjectId58(data.subcategoryId);
+    } catch (error2) {
+      throw new BadRequestError108("Invalid subcategoryId format.");
+    }
+  }
+  if (data.itemRefId) {
+    try {
+      data.itemRefId = new ObjectId58(data.itemRefId);
+    } catch (error2) {
+      throw new BadRequestError108("Invalid itemRefId format.");
+    }
+  }
+  if (data.purpose === "for-sale" && (data.price === void 0 || data.price === null || data.price === 0)) {
+    throw new BadRequestError108(
+      "Price must be greater than 0 for items marked as 'for-sale'."
+    );
+  }
+  if (data.isPublic && (data.marketplacePrice === void 0 || data.marketplacePrice === null)) {
+    throw new BadRequestError108(
+      "Marketplace price is required for items marked as public."
+    );
+  }
+  return {
+    _id: data._id,
+    orgId: data.orgId,
+    name: data.name,
+    description: data.description ?? "",
+    assetCategory: data.assetCategory,
+    assetClass: data.assetClass,
+    unit: data.unit ?? "",
+    price: data.price ?? 0,
+    marketplacePrice: data.marketplacePrice ?? 0,
+    isPublic: data.isPublic ?? false,
+    sku: data.sku ?? "",
+    brand: data.brand ?? "",
+    trackingType: data.trackingType,
+    purpose: data.purpose,
+    itemRefId: data.itemRefId ?? "",
+    remarks: data.remarks ?? "",
+    departmentId: data.departmentId,
+    departmentName: data.departmentName,
+    categoryId: data.categoryId ?? "",
+    categoryName: data.categoryName ?? "",
+    subcategoryId: data.subcategoryId ?? "",
+    subcategoryName: data.subcategoryName ?? "",
+    categoryPath: data.categoryPath ?? "",
+    tags: data.tags ?? [],
+    quantityOnHand: data.quantityOnHand ?? 0,
+    status: data.status ?? "active",
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? "",
+    deletedAt: data.deletedAt ?? ""
+  };
+}
+
+// src/resources/asset-item/asset.item.repository.ts
+import {
+  AppError as AppError51,
+  BadRequestError as BadRequestError109,
+  InternalServerError as InternalServerError47,
+  logger as logger54,
+  makeCacheKey as makeCacheKey33,
+  paginate as paginate29,
+  useRepo as useRepo32
+} from "@goweekdays/utils";
+import { ObjectId as ObjectId59 } from "mongodb";
+function useAssetItemRepo() {
+  const namespace_collection = "asset.items";
+  const repo = useRepo32(namespace_collection);
+  async function createIndexes() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { categoryPath: 1 } },
+        { key: { departmentId: 1 } },
+        { key: { categoryId: 1 } },
+        { key: { subcategoryId: 1 } },
+        { key: { brand: 1 } },
+        { key: { "tags.name": 1 } },
+        { key: { assetCategory: 1 } },
+        { key: { purpose: 1 } },
+        { key: { trackingType: 1 } },
+        { key: { status: 1 } },
+        { key: { name: "text" } }
+      ]);
+    } catch (error) {
+      throw new BadRequestError109("Failed to create asset item indexes.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelAssetItem(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      if (error instanceof AppError51) {
+        throw error;
+      }
+      logger54.log({ level: "error", message: error.message });
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new BadRequestError109("Asset item name already exists.");
+      }
+      throw new InternalServerError47("Failed to create asset item.");
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    status: status2 = "active",
+    assetCategory = "",
+    trackingType = "",
+    purpose = "",
+    departmentId = "",
+    categoryId = "",
+    subcategoryId = "",
+    brand = "",
+    tags = []
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { status: status2 };
+    if (search) {
+      query.$text = { $search: search };
+    }
+    if (assetCategory) {
+      query.assetCategory = assetCategory;
+    }
+    if (trackingType) {
+      query.trackingType = trackingType;
+    }
+    if (purpose) {
+      query.purpose = purpose;
+    }
+    if (departmentId) {
+      query.departmentId = departmentId;
+    }
+    if (categoryId) {
+      query.categoryId = categoryId;
+    }
+    if (subcategoryId) {
+      query.subcategoryId = subcategoryId;
+    }
+    if (brand) {
+      query.brand = brand;
+    }
+    if (tags.length > 0) {
+      query["tags.name"] = { $all: tags };
+    }
+    const cacheKey = makeCacheKey33(namespace_collection, {
+      search,
+      page,
+      limit,
+      status: status2,
+      assetCategory,
+      trackingType,
+      purpose,
+      departmentId,
+      categoryId,
+      subcategoryId,
+      brand,
+      tags: tags.join(","),
+      tag: "getAll"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached)
+        return cached;
+      const items = await repo.collection.aggregate([
+        { $match: query },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await repo.collection.countDocuments(query);
+      const data = paginate29(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600);
+      return data;
+    } catch (error) {
+      logger54.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(id) {
+    const cacheKey = makeCacheKey33(namespace_collection, {
+      id,
+      tag: "by-id"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached)
+        return cached;
+      const result = await repo.collection.findOne({
+        _id: new ObjectId59(id)
+      });
+      if (!result) {
+        throw new BadRequestError109("Asset item not found.");
+      }
+      repo.setCache(cacheKey, result, 300);
+      return result;
+    } catch (error) {
+      if (error instanceof AppError51)
+        throw error;
+      throw new InternalServerError47("Failed to get asset item.");
+    }
+  }
+  async function updateById(id, value) {
+    try {
+      const result = await repo.collection.findOneAndUpdate(
+        { _id: new ObjectId59(id) },
+        { $set: { ...value, updatedAt: /* @__PURE__ */ new Date() } },
+        { returnDocument: "after" }
+      );
+      if (!result) {
+        throw new BadRequestError109("Asset item not found.");
+      }
+      repo.delCachedData();
+      return result;
+    } catch (error) {
+      if (error instanceof AppError51)
+        throw error;
+      throw new InternalServerError47("Failed to update asset item.");
+    }
+  }
+  async function incrementQuantity(id, amount, session) {
+    try {
+      const result = await repo.collection.findOneAndUpdate(
+        { _id: new ObjectId59(id) },
+        {
+          $inc: { quantityOnHand: amount },
+          $set: { updatedAt: /* @__PURE__ */ new Date() }
+        },
+        { returnDocument: "after", session }
+      );
+      if (!result) {
+        throw new BadRequestError109("Asset item not found.");
+      }
+      repo.delCachedData();
+      return result;
+    } catch (error) {
+      if (error instanceof AppError51)
+        throw error;
+      throw new InternalServerError47("Failed to update asset item quantity.");
+    }
+  }
+  async function deleteById(id) {
+    try {
+      const result = await repo.collection.findOneAndUpdate(
+        { _id: new ObjectId59(id) },
+        { $set: { deletedAt: /* @__PURE__ */ new Date(), status: "archived" } },
+        { returnDocument: "after" }
+      );
+      if (!result) {
+        throw new BadRequestError109("Asset item not found.");
+      }
+      repo.delCachedData();
+      return result;
+    } catch (error) {
+      if (error instanceof AppError51)
+        throw error;
+      throw new InternalServerError47("Failed to delete asset item.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateById,
+    incrementQuantity,
+    deleteById
+  };
+}
+
+// src/resources/asset-item/asset.item.service.ts
+import {
+  AppError as AppError54,
+  InternalServerError as InternalServerError50,
+  useAtlas as useAtlas17
+} from "@goweekdays/utils";
+
+// src/resources/tag/tag.repository.ts
+import {
+  AppError as AppError52,
+  BadRequestError as BadRequestError110,
+  useRepo as useRepo33,
+  makeCacheKey as makeCacheKey34,
+  paginate as paginate30,
+  logger as logger55,
+  InternalServerError as InternalServerError48
+} from "@goweekdays/utils";
+
+// src/resources/tag/tag.model.ts
+import Joi97 from "joi";
+import { ObjectId as ObjectId60 } from "mongodb";
+var schemaTagFields = {
+  name: Joi97.string().required(),
+  type: Joi97.string().valid("public", "private").required(),
+  orgId: Joi97.string().hex().optional().allow("", null),
+  categoryPath: Joi97.string().optional().allow("", null),
+  status: Joi97.string().valid("active", "pending").optional()
+};
+var schemaTagCreate = Joi97.object(schemaTagFields);
+var schemaTagStd = Joi97.object({
+  ...schemaTagFields,
+  normalizedName: Joi97.string().required(),
+  usageCount: Joi97.number().integer().min(0).optional()
+});
+var schemaTagUpdate = Joi97.object({
+  name: Joi97.string().optional(),
+  type: Joi97.string().valid("public", "private").optional(),
+  orgId: Joi97.string().hex().optional().allow("", null),
+  categoryPath: Joi97.string().optional().allow("", null),
+  status: Joi97.string().valid("active", "pending").optional()
+}).min(1);
+function modelTag(data) {
+  const { error } = schemaTagStd.validate(data, { allowUnknown: false });
+  if (error) {
+    throw new Error(`Invalid tag data: ${error.message}`);
+  }
+  if (data.orgId) {
+    try {
+      data.orgId = new ObjectId60(data.orgId);
+    } catch (error2) {
+      throw new Error(`Invalid orgId: ${data.orgId}`);
+    }
+  }
+  return {
+    _id: data._id,
+    name: data.name,
+    normalizedName: data.normalizedName,
+    type: data.type,
+    orgId: data.orgId ?? "",
+    categoryPath: data.categoryPath ?? "",
+    status: data.status ?? "pending",
+    usageCount: data.usageCount ?? 0,
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/tag/tag.repository.ts
+import { ObjectId as ObjectId61 } from "mongodb";
+import Joi98 from "joi";
+function useTagRepo() {
+  const namespace_collection = "tags";
+  const repo = useRepo33(namespace_collection);
+  async function createIndexes() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { name: 1 } },
+        { key: { normalizedName: 1 } },
+        { key: { type: 1 } },
+        { key: { orgId: 1 } },
+        { key: { status: 1 } },
+        { key: { categoryPath: 1 } },
+        {
+          key: { normalizedName: 1, orgId: 1 },
+          unique: true,
+          name: "unique_normalized_name_per_org"
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on tags.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelTag(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      logger55.log({
+        level: "error",
+        message: error.message
+      });
+      const isDuplicate = /normalizedName|unique/i.test(error.message);
+      if (isDuplicate) {
+        throw new BadRequestError110("A tag with this name already exists.");
+      }
+      throw new BadRequestError110(`Failed to create tag: ${error.message}`);
+    }
+  }
+  async function getAll(options) {
+    const validation = Joi98.object({
+      page: Joi98.number().min(1).optional().allow("", null),
+      limit: Joi98.number().min(1).optional().allow("", null),
+      search: Joi98.string().optional().allow("", null),
+      type: Joi98.string().valid("public", "private").optional().allow("", null),
+      orgId: Joi98.string().hex().optional().allow("", null),
+      status: Joi98.string().valid("active", "pending").optional().allow("", null),
+      categoryPath: Joi98.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(options);
+    if (error) {
+      throw new BadRequestError110(error.message);
+    }
+    options.page = options.page && options.page > 0 ? options.page - 1 : 0;
+    options.limit = options.limit ?? 10;
+    const query = {};
+    const cacheKeyOptions = {
+      limit: options.limit,
+      page: options.page
+    };
+    if (options.search) {
+      query.name = { $regex: options.search, $options: "i" };
+      cacheKeyOptions.search = options.search;
+    }
+    if (options.type) {
+      query.type = options.type;
+      cacheKeyOptions.type = options.type;
+    }
+    if (options.orgId) {
+      query.orgId = new ObjectId61(options.orgId);
+      cacheKeyOptions.orgId = options.orgId;
+    }
+    if (options.status) {
+      query.status = options.status;
+      cacheKeyOptions.status = options.status;
+    }
+    if (options.categoryPath) {
+      query.categoryPath = options.categoryPath;
+      cacheKeyOptions.categoryPath = options.categoryPath;
+    }
+    const cacheKey = makeCacheKey34(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      const items = await repo.collection.aggregate([
+        { $match: query },
+        { $sort: { name: 1 } },
+        { $skip: options.page * options.limit },
+        { $limit: options.limit },
+        {
+          $project: {
+            _id: 1,
+            name: 1,
+            normalizedName: 1,
+            type: 1,
+            orgId: 1,
+            categoryPath: 1,
+            status: 1,
+            usageCount: 1
+          }
+        }
+      ]).toArray();
+      const length = await repo.collection.countDocuments(query);
+      const data = paginate30(items, options.page, options.limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        logger55.log({
+          level: "info",
+          message: `Cache set for getAll tags: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger55.log({
+          level: "error",
+          message: `Failed to set cache for getAll tags: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      logger55.log({ level: "error", message: `${error2}` });
+      throw error2;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId61(_id);
+    } catch (error) {
+      throw new BadRequestError110("Invalid ID.");
+    }
+    const cacheKey = makeCacheKey34(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      const result = await repo.collection.findOne({ _id });
+      if (!result) {
+        throw new BadRequestError110("Tag not found.");
+      }
+      repo.setCache(cacheKey, result, 300).then(() => {
+        logger55.log({
+          level: "info",
+          message: `Cache set for tag by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger55.log({
+          level: "error",
+          message: `Failed to set cache for tag by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError52) {
+        throw error;
+      } else {
+        throw new InternalServerError48("Failed to get tag.");
+      }
+    }
+  }
+  async function updateById(_id, options, session) {
+    try {
+      _id = new ObjectId61(_id);
+    } catch (error) {
+      throw new BadRequestError110("Invalid Tag ID.");
+    }
+    try {
+      await repo.collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      repo.delCachedData();
+      return "Successfully updated tag.";
+    } catch (error) {
+      const isDuplicate = /normalizedName|unique/i.test(error.message);
+      if (isDuplicate) {
+        throw new BadRequestError110("A tag with this name already exists.");
+      }
+      throw new InternalServerError48("Failed to update tag.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId61(_id);
+    } catch (error) {
+      throw new BadRequestError110("Invalid ID.");
+    }
+    try {
+      await repo.collection.deleteOne({ _id }, { session });
+      repo.delCachedData();
+      return "Successfully deleted tag.";
+    } catch (error) {
+      throw new InternalServerError48("Failed to delete tag.");
+    }
+  }
+  async function findByNormalizedNameAndOrg(normalizedName, orgId) {
+    try {
+      const query = { normalizedName };
+      query.orgId = new ObjectId61(orgId);
+      return await repo.collection.findOne(query);
+    } catch (error) {
+      if (error instanceof AppError52)
+        throw error;
+      throw new InternalServerError48("Failed to find tag.");
+    }
+  }
+  async function incrementUsageCount(_id, amount = 1, session) {
+    try {
+      _id = new ObjectId61(_id);
+    } catch (error) {
+      throw new BadRequestError110("Invalid ID.");
+    }
+    try {
+      await repo.collection.updateOne(
+        { _id },
+        { $inc: { usageCount: amount } },
+        { session }
+      );
+      repo.delCachedData();
+    } catch (error) {
+      throw new InternalServerError48("Failed to update tag usage count.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    findByNormalizedNameAndOrg,
+    updateById,
+    deleteById,
+    incrementUsageCount
+  };
+}
+
+// src/resources/asset-item-category/category.repository.ts
+import {
+  AppError as AppError53,
+  BadRequestError as BadRequestError112,
+  InternalServerError as InternalServerError49,
+  logger as logger56,
+  makeCacheKey as makeCacheKey35,
+  paginate as paginate31,
+  useRepo as useRepo34
+} from "@goweekdays/utils";
+
+// src/resources/asset-item-category/category.model.ts
+import Joi99 from "joi";
+import { ObjectId as ObjectId62 } from "mongodb";
+import { BadRequestError as BadRequestError111 } from "@goweekdays/utils";
+var categoryLevels = [
+  "department",
+  "category",
+  "subcategory"
+];
+var schemaCategoryNodeFields = {
+  orgId: Joi99.string().hex().length(24).optional().allow("", null),
+  level: Joi99.string().valid(...categoryLevels).required(),
+  type: Joi99.string().valid("public", "private").optional().default("public"),
+  name: Joi99.string().required(),
+  displayName: Joi99.string().required(),
+  parentId: Joi99.string().hex().length(24).optional().allow("", null),
+  path: Joi99.string().optional().allow("", null),
+  isActive: Joi99.boolean().optional().default(true)
+};
+var schemaCategoryNodeCreate = Joi99.object({
+  displayName: Joi99.string().required(),
+  parentId: Joi99.string().hex().length(24).optional().allow("", null),
+  orgId: Joi99.string().hex().length(24).optional().allow("", null)
+});
+var schemaCategoryNodeUpdate = Joi99.object({
+  displayName: Joi99.string().optional()
+});
+var schemaCategoryNodeStd = Joi99.object(schemaCategoryNodeFields);
+var schemaCategoryGetAll = Joi99.object({
+  page: Joi99.number().integer().min(1).default(1),
+  limit: Joi99.number().integer().min(1).max(100).default(20),
+  org: Joi99.string().hex().length(24).optional().allow("", null).default(""),
+  parent: Joi99.string().hex().length(24).optional().allow("", null).default(""),
+  level: Joi99.string().valid(...categoryLevels, "").optional().default(""),
+  type: Joi99.string().valid("public", "private", "").optional().default(""),
+  search: Joi99.string().optional().allow("", null).default(""),
+  status: Joi99.string().optional().allow("", null).default("active")
+});
+function normalizeName(displayName) {
+  return displayName.trim().toLowerCase().replace(/\s+/g, "_");
+}
+function buildCategoryPath(departmentName, categoryName, subcategoryName) {
+  return [departmentName, categoryName, subcategoryName].filter(Boolean).join(".").replace(/ /g, "_").toLowerCase();
+}
+function modelCategoryNode(data) {
+  const { error } = schemaCategoryNodeStd.validate(data);
+  if (error) {
+    throw new BadRequestError111(`Invalid category node data: ${error.message}`);
+  }
+  if (data.orgId) {
+    try {
+      data.orgId = new ObjectId62(data.orgId);
+    } catch {
+      throw new BadRequestError111(`Invalid orgId: ${data.orgId}`);
+    }
+  }
+  if (data.parentId) {
+    try {
+      data.parentId = new ObjectId62(data.parentId);
+    } catch {
+      throw new BadRequestError111(`Invalid parentId: ${data.parentId}`);
+    }
+  }
+  return {
+    _id: data._id,
+    orgId: data.orgId ?? "",
+    level: data.level,
+    type: data.type ?? "public",
+    name: data.name,
+    displayName: data.displayName,
+    parentId: data.parentId ?? "",
+    path: data.path ?? "",
+    status: data.status ?? "active",
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/asset-item-category/category.repository.ts
+import { ObjectId as ObjectId63 } from "mongodb";
+function useCategoryRepo() {
+  const namespace_collection = "categories";
+  const repo = useRepo34(namespace_collection);
+  async function createIndexes() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { level: 1 } },
+        { key: { parentId: 1 } },
+        {
+          key: { name: "text" },
+          name: "text_name"
+        },
+        {
+          key: { name: 1, parentId: 1 },
+          unique: true,
+          name: "unique_name_per_parent"
+        },
+        { key: { path: 1 } },
+        { key: { isActive: 1 } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError49("Failed to create category indexes.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelCategoryNode(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      logger56.log({ level: "error", message: error.message });
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new BadRequestError112(
+          "Category name already exists under this parent."
+        );
+      }
+      throw new InternalServerError49("Failed to create category node.");
+    }
+  }
+  async function getAll({
+    page = 1,
+    limit = 20,
+    org = "",
+    parent = "",
+    level = "",
+    type = "",
+    search = "",
+    status: status2 = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { status: status2 };
+    if (org) {
+      try {
+        query.orgId = new ObjectId63(org);
+      } catch (error) {
+        throw new BadRequestError112("Invalid org ID.");
+      }
+    }
+    if (level) {
+      query.level = level;
+    }
+    if (type) {
+      query.type = type;
+    }
+    if (parent) {
+      try {
+        query.parentId = new ObjectId63(parent);
+      } catch (error) {
+        throw new BadRequestError112("Invalid parentId.");
+      }
+    }
+    const cacheKeyOptions = {
+      page,
+      limit,
+      org,
+      parent,
+      level,
+      type,
+      status: status2,
+      tag: "all"
+    };
+    if (search) {
+      query.$text = { $search: `"${search}"` };
+      cacheKeyOptions.search = search;
+    }
+    const cacheKey = makeCacheKey35(namespace_collection, cacheKeyOptions);
+    logger56.log({
+      level: "info",
+      message: `Cache key for getAll categories: ${cacheKey}`
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger56.log({
+          level: "info",
+          message: `Cache hit for getAll categories: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await repo.collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await repo.collection.countDocuments(query);
+      const data = paginate31(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        logger56.log({
+          level: "info",
+          message: `Cache set for getAll categories: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger56.log({
+          level: "error",
+          message: `Failed to set cache for getAll categories: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      logger56.log({ level: "error", message: `${error}` });
+      throw new InternalServerError49("Failed to get categories.");
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId63(_id);
+    } catch {
+      throw new BadRequestError112("Invalid category ID.");
+    }
+    const cacheKey = makeCacheKey35(namespace_collection, {
+      _id: String(_id),
+      tag: "by-id"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached)
+        return cached;
+      const result = await repo.collection.findOne({ _id });
+      if (!result) {
+        throw new BadRequestError112("Category node not found.");
+      }
+      repo.setCache(cacheKey, result, 300).catch((err) => {
+        logger56.log({
+          level: "error",
+          message: `Failed to set cache for category by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError53)
+        throw error;
+      throw new InternalServerError49("Failed to get category node.");
+    }
+  }
+  async function getByNameParent(name, { parentId = "", orgId = "" } = {}) {
+    const query = {
+      $text: { $search: `"${name.trim()}"` }
+    };
+    if (parentId) {
+      try {
+        query.parentId = new ObjectId63(parentId);
+      } catch (error) {
+        throw new BadRequestError112("Invalid parentId.");
+      }
+    }
+    if (orgId) {
+      try {
+        query.orgId = new ObjectId63(orgId);
+      } catch (error) {
+        throw new BadRequestError112("Invalid orgId.");
+      }
+    }
+    try {
+      const cacheKey = makeCacheKey35(namespace_collection, {
+        name,
+        parentId: parentId ?? "null",
+        orgId: orgId ?? "null",
+        tag: "by-name-parent"
+      });
+      logger56.log({
+        level: "info",
+        message: `Cache key for getByNameParentId: ${cacheKey}`
+      });
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        logger56.log({
+          level: "info",
+          message: `Cache hit for getByNameParentId: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await repo.collection.findOne(query);
+      if (result) {
+        repo.setCache(cacheKey, result, 300).catch((err) => {
+          logger56.log({
+            level: "error",
+            message: `Failed to set cache for category by name and parentId: ${err.message}`
+          });
+        });
+      }
+      return result;
+    } catch (error) {
+      console.log(error);
+      throw new InternalServerError49("Failed to get category node by name.");
+    }
+  }
+  async function updateById(_id, update, session) {
+    try {
+      _id = new ObjectId63(_id);
+    } catch {
+      throw new BadRequestError112("Invalid category ID.");
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: update },
+        { session }
+      );
+      if (res.matchedCount === 0) {
+        throw new BadRequestError112("Category node not found.");
+      }
+      repo.delCachedData();
+    } catch (error) {
+      if (error instanceof AppError53)
+        throw error;
+      logger56.log({ level: "error", message: error.message });
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new BadRequestError112(
+          "Category name already exists under this parent."
+        );
+      }
+      throw new InternalServerError49("Failed to update category node.");
+    }
+  }
+  async function hasChildren(_id) {
+    try {
+      _id = new ObjectId63(_id);
+    } catch {
+      throw new BadRequestError112("Invalid category ID.");
+    }
+    try {
+      const count = await repo.collection.countDocuments({ parentId: _id });
+      return count > 0;
+    } catch (error) {
+      throw new InternalServerError49("Failed to check for child categories.");
+    }
+  }
+  async function softDeleteById(_id, session) {
+    try {
+      _id = new ObjectId63(_id);
+    } catch {
+      throw new BadRequestError112("Invalid category ID.");
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      if (res.matchedCount === 0) {
+        throw new BadRequestError112("Category node not found.");
+      }
+      repo.delCachedData();
+    } catch (error) {
+      if (error instanceof AppError53)
+        throw error;
+      throw new InternalServerError49("Failed to delete category node.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getByNameParent,
+    updateById,
+    hasChildren,
+    softDeleteById
+  };
+}
+
+// src/resources/asset-item/asset.item.service.ts
+function normalizeTagName(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function useAssetItemService() {
+  const assetItemRepo = useAssetItemRepo();
+  const tagRepo = useTagRepo();
+  const categoryRepo = useCategoryRepo();
+  async function resolveTags(tagNames, orgId, categoryPath, session) {
+    const resolvedTags = [];
+    for (const tag of tagNames) {
+      const normalizedName = normalizeTagName(tag.name);
+      const existing = await tagRepo.findByNormalizedNameAndOrg(
+        normalizedName,
+        orgId
+      );
+      if (existing && existing._id) {
+        await tagRepo.incrementUsageCount(existing._id, 1, session);
+        resolvedTags.push({
+          id: String(existing._id),
+          name: existing.name
+        });
+      } else {
+        const tagData = {
+          name: tag.name.trim(),
+          normalizedName,
+          type: "private",
+          orgId,
+          categoryPath,
+          status: "active",
+          usageCount: 1
+        };
+        const tagId = await tagRepo.add(tagData, session);
+        resolvedTags.push({
+          id: String(tagId),
+          name: tag.name.trim()
+        });
+      }
+    }
+    return resolvedTags;
+  }
+  async function add(value) {
+    const session = useAtlas17.getClient()?.startSession();
+    if (!session) {
+      throw new InternalServerError50(
+        "Unable to start session for asset item service."
+      );
+    }
+    try {
+      await session.startTransaction();
+      const department = await categoryRepo.getById(value.departmentId);
+      value.departmentName = department.displayName;
+      if (value.categoryId) {
+        const category = await categoryRepo.getById(value.categoryId);
+        value.categoryName = category.displayName;
+      }
+      if (value.subcategoryId) {
+        const subcategory = await categoryRepo.getById(value.subcategoryId);
+        value.subcategoryName = subcategory.displayName;
+      }
+      const categoryPath = buildCategoryPath(
+        value.departmentName,
+        value.categoryName ?? "",
+        value.subcategoryName ?? ""
+      );
+      value.categoryPath = categoryPath;
+      const resolvedTags = value.tags.length ? await resolveTags(
+        value.tags,
+        value.orgId,
+        value.categoryPath,
+        session
+      ) : [];
+      const assetItem = {
+        ...value,
+        tags: resolvedTags
+      };
+      const assetItemId = await assetItemRepo.add(assetItem, session);
+      await session.commitTransaction();
+      return assetItemId;
+    } catch (error) {
+      await session.abortTransaction();
+      if (error instanceof AppError54)
+        throw error;
+      throw new InternalServerError50("Failed to create asset item.");
+    } finally {
+      session.endSession();
+    }
+  }
+  return {
+    add
+  };
+}
+
+// src/resources/asset-item/asset.item.controller.ts
+import Joi100 from "joi";
+import { BadRequestError as BadRequestError114 } from "@goweekdays/utils";
+var paginationSchema3 = Joi100.object({
+  page: Joi100.number().min(1).optional().allow("", null),
+  limit: Joi100.number().min(1).optional().allow("", null),
+  search: Joi100.string().optional().allow("", null),
+  status: Joi100.string().valid(...assetItemStatuses).optional().allow("", null),
+  assetCategory: Joi100.string().valid(...assetItemCategories).optional().allow("", null),
+  trackingType: Joi100.string().valid(...assetItemTrackingTypes).optional().allow("", null),
+  purpose: Joi100.string().valid(...assetItemPurposes).optional().allow("", null),
+  departmentId: Joi100.string().optional().allow("", null),
+  categoryId: Joi100.string().optional().allow("", null),
+  subcategoryId: Joi100.string().optional().allow("", null),
+  brand: Joi100.string().optional().allow("", null),
+  tags: Joi100.string().optional().allow("", null)
+});
+var idParamSchema2 = Joi100.object({
+  id: Joi100.string().hex().length(24).required()
+});
+function useAssetItemController() {
+  const repo = useAssetItemRepo();
+  const service = useAssetItemService();
+  async function add(req, res, next) {
+    try {
+      const { error, value } = schemaAssetItemCreate.validate(req.body);
+      if (error) {
+        next(new BadRequestError114(error.message));
+        return;
+      }
+      const assetItemId = await service.add(value);
+      res.status(201).json({
+        message: "Asset item created successfully.",
+        assetItemId
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function getAll(req, res, next) {
+    const { error } = paginationSchema3.validate(req.query);
+    if (error) {
+      next(new BadRequestError114(error.message));
+      return;
+    }
+    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 assetCategory = req.query.assetCategory ?? "";
+    const trackingType = req.query.trackingType ?? "";
+    const purpose = req.query.purpose ?? "";
+    const departmentId = req.query.departmentId ?? "";
+    const categoryId = req.query.categoryId ?? "";
+    const subcategoryId = req.query.subcategoryId ?? "";
+    const brand = req.query.brand ?? "";
+    const tagsParam = req.query.tags ?? "";
+    const tags = tagsParam ? tagsParam.split(",").filter(Boolean) : [];
+    if (!isFinite(page)) {
+      next(new BadRequestError114("Invalid page number."));
+      return;
+    }
+    if (!isFinite(limit)) {
+      next(new BadRequestError114("Invalid limit number."));
+      return;
+    }
+    try {
+      const results = await repo.getAll({
+        page,
+        limit,
+        search,
+        status: status2,
+        assetCategory,
+        trackingType,
+        purpose,
+        departmentId,
+        categoryId,
+        subcategoryId,
+        brand,
+        tags
+      });
+      res.json(results);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const { error } = idParamSchema2.validate(req.params);
+    if (error) {
+      next(new BadRequestError114(error.message));
+      return;
+    }
+    try {
+      const assetItem = await repo.getById(req.params.id);
+      res.json(assetItem);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const { error: paramError } = idParamSchema2.validate(req.params);
+    if (paramError) {
+      next(new BadRequestError114(paramError.message));
+      return;
+    }
+    const { error: bodyError } = schemaAssetItemUpdate.validate(req.body);
+    if (bodyError) {
+      next(new BadRequestError114(bodyError.message));
+      return;
+    }
+    try {
+      const updatedAssetItem = await repo.updateById(req.params.id, req.body);
+      res.json({
+        message: "Asset item updated successfully.",
+        assetItem: updatedAssetItem
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const { error } = idParamSchema2.validate(req.params);
+    if (error) {
+      next(new BadRequestError114(error.message));
+      return;
+    }
+    try {
+      await repo.deleteById(req.params.id);
+      res.json({
+        message: "Asset item deleted successfully."
+      });
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/asset-item-unit/asset.unit.model.ts
+import Joi101 from "joi";
+import { ObjectId as ObjectId64 } from "mongodb";
+var assetUnitStatuses = [
+  "available",
+  "assigned",
+  "maintenance",
+  "disposed"
+];
+var schemaAssetUnitBase = {
+  itemId: Joi101.string().hex().length(24).required(),
+  serialNumber: Joi101.string().optional().allow("", null),
+  plateNumber: Joi101.string().optional().allow("", null),
+  status: Joi101.string().valid(...assetUnitStatuses).required(),
+  locationId: Joi101.string().optional().allow("", null),
+  assignedTo: Joi101.string().optional().allow("", null)
+};
+var schemaAssetUnit = Joi101.object(schemaAssetUnitBase);
+var schemaAssetUnitUpdate = Joi101.object({
+  serialNumber: Joi101.string().optional().allow("", null),
+  plateNumber: Joi101.string().optional().allow("", null),
+  status: Joi101.string().valid(...assetUnitStatuses).optional(),
+  locationId: Joi101.string().optional().allow("", null),
+  assignedTo: Joi101.string().optional().allow("", null)
+});
+function modelAssetUnit(data) {
+  const { error } = schemaAssetUnit.validate(data);
+  if (error) {
+    throw new Error(`Invalid asset unit data: ${error.message}`);
+  }
+  if (data.itemId && typeof data.itemId === "string") {
+    try {
+      data.itemId = new ObjectId64(data.itemId);
+    } catch {
+      throw new Error(`Invalid itemId format: ${data.itemId}`);
+    }
+  }
+  return {
+    _id: data._id,
+    itemId: data.itemId,
+    serialNumber: data.serialNumber ?? "",
+    plateNumber: data.plateNumber ?? "",
+    status: data.status,
+    locationId: data.locationId ?? "",
+    assignedTo: data.assignedTo ?? "",
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ?? ""
+  };
+}
+
+// src/resources/asset-item-unit/asset.unit.repository.ts
+import {
+  AppError as AppError55,
+  BadRequestError as BadRequestError115,
+  InternalServerError as InternalServerError51,
+  logger as logger57,
+  makeCacheKey as makeCacheKey36,
+  paginate as paginate32,
+  useRepo as useRepo35
+} from "@goweekdays/utils";
+import { ObjectId as ObjectId65 } from "mongodb";
+function useAssetUnitRepo() {
+  const namespace_collection = "asset.units";
+  const repo = useRepo35(namespace_collection);
+  async function createIndexes() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { itemId: 1 } },
+        { key: { status: 1 } },
+        { key: { locationId: 1 } },
+        { key: { itemId: 1, status: 1 } }
+      ]);
+    } catch (error) {
+      throw new BadRequestError115("Failed to create asset unit indexes.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelAssetUnit(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      logger57.log({ level: "error", message: error.message });
+      throw new InternalServerError51("Failed to create asset unit.");
+    }
+  }
+  async function getByItemId({
+    itemId,
+    status: status2 = "",
+    page = 1,
+    limit = 10
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      itemId: new ObjectId65(itemId)
+    };
+    if (status2) {
+      query.status = status2;
+    }
+    const cacheKey = makeCacheKey36(namespace_collection, {
+      itemId,
+      status: status2,
+      page,
+      limit,
+      tag: "byItemId"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached)
+        return cached;
+      const items = await repo.collection.aggregate([
+        { $match: query },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await repo.collection.countDocuments(query);
+      const data = paginate32(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600);
+      return data;
+    } catch (error) {
+      logger57.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(id) {
+    const cacheKey = makeCacheKey36(namespace_collection, {
+      id,
+      tag: "by-id"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached)
+        return cached;
+      const result = await repo.collection.findOne({
+        _id: new ObjectId65(id)
+      });
+      if (!result) {
+        throw new BadRequestError115("Asset unit not found.");
+      }
+      repo.setCache(cacheKey, result, 300);
+      return result;
+    } catch (error) {
+      if (error instanceof AppError55)
+        throw error;
+      throw new InternalServerError51("Failed to get asset unit.");
+    }
+  }
+  async function updateById(id, value, session) {
+    try {
+      const result = await repo.collection.findOneAndUpdate(
+        { _id: new ObjectId65(id) },
+        { $set: { ...value, updatedAt: /* @__PURE__ */ new Date() } },
+        { returnDocument: "after", session }
+      );
+      if (!result) {
+        throw new BadRequestError115("Asset unit not found.");
+      }
+      repo.delCachedData();
+      return result;
+    } catch (error) {
+      if (error instanceof AppError55)
+        throw error;
+      throw new InternalServerError51("Failed to update asset unit.");
+    }
+  }
+  async function countByItemIdAndStatus(itemId, status2) {
+    try {
+      return await repo.collection.countDocuments({
+        itemId: new ObjectId65(itemId),
+        status: status2
+      });
+    } catch (error) {
+      throw new InternalServerError51("Failed to count asset units.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getByItemId,
+    getById,
+    updateById,
+    countByItemIdAndStatus
+  };
+}
+
+// src/resources/asset-item-unit/asset.unit.controller.ts
+import Joi102 from "joi";
+import { BadRequestError as BadRequestError116 } from "@goweekdays/utils";
+var querySchema = Joi102.object({
+  itemId: Joi102.string().hex().length(24).required(),
+  status: Joi102.string().valid(...assetUnitStatuses).optional().allow("", null),
+  page: Joi102.number().min(1).optional().allow("", null),
+  limit: Joi102.number().min(1).optional().allow("", null)
+});
+var idParamSchema3 = Joi102.object({
+  id: Joi102.string().hex().length(24).required()
+});
+function useAssetUnitController() {
+  const repo = useAssetUnitRepo();
+  async function add(req, res, next) {
+    try {
+      const { error } = schemaAssetUnit.validate(req.body);
+      if (error) {
+        next(new BadRequestError116(error.message));
+        return;
+      }
+      const unitId = await repo.add(req.body);
+      res.status(201).json({
+        message: "Asset unit created successfully.",
+        unitId
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function getByItemId(req, res, next) {
+    const { error } = querySchema.validate(req.query);
+    if (error) {
+      next(new BadRequestError116(error.message));
+      return;
+    }
+    const itemId = req.query.itemId;
+    const status2 = req.query.status ?? "";
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    try {
+      const results = await repo.getByItemId({ itemId, status: status2, page, limit });
+      res.json(results);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const { error } = idParamSchema3.validate(req.params);
+    if (error) {
+      next(new BadRequestError116(error.message));
+      return;
+    }
+    try {
+      const unit = await repo.getById(req.params.id);
+      res.json(unit);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const { error: paramError } = idParamSchema3.validate(req.params);
+    if (paramError) {
+      next(new BadRequestError116(paramError.message));
+      return;
+    }
+    const { error: bodyError } = schemaAssetUnitUpdate.validate(req.body);
+    if (bodyError) {
+      next(new BadRequestError116(bodyError.message));
+      return;
+    }
+    try {
+      const updatedUnit = await repo.updateById(req.params.id, req.body);
+      res.json({
+        message: "Asset unit updated successfully.",
+        unit: updatedUnit
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  return {
+    add,
+    getByItemId,
+    getById,
+    updateById
+  };
+}
+
+// src/resources/asset-item-movement/stock.movement.model.ts
+import Joi103 from "joi";
+import { ObjectId as ObjectId66 } from "mongodb";
+var stockMovementTypes = [
+  "in",
+  "out",
+  "transfer",
+  "adjustment",
+  "conversion"
+];
+var stockMovementReferenceTypes = [
+  "purchase",
+  "sale",
+  "transfer",
+  "manual",
+  "conversion"
+];
+var schemaStockMovement = Joi103.object({
+  itemId: Joi103.string().hex().length(24).required(),
+  type: Joi103.string().valid(...stockMovementTypes).required(),
+  quantity: Joi103.number().positive().required(),
+  unitCost: Joi103.number().min(0).optional().allow(null),
+  totalCost: Joi103.number().min(0).optional().allow(null),
+  reference: Joi103.object({
+    type: Joi103.string().valid(...stockMovementReferenceTypes).required(),
+    id: Joi103.string().optional().allow("", null)
+  }).optional().allow(null),
+  fromLocationId: Joi103.string().optional().allow("", null),
+  toLocationId: Joi103.string().optional().allow("", null),
+  fromItemId: Joi103.string().hex().length(24).optional().allow("", null),
+  toItemId: Joi103.string().hex().length(24).optional().allow("", null),
+  reason: Joi103.string().optional().allow("", null)
+});
+function modelStockMovement(data) {
+  const { error } = schemaStockMovement.validate(data);
+  if (error) {
+    throw new Error(`Invalid stock movement data: ${error.message}`);
+  }
+  if (data.itemId && typeof data.itemId === "string") {
+    try {
+      data.itemId = new ObjectId66(data.itemId);
+    } catch {
+      throw new Error(`Invalid itemId format: ${data.itemId}`);
+    }
+  }
+  return {
+    _id: data._id,
+    itemId: data.itemId,
+    type: data.type,
+    quantity: data.quantity,
+    unitCost: data.unitCost ?? 0,
+    totalCost: data.totalCost ?? 0,
+    reference: data.reference ?? void 0,
+    fromLocationId: data.fromLocationId ?? "",
+    toLocationId: data.toLocationId ?? "",
+    fromItemId: data.fromItemId ?? "",
+    toItemId: data.toItemId ?? "",
+    reason: data.reason ?? "",
+    createdAt: data.createdAt ?? /* @__PURE__ */ new Date()
+  };
+}
+
+// src/resources/asset-item-movement/stock.movement.repository.ts
+import {
+  AppError as AppError56,
+  BadRequestError as BadRequestError117,
+  InternalServerError as InternalServerError52,
+  logger as logger58,
+  makeCacheKey as makeCacheKey37,
+  paginate as paginate33,
+  useRepo as useRepo36
+} from "@goweekdays/utils";
+import { ObjectId as ObjectId67 } from "mongodb";
+function useStockMovementRepo() {
+  const namespace_collection = "stock.movements";
+  const repo = useRepo36(namespace_collection);
+  async function createIndexes() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { itemId: 1 } },
+        { key: { createdAt: -1 } },
+        { key: { itemId: 1, createdAt: -1 } },
+        { key: { type: 1 } }
+      ]);
+    } catch (error) {
+      throw new BadRequestError117("Failed to create stock movement indexes.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelStockMovement(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      logger58.log({ level: "error", message: error.message });
+      throw new InternalServerError52("Failed to create stock movement.");
+    }
+  }
+  async function getByItemId({
+    itemId,
+    type = "",
+    page = 1,
+    limit = 10
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      itemId: new ObjectId67(itemId)
+    };
+    if (type) {
+      query.type = type;
+    }
+    const cacheKey = makeCacheKey37(namespace_collection, {
+      itemId,
+      type,
+      page,
+      limit,
+      tag: "byItemId"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached)
+        return cached;
+      const items = await repo.collection.aggregate([
+        { $match: query },
+        { $sort: { createdAt: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await repo.collection.countDocuments(query);
+      const data = paginate33(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600);
+      return data;
+    } catch (error) {
+      logger58.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(id) {
+    const cacheKey = makeCacheKey37(namespace_collection, {
+      id,
+      tag: "by-id"
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached)
+        return cached;
+      const result = await repo.collection.findOne({
+        _id: new ObjectId67(id)
+      });
+      if (!result) {
+        throw new BadRequestError117("Stock movement not found.");
+      }
+      repo.setCache(cacheKey, result, 300);
+      return result;
+    } catch (error) {
+      if (error instanceof AppError56)
+        throw error;
+      throw new InternalServerError52("Failed to get stock movement.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getByItemId,
+    getById
+  };
+}
+
+// src/resources/asset-item-movement/stock.movement.service.ts
+import { BadRequestError as BadRequestError118 } from "@goweekdays/utils";
+import { useAtlas as useAtlas18 } from "@goweekdays/utils";
+function useStockMovementService() {
+  const movementRepo = useStockMovementRepo();
+  const assetItemRepo = useAssetItemRepo();
+  const assetUnitRepo = useAssetUnitRepo();
+  async function stockIn(value, units) {
+    const item = await assetItemRepo.getById(String(value.itemId));
+    const session = useAtlas18.getClient()?.startSession();
+    if (!session)
+      throw new BadRequestError118("Failed to start session.");
+    try {
+      session.startTransaction();
+      value.type = "in";
+      const movementId = await movementRepo.add(value, session);
+      if (item.trackingType === "individual" && units && units.length > 0) {
+        for (const unit of units) {
+          await assetUnitRepo.add(
+            {
+              itemId: value.itemId,
+              serialNumber: unit.serialNumber,
+              plateNumber: unit.plateNumber,
+              status: "available",
+              locationId: value.toLocationId
+            },
+            session
+          );
+        }
+      }
+      await assetItemRepo.incrementQuantity(
+        String(value.itemId),
+        value.quantity,
+        session
+      );
+      await session.commitTransaction();
+      return movementId;
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function stockOut(value, unitIds) {
+    const item = await assetItemRepo.getById(String(value.itemId));
+    if (item.trackingType === "quantity" && (item.quantityOnHand ?? 0) < value.quantity) {
+      throw new BadRequestError118("Insufficient stock.");
+    }
+    const session = useAtlas18.getClient()?.startSession();
+    if (!session)
+      throw new BadRequestError118("Failed to start session.");
+    try {
+      session.startTransaction();
+      value.type = "out";
+      const movementId = await movementRepo.add(value, session);
+      if (item.trackingType === "individual" && unitIds && unitIds.length > 0) {
+        for (const unitId of unitIds) {
+          await assetUnitRepo.updateById(
+            unitId,
+            { status: "assigned", assignedTo: value.reference?.id },
+            session
+          );
+        }
+      }
+      await assetItemRepo.incrementQuantity(
+        String(value.itemId),
+        -value.quantity,
+        session
+      );
+      await session.commitTransaction();
+      return movementId;
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function transfer(value, unitIds) {
+    if (!value.fromLocationId || !value.toLocationId) {
+      throw new BadRequestError118(
+        "Transfer requires both fromLocationId and toLocationId."
+      );
+    }
+    const item = await assetItemRepo.getById(String(value.itemId));
+    const session = useAtlas18.getClient()?.startSession();
+    if (!session)
+      throw new BadRequestError118("Failed to start session.");
+    try {
+      session.startTransaction();
+      value.type = "transfer";
+      const movementId = await movementRepo.add(value, session);
+      if (item.trackingType === "individual" && unitIds && unitIds.length > 0) {
+        for (const unitId of unitIds) {
+          await assetUnitRepo.updateById(
+            unitId,
+            { locationId: value.toLocationId },
+            session
+          );
+        }
+      }
+      await session.commitTransaction();
+      return movementId;
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function adjustment(value) {
+    if (!value.reason) {
+      throw new BadRequestError118("Adjustment requires a reason.");
+    }
+    const session = useAtlas18.getClient()?.startSession();
+    if (!session)
+      throw new BadRequestError118("Failed to start session.");
+    try {
+      session.startTransaction();
+      value.type = "adjustment";
+      const movementId = await movementRepo.add(value, session);
+      await assetItemRepo.incrementQuantity(
+        String(value.itemId),
+        value.quantity,
+        session
+      );
+      await session.commitTransaction();
+      return movementId;
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function conversion(newItem, quantity, unitIds) {
+    const sourceItem = await assetItemRepo.getById(String(newItem.itemRefId));
+    if (!newItem.itemRefId) {
+      throw new BadRequestError118("Conversion requires itemRefId.");
+    }
+    if (sourceItem.trackingType === "quantity" && (sourceItem.quantityOnHand ?? 0) < quantity) {
+      throw new BadRequestError118("Insufficient stock on source item.");
+    }
+    const session = useAtlas18.getClient()?.startSession();
+    if (!session)
+      throw new BadRequestError118("Failed to start session.");
+    try {
+      session.startTransaction();
+      const newItemId = await assetItemRepo.add(newItem, session);
+      const movementData = {
+        itemId: newItem.itemRefId,
+        type: "conversion",
+        quantity,
+        fromItemId: String(newItem.itemRefId),
+        toItemId: String(newItemId),
+        reference: { type: "conversion", id: String(newItemId) }
+      };
+      const movementId = await movementRepo.add(movementData, session);
+      await assetItemRepo.incrementQuantity(
+        String(newItem.itemRefId),
+        -quantity,
+        session
+      );
+      await assetItemRepo.incrementQuantity(
+        String(newItemId),
+        quantity,
+        session
+      );
+      if (sourceItem.trackingType === "individual" && unitIds && unitIds.length > 0) {
+        for (const unitId of unitIds) {
+          await assetUnitRepo.updateById(
+            unitId,
+            { itemId: String(newItemId) },
+            session
+          );
+        }
+      }
+      await session.commitTransaction();
+      return { movementId, newItemId };
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  return {
+    stockIn,
+    stockOut,
+    transfer,
+    adjustment,
+    conversion
+  };
+}
+
+// src/resources/asset-item-movement/stock.movement.controller.ts
+import Joi104 from "joi";
+import { BadRequestError as BadRequestError119 } from "@goweekdays/utils";
+var querySchema2 = Joi104.object({
+  itemId: Joi104.string().hex().length(24).required(),
+  type: Joi104.string().valid(...stockMovementTypes).optional().allow("", null),
+  page: Joi104.number().min(1).optional().allow("", null),
+  limit: Joi104.number().min(1).optional().allow("", null)
+});
+var idParamSchema4 = Joi104.object({
+  id: Joi104.string().hex().length(24).required()
+});
+var stockInSchema = Joi104.object({
+  itemId: Joi104.string().hex().length(24).required(),
+  quantity: Joi104.number().positive().required(),
+  unitCost: Joi104.number().min(0).optional().allow(null),
+  totalCost: Joi104.number().min(0).optional().allow(null),
+  reference: Joi104.object({
+    type: Joi104.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
+    id: Joi104.string().optional().allow("", null)
+  }).optional().allow(null),
+  toLocationId: Joi104.string().optional().allow("", null),
+  units: Joi104.array().items(
+    Joi104.object({
+      serialNumber: Joi104.string().optional().allow("", null),
+      plateNumber: Joi104.string().optional().allow("", null)
+    })
+  ).optional()
+});
+var stockOutSchema = Joi104.object({
+  itemId: Joi104.string().hex().length(24).required(),
+  quantity: Joi104.number().positive().required(),
+  unitCost: Joi104.number().min(0).optional().allow(null),
+  totalCost: Joi104.number().min(0).optional().allow(null),
+  reference: Joi104.object({
+    type: Joi104.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
+    id: Joi104.string().optional().allow("", null)
+  }).optional().allow(null),
+  fromLocationId: Joi104.string().optional().allow("", null),
+  unitIds: Joi104.array().items(Joi104.string().hex().length(24)).optional()
+});
+var transferSchema = Joi104.object({
+  itemId: Joi104.string().hex().length(24).required(),
+  quantity: Joi104.number().positive().required(),
+  fromLocationId: Joi104.string().required(),
+  toLocationId: Joi104.string().required(),
+  reference: Joi104.object({
+    type: Joi104.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
+    id: Joi104.string().optional().allow("", null)
+  }).optional().allow(null),
+  unitIds: Joi104.array().items(Joi104.string().hex().length(24)).optional()
+});
+var adjustmentSchema = Joi104.object({
+  itemId: Joi104.string().hex().length(24).required(),
+  quantity: Joi104.number().required(),
+  reason: Joi104.string().required(),
+  reference: Joi104.object({
+    type: Joi104.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
+    id: Joi104.string().optional().allow("", null)
+  }).optional().allow(null)
+});
+var conversionSchema = Joi104.object({
+  quantity: Joi104.number().positive().required(),
+  newItem: Joi104.object({
+    name: Joi104.string().required(),
+    description: Joi104.string().optional().allow("", null),
+    assetCategory: Joi104.string().valid(...assetItemCategories).required(),
+    assetClass: Joi104.string().valid(...assetItemClasses).required(),
+    trackingType: Joi104.string().valid(...assetItemTrackingTypes).required(),
+    purpose: Joi104.string().valid(...assetItemPurposes).required(),
+    itemRefId: Joi104.string().hex().length(24).required(),
+    remarks: Joi104.string().optional().allow("", null),
+    departmentId: Joi104.string().required(),
+    departmentName: Joi104.string().required(),
+    categoryId: Joi104.string().required(),
+    categoryName: Joi104.string().required(),
+    subcategoryId: Joi104.string().required(),
+    subcategoryName: Joi104.string().required(),
+    categoryPath: Joi104.string().required(),
+    brand: Joi104.string().optional().allow("", null),
+    tags: Joi104.array().items(
+      Joi104.object({
+        id: Joi104.string().required(),
+        name: Joi104.string().required()
+      })
+    ).optional().default([])
+  }).required(),
+  unitIds: Joi104.array().items(Joi104.string().hex().length(24)).optional()
+});
+function useStockMovementController() {
+  const repo = useStockMovementRepo();
+  const service = useStockMovementService();
+  async function stockIn(req, res, next) {
+    try {
+      const { error } = stockInSchema.validate(req.body);
+      if (error) {
+        next(new BadRequestError119(error.message));
+        return;
+      }
+      const { units, ...movement } = req.body;
+      const movementId = await service.stockIn(movement, units);
+      res.status(201).json({
+        message: "Stock in recorded successfully.",
+        movementId
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function stockOut(req, res, next) {
+    try {
+      const { error } = stockOutSchema.validate(req.body);
+      if (error) {
+        next(new BadRequestError119(error.message));
+        return;
+      }
+      const { unitIds, ...movement } = req.body;
+      const movementId = await service.stockOut(movement, unitIds);
+      res.status(201).json({
+        message: "Stock out recorded successfully.",
+        movementId
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function transfer(req, res, next) {
+    try {
+      const { error } = transferSchema.validate(req.body);
+      if (error) {
+        next(new BadRequestError119(error.message));
+        return;
+      }
+      const { unitIds, ...movement } = req.body;
+      const movementId = await service.transfer(movement, unitIds);
+      res.status(201).json({
+        message: "Transfer recorded successfully.",
+        movementId
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function adjustment(req, res, next) {
+    try {
+      const { error } = adjustmentSchema.validate(req.body);
+      if (error) {
+        next(new BadRequestError119(error.message));
+        return;
+      }
+      const movementId = await service.adjustment(req.body);
+      res.status(201).json({
+        message: "Adjustment recorded successfully.",
+        movementId
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function getByItemId(req, res, next) {
+    const { error } = querySchema2.validate(req.query);
+    if (error) {
+      next(new BadRequestError119(error.message));
+      return;
+    }
+    const itemId = req.query.itemId;
+    const type = req.query.type ?? "";
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    try {
+      const results = await repo.getByItemId({ itemId, type, page, limit });
+      res.json(results);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const { error } = idParamSchema4.validate(req.params);
+    if (error) {
+      next(new BadRequestError119(error.message));
+      return;
+    }
+    try {
+      const movement = await repo.getById(req.params.id);
+      res.json(movement);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function conversion(req, res, next) {
+    try {
+      const { error } = conversionSchema.validate(req.body);
+      if (error) {
+        next(new BadRequestError119(error.message));
+        return;
+      }
+      const { quantity, newItem, unitIds } = req.body;
+      const result = await service.conversion(newItem, quantity, unitIds);
+      res.status(201).json({
+        message: "Conversion recorded successfully.",
+        movementId: result.movementId,
+        newItemId: result.newItemId
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  return {
+    stockIn,
+    stockOut,
+    transfer,
+    adjustment,
+    conversion,
+    getByItemId,
+    getById
+  };
+}
+
+// src/resources/asset-item-category/category.service.ts
+import { BadRequestError as BadRequestError120 } from "@goweekdays/utils";
+function useCategoryService() {
+  const repo = useCategoryRepo();
+  async function add(value) {
+    const { error } = schemaCategoryNodeCreate.validate(value);
+    if (error) {
+      throw new BadRequestError120(error.message);
+    }
+    const name = normalizeName(value.displayName);
+    let level;
+    let path = "";
+    if (!value.parentId) {
+      level = "department";
+      const existing = await repo.getByNameParent(name, { orgId: value.orgId });
+      if (existing) {
+        throw new BadRequestError120(
+          `Department "${value.displayName}" already exists.`
+        );
+      }
+    } else {
+      const parent = await repo.getById(value.parentId);
+      if (parent && parent.level === "department") {
+        level = "category";
+      } else if (parent && parent.level === "category") {
+        level = "subcategory";
+      } else {
+        throw new BadRequestError120(
+          "Cannot create a child under a subcategory. Maximum depth is 3 levels."
+        );
+      }
+      const existing = await repo.getByNameParent(name, {
+        parentId: value.parentId,
+        orgId: value.orgId
+      });
+      if (existing) {
+        throw new BadRequestError120(
+          `"${value.displayName}" already exists under this parent.`
+        );
+      }
+      if (level === "subcategory") {
+        const department = await repo.getById(parent.parentId);
+        path = buildCategoryPath(department.name, parent.name, name);
+      }
+    }
+    const data = {
+      orgId: value.orgId ?? "",
+      level,
+      type: value.orgId ? "private" : "public",
+      name,
+      displayName: value.displayName.trim(),
+      parentId: value.parentId ?? "",
+      path
+    };
+    return await repo.add(data);
+  }
+  async function updateById(_id, value) {
+    const { error } = schemaCategoryNodeUpdate.validate(value);
+    if (error) {
+      throw new BadRequestError120(error.message);
+    }
+    const update = {
+      displayName: "",
+      name: "",
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    if (value.displayName) {
+      update.displayName = value.displayName.trim();
+      update.name = normalizeName(value.displayName);
+    }
+    await repo.updateById(_id, update);
+  }
+  async function deleteById(_id) {
+    const hasChildren = await repo.hasChildren(_id);
+    if (hasChildren) {
+      throw new BadRequestError120(
+        "Cannot delete a category that has child categories. Remove or reassign children first."
+      );
+    }
+    await repo.softDeleteById(_id);
+  }
+  return {
+    add,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/asset-item-category/category.controller.ts
+import Joi105 from "joi";
+import { BadRequestError as BadRequestError121 } from "@goweekdays/utils";
+function useCategoryController() {
+  const repo = useCategoryRepo();
+  const service = useCategoryService();
+  async function add(req, res, next) {
+    const orgId = req.params.org ?? "";
+    const { error, value } = schemaCategoryNodeCreate.validate({
+      ...req.body,
+      orgId
+    });
+    if (error) {
+      next(new BadRequestError121(error.message));
+      return;
+    }
+    try {
+      const id = await service.add(value);
+      res.status(201).json({ message: "Category created successfully.", id });
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const org = req.params.org ?? "";
+    const { error, value } = schemaCategoryGetAll.validate({
+      ...req.query,
+      org
+    });
+    if (error) {
+      next(new BadRequestError121(error.message));
+      return;
+    }
+    try {
+      const data = await repo.getAll(value);
+      res.json(data);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const _id = req.params.id;
+    const { error: errorId } = Joi105.string().hex().length(24).required().validate(_id);
+    if (errorId) {
+      next(new BadRequestError121("Invalid category ID."));
+      return;
+    }
+    try {
+      const category = await repo.getById(_id);
+      if (!category) {
+        next(new BadRequestError121("Category not found."));
+        return;
+      }
+      res.json(category);
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function updateById(req, res, next) {
+    const _id = req.params.id;
+    const { error: errorId } = Joi105.string().hex().length(24).required().validate(_id);
+    if (errorId) {
+      next(new BadRequestError121("Invalid category ID."));
+      return;
+    }
+    const { error, value } = schemaCategoryNodeUpdate.validate(req.body);
+    if (error) {
+      next(new BadRequestError121(error.message));
+      return;
+    }
+    const { displayName } = value;
+    try {
+      await service.updateById(_id, { displayName });
+      res.json({ message: "Category updated successfully." });
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const _id = req.params.id;
+    const { error: errorId } = Joi105.string().hex().length(24).required().validate(_id);
+    if (errorId) {
+      next(new BadRequestError121("Invalid category ID."));
+      return;
+    }
+    try {
+      await service.deleteById(_id);
+      res.json({ message: "Category deleted successfully." });
+    } catch (error) {
+      next(error);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/tag/tag.service.ts
+import { AppError as AppError57, BadRequestError as BadRequestError122 } from "@goweekdays/utils";
+import Joi106 from "joi";
+function normalizeTagName2(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function useTagService() {
+  const {
+    add: _add,
+    getById: _getById,
+    updateById: _updateById,
+    deleteById: _deleteById
+  } = useTagRepo();
+  async function add(value) {
+    const { error } = schemaTagCreate.validate(value);
+    if (error) {
+      throw new BadRequestError122(error.message);
+    }
+    const normalizedName = normalizeTagName2(value.name);
+    const data = {
+      name: value.name,
+      normalizedName,
+      type: value.type,
+      orgId: value.orgId ?? "",
+      categoryPath: value.categoryPath ?? "",
+      status: "pending",
+      usageCount: 0
+    };
+    try {
+      const id = await _add(data);
+      return id;
+    } catch (error2) {
+      if (error2 instanceof AppError57)
+        throw error2;
+      throw new BadRequestError122("Failed to add tag.");
+    }
+  }
+  async function updateById(id, value) {
+    const { error: errorId } = Joi106.string().hex().required().validate(id);
+    if (errorId) {
+      throw new BadRequestError122("Invalid Tag ID.");
+    }
+    const { error } = schemaTagUpdate.validate(value);
+    if (error) {
+      throw new BadRequestError122(`Invalid tag update data: ${error.message}`);
+    }
+    const existingTag = await _getById(id);
+    if (!existingTag) {
+      throw new BadRequestError122("Tag not found.");
+    }
+    const updatedData = { ...value };
+    if (value.name) {
+      updatedData.normalizedName = normalizeTagName2(value.name);
+    }
+    const message = await _updateById(id, updatedData);
+    return message;
+  }
+  async function deleteById(id) {
+    const { error } = Joi106.string().hex().required().validate(id);
+    if (error) {
+      throw new BadRequestError122("Invalid Tag ID.");
+    }
+    const existingTag = await _getById(id);
+    if (!existingTag) {
+      throw new BadRequestError122("Tag not found.");
+    }
+    const message = await _deleteById(id);
+    return message;
+  }
+  return {
+    add,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/tag/tag.controller.ts
+import Joi107 from "joi";
+import { BadRequestError as BadRequestError123, logger as logger59 } from "@goweekdays/utils";
+function useTagController() {
+  const { getAll: _getAll, getById: _getById } = useTagRepo();
+  const {
+    add: _add,
+    updateById: _updateById,
+    deleteById: _deleteById
+  } = useTagService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaTagCreate.validate(value);
+    if (error) {
+      next(new BadRequestError123(error.message));
+      logger59.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 = Joi107.object({
+      page: Joi107.number().min(1).optional().allow("", null),
+      limit: Joi107.number().min(1).optional().allow("", null),
+      search: Joi107.string().optional().allow("", null),
+      type: Joi107.string().valid("public", "private").optional().allow("", null),
+      orgId: Joi107.string().hex().optional().allow("", null),
+      status: Joi107.string().valid("active", "pending").optional().allow("", null),
+      categoryPath: Joi107.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError123(error.message));
+      return;
+    }
+    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 type = req.query.type ?? "";
+    const orgId = req.query.orgId ?? "";
+    const status2 = req.query.status ?? "";
+    const categoryPath = req.query.categoryPath ?? "";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new BadRequestError123("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new BadRequestError123("Invalid limit number."));
+      return;
+    }
+    try {
+      const tags = await _getAll({
+        page,
+        limit,
+        search,
+        type,
+        orgId,
+        status: status2,
+        categoryPath
+      });
+      res.json(tags);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = Joi107.object({
+      id: Joi107.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError123(error.message));
+      return;
+    }
+    try {
+      const tag = await _getById(id);
+      res.json(tag);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const _id = req.params.id;
+    const { error: errorId } = Joi107.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new BadRequestError123("Invalid Tag ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaTagUpdate.validate(payload);
+    if (error) {
+      next(new BadRequestError123(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 BadRequestError123("Tag ID is required."));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
 export {
   ACCESS_TOKEN_EXPIRY,
   ACCESS_TOKEN_SECRET,
@@ -22539,6 +25105,14 @@ export {
   VERIFICATION_USER_INVITE_DURATION,
   XENDIT_BASE_URL,
   XENDIT_SECRET_KEY,
+  assetItemCategories,
+  assetItemClasses,
+  assetItemPurposes,
+  assetItemStatuses,
+  assetItemTrackingTypes,
+  assetUnitStatuses,
+  buildCategoryPath,
+  categoryLevels,
   chartOfAccountControlTypes,
   chartOfAccountNormalBalances,
   chartOfAccountStatuses,
@@ -22553,7 +25127,10 @@ export {
   ledgerBillTypes,
   modelAccountBalance,
   modelApp,
+  modelAssetItem,
+  modelAssetUnit,
   modelBusinessProfile,
+  modelCategoryNode,
   modelChartOfAccount,
   modelCustomer,
   modelJobApplication,
@@ -22579,14 +25156,22 @@ export {
   modelPlan,
   modelPromo,
   modelRole,
+  modelStockMovement,
   modelSubscription,
   modelSubscriptionTransaction,
+  modelTag,
   modelTax,
   modelUser,
   modelVerification,
+  normalizeName,
   schemaAccountBalance,
   schemaApp,
   schemaAppUpdate,
+  schemaAssetItem,
+  schemaAssetItemCreate,
+  schemaAssetItemUpdate,
+  schemaAssetUnit,
+  schemaAssetUnitUpdate,
   schemaAward,
   schemaBuilding,
   schemaBuildingUnit,
@@ -22598,6 +25183,10 @@ export {
   schemaBusinessProfileRegisteredAddress,
   schemaBusinessProfileTIN,
   schemaBusinessProfileTradeName,
+  schemaCategoryGetAll,
+  schemaCategoryNodeCreate,
+  schemaCategoryNodeStd,
+  schemaCategoryNodeUpdate,
   schemaCertification,
   schemaChartOfAccountBase,
   schemaChartOfAccountStd,
@@ -22667,6 +25256,7 @@ export {
   schemaRole,
   schemaRoleUpdate,
   schemaSkill,
+  schemaStockMovement,
   schemaSubscribe,
   schemaSubscription,
   schemaSubscriptionCompute,
@@ -22674,6 +25264,9 @@ export {
   schemaSubscriptionSeats,
   schemaSubscriptionTransaction,
   schemaSubscriptionUpdate,
+  schemaTagCreate,
+  schemaTagStd,
+  schemaTagUpdate,
   schemaTax,
   schemaTaxUpdate,
   schemaUpdateOptions,
@@ -22681,6 +25274,8 @@ export {
   schemaVerification,
   schemaVerificationOrgInvite,
   schemaWorkExp,
+  stockMovementReferenceTypes,
+  stockMovementTypes,
   taxDirections,
   taxTypes,
   transactionSchema,
@@ -22688,6 +25283,11 @@ export {
   useAppController,
   useAppRepo,
   useAppService,
+  useAssetItemController,
+  useAssetItemRepo,
+  useAssetItemService,
+  useAssetUnitController,
+  useAssetUnitRepo,
   useAuthController,
   useAuthService,
   useBuildingController,
@@ -22698,6 +25298,9 @@ export {
   useBuildingUnitService,
   useBusinessProfileCtrl,
   useBusinessProfileRepo,
+  useCategoryController,
+  useCategoryRepo,
+  useCategoryService,
   useChartOfAccountController,
   useChartOfAccountRepo,
   useCounterModel,
@@ -22753,11 +25356,17 @@ export {
   useRoleController,
   useRoleRepo,
   useRoleService,
+  useStockMovementController,
+  useStockMovementRepo,
+  useStockMovementService,
   useSubscriptionController,
   useSubscriptionRepo,
   useSubscriptionService,
   useSubscriptionTransactionController,
   useSubscriptionTransactionRepo,
+  useTagController,
+  useTagRepo,
+  useTagService,
   useTaxController,
   useTaxRepo,
   useUserController,