@goweekdays/core 2.15.8 → 2.15.10

package/dist/index.js

@@ -22578,19 +22578,36 @@ var schemaAssetItemCreate = import_joi96.default.object({
 }, "subcategory-requires-category");
 var schemaAssetItemUpdate = import_joi96.default.object({
   name: import_joi96.default.string().optional(),
+  sku: import_joi96.default.string().optional().allow("", null),
+  price: import_joi96.default.number().min(0).optional().allow("", null),
+  unit: import_joi96.default.string().optional(),
   description: import_joi96.default.string().optional().allow("", null),
   assetCategory: import_joi96.default.string().valid(...assetItemCategories).optional(),
-  assetClass: import_joi96.default.string().valid(...assetItemClasses).optional(),
+  assetClass: import_joi96.default.string().valid(...assetItemClasses).optional().allow("", null),
+  trackingType: import_joi96.default.string().valid(...assetItemTrackingTypes).optional(),
+  departmentId: import_joi96.default.string().hex().length(24).optional(),
+  departmentName: import_joi96.default.string().optional(),
+  categoryId: import_joi96.default.string().hex().length(24).optional().allow("", null),
+  categoryName: import_joi96.default.string().optional().allow("", null),
+  subcategoryId: import_joi96.default.string().hex().length(24).optional().allow("", null),
+  subcategoryName: import_joi96.default.string().optional().allow("", null),
+  categoryPath: import_joi96.default.string().optional().allow("", null),
   brand: import_joi96.default.string().optional().allow("", null),
-  sku: import_joi96.default.string().optional().allow("", null),
-  price: import_joi96.default.number().min(0).optional().allow("", null),
   tags: import_joi96.default.array().items(
     import_joi96.default.object({
       id: import_joi96.default.string().required(),
       name: import_joi96.default.string().required()
     })
   ).optional(),
-  quantityOnHand: import_joi96.default.number().min(0).optional()
+  isPublic: import_joi96.default.boolean().optional(),
+  updatedAt: import_joi96.default.date().optional()
+}).custom((value, helpers) => {
+  if (value.subcategoryId && !value.categoryId) {
+    return helpers.error("any.custom", {
+      message: "categoryId is required when subcategoryId is provided."
+    });
+  }
+  return value;
 });
 function modelAssetItem(data) {
   const { error } = schemaAssetItem.validate(data);
@@ -22638,10 +22655,12 @@ function modelAssetItem(data) {
       "Marketplace price is required for items marked as public."
     );
   }
+  data.normalizedName = data.name.trim().toLowerCase();
   return {
     _id: data._id,
     orgId: data.orgId,
     name: data.name,
+    normalizedName: data.normalizedName,
     description: data.description ?? "",
     assetCategory: data.assetCategory,
     assetClass: data.assetClass,
@@ -22690,7 +22709,17 @@ function useAssetItemRepo() {
         { key: { purpose: 1 } },
         { key: { trackingType: 1 } },
         { key: { status: 1 } },
-        { key: { name: "text" } }
+        { key: { name: "text" } },
+        { key: { public: 1 } },
+        {
+          key: {
+            orgId: 1,
+            normalizedName: 1,
+            purpose: 1,
+            itemRefId: 1
+          },
+          unique: true
+        }
       ]);
     } catch (error) {
       throw new import_utils116.BadRequestError("Failed to create asset item indexes.");
@@ -22726,10 +22755,14 @@ function useAssetItemRepo() {
     categoryId = "",
     subcategoryId = "",
     brand = "",
-    tags = []
+    tags = [],
+    isPublic = false
   } = {}) {
     page = page > 0 ? page - 1 : 0;
     const query = { status: status2 };
+    if (isPublic) {
+      query.isPublic = true;
+    }
     if (search) {
       query.$text = { $search: search };
     }
@@ -22770,7 +22803,8 @@ function useAssetItemRepo() {
       subcategoryId,
       brand,
       tags: tags.join(","),
-      tag: "getAll"
+      tag: "getAll",
+      public: isPublic ? "true" : "false"
     });
     try {
       const cached = await repo.getCache(cacheKey);
@@ -22815,10 +22849,16 @@ function useAssetItemRepo() {
     }
   }
   async function updateById(id, value) {
+    const { error, value: validatedValue } = schemaAssetItemUpdate.validate(value);
+    if (error) {
+      throw new import_utils116.BadRequestError(
+        `Invalid asset item update data: ${error.message}`
+      );
+    }
     try {
       const result = await repo.collection.findOneAndUpdate(
         { _id: new import_mongodb59.ObjectId(id) },
-        { $set: { ...value, updatedAt: /* @__PURE__ */ new Date() } },
+        { $set: { ...validatedValue, updatedAt: /* @__PURE__ */ new Date() } },
         { returnDocument: "after" }
       );
       if (!result) {
@@ -22826,9 +22866,9 @@ function useAssetItemRepo() {
       }
       repo.delCachedData();
       return result;
-    } catch (error) {
-      if (error instanceof import_utils116.AppError)
-        throw error;
+    } catch (error2) {
+      if (error2 instanceof import_utils116.AppError)
+        throw error2;
       throw new import_utils116.InternalServerError("Failed to update asset item.");
     }
   }
@@ -22883,7 +22923,7 @@ function useAssetItemRepo() {
 }
 
 // src/resources/asset-item/asset.item.service.ts
-var import_utils120 = require("@goweekdays/utils");
+var import_utils126 = require("@goweekdays/utils");
 
 // src/resources/tag/tag.repository.ts
 var import_utils117 = require("@goweekdays/utils");
@@ -23543,246 +23583,187 @@ function useCategoryRepo() {
   };
 }
 
-// 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;
+// src/resources/asset-item-movement/stock.movement.model.ts
+var import_joi100 = __toESM(require("joi"));
+var import_mongodb64 = require("mongodb");
+var stockMovementTypes = [
+  "in",
+  "out",
+  "transfer",
+  "adjustment",
+  "conversion"
+];
+var stockMovementReferenceTypes = [
+  "purchase",
+  "sale",
+  "transfer",
+  "manual",
+  "conversion"
+];
+var schemaStockMovement = import_joi100.default.object({
+  itemId: import_joi100.default.string().hex().length(24).required(),
+  type: import_joi100.default.string().valid(...stockMovementTypes).required(),
+  quantity: import_joi100.default.number().positive().required(),
+  unitCost: import_joi100.default.number().min(0).optional().allow(null),
+  totalCost: import_joi100.default.number().min(0).optional().allow(null),
+  reference: import_joi100.default.object({
+    type: import_joi100.default.string().valid(...stockMovementReferenceTypes).required(),
+    id: import_joi100.default.string().optional().allow("", null)
+  }).optional().allow(null),
+  fromLocationId: import_joi100.default.string().optional().allow("", null),
+  toLocationId: import_joi100.default.string().optional().allow("", null),
+  fromItemId: import_joi100.default.string().hex().length(24).optional().allow("", null),
+  toItemId: import_joi100.default.string().hex().length(24).optional().allow("", null),
+  reason: import_joi100.default.string().optional().allow("", null)
+});
+function modelStockMovement(data) {
+  const { error } = schemaStockMovement.validate(data);
+  if (error) {
+    throw new Error(`Invalid stock movement data: ${error.message}`);
   }
-  async function add(value) {
-    const session = import_utils120.useAtlas.getClient()?.startSession();
-    if (!session) {
-      throw new import_utils120.InternalServerError(
-        "Unable to start session for asset item service."
-      );
-    }
+  if (data.itemId && typeof data.itemId === "string") {
     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 import_utils120.AppError)
-        throw error;
-      throw new import_utils120.InternalServerError("Failed to create asset item.");
-    } finally {
-      session.endSession();
+      data.itemId = new import_mongodb64.ObjectId(data.itemId);
+    } catch {
+      throw new Error(`Invalid itemId format: ${data.itemId}`);
     }
   }
   return {
-    add
+    _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/asset.item.controller.ts
-var import_joi100 = __toESM(require("joi"));
-var import_utils121 = require("@goweekdays/utils");
-var paginationSchema3 = import_joi100.default.object({
-  page: import_joi100.default.number().min(1).optional().allow("", null),
-  limit: import_joi100.default.number().min(1).optional().allow("", null),
-  search: import_joi100.default.string().optional().allow("", null),
-  status: import_joi100.default.string().valid(...assetItemStatuses).optional().allow("", null),
-  assetCategory: import_joi100.default.string().valid(...assetItemCategories).optional().allow("", null),
-  trackingType: import_joi100.default.string().valid(...assetItemTrackingTypes).optional().allow("", null),
-  purpose: import_joi100.default.string().valid(...assetItemPurposes).optional().allow("", null),
-  departmentId: import_joi100.default.string().optional().allow("", null),
-  categoryId: import_joi100.default.string().optional().allow("", null),
-  subcategoryId: import_joi100.default.string().optional().allow("", null),
-  brand: import_joi100.default.string().optional().allow("", null),
-  tags: import_joi100.default.string().optional().allow("", null)
-});
-var idParamSchema2 = import_joi100.default.object({
-  id: import_joi100.default.string().hex().length(24).required()
-});
-function useAssetItemController() {
-  const repo = useAssetItemRepo();
-  const service = useAssetItemService();
-  async function add(req, res, next) {
+// src/resources/asset-item-movement/stock.movement.repository.ts
+var import_utils120 = require("@goweekdays/utils");
+var import_mongodb65 = require("mongodb");
+function useStockMovementRepo() {
+  const namespace_collection = "stock.movements";
+  const repo = (0, import_utils120.useRepo)(namespace_collection);
+  async function createIndexes() {
     try {
-      const { error, value } = schemaAssetItemCreate.validate(req.body);
-      if (error) {
-        next(new import_utils121.BadRequestError(error.message));
-        return;
-      }
-      const assetItemId = await service.add(value);
-      res.status(201).json({
-        message: "Asset item created successfully.",
-        assetItemId
-      });
+      await repo.collection.createIndexes([
+        { key: { itemId: 1 } },
+        { key: { createdAt: -1 } },
+        { key: { itemId: 1, createdAt: -1 } },
+        { key: { type: 1 } }
+      ]);
     } catch (error) {
-      next(error);
+      throw new import_utils120.BadRequestError("Failed to create stock movement indexes.");
     }
   }
-  async function getAll(req, res, next) {
-    const { error } = paginationSchema3.validate(req.query);
-    if (error) {
-      next(new import_utils121.BadRequestError(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 import_utils121.BadRequestError("Invalid page number."));
-      return;
-    }
-    if (!isFinite(limit)) {
-      next(new import_utils121.BadRequestError("Invalid limit number."));
-      return;
-    }
+  async function add(value, session) {
     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);
+      value = modelStockMovement(value);
+      const res = await repo.collection.insertOne(value, { session });
+      repo.delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_utils120.logger.log({ level: "error", message: error.message });
+      throw new import_utils120.InternalServerError("Failed to create stock movement.");
     }
   }
-  async function getById(req, res, next) {
-    const { error } = idParamSchema2.validate(req.params);
-    if (error) {
-      next(new import_utils121.BadRequestError(error.message));
-      return;
+  async function getByItemId({
+    itemId,
+    type = "",
+    page = 1,
+    limit = 10
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      itemId: new import_mongodb65.ObjectId(itemId)
+    };
+    if (type) {
+      query.type = type;
     }
-    try {
-      const assetItem = await repo.getById(req.params.id);
-      res.json(assetItem);
-    } catch (error2) {
-      next(error2);
+    const cacheKey = (0, import_utils120.makeCacheKey)(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 = (0, import_utils120.paginate)(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600);
+      return data;
+    } catch (error) {
+      import_utils120.logger.log({ level: "error", message: `${error}` });
+      throw error;
     }
   }
-  async function updateById(req, res, next) {
-    const { error: paramError } = idParamSchema2.validate(req.params);
-    if (paramError) {
-      next(new import_utils121.BadRequestError(paramError.message));
-      return;
-    }
-    const { error: bodyError } = schemaAssetItemUpdate.validate(req.body);
-    if (bodyError) {
-      next(new import_utils121.BadRequestError(bodyError.message));
-      return;
-    }
+  async function getById(id) {
+    const cacheKey = (0, import_utils120.makeCacheKey)(namespace_collection, {
+      id,
+      tag: "by-id"
+    });
     try {
-      const updatedAssetItem = await repo.updateById(req.params.id, req.body);
-      res.json({
-        message: "Asset item updated successfully.",
-        assetItem: updatedAssetItem
+      const cached = await repo.getCache(cacheKey);
+      if (cached)
+        return cached;
+      const result = await repo.collection.findOne({
+        _id: new import_mongodb65.ObjectId(id)
       });
+      if (!result) {
+        throw new import_utils120.BadRequestError("Stock movement not found.");
+      }
+      repo.setCache(cacheKey, result, 300);
+      return result;
     } catch (error) {
-      next(error);
+      if (error instanceof import_utils120.AppError)
+        throw error;
+      throw new import_utils120.InternalServerError("Failed to get stock movement.");
     }
   }
-  async function deleteById(req, res, next) {
-    const { error } = idParamSchema2.validate(req.params);
-    if (error) {
-      next(new import_utils121.BadRequestError(error.message));
-      return;
-    }
+  async function countByItemId(itemId) {
     try {
-      await repo.deleteById(req.params.id);
-      res.json({
-        message: "Asset item deleted successfully."
+      return await repo.collection.countDocuments({
+        itemId: new import_mongodb65.ObjectId(itemId)
       });
-    } catch (error2) {
-      next(error2);
+    } catch (error) {
+      throw new import_utils120.InternalServerError("Failed to count stock movements.");
     }
   }
   return {
+    createIndexes,
     add,
-    getAll,
+    getByItemId,
     getById,
-    updateById,
-    deleteById
+    countByItemId
   };
 }
 
+// src/resources/asset-item-movement/stock.movement.service.ts
+var import_utils122 = require("@goweekdays/utils");
+var import_utils123 = require("@goweekdays/utils");
+
+// src/resources/asset-item-unit/asset.unit.repository.ts
+var import_utils121 = require("@goweekdays/utils");
+
 // src/resources/asset-item-unit/asset.unit.model.ts
 var import_joi101 = __toESM(require("joi"));
-var import_mongodb64 = require("mongodb");
+var import_mongodb66 = require("mongodb");
 var assetUnitStatuses = [
   "available",
   "assigned",
@@ -23812,7 +23793,7 @@ function modelAssetUnit(data) {
   }
   if (data.itemId && typeof data.itemId === "string") {
     try {
-      data.itemId = new import_mongodb64.ObjectId(data.itemId);
+      data.itemId = new import_mongodb66.ObjectId(data.itemId);
     } catch {
       throw new Error(`Invalid itemId format: ${data.itemId}`);
     }
@@ -23831,11 +23812,10 @@ function modelAssetUnit(data) {
 }
 
 // src/resources/asset-item-unit/asset.unit.repository.ts
-var import_utils122 = require("@goweekdays/utils");
-var import_mongodb65 = require("mongodb");
+var import_mongodb67 = require("mongodb");
 function useAssetUnitRepo() {
   const namespace_collection = "asset.units";
-  const repo = (0, import_utils122.useRepo)(namespace_collection);
+  const repo = (0, import_utils121.useRepo)(namespace_collection);
   async function createIndexes() {
     try {
       await repo.collection.createIndexes([
@@ -23845,7 +23825,7 @@ function useAssetUnitRepo() {
         { key: { itemId: 1, status: 1 } }
       ]);
     } catch (error) {
-      throw new import_utils122.BadRequestError("Failed to create asset unit indexes.");
+      throw new import_utils121.BadRequestError("Failed to create asset unit indexes.");
     }
   }
   async function add(value, session) {
@@ -23855,8 +23835,8 @@ function useAssetUnitRepo() {
       repo.delCachedData();
       return res.insertedId;
     } catch (error) {
-      import_utils122.logger.log({ level: "error", message: error.message });
-      throw new import_utils122.InternalServerError("Failed to create asset unit.");
+      import_utils121.logger.log({ level: "error", message: error.message });
+      throw new import_utils121.InternalServerError("Failed to create asset unit.");
     }
   }
   async function getByItemId({
@@ -23867,12 +23847,12 @@ function useAssetUnitRepo() {
   }) {
     page = page > 0 ? page - 1 : 0;
     const query = {
-      itemId: new import_mongodb65.ObjectId(itemId)
+      itemId: new import_mongodb67.ObjectId(itemId)
     };
     if (status2) {
       query.status = status2;
     }
-    const cacheKey = (0, import_utils122.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils121.makeCacheKey)(namespace_collection, {
       itemId,
       status: status2,
       page,
@@ -23890,16 +23870,16 @@ function useAssetUnitRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await repo.collection.countDocuments(query);
-      const data = (0, import_utils122.paginate)(items, page, limit, length);
+      const data = (0, import_utils121.paginate)(items, page, limit, length);
       repo.setCache(cacheKey, data, 600);
       return data;
     } catch (error) {
-      import_utils122.logger.log({ level: "error", message: `${error}` });
+      import_utils121.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
   async function getById(id) {
-    const cacheKey = (0, import_utils122.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_utils121.makeCacheKey)(namespace_collection, {
       id,
       tag: "by-id"
     });
@@ -23908,45 +23888,54 @@ function useAssetUnitRepo() {
       if (cached)
         return cached;
       const result = await repo.collection.findOne({
-        _id: new import_mongodb65.ObjectId(id)
+        _id: new import_mongodb67.ObjectId(id)
       });
       if (!result) {
-        throw new import_utils122.BadRequestError("Asset unit not found.");
+        throw new import_utils121.BadRequestError("Asset unit not found.");
       }
       repo.setCache(cacheKey, result, 300);
       return result;
     } catch (error) {
-      if (error instanceof import_utils122.AppError)
+      if (error instanceof import_utils121.AppError)
         throw error;
-      throw new import_utils122.InternalServerError("Failed to get asset unit.");
+      throw new import_utils121.InternalServerError("Failed to get asset unit.");
     }
   }
   async function updateById(id, value, session) {
     try {
       const result = await repo.collection.findOneAndUpdate(
-        { _id: new import_mongodb65.ObjectId(id) },
+        { _id: new import_mongodb67.ObjectId(id) },
         { $set: { ...value, updatedAt: /* @__PURE__ */ new Date() } },
         { returnDocument: "after", session }
       );
       if (!result) {
-        throw new import_utils122.BadRequestError("Asset unit not found.");
+        throw new import_utils121.BadRequestError("Asset unit not found.");
       }
       repo.delCachedData();
       return result;
     } catch (error) {
-      if (error instanceof import_utils122.AppError)
+      if (error instanceof import_utils121.AppError)
         throw error;
-      throw new import_utils122.InternalServerError("Failed to update asset unit.");
+      throw new import_utils121.InternalServerError("Failed to update asset unit.");
+    }
+  }
+  async function countByItemId(itemId) {
+    try {
+      return await repo.collection.countDocuments({
+        itemId: new import_mongodb67.ObjectId(itemId)
+      });
+    } catch (error) {
+      throw new import_utils121.InternalServerError("Failed to count asset units.");
     }
   }
   async function countByItemIdAndStatus(itemId, status2) {
     try {
       return await repo.collection.countDocuments({
-        itemId: new import_mongodb65.ObjectId(itemId),
+        itemId: new import_mongodb67.ObjectId(itemId),
         status: status2
       });
     } catch (error) {
-      throw new import_utils122.InternalServerError("Failed to count asset units.");
+      throw new import_utils121.InternalServerError("Failed to count asset units.");
     }
   }
   return {
@@ -23955,671 +23944,816 @@ function useAssetUnitRepo() {
     getByItemId,
     getById,
     updateById,
+    countByItemId,
     countByItemIdAndStatus
   };
 }
 
-// src/resources/asset-item-unit/asset.unit.controller.ts
-var import_joi102 = __toESM(require("joi"));
-var import_utils123 = require("@goweekdays/utils");
-var querySchema = import_joi102.default.object({
-  itemId: import_joi102.default.string().hex().length(24).required(),
-  status: import_joi102.default.string().valid(...assetUnitStatuses).optional().allow("", null),
-  page: import_joi102.default.number().min(1).optional().allow("", null),
-  limit: import_joi102.default.number().min(1).optional().allow("", null)
-});
-var idParamSchema3 = import_joi102.default.object({
-  id: import_joi102.default.string().hex().length(24).required()
-});
-function useAssetUnitController() {
-  const repo = useAssetUnitRepo();
-  async function add(req, res, next) {
+// src/resources/asset-item-movement/stock.movement.service.ts
+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 = import_utils123.useAtlas.getClient()?.startSession();
+    if (!session)
+      throw new import_utils122.BadRequestError("Failed to start session.");
     try {
-      const { error } = schemaAssetUnit.validate(req.body);
-      if (error) {
-        next(new import_utils123.BadRequestError(error.message));
-        return;
+      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
+          );
+        }
       }
-      const unitId = await repo.add(req.body);
-      res.status(201).json({
-        message: "Asset unit created successfully.",
-        unitId
-      });
+      await assetItemRepo.incrementQuantity(
+        String(value.itemId),
+        value.quantity,
+        session
+      );
+      await session.commitTransaction();
+      return movementId;
     } catch (error) {
-      next(error);
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
     }
   }
-  async function getByItemId(req, res, next) {
-    const { error } = querySchema.validate(req.query);
-    if (error) {
-      next(new import_utils123.BadRequestError(error.message));
-      return;
+  async function stockOut(value, unitIds) {
+    const item = await assetItemRepo.getById(String(value.itemId));
+    if (item.trackingType === "quantity" && (item.quantityOnHand ?? 0) < value.quantity) {
+      throw new import_utils122.BadRequestError("Insufficient stock.");
     }
-    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;
+    const session = import_utils123.useAtlas.getClient()?.startSession();
+    if (!session)
+      throw new import_utils122.BadRequestError("Failed to start session.");
     try {
-      const results = await repo.getByItemId({ itemId, status: status2, page, limit });
-      res.json(results);
-    } catch (error2) {
-      next(error2);
+      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 getById(req, res, next) {
-    const { error } = idParamSchema3.validate(req.params);
-    if (error) {
-      next(new import_utils123.BadRequestError(error.message));
-      return;
+  async function transfer(value, unitIds) {
+    if (!value.fromLocationId || !value.toLocationId) {
+      throw new import_utils122.BadRequestError(
+        "Transfer requires both fromLocationId and toLocationId."
+      );
     }
+    const item = await assetItemRepo.getById(String(value.itemId));
+    const session = import_utils123.useAtlas.getClient()?.startSession();
+    if (!session)
+      throw new import_utils122.BadRequestError("Failed to start session.");
     try {
-      const unit = await repo.getById(req.params.id);
-      res.json(unit);
-    } catch (error2) {
-      next(error2);
+      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 updateById(req, res, next) {
-    const { error: paramError } = idParamSchema3.validate(req.params);
-    if (paramError) {
-      next(new import_utils123.BadRequestError(paramError.message));
-      return;
-    }
-    const { error: bodyError } = schemaAssetUnitUpdate.validate(req.body);
-    if (bodyError) {
-      next(new import_utils123.BadRequestError(bodyError.message));
-      return;
+  async function adjustment(value) {
+    if (!value.reason) {
+      throw new import_utils122.BadRequestError("Adjustment requires a reason.");
     }
+    const session = import_utils123.useAtlas.getClient()?.startSession();
+    if (!session)
+      throw new import_utils122.BadRequestError("Failed to start session.");
     try {
-      const updatedUnit = await repo.updateById(req.params.id, req.body);
-      res.json({
-        message: "Asset unit updated successfully.",
-        unit: updatedUnit
-      });
+      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) {
-      next(error);
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
     }
   }
-  return {
-    add,
-    getByItemId,
-    getById,
-    updateById
-  };
-}
-
-// src/resources/asset-item-movement/stock.movement.model.ts
-var import_joi103 = __toESM(require("joi"));
-var import_mongodb66 = require("mongodb");
-var stockMovementTypes = [
-  "in",
-  "out",
-  "transfer",
-  "adjustment",
-  "conversion"
-];
-var stockMovementReferenceTypes = [
-  "purchase",
-  "sale",
-  "transfer",
-  "manual",
-  "conversion"
-];
-var schemaStockMovement = import_joi103.default.object({
-  itemId: import_joi103.default.string().hex().length(24).required(),
-  type: import_joi103.default.string().valid(...stockMovementTypes).required(),
-  quantity: import_joi103.default.number().positive().required(),
-  unitCost: import_joi103.default.number().min(0).optional().allow(null),
-  totalCost: import_joi103.default.number().min(0).optional().allow(null),
-  reference: import_joi103.default.object({
-    type: import_joi103.default.string().valid(...stockMovementReferenceTypes).required(),
-    id: import_joi103.default.string().optional().allow("", null)
-  }).optional().allow(null),
-  fromLocationId: import_joi103.default.string().optional().allow("", null),
-  toLocationId: import_joi103.default.string().optional().allow("", null),
-  fromItemId: import_joi103.default.string().hex().length(24).optional().allow("", null),
-  toItemId: import_joi103.default.string().hex().length(24).optional().allow("", null),
-  reason: import_joi103.default.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") {
+  async function conversion(newItem, quantity, unitIds) {
+    const sourceItem = await assetItemRepo.getById(String(newItem.itemRefId));
+    if (!newItem.itemRefId) {
+      throw new import_utils122.BadRequestError("Conversion requires itemRefId.");
+    }
+    if (sourceItem.trackingType === "quantity" && (sourceItem.quantityOnHand ?? 0) < quantity) {
+      throw new import_utils122.BadRequestError("Insufficient stock on source item.");
+    }
+    const session = import_utils123.useAtlas.getClient()?.startSession();
+    if (!session)
+      throw new import_utils122.BadRequestError("Failed to start session.");
     try {
-      data.itemId = new import_mongodb66.ObjectId(data.itemId);
-    } catch {
-      throw new Error(`Invalid itemId format: ${data.itemId}`);
+      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 {
-    _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()
+    stockIn,
+    stockOut,
+    transfer,
+    adjustment,
+    conversion
   };
 }
 
-// src/resources/asset-item-movement/stock.movement.repository.ts
+// src/resources/asset-item-movement/stock.movement.controller.ts
+var import_joi102 = __toESM(require("joi"));
 var import_utils124 = require("@goweekdays/utils");
-var import_mongodb67 = require("mongodb");
-function useStockMovementRepo() {
-  const namespace_collection = "stock.movements";
-  const repo = (0, import_utils124.useRepo)(namespace_collection);
-  async function createIndexes() {
+var querySchema = import_joi102.default.object({
+  itemId: import_joi102.default.string().hex().length(24).required(),
+  type: import_joi102.default.string().valid(...stockMovementTypes).optional().allow("", null),
+  page: import_joi102.default.number().min(1).optional().allow("", null),
+  limit: import_joi102.default.number().min(1).optional().allow("", null)
+});
+var idParamSchema2 = import_joi102.default.object({
+  id: import_joi102.default.string().hex().length(24).required()
+});
+var stockInSchema = import_joi102.default.object({
+  itemId: import_joi102.default.string().hex().length(24).required(),
+  quantity: import_joi102.default.number().positive().required(),
+  unitCost: import_joi102.default.number().min(0).optional().allow(null),
+  totalCost: import_joi102.default.number().min(0).optional().allow(null),
+  reference: import_joi102.default.object({
+    type: import_joi102.default.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
+    id: import_joi102.default.string().optional().allow("", null)
+  }).optional().allow(null),
+  toLocationId: import_joi102.default.string().optional().allow("", null),
+  units: import_joi102.default.array().items(
+    import_joi102.default.object({
+      serialNumber: import_joi102.default.string().optional().allow("", null),
+      plateNumber: import_joi102.default.string().optional().allow("", null)
+    })
+  ).optional()
+});
+var stockOutSchema = import_joi102.default.object({
+  itemId: import_joi102.default.string().hex().length(24).required(),
+  quantity: import_joi102.default.number().positive().required(),
+  unitCost: import_joi102.default.number().min(0).optional().allow(null),
+  totalCost: import_joi102.default.number().min(0).optional().allow(null),
+  reference: import_joi102.default.object({
+    type: import_joi102.default.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
+    id: import_joi102.default.string().optional().allow("", null)
+  }).optional().allow(null),
+  fromLocationId: import_joi102.default.string().optional().allow("", null),
+  unitIds: import_joi102.default.array().items(import_joi102.default.string().hex().length(24)).optional()
+});
+var transferSchema = import_joi102.default.object({
+  itemId: import_joi102.default.string().hex().length(24).required(),
+  quantity: import_joi102.default.number().positive().required(),
+  fromLocationId: import_joi102.default.string().required(),
+  toLocationId: import_joi102.default.string().required(),
+  reference: import_joi102.default.object({
+    type: import_joi102.default.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
+    id: import_joi102.default.string().optional().allow("", null)
+  }).optional().allow(null),
+  unitIds: import_joi102.default.array().items(import_joi102.default.string().hex().length(24)).optional()
+});
+var adjustmentSchema = import_joi102.default.object({
+  itemId: import_joi102.default.string().hex().length(24).required(),
+  quantity: import_joi102.default.number().required(),
+  reason: import_joi102.default.string().required(),
+  reference: import_joi102.default.object({
+    type: import_joi102.default.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
+    id: import_joi102.default.string().optional().allow("", null)
+  }).optional().allow(null)
+});
+var conversionSchema = import_joi102.default.object({
+  quantity: import_joi102.default.number().positive().required(),
+  newItem: import_joi102.default.object({
+    name: import_joi102.default.string().required(),
+    description: import_joi102.default.string().optional().allow("", null),
+    assetCategory: import_joi102.default.string().valid(...assetItemCategories).required(),
+    assetClass: import_joi102.default.string().valid(...assetItemClasses).required(),
+    trackingType: import_joi102.default.string().valid(...assetItemTrackingTypes).required(),
+    purpose: import_joi102.default.string().valid(...assetItemPurposes).required(),
+    itemRefId: import_joi102.default.string().hex().length(24).required(),
+    remarks: import_joi102.default.string().optional().allow("", null),
+    departmentId: import_joi102.default.string().required(),
+    departmentName: import_joi102.default.string().required(),
+    categoryId: import_joi102.default.string().required(),
+    categoryName: import_joi102.default.string().required(),
+    subcategoryId: import_joi102.default.string().required(),
+    subcategoryName: import_joi102.default.string().required(),
+    categoryPath: import_joi102.default.string().required(),
+    brand: import_joi102.default.string().optional().allow("", null),
+    tags: import_joi102.default.array().items(
+      import_joi102.default.object({
+        id: import_joi102.default.string().required(),
+        name: import_joi102.default.string().required()
+      })
+    ).optional().default([])
+  }).required(),
+  unitIds: import_joi102.default.array().items(import_joi102.default.string().hex().length(24)).optional()
+});
+function useStockMovementController() {
+  const repo = useStockMovementRepo();
+  const service = useStockMovementService();
+  async function stockIn(req, res, next) {
     try {
-      await repo.collection.createIndexes([
-        { key: { itemId: 1 } },
-        { key: { createdAt: -1 } },
-        { key: { itemId: 1, createdAt: -1 } },
-        { key: { type: 1 } }
-      ]);
+      const { error } = stockInSchema.validate(req.body);
+      if (error) {
+        next(new import_utils124.BadRequestError(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) {
-      throw new import_utils124.BadRequestError("Failed to create stock movement indexes.");
+      next(error);
     }
   }
-  async function add(value, session) {
+  async function stockOut(req, res, next) {
     try {
-      value = modelStockMovement(value);
-      const res = await repo.collection.insertOne(value, { session });
-      repo.delCachedData();
-      return res.insertedId;
+      const { error } = stockOutSchema.validate(req.body);
+      if (error) {
+        next(new import_utils124.BadRequestError(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) {
-      import_utils124.logger.log({ level: "error", message: error.message });
-      throw new import_utils124.InternalServerError("Failed to create stock movement.");
+      next(error);
     }
   }
-  async function getByItemId({
-    itemId,
-    type = "",
-    page = 1,
-    limit = 10
-  }) {
-    page = page > 0 ? page - 1 : 0;
-    const query = {
-      itemId: new import_mongodb67.ObjectId(itemId)
-    };
-    if (type) {
-      query.type = type;
-    }
-    const cacheKey = (0, import_utils124.makeCacheKey)(namespace_collection, {
-      itemId,
-      type,
-      page,
-      limit,
-      tag: "byItemId"
-    });
+  async function transfer(req, res, next) {
     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 = (0, import_utils124.paginate)(items, page, limit, length);
-      repo.setCache(cacheKey, data, 600);
-      return data;
+      const { error } = transferSchema.validate(req.body);
+      if (error) {
+        next(new import_utils124.BadRequestError(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) {
-      import_utils124.logger.log({ level: "error", message: `${error}` });
-      throw error;
+      next(error);
     }
   }
-  async function getById(id) {
-    const cacheKey = (0, import_utils124.makeCacheKey)(namespace_collection, {
-      id,
-      tag: "by-id"
-    });
+  async function adjustment(req, res, next) {
     try {
-      const cached = await repo.getCache(cacheKey);
-      if (cached)
-        return cached;
-      const result = await repo.collection.findOne({
-        _id: new import_mongodb67.ObjectId(id)
+      const { error } = adjustmentSchema.validate(req.body);
+      if (error) {
+        next(new import_utils124.BadRequestError(error.message));
+        return;
+      }
+      const movementId = await service.adjustment(req.body);
+      res.status(201).json({
+        message: "Adjustment recorded successfully.",
+        movementId
       });
-      if (!result) {
-        throw new import_utils124.BadRequestError("Stock movement not found.");
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function getByItemId(req, res, next) {
+    const { error } = querySchema.validate(req.query);
+    if (error) {
+      next(new import_utils124.BadRequestError(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 } = idParamSchema2.validate(req.params);
+    if (error) {
+      next(new import_utils124.BadRequestError(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 import_utils124.BadRequestError(error.message));
+        return;
       }
-      repo.setCache(cacheKey, result, 300);
-      return result;
+      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) {
-      if (error instanceof import_utils124.AppError)
-        throw error;
-      throw new import_utils124.InternalServerError("Failed to get stock movement.");
+      next(error);
     }
   }
   return {
-    createIndexes,
-    add,
+    stockIn,
+    stockOut,
+    transfer,
+    adjustment,
+    conversion,
     getByItemId,
     getById
   };
 }
 
-// src/resources/asset-item-movement/stock.movement.service.ts
+// src/resources/asset-item-unit/asset.unit.controller.ts
+var import_joi103 = __toESM(require("joi"));
 var import_utils125 = require("@goweekdays/utils");
-var import_utils126 = require("@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 = import_utils126.useAtlas.getClient()?.startSession();
-    if (!session)
-      throw new import_utils125.BadRequestError("Failed to start session.");
+var querySchema2 = import_joi103.default.object({
+  itemId: import_joi103.default.string().hex().length(24).required(),
+  status: import_joi103.default.string().valid(...assetUnitStatuses).optional().allow("", null),
+  page: import_joi103.default.number().min(1).optional().allow("", null),
+  limit: import_joi103.default.number().min(1).optional().allow("", null)
+});
+var idParamSchema3 = import_joi103.default.object({
+  id: import_joi103.default.string().hex().length(24).required()
+});
+function useAssetUnitController() {
+  const repo = useAssetUnitRepo();
+  async function add(req, res, next) {
     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
-          );
-        }
+      const { error } = schemaAssetUnit.validate(req.body);
+      if (error) {
+        next(new import_utils125.BadRequestError(error.message));
+        return;
       }
-      await assetItemRepo.incrementQuantity(
-        String(value.itemId),
-        value.quantity,
-        session
-      );
-      await session.commitTransaction();
-      return movementId;
+      const unitId = await repo.add(req.body);
+      res.status(201).json({
+        message: "Asset unit created successfully.",
+        unitId
+      });
     } catch (error) {
-      await session.abortTransaction();
-      throw error;
-    } finally {
-      await session.endSession();
+      next(error);
     }
   }
-  async function stockOut(value, unitIds) {
-    const item = await assetItemRepo.getById(String(value.itemId));
-    if (item.trackingType === "quantity" && (item.quantityOnHand ?? 0) < value.quantity) {
-      throw new import_utils125.BadRequestError("Insufficient stock.");
+  async function getByItemId(req, res, next) {
+    const { error } = querySchema2.validate(req.query);
+    if (error) {
+      next(new import_utils125.BadRequestError(error.message));
+      return;
     }
-    const session = import_utils126.useAtlas.getClient()?.startSession();
-    if (!session)
-      throw new import_utils125.BadRequestError("Failed to start session.");
+    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 {
-      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();
+      const results = await repo.getByItemId({ itemId, status: status2, page, limit });
+      res.json(results);
+    } catch (error2) {
+      next(error2);
     }
   }
-  async function transfer(value, unitIds) {
-    if (!value.fromLocationId || !value.toLocationId) {
-      throw new import_utils125.BadRequestError(
-        "Transfer requires both fromLocationId and toLocationId."
-      );
+  async function getById(req, res, next) {
+    const { error } = idParamSchema3.validate(req.params);
+    if (error) {
+      next(new import_utils125.BadRequestError(error.message));
+      return;
     }
-    const item = await assetItemRepo.getById(String(value.itemId));
-    const session = import_utils126.useAtlas.getClient()?.startSession();
-    if (!session)
-      throw new import_utils125.BadRequestError("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;
+      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 import_utils125.BadRequestError(paramError.message));
+      return;
+    }
+    const { error: bodyError } = schemaAssetUnitUpdate.validate(req.body);
+    if (bodyError) {
+      next(new import_utils125.BadRequestError(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) {
-      await session.abortTransaction();
-      throw error;
-    } finally {
-      await session.endSession();
+      next(error);
     }
   }
-  async function adjustment(value) {
-    if (!value.reason) {
-      throw new import_utils125.BadRequestError("Adjustment requires a reason.");
+  return {
+    add,
+    getByItemId,
+    getById,
+    updateById
+  };
+}
+
+// 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();
+  const stockMovementRepo = useStockMovementRepo();
+  const assetUnitRepo = useAssetUnitRepo();
+  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 = import_utils126.useAtlas.getClient()?.startSession();
-    if (!session)
-      throw new import_utils125.BadRequestError("Failed to start session.");
+    if (!session) {
+      throw new import_utils126.InternalServerError(
+        "Unable to start session for asset item service."
+      );
+    }
     try {
-      session.startTransaction();
-      value.type = "adjustment";
-      const movementId = await movementRepo.add(value, session);
-      await assetItemRepo.incrementQuantity(
-        String(value.itemId),
-        value.quantity,
-        session
+      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 movementId;
+      return assetItemId;
     } catch (error) {
       await session.abortTransaction();
-      throw error;
+      if (error instanceof import_utils126.AppError)
+        throw error;
+      throw new import_utils126.InternalServerError("Failed to create asset item.");
     } finally {
-      await session.endSession();
+      session.endSession();
     }
   }
-  async function conversion(newItem, quantity, unitIds) {
-    const sourceItem = await assetItemRepo.getById(String(newItem.itemRefId));
-    if (!newItem.itemRefId) {
-      throw new import_utils125.BadRequestError("Conversion requires itemRefId.");
+  async function makePublic(id, value) {
+    try {
+      await assetItemRepo.updateById(id, {
+        isPublic: value,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      return "Asset item visibility updated successfully.";
+    } catch (error) {
+      if (error instanceof import_utils126.AppError)
+        throw error;
+      throw new import_utils126.InternalServerError("Failed to update asset item visibility.");
     }
-    if (sourceItem.trackingType === "quantity" && (sourceItem.quantityOnHand ?? 0) < quantity) {
-      throw new import_utils125.BadRequestError("Insufficient stock on source item.");
+  }
+  async function deleteById(id) {
+    const [movementCount, unitCount] = await Promise.all([
+      stockMovementRepo.countByItemId(id),
+      assetUnitRepo.countByItemId(id)
+    ]);
+    if (movementCount > 0 || unitCount > 0) {
+      throw new import_utils126.BadRequestError(
+        "Cannot delete asset item because it has associated movement or unit records."
+      );
     }
-    const session = import_utils126.useAtlas.getClient()?.startSession();
-    if (!session)
-      throw new import_utils125.BadRequestError("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 };
+      await assetItemRepo.deleteById(id);
+      return "Asset item deleted successfully.";
     } catch (error) {
-      await session.abortTransaction();
-      throw error;
-    } finally {
-      await session.endSession();
+      if (error instanceof import_utils126.AppError)
+        throw error;
+      throw new import_utils126.InternalServerError("Failed to delete asset item.");
     }
   }
   return {
-    stockIn,
-    stockOut,
-    transfer,
-    adjustment,
-    conversion
+    add,
+    makePublic,
+    deleteById
   };
 }
 
-// src/resources/asset-item-movement/stock.movement.controller.ts
+// src/resources/asset-item/asset.item.controller.ts
 var import_joi104 = __toESM(require("joi"));
 var import_utils127 = require("@goweekdays/utils");
-var querySchema2 = import_joi104.default.object({
-  itemId: import_joi104.default.string().hex().length(24).required(),
-  type: import_joi104.default.string().valid(...stockMovementTypes).optional().allow("", null),
+var paginationSchema3 = import_joi104.default.object({
   page: import_joi104.default.number().min(1).optional().allow("", null),
-  limit: import_joi104.default.number().min(1).optional().allow("", null)
+  limit: import_joi104.default.number().min(1).optional().allow("", null),
+  search: import_joi104.default.string().optional().allow("", null),
+  status: import_joi104.default.string().valid(...assetItemStatuses).optional().allow("", null),
+  assetCategory: import_joi104.default.string().valid(...assetItemCategories).optional().allow("", null),
+  trackingType: import_joi104.default.string().valid(...assetItemTrackingTypes).optional().allow("", null),
+  purpose: import_joi104.default.string().valid(...assetItemPurposes).optional().allow("", null),
+  departmentId: import_joi104.default.string().optional().allow("", null),
+  categoryId: import_joi104.default.string().optional().allow("", null),
+  subcategoryId: import_joi104.default.string().optional().allow("", null),
+  brand: import_joi104.default.string().optional().allow("", null),
+  tags: import_joi104.default.string().optional().allow("", null),
+  public: import_joi104.default.boolean().optional().allow("", null)
 });
 var idParamSchema4 = import_joi104.default.object({
   id: import_joi104.default.string().hex().length(24).required()
 });
-var stockInSchema = import_joi104.default.object({
-  itemId: import_joi104.default.string().hex().length(24).required(),
-  quantity: import_joi104.default.number().positive().required(),
-  unitCost: import_joi104.default.number().min(0).optional().allow(null),
-  totalCost: import_joi104.default.number().min(0).optional().allow(null),
-  reference: import_joi104.default.object({
-    type: import_joi104.default.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
-    id: import_joi104.default.string().optional().allow("", null)
-  }).optional().allow(null),
-  toLocationId: import_joi104.default.string().optional().allow("", null),
-  units: import_joi104.default.array().items(
-    import_joi104.default.object({
-      serialNumber: import_joi104.default.string().optional().allow("", null),
-      plateNumber: import_joi104.default.string().optional().allow("", null)
-    })
-  ).optional()
-});
-var stockOutSchema = import_joi104.default.object({
-  itemId: import_joi104.default.string().hex().length(24).required(),
-  quantity: import_joi104.default.number().positive().required(),
-  unitCost: import_joi104.default.number().min(0).optional().allow(null),
-  totalCost: import_joi104.default.number().min(0).optional().allow(null),
-  reference: import_joi104.default.object({
-    type: import_joi104.default.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
-    id: import_joi104.default.string().optional().allow("", null)
-  }).optional().allow(null),
-  fromLocationId: import_joi104.default.string().optional().allow("", null),
-  unitIds: import_joi104.default.array().items(import_joi104.default.string().hex().length(24)).optional()
-});
-var transferSchema = import_joi104.default.object({
-  itemId: import_joi104.default.string().hex().length(24).required(),
-  quantity: import_joi104.default.number().positive().required(),
-  fromLocationId: import_joi104.default.string().required(),
-  toLocationId: import_joi104.default.string().required(),
-  reference: import_joi104.default.object({
-    type: import_joi104.default.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
-    id: import_joi104.default.string().optional().allow("", null)
-  }).optional().allow(null),
-  unitIds: import_joi104.default.array().items(import_joi104.default.string().hex().length(24)).optional()
-});
-var adjustmentSchema = import_joi104.default.object({
-  itemId: import_joi104.default.string().hex().length(24).required(),
-  quantity: import_joi104.default.number().required(),
-  reason: import_joi104.default.string().required(),
-  reference: import_joi104.default.object({
-    type: import_joi104.default.string().valid("purchase", "sale", "transfer", "manual", "conversion").required(),
-    id: import_joi104.default.string().optional().allow("", null)
-  }).optional().allow(null)
-});
-var conversionSchema = import_joi104.default.object({
-  quantity: import_joi104.default.number().positive().required(),
-  newItem: import_joi104.default.object({
-    name: import_joi104.default.string().required(),
-    description: import_joi104.default.string().optional().allow("", null),
-    assetCategory: import_joi104.default.string().valid(...assetItemCategories).required(),
-    assetClass: import_joi104.default.string().valid(...assetItemClasses).required(),
-    trackingType: import_joi104.default.string().valid(...assetItemTrackingTypes).required(),
-    purpose: import_joi104.default.string().valid(...assetItemPurposes).required(),
-    itemRefId: import_joi104.default.string().hex().length(24).required(),
-    remarks: import_joi104.default.string().optional().allow("", null),
-    departmentId: import_joi104.default.string().required(),
-    departmentName: import_joi104.default.string().required(),
-    categoryId: import_joi104.default.string().required(),
-    categoryName: import_joi104.default.string().required(),
-    subcategoryId: import_joi104.default.string().required(),
-    subcategoryName: import_joi104.default.string().required(),
-    categoryPath: import_joi104.default.string().required(),
-    brand: import_joi104.default.string().optional().allow("", null),
-    tags: import_joi104.default.array().items(
-      import_joi104.default.object({
-        id: import_joi104.default.string().required(),
-        name: import_joi104.default.string().required()
-      })
-    ).optional().default([])
-  }).required(),
-  unitIds: import_joi104.default.array().items(import_joi104.default.string().hex().length(24)).optional()
-});
-function useStockMovementController() {
-  const repo = useStockMovementRepo();
-  const service = useStockMovementService();
-  async function stockIn(req, res, next) {
+function useAssetItemController() {
+  const repo = useAssetItemRepo();
+  const service = useAssetItemService();
+  async function add(req, res, next) {
     try {
-      const { error } = stockInSchema.validate(req.body);
+      const { error, value } = schemaAssetItemCreate.validate(req.body);
       if (error) {
         next(new import_utils127.BadRequestError(error.message));
         return;
       }
-      const { units, ...movement } = req.body;
-      const movementId = await service.stockIn(movement, units);
+      const assetItemId = await service.add(value);
       res.status(201).json({
-        message: "Stock in recorded successfully.",
-        movementId
+        message: "Asset item created successfully.",
+        assetItemId
       });
     } catch (error) {
       next(error);
     }
   }
-  async function stockOut(req, res, next) {
+  async function getAll(req, res, next) {
+    const { error } = paginationSchema3.validate(req.query);
+    if (error) {
+      next(new import_utils127.BadRequestError(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) : [];
+    const isPublic = req.query.public === "true";
+    if (!isFinite(page)) {
+      next(new import_utils127.BadRequestError("Invalid page number."));
+      return;
+    }
+    if (!isFinite(limit)) {
+      next(new import_utils127.BadRequestError("Invalid limit number."));
+      return;
+    }
     try {
-      const { error } = stockOutSchema.validate(req.body);
-      if (error) {
-        next(new import_utils127.BadRequestError(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
+      const results = await repo.getAll({
+        page,
+        limit,
+        search,
+        status: status2,
+        assetCategory,
+        trackingType,
+        purpose,
+        departmentId,
+        categoryId,
+        subcategoryId,
+        brand,
+        tags,
+        isPublic
       });
-    } catch (error) {
-      next(error);
+      res.json(results);
+    } catch (error2) {
+      next(error2);
     }
   }
-  async function transfer(req, res, next) {
+  async function getById(req, res, next) {
+    const { error } = idParamSchema4.validate(req.params);
+    if (error) {
+      next(new import_utils127.BadRequestError(error.message));
+      return;
+    }
     try {
-      const { error } = transferSchema.validate(req.body);
-      if (error) {
-        next(new import_utils127.BadRequestError(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);
+      const assetItem = await repo.getById(req.params.id);
+      res.json(assetItem);
+    } catch (error2) {
+      next(error2);
     }
   }
-  async function adjustment(req, res, next) {
+  async function updateById(req, res, next) {
+    const { error: paramError } = import_joi104.default.object({
+      id: import_joi104.default.string().hex().length(24).required(),
+      orgId: import_joi104.default.string().hex().required()
+    }).validate(req.params);
+    if (paramError) {
+      next(new import_utils127.BadRequestError(paramError.message));
+      return;
+    }
+    const { error: bodyError } = schemaAssetItemUpdate.validate(req.body);
+    if (bodyError) {
+      next(new import_utils127.BadRequestError(bodyError.message));
+      return;
+    }
     try {
-      const { error } = adjustmentSchema.validate(req.body);
-      if (error) {
-        next(new import_utils127.BadRequestError(error.message));
-        return;
-      }
-      const movementId = await service.adjustment(req.body);
-      res.status(201).json({
-        message: "Adjustment recorded successfully.",
-        movementId
+      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 getByItemId(req, res, next) {
-    const { error } = querySchema2.validate(req.query);
+  async function makePublic(req, res, next) {
+    const { error, value } = import_joi104.default.object({
+      orgId: import_joi104.default.string().hex().required(),
+      id: import_joi104.default.string().hex().length(24).required(),
+      isPublic: import_joi104.default.boolean().required()
+    }).validate({ ...req.params, ...req.body });
     if (error) {
       next(new import_utils127.BadRequestError(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);
+      const message = await service.makePublic(value.id, value.isPublic);
+      res.json({
+        message
+      });
+      return;
     } catch (error2) {
-      next(error2);
+      if (error2 instanceof import_utils127.AppError) {
+        next(error2);
+        return;
+      }
+      next(new import_utils127.InternalServerError("Failed to update asset item visibility."));
     }
   }
-  async function getById(req, res, next) {
-    const { error } = idParamSchema4.validate(req.params);
+  async function deleteById(req, res, next) {
+    const { error } = import_joi104.default.object({
+      id: import_joi104.default.string().hex().length(24).required(),
+      orgId: import_joi104.default.string().hex().required()
+    }).validate(req.params);
     if (error) {
       next(new import_utils127.BadRequestError(error.message));
       return;
     }
     try {
-      const movement = await repo.getById(req.params.id);
-      res.json(movement);
+      await service.deleteById(req.params.id);
+      res.json({
+        message: "Asset item deleted successfully."
+      });
     } catch (error2) {
       next(error2);
     }
   }
-  async function conversion(req, res, next) {
-    try {
-      const { error } = conversionSchema.validate(req.body);
-      if (error) {
-        next(new import_utils127.BadRequestError(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
+    add,
+    getAll,
+    getById,
+    updateById,
+    makePublic,
+    deleteById
   };
 }