@goweekdays/core 2.15.6 → 2.15.8

package/dist/index.js

@@ -72,6 +72,14 @@ __export(src_exports, {
   VERIFICATION_USER_INVITE_DURATION: () => VERIFICATION_USER_INVITE_DURATION,
   XENDIT_BASE_URL: () => XENDIT_BASE_URL,
   XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
+  assetItemCategories: () => assetItemCategories,
+  assetItemClasses: () => assetItemClasses,
+  assetItemPurposes: () => assetItemPurposes,
+  assetItemStatuses: () => assetItemStatuses,
+  assetItemTrackingTypes: () => assetItemTrackingTypes,
+  assetUnitStatuses: () => assetUnitStatuses,
+  buildCategoryPath: () => buildCategoryPath,
+  categoryLevels: () => categoryLevels,
   chartOfAccountControlTypes: () => chartOfAccountControlTypes,
   chartOfAccountNormalBalances: () => chartOfAccountNormalBalances,
   chartOfAccountStatuses: () => chartOfAccountStatuses,
@@ -86,7 +94,10 @@ __export(src_exports, {
   ledgerBillTypes: () => ledgerBillTypes,
   modelAccountBalance: () => modelAccountBalance,
   modelApp: () => modelApp,
+  modelAssetItem: () => modelAssetItem,
+  modelAssetUnit: () => modelAssetUnit,
   modelBusinessProfile: () => modelBusinessProfile,
+  modelCategoryNode: () => modelCategoryNode,
   modelChartOfAccount: () => modelChartOfAccount,
   modelCustomer: () => modelCustomer,
   modelJobApplication: () => modelJobApplication,
@@ -112,14 +123,22 @@ __export(src_exports, {
   modelPlan: () => modelPlan,
   modelPromo: () => modelPromo,
   modelRole: () => modelRole,
+  modelStockMovement: () => modelStockMovement,
   modelSubscription: () => modelSubscription,
   modelSubscriptionTransaction: () => modelSubscriptionTransaction,
+  modelTag: () => modelTag,
   modelTax: () => modelTax,
   modelUser: () => modelUser,
   modelVerification: () => modelVerification,
+  normalizeName: () => normalizeName,
   schemaAccountBalance: () => schemaAccountBalance,
   schemaApp: () => schemaApp,
   schemaAppUpdate: () => schemaAppUpdate,
+  schemaAssetItem: () => schemaAssetItem,
+  schemaAssetItemCreate: () => schemaAssetItemCreate,
+  schemaAssetItemUpdate: () => schemaAssetItemUpdate,
+  schemaAssetUnit: () => schemaAssetUnit,
+  schemaAssetUnitUpdate: () => schemaAssetUnitUpdate,
   schemaAward: () => schemaAward,
   schemaBuilding: () => schemaBuilding,
   schemaBuildingUnit: () => schemaBuildingUnit,
@@ -131,6 +150,10 @@ __export(src_exports, {
   schemaBusinessProfileRegisteredAddress: () => schemaBusinessProfileRegisteredAddress,
   schemaBusinessProfileTIN: () => schemaBusinessProfileTIN,
   schemaBusinessProfileTradeName: () => schemaBusinessProfileTradeName,
+  schemaCategoryGetAll: () => schemaCategoryGetAll,
+  schemaCategoryNodeCreate: () => schemaCategoryNodeCreate,
+  schemaCategoryNodeStd: () => schemaCategoryNodeStd,
+  schemaCategoryNodeUpdate: () => schemaCategoryNodeUpdate,
   schemaCertification: () => schemaCertification,
   schemaChartOfAccountBase: () => schemaChartOfAccountBase,
   schemaChartOfAccountStd: () => schemaChartOfAccountStd,
@@ -200,6 +223,7 @@ __export(src_exports, {
   schemaRole: () => schemaRole,
   schemaRoleUpdate: () => schemaRoleUpdate,
   schemaSkill: () => schemaSkill,
+  schemaStockMovement: () => schemaStockMovement,
   schemaSubscribe: () => schemaSubscribe,
   schemaSubscription: () => schemaSubscription,
   schemaSubscriptionCompute: () => schemaSubscriptionCompute,
@@ -207,6 +231,9 @@ __export(src_exports, {
   schemaSubscriptionSeats: () => schemaSubscriptionSeats,
   schemaSubscriptionTransaction: () => schemaSubscriptionTransaction,
   schemaSubscriptionUpdate: () => schemaSubscriptionUpdate,
+  schemaTagCreate: () => schemaTagCreate,
+  schemaTagStd: () => schemaTagStd,
+  schemaTagUpdate: () => schemaTagUpdate,
   schemaTax: () => schemaTax,
   schemaTaxUpdate: () => schemaTaxUpdate,
   schemaUpdateOptions: () => schemaUpdateOptions,
@@ -214,6 +241,8 @@ __export(src_exports, {
   schemaVerification: () => schemaVerification,
   schemaVerificationOrgInvite: () => schemaVerificationOrgInvite,
   schemaWorkExp: () => schemaWorkExp,
+  stockMovementReferenceTypes: () => stockMovementReferenceTypes,
+  stockMovementTypes: () => stockMovementTypes,
   taxDirections: () => taxDirections,
   taxTypes: () => taxTypes,
   transactionSchema: () => transactionSchema,
@@ -221,6 +250,11 @@ __export(src_exports, {
   useAppController: () => useAppController,
   useAppRepo: () => useAppRepo,
   useAppService: () => useAppService,
+  useAssetItemController: () => useAssetItemController,
+  useAssetItemRepo: () => useAssetItemRepo,
+  useAssetItemService: () => useAssetItemService,
+  useAssetUnitController: () => useAssetUnitController,
+  useAssetUnitRepo: () => useAssetUnitRepo,
   useAuthController: () => useAuthController,
   useAuthService: () => useAuthService,
   useBuildingController: () => useBuildingController,
@@ -231,6 +265,9 @@ __export(src_exports, {
   useBuildingUnitService: () => useBuildingUnitService,
   useBusinessProfileCtrl: () => useBusinessProfileCtrl,
   useBusinessProfileRepo: () => useBusinessProfileRepo,
+  useCategoryController: () => useCategoryController,
+  useCategoryRepo: () => useCategoryRepo,
+  useCategoryService: () => useCategoryService,
   useChartOfAccountController: () => useChartOfAccountController,
   useChartOfAccountRepo: () => useChartOfAccountRepo,
   useCounterModel: () => useCounterModel,
@@ -286,11 +323,17 @@ __export(src_exports, {
   useRoleController: () => useRoleController,
   useRoleRepo: () => useRoleRepo,
   useRoleService: () => useRoleService,
+  useStockMovementController: () => useStockMovementController,
+  useStockMovementRepo: () => useStockMovementRepo,
+  useStockMovementService: () => useStockMovementService,
   useSubscriptionController: () => useSubscriptionController,
   useSubscriptionRepo: () => useSubscriptionRepo,
   useSubscriptionService: () => useSubscriptionService,
   useSubscriptionTransactionController: () => useSubscriptionTransactionController,
   useSubscriptionTransactionRepo: () => useSubscriptionTransactionRepo,
+  useTagController: () => useTagController,
+  useTagRepo: () => useTagRepo,
+  useTagService: () => useTagService,
   useTaxController: () => useTaxController,
   useTaxRepo: () => useTaxRepo,
   useUserController: () => useUserController,
@@ -3671,6 +3714,11 @@ function useAppService() {
         name: "Finance",
         description: "Finance and billing services."
       },
+      {
+        code: "assets",
+        name: "Assets",
+        description: "Asset management and tracking."
+      },
       {
         code: "marketplace",
         name: "Marketplace",
@@ -22459,6 +22507,2523 @@ function useJournalLineController() {
     getById
   };
 }
+
+// src/resources/asset-item/asset.item.model.ts
+var import_utils115 = require("@goweekdays/utils");
+var import_joi96 = __toESM(require("joi"));
+var import_mongodb58 = require("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: import_joi96.default.string().hex().length(24).required(),
+  name: import_joi96.default.string().required(),
+  sku: import_joi96.default.string().optional().allow("", null).default(""),
+  price: import_joi96.default.number().min(0).optional().allow("", null).default(0),
+  unit: import_joi96.default.string().required(),
+  description: import_joi96.default.string().optional().allow("", null),
+  assetCategory: import_joi96.default.string().valid(...assetItemCategories).required(),
+  assetClass: import_joi96.default.string().valid(...assetItemClasses).optional().allow("", null),
+  trackingType: import_joi96.default.string().valid(...assetItemTrackingTypes).required(),
+  purpose: import_joi96.default.string().valid(...assetItemPurposes).required(),
+  itemRefId: import_joi96.default.string().hex().length(24).optional().allow("", null),
+  remarks: import_joi96.default.string().optional().allow("", null),
+  departmentId: import_joi96.default.string().hex().length(24).required(),
+  categoryId: import_joi96.default.string().hex().length(24).optional().allow("", null),
+  subcategoryId: import_joi96.default.string().hex().length(24).optional().allow("", null),
+  categoryPath: import_joi96.default.string().optional().allow("", null),
+  brand: import_joi96.default.string().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().default([]),
+  quantityOnHand: import_joi96.default.number().min(0).optional().default(0)
+};
+var schemaAssetItem = import_joi96.default.object({
+  ...schemaAssetItemBase,
+  departmentName: import_joi96.default.string().required(),
+  categoryName: import_joi96.default.string().optional().allow("", null),
+  subcategoryName: import_joi96.default.string().optional().allow("", null),
+  status: import_joi96.default.string().valid(...assetItemStatuses).optional().allow("", null)
+});
+var schemaAssetItemCreate = import_joi96.default.object({
+  ...schemaAssetItemBase,
+  tags: import_joi96.default.array().items(
+    import_joi96.default.object({
+      id: import_joi96.default.string().required(),
+      name: import_joi96.default.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 = import_joi96.default.object({
+  name: 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(),
+  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()
+});
+function modelAssetItem(data) {
+  const { error } = schemaAssetItem.validate(data);
+  if (error) {
+    throw new import_utils115.BadRequestError(`Invalid asset item data: ${error.message}`);
+  }
+  try {
+    data.orgId = new import_mongodb58.ObjectId(data.orgId);
+  } catch (error2) {
+    throw new import_utils115.BadRequestError("Invalid orgId format.");
+  }
+  try {
+    data.departmentId = new import_mongodb58.ObjectId(data.departmentId);
+  } catch (error2) {
+    throw new import_utils115.BadRequestError("Invalid departmentId format.");
+  }
+  if (data.categoryId) {
+    try {
+      data.categoryId = new import_mongodb58.ObjectId(data.categoryId);
+    } catch (error2) {
+      throw new import_utils115.BadRequestError("Invalid categoryId format.");
+    }
+  }
+  if (data.subcategoryId) {
+    try {
+      data.subcategoryId = new import_mongodb58.ObjectId(data.subcategoryId);
+    } catch (error2) {
+      throw new import_utils115.BadRequestError("Invalid subcategoryId format.");
+    }
+  }
+  if (data.itemRefId) {
+    try {
+      data.itemRefId = new import_mongodb58.ObjectId(data.itemRefId);
+    } catch (error2) {
+      throw new import_utils115.BadRequestError("Invalid itemRefId format.");
+    }
+  }
+  if (data.purpose === "for-sale" && (data.price === void 0 || data.price === null || data.price === 0)) {
+    throw new import_utils115.BadRequestError(
+      "Price must be greater than 0 for items marked as 'for-sale'."
+    );
+  }
+  if (data.isPublic && (data.marketplacePrice === void 0 || data.marketplacePrice === null)) {
+    throw new import_utils115.BadRequestError(
+      "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
+var import_utils116 = require("@goweekdays/utils");
+var import_mongodb59 = require("mongodb");
+function useAssetItemRepo() {
+  const namespace_collection = "asset.items";
+  const repo = (0, import_utils116.useRepo)(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 import_utils116.BadRequestError("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 import_utils116.AppError) {
+        throw error;
+      }
+      import_utils116.logger.log({ level: "error", message: error.message });
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_utils116.BadRequestError("Asset item name already exists.");
+      }
+      throw new import_utils116.InternalServerError("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 = (0, import_utils116.makeCacheKey)(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 = (0, import_utils116.paginate)(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600);
+      return data;
+    } catch (error) {
+      import_utils116.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(id) {
+    const cacheKey = (0, import_utils116.makeCacheKey)(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 import_mongodb59.ObjectId(id)
+      });
+      if (!result) {
+        throw new import_utils116.BadRequestError("Asset item not found.");
+      }
+      repo.setCache(cacheKey, result, 300);
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils116.AppError)
+        throw error;
+      throw new import_utils116.InternalServerError("Failed to get asset item.");
+    }
+  }
+  async function updateById(id, value) {
+    try {
+      const result = await repo.collection.findOneAndUpdate(
+        { _id: new import_mongodb59.ObjectId(id) },
+        { $set: { ...value, updatedAt: /* @__PURE__ */ new Date() } },
+        { returnDocument: "after" }
+      );
+      if (!result) {
+        throw new import_utils116.BadRequestError("Asset item not found.");
+      }
+      repo.delCachedData();
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils116.AppError)
+        throw error;
+      throw new import_utils116.InternalServerError("Failed to update asset item.");
+    }
+  }
+  async function incrementQuantity(id, amount, session) {
+    try {
+      const result = await repo.collection.findOneAndUpdate(
+        { _id: new import_mongodb59.ObjectId(id) },
+        {
+          $inc: { quantityOnHand: amount },
+          $set: { updatedAt: /* @__PURE__ */ new Date() }
+        },
+        { returnDocument: "after", session }
+      );
+      if (!result) {
+        throw new import_utils116.BadRequestError("Asset item not found.");
+      }
+      repo.delCachedData();
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils116.AppError)
+        throw error;
+      throw new import_utils116.InternalServerError("Failed to update asset item quantity.");
+    }
+  }
+  async function deleteById(id) {
+    try {
+      const result = await repo.collection.findOneAndUpdate(
+        { _id: new import_mongodb59.ObjectId(id) },
+        { $set: { deletedAt: /* @__PURE__ */ new Date(), status: "archived" } },
+        { returnDocument: "after" }
+      );
+      if (!result) {
+        throw new import_utils116.BadRequestError("Asset item not found.");
+      }
+      repo.delCachedData();
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils116.AppError)
+        throw error;
+      throw new import_utils116.InternalServerError("Failed to delete asset item.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateById,
+    incrementQuantity,
+    deleteById
+  };
+}
+
+// src/resources/asset-item/asset.item.service.ts
+var import_utils120 = require("@goweekdays/utils");
+
+// src/resources/tag/tag.repository.ts
+var import_utils117 = require("@goweekdays/utils");
+
+// src/resources/tag/tag.model.ts
+var import_joi97 = __toESM(require("joi"));
+var import_mongodb60 = require("mongodb");
+var schemaTagFields = {
+  name: import_joi97.default.string().required(),
+  type: import_joi97.default.string().valid("public", "private").required(),
+  orgId: import_joi97.default.string().hex().optional().allow("", null),
+  categoryPath: import_joi97.default.string().optional().allow("", null),
+  status: import_joi97.default.string().valid("active", "pending").optional()
+};
+var schemaTagCreate = import_joi97.default.object(schemaTagFields);
+var schemaTagStd = import_joi97.default.object({
+  ...schemaTagFields,
+  normalizedName: import_joi97.default.string().required(),
+  usageCount: import_joi97.default.number().integer().min(0).optional()
+});
+var schemaTagUpdate = import_joi97.default.object({
+  name: import_joi97.default.string().optional(),
+  type: import_joi97.default.string().valid("public", "private").optional(),
+  orgId: import_joi97.default.string().hex().optional().allow("", null),
+  categoryPath: import_joi97.default.string().optional().allow("", null),
+  status: import_joi97.default.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 import_mongodb60.ObjectId(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
+var import_mongodb61 = require("mongodb");
+var import_joi98 = __toESM(require("joi"));
+function useTagRepo() {
+  const namespace_collection = "tags";
+  const repo = (0, import_utils117.useRepo)(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) {
+      import_utils117.logger.log({
+        level: "error",
+        message: error.message
+      });
+      const isDuplicate = /normalizedName|unique/i.test(error.message);
+      if (isDuplicate) {
+        throw new import_utils117.BadRequestError("A tag with this name already exists.");
+      }
+      throw new import_utils117.BadRequestError(`Failed to create tag: ${error.message}`);
+    }
+  }
+  async function getAll(options) {
+    const validation = import_joi98.default.object({
+      page: import_joi98.default.number().min(1).optional().allow("", null),
+      limit: import_joi98.default.number().min(1).optional().allow("", null),
+      search: import_joi98.default.string().optional().allow("", null),
+      type: import_joi98.default.string().valid("public", "private").optional().allow("", null),
+      orgId: import_joi98.default.string().hex().optional().allow("", null),
+      status: import_joi98.default.string().valid("active", "pending").optional().allow("", null),
+      categoryPath: import_joi98.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(options);
+    if (error) {
+      throw new import_utils117.BadRequestError(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 import_mongodb61.ObjectId(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 = (0, import_utils117.makeCacheKey)(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 = (0, import_utils117.paginate)(items, options.page, options.limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        import_utils117.logger.log({
+          level: "info",
+          message: `Cache set for getAll tags: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils117.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll tags: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      import_utils117.logger.log({ level: "error", message: `${error2}` });
+      throw error2;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb61.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils117.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_utils117.makeCacheKey)(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 import_utils117.BadRequestError("Tag not found.");
+      }
+      repo.setCache(cacheKey, result, 300).then(() => {
+        import_utils117.logger.log({
+          level: "info",
+          message: `Cache set for tag by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils117.logger.log({
+          level: "error",
+          message: `Failed to set cache for tag by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils117.AppError) {
+        throw error;
+      } else {
+        throw new import_utils117.InternalServerError("Failed to get tag.");
+      }
+    }
+  }
+  async function updateById(_id, options, session) {
+    try {
+      _id = new import_mongodb61.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils117.BadRequestError("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 import_utils117.BadRequestError("A tag with this name already exists.");
+      }
+      throw new import_utils117.InternalServerError("Failed to update tag.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb61.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils117.BadRequestError("Invalid ID.");
+    }
+    try {
+      await repo.collection.deleteOne({ _id }, { session });
+      repo.delCachedData();
+      return "Successfully deleted tag.";
+    } catch (error) {
+      throw new import_utils117.InternalServerError("Failed to delete tag.");
+    }
+  }
+  async function findByNormalizedNameAndOrg(normalizedName, orgId) {
+    try {
+      const query = { normalizedName };
+      query.orgId = new import_mongodb61.ObjectId(orgId);
+      return await repo.collection.findOne(query);
+    } catch (error) {
+      if (error instanceof import_utils117.AppError)
+        throw error;
+      throw new import_utils117.InternalServerError("Failed to find tag.");
+    }
+  }
+  async function incrementUsageCount(_id, amount = 1, session) {
+    try {
+      _id = new import_mongodb61.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils117.BadRequestError("Invalid ID.");
+    }
+    try {
+      await repo.collection.updateOne(
+        { _id },
+        { $inc: { usageCount: amount } },
+        { session }
+      );
+      repo.delCachedData();
+    } catch (error) {
+      throw new import_utils117.InternalServerError("Failed to update tag usage count.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    findByNormalizedNameAndOrg,
+    updateById,
+    deleteById,
+    incrementUsageCount
+  };
+}
+
+// src/resources/asset-item-category/category.repository.ts
+var import_utils119 = require("@goweekdays/utils");
+
+// src/resources/asset-item-category/category.model.ts
+var import_joi99 = __toESM(require("joi"));
+var import_mongodb62 = require("mongodb");
+var import_utils118 = require("@goweekdays/utils");
+var categoryLevels = [
+  "department",
+  "category",
+  "subcategory"
+];
+var schemaCategoryNodeFields = {
+  orgId: import_joi99.default.string().hex().length(24).optional().allow("", null),
+  level: import_joi99.default.string().valid(...categoryLevels).required(),
+  type: import_joi99.default.string().valid("public", "private").optional().default("public"),
+  name: import_joi99.default.string().required(),
+  displayName: import_joi99.default.string().required(),
+  parentId: import_joi99.default.string().hex().length(24).optional().allow("", null),
+  path: import_joi99.default.string().optional().allow("", null),
+  isActive: import_joi99.default.boolean().optional().default(true)
+};
+var schemaCategoryNodeCreate = import_joi99.default.object({
+  displayName: import_joi99.default.string().required(),
+  parentId: import_joi99.default.string().hex().length(24).optional().allow("", null),
+  orgId: import_joi99.default.string().hex().length(24).optional().allow("", null)
+});
+var schemaCategoryNodeUpdate = import_joi99.default.object({
+  displayName: import_joi99.default.string().optional()
+});
+var schemaCategoryNodeStd = import_joi99.default.object(schemaCategoryNodeFields);
+var schemaCategoryGetAll = import_joi99.default.object({
+  page: import_joi99.default.number().integer().min(1).default(1),
+  limit: import_joi99.default.number().integer().min(1).max(100).default(20),
+  org: import_joi99.default.string().hex().length(24).optional().allow("", null).default(""),
+  parent: import_joi99.default.string().hex().length(24).optional().allow("", null).default(""),
+  level: import_joi99.default.string().valid(...categoryLevels, "").optional().default(""),
+  type: import_joi99.default.string().valid("public", "private", "").optional().default(""),
+  search: import_joi99.default.string().optional().allow("", null).default(""),
+  status: import_joi99.default.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 import_utils118.BadRequestError(`Invalid category node data: ${error.message}`);
+  }
+  if (data.orgId) {
+    try {
+      data.orgId = new import_mongodb62.ObjectId(data.orgId);
+    } catch {
+      throw new import_utils118.BadRequestError(`Invalid orgId: ${data.orgId}`);
+    }
+  }
+  if (data.parentId) {
+    try {
+      data.parentId = new import_mongodb62.ObjectId(data.parentId);
+    } catch {
+      throw new import_utils118.BadRequestError(`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
+var import_mongodb63 = require("mongodb");
+function useCategoryRepo() {
+  const namespace_collection = "categories";
+  const repo = (0, import_utils119.useRepo)(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 import_utils119.InternalServerError("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) {
+      import_utils119.logger.log({ level: "error", message: error.message });
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_utils119.BadRequestError(
+          "Category name already exists under this parent."
+        );
+      }
+      throw new import_utils119.InternalServerError("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 import_mongodb63.ObjectId(org);
+      } catch (error) {
+        throw new import_utils119.BadRequestError("Invalid org ID.");
+      }
+    }
+    if (level) {
+      query.level = level;
+    }
+    if (type) {
+      query.type = type;
+    }
+    if (parent) {
+      try {
+        query.parentId = new import_mongodb63.ObjectId(parent);
+      } catch (error) {
+        throw new import_utils119.BadRequestError("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 = (0, import_utils119.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_utils119.logger.log({
+      level: "info",
+      message: `Cache key for getAll categories: ${cacheKey}`
+    });
+    try {
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_utils119.logger.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 = (0, import_utils119.paginate)(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600).then(() => {
+        import_utils119.logger.log({
+          level: "info",
+          message: `Cache set for getAll categories: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils119.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll categories: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_utils119.logger.log({ level: "error", message: `${error}` });
+      throw new import_utils119.InternalServerError("Failed to get categories.");
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb63.ObjectId(_id);
+    } catch {
+      throw new import_utils119.BadRequestError("Invalid category ID.");
+    }
+    const cacheKey = (0, import_utils119.makeCacheKey)(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 import_utils119.BadRequestError("Category node not found.");
+      }
+      repo.setCache(cacheKey, result, 300).catch((err) => {
+        import_utils119.logger.log({
+          level: "error",
+          message: `Failed to set cache for category by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils119.AppError)
+        throw error;
+      throw new import_utils119.InternalServerError("Failed to get category node.");
+    }
+  }
+  async function getByNameParent(name, { parentId = "", orgId = "" } = {}) {
+    const query = {
+      $text: { $search: `"${name.trim()}"` }
+    };
+    if (parentId) {
+      try {
+        query.parentId = new import_mongodb63.ObjectId(parentId);
+      } catch (error) {
+        throw new import_utils119.BadRequestError("Invalid parentId.");
+      }
+    }
+    if (orgId) {
+      try {
+        query.orgId = new import_mongodb63.ObjectId(orgId);
+      } catch (error) {
+        throw new import_utils119.BadRequestError("Invalid orgId.");
+      }
+    }
+    try {
+      const cacheKey = (0, import_utils119.makeCacheKey)(namespace_collection, {
+        name,
+        parentId: parentId ?? "null",
+        orgId: orgId ?? "null",
+        tag: "by-name-parent"
+      });
+      import_utils119.logger.log({
+        level: "info",
+        message: `Cache key for getByNameParentId: ${cacheKey}`
+      });
+      const cached = await repo.getCache(cacheKey);
+      if (cached) {
+        import_utils119.logger.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) => {
+          import_utils119.logger.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 import_utils119.InternalServerError("Failed to get category node by name.");
+    }
+  }
+  async function updateById(_id, update, session) {
+    try {
+      _id = new import_mongodb63.ObjectId(_id);
+    } catch {
+      throw new import_utils119.BadRequestError("Invalid category ID.");
+    }
+    try {
+      const res = await repo.collection.updateOne(
+        { _id },
+        { $set: update },
+        { session }
+      );
+      if (res.matchedCount === 0) {
+        throw new import_utils119.BadRequestError("Category node not found.");
+      }
+      repo.delCachedData();
+    } catch (error) {
+      if (error instanceof import_utils119.AppError)
+        throw error;
+      import_utils119.logger.log({ level: "error", message: error.message });
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_utils119.BadRequestError(
+          "Category name already exists under this parent."
+        );
+      }
+      throw new import_utils119.InternalServerError("Failed to update category node.");
+    }
+  }
+  async function hasChildren(_id) {
+    try {
+      _id = new import_mongodb63.ObjectId(_id);
+    } catch {
+      throw new import_utils119.BadRequestError("Invalid category ID.");
+    }
+    try {
+      const count = await repo.collection.countDocuments({ parentId: _id });
+      return count > 0;
+    } catch (error) {
+      throw new import_utils119.InternalServerError("Failed to check for child categories.");
+    }
+  }
+  async function softDeleteById(_id, session) {
+    try {
+      _id = new import_mongodb63.ObjectId(_id);
+    } catch {
+      throw new import_utils119.BadRequestError("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 import_utils119.BadRequestError("Category node not found.");
+      }
+      repo.delCachedData();
+    } catch (error) {
+      if (error instanceof import_utils119.AppError)
+        throw error;
+      throw new import_utils119.InternalServerError("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 = import_utils120.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new import_utils120.InternalServerError(
+        "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 import_utils120.AppError)
+        throw error;
+      throw new import_utils120.InternalServerError("Failed to create asset item.");
+    } finally {
+      session.endSession();
+    }
+  }
+  return {
+    add
+  };
+}
+
+// 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) {
+    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
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  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;
+    }
+    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 import_utils121.BadRequestError(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 import_utils121.BadRequestError(paramError.message));
+      return;
+    }
+    const { error: bodyError } = schemaAssetItemUpdate.validate(req.body);
+    if (bodyError) {
+      next(new import_utils121.BadRequestError(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 import_utils121.BadRequestError(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
+var import_joi101 = __toESM(require("joi"));
+var import_mongodb64 = require("mongodb");
+var assetUnitStatuses = [
+  "available",
+  "assigned",
+  "maintenance",
+  "disposed"
+];
+var schemaAssetUnitBase = {
+  itemId: import_joi101.default.string().hex().length(24).required(),
+  serialNumber: import_joi101.default.string().optional().allow("", null),
+  plateNumber: import_joi101.default.string().optional().allow("", null),
+  status: import_joi101.default.string().valid(...assetUnitStatuses).required(),
+  locationId: import_joi101.default.string().optional().allow("", null),
+  assignedTo: import_joi101.default.string().optional().allow("", null)
+};
+var schemaAssetUnit = import_joi101.default.object(schemaAssetUnitBase);
+var schemaAssetUnitUpdate = import_joi101.default.object({
+  serialNumber: import_joi101.default.string().optional().allow("", null),
+  plateNumber: import_joi101.default.string().optional().allow("", null),
+  status: import_joi101.default.string().valid(...assetUnitStatuses).optional(),
+  locationId: import_joi101.default.string().optional().allow("", null),
+  assignedTo: import_joi101.default.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 import_mongodb64.ObjectId(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
+var import_utils122 = require("@goweekdays/utils");
+var import_mongodb65 = require("mongodb");
+function useAssetUnitRepo() {
+  const namespace_collection = "asset.units";
+  const repo = (0, import_utils122.useRepo)(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 import_utils122.BadRequestError("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) {
+      import_utils122.logger.log({ level: "error", message: error.message });
+      throw new import_utils122.InternalServerError("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 import_mongodb65.ObjectId(itemId)
+    };
+    if (status2) {
+      query.status = status2;
+    }
+    const cacheKey = (0, import_utils122.makeCacheKey)(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 = (0, import_utils122.paginate)(items, page, limit, length);
+      repo.setCache(cacheKey, data, 600);
+      return data;
+    } catch (error) {
+      import_utils122.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(id) {
+    const cacheKey = (0, import_utils122.makeCacheKey)(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 import_mongodb65.ObjectId(id)
+      });
+      if (!result) {
+        throw new import_utils122.BadRequestError("Asset unit not found.");
+      }
+      repo.setCache(cacheKey, result, 300);
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils122.AppError)
+        throw error;
+      throw new import_utils122.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) },
+        { $set: { ...value, updatedAt: /* @__PURE__ */ new Date() } },
+        { returnDocument: "after", session }
+      );
+      if (!result) {
+        throw new import_utils122.BadRequestError("Asset unit not found.");
+      }
+      repo.delCachedData();
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils122.AppError)
+        throw error;
+      throw new import_utils122.InternalServerError("Failed to update asset unit.");
+    }
+  }
+  async function countByItemIdAndStatus(itemId, status2) {
+    try {
+      return await repo.collection.countDocuments({
+        itemId: new import_mongodb65.ObjectId(itemId),
+        status: status2
+      });
+    } catch (error) {
+      throw new import_utils122.InternalServerError("Failed to count asset units.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getByItemId,
+    getById,
+    updateById,
+    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) {
+    try {
+      const { error } = schemaAssetUnit.validate(req.body);
+      if (error) {
+        next(new import_utils123.BadRequestError(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 import_utils123.BadRequestError(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 import_utils123.BadRequestError(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 import_utils123.BadRequestError(paramError.message));
+      return;
+    }
+    const { error: bodyError } = schemaAssetUnitUpdate.validate(req.body);
+    if (bodyError) {
+      next(new import_utils123.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) {
+      next(error);
+    }
+  }
+  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") {
+    try {
+      data.itemId = new import_mongodb66.ObjectId(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
+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() {
+    try {
+      await repo.collection.createIndexes([
+        { key: { itemId: 1 } },
+        { key: { createdAt: -1 } },
+        { key: { itemId: 1, createdAt: -1 } },
+        { key: { type: 1 } }
+      ]);
+    } catch (error) {
+      throw new import_utils124.BadRequestError("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) {
+      import_utils124.logger.log({ level: "error", message: error.message });
+      throw new import_utils124.InternalServerError("Failed to create stock movement.");
+    }
+  }
+  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"
+    });
+    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;
+    } catch (error) {
+      import_utils124.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(id) {
+    const cacheKey = (0, import_utils124.makeCacheKey)(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 import_mongodb67.ObjectId(id)
+      });
+      if (!result) {
+        throw new import_utils124.BadRequestError("Stock movement not found.");
+      }
+      repo.setCache(cacheKey, result, 300);
+      return result;
+    } catch (error) {
+      if (error instanceof import_utils124.AppError)
+        throw error;
+      throw new import_utils124.InternalServerError("Failed to get stock movement.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getByItemId,
+    getById
+  };
+}
+
+// src/resources/asset-item-movement/stock.movement.service.ts
+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.");
+    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 import_utils125.BadRequestError("Insufficient stock.");
+    }
+    const session = import_utils126.useAtlas.getClient()?.startSession();
+    if (!session)
+      throw new import_utils125.BadRequestError("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 import_utils125.BadRequestError(
+        "Transfer requires both fromLocationId and toLocationId."
+      );
+    }
+    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;
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function adjustment(value) {
+    if (!value.reason) {
+      throw new import_utils125.BadRequestError("Adjustment requires a reason.");
+    }
+    const session = import_utils126.useAtlas.getClient()?.startSession();
+    if (!session)
+      throw new import_utils125.BadRequestError("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 import_utils125.BadRequestError("Conversion requires itemRefId.");
+    }
+    if (sourceItem.trackingType === "quantity" && (sourceItem.quantityOnHand ?? 0) < quantity) {
+      throw new import_utils125.BadRequestError("Insufficient stock on source item.");
+    }
+    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 };
+    } 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
+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),
+  page: import_joi104.default.number().min(1).optional().allow("", null),
+  limit: import_joi104.default.number().min(1).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) {
+    try {
+      const { error } = stockInSchema.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);
+      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 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
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function transfer(req, res, next) {
+    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);
+    }
+  }
+  async function adjustment(req, res, next) {
+    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
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function getByItemId(req, res, next) {
+    const { error } = querySchema2.validate(req.query);
+    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);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const { error } = idParamSchema4.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);
+    } 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
+  };
+}
+
+// src/resources/asset-item-category/category.service.ts
+var import_utils128 = require("@goweekdays/utils");
+function useCategoryService() {
+  const repo = useCategoryRepo();
+  async function add(value) {
+    const { error } = schemaCategoryNodeCreate.validate(value);
+    if (error) {
+      throw new import_utils128.BadRequestError(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 import_utils128.BadRequestError(
+          `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 import_utils128.BadRequestError(
+          "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 import_utils128.BadRequestError(
+          `"${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 import_utils128.BadRequestError(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 import_utils128.BadRequestError(
+        "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
+var import_joi105 = __toESM(require("joi"));
+var import_utils129 = require("@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 import_utils129.BadRequestError(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 import_utils129.BadRequestError(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 } = import_joi105.default.string().hex().length(24).required().validate(_id);
+    if (errorId) {
+      next(new import_utils129.BadRequestError("Invalid category ID."));
+      return;
+    }
+    try {
+      const category = await repo.getById(_id);
+      if (!category) {
+        next(new import_utils129.BadRequestError("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 } = import_joi105.default.string().hex().length(24).required().validate(_id);
+    if (errorId) {
+      next(new import_utils129.BadRequestError("Invalid category ID."));
+      return;
+    }
+    const { error, value } = schemaCategoryNodeUpdate.validate(req.body);
+    if (error) {
+      next(new import_utils129.BadRequestError(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 } = import_joi105.default.string().hex().length(24).required().validate(_id);
+    if (errorId) {
+      next(new import_utils129.BadRequestError("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
+var import_utils130 = require("@goweekdays/utils");
+var import_joi106 = __toESM(require("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 import_utils130.BadRequestError(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 import_utils130.AppError)
+        throw error2;
+      throw new import_utils130.BadRequestError("Failed to add tag.");
+    }
+  }
+  async function updateById(id, value) {
+    const { error: errorId } = import_joi106.default.string().hex().required().validate(id);
+    if (errorId) {
+      throw new import_utils130.BadRequestError("Invalid Tag ID.");
+    }
+    const { error } = schemaTagUpdate.validate(value);
+    if (error) {
+      throw new import_utils130.BadRequestError(`Invalid tag update data: ${error.message}`);
+    }
+    const existingTag = await _getById(id);
+    if (!existingTag) {
+      throw new import_utils130.BadRequestError("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 } = import_joi106.default.string().hex().required().validate(id);
+    if (error) {
+      throw new import_utils130.BadRequestError("Invalid Tag ID.");
+    }
+    const existingTag = await _getById(id);
+    if (!existingTag) {
+      throw new import_utils130.BadRequestError("Tag not found.");
+    }
+    const message = await _deleteById(id);
+    return message;
+  }
+  return {
+    add,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/tag/tag.controller.ts
+var import_joi107 = __toESM(require("joi"));
+var import_utils131 = require("@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 import_utils131.BadRequestError(error.message));
+      import_utils131.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const message = await _add(value);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi107.default.object({
+      page: import_joi107.default.number().min(1).optional().allow("", null),
+      limit: import_joi107.default.number().min(1).optional().allow("", null),
+      search: import_joi107.default.string().optional().allow("", null),
+      type: import_joi107.default.string().valid("public", "private").optional().allow("", null),
+      orgId: import_joi107.default.string().hex().optional().allow("", null),
+      status: import_joi107.default.string().valid("active", "pending").optional().allow("", null),
+      categoryPath: import_joi107.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_utils131.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 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 import_utils131.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_utils131.BadRequestError("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 = import_joi107.default.object({
+      id: import_joi107.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_utils131.BadRequestError(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 } = import_joi107.default.string().hex().required().validate(_id);
+    if (errorId) {
+      next(new import_utils131.BadRequestError("Invalid Tag ID."));
+      return;
+    }
+    const payload = req.body;
+    const { error } = schemaTagUpdate.validate(payload);
+    if (error) {
+      next(new import_utils131.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateById(_id, payload);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    if (!id) {
+      next(new import_utils131.BadRequestError("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
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCESS_TOKEN_EXPIRY,
@@ -22503,6 +25068,14 @@ function useJournalLineController() {
   VERIFICATION_USER_INVITE_DURATION,
   XENDIT_BASE_URL,
   XENDIT_SECRET_KEY,
+  assetItemCategories,
+  assetItemClasses,
+  assetItemPurposes,
+  assetItemStatuses,
+  assetItemTrackingTypes,
+  assetUnitStatuses,
+  buildCategoryPath,
+  categoryLevels,
   chartOfAccountControlTypes,
   chartOfAccountNormalBalances,
   chartOfAccountStatuses,
@@ -22517,7 +25090,10 @@ function useJournalLineController() {
   ledgerBillTypes,
   modelAccountBalance,
   modelApp,
+  modelAssetItem,
+  modelAssetUnit,
   modelBusinessProfile,
+  modelCategoryNode,
   modelChartOfAccount,
   modelCustomer,
   modelJobApplication,
@@ -22543,14 +25119,22 @@ function useJournalLineController() {
   modelPlan,
   modelPromo,
   modelRole,
+  modelStockMovement,
   modelSubscription,
   modelSubscriptionTransaction,
+  modelTag,
   modelTax,
   modelUser,
   modelVerification,
+  normalizeName,
   schemaAccountBalance,
   schemaApp,
   schemaAppUpdate,
+  schemaAssetItem,
+  schemaAssetItemCreate,
+  schemaAssetItemUpdate,
+  schemaAssetUnit,
+  schemaAssetUnitUpdate,
   schemaAward,
   schemaBuilding,
   schemaBuildingUnit,
@@ -22562,6 +25146,10 @@ function useJournalLineController() {
   schemaBusinessProfileRegisteredAddress,
   schemaBusinessProfileTIN,
   schemaBusinessProfileTradeName,
+  schemaCategoryGetAll,
+  schemaCategoryNodeCreate,
+  schemaCategoryNodeStd,
+  schemaCategoryNodeUpdate,
   schemaCertification,
   schemaChartOfAccountBase,
   schemaChartOfAccountStd,
@@ -22631,6 +25219,7 @@ function useJournalLineController() {
   schemaRole,
   schemaRoleUpdate,
   schemaSkill,
+  schemaStockMovement,
   schemaSubscribe,
   schemaSubscription,
   schemaSubscriptionCompute,
@@ -22638,6 +25227,9 @@ function useJournalLineController() {
   schemaSubscriptionSeats,
   schemaSubscriptionTransaction,
   schemaSubscriptionUpdate,
+  schemaTagCreate,
+  schemaTagStd,
+  schemaTagUpdate,
   schemaTax,
   schemaTaxUpdate,
   schemaUpdateOptions,
@@ -22645,6 +25237,8 @@ function useJournalLineController() {
   schemaVerification,
   schemaVerificationOrgInvite,
   schemaWorkExp,
+  stockMovementReferenceTypes,
+  stockMovementTypes,
   taxDirections,
   taxTypes,
   transactionSchema,
@@ -22652,6 +25246,11 @@ function useJournalLineController() {
   useAppController,
   useAppRepo,
   useAppService,
+  useAssetItemController,
+  useAssetItemRepo,
+  useAssetItemService,
+  useAssetUnitController,
+  useAssetUnitRepo,
   useAuthController,
   useAuthService,
   useBuildingController,
@@ -22662,6 +25261,9 @@ function useJournalLineController() {
   useBuildingUnitService,
   useBusinessProfileCtrl,
   useBusinessProfileRepo,
+  useCategoryController,
+  useCategoryRepo,
+  useCategoryService,
   useChartOfAccountController,
   useChartOfAccountRepo,
   useCounterModel,
@@ -22717,11 +25319,17 @@ function useJournalLineController() {
   useRoleController,
   useRoleRepo,
   useRoleService,
+  useStockMovementController,
+  useStockMovementRepo,
+  useStockMovementService,
   useSubscriptionController,
   useSubscriptionRepo,
   useSubscriptionService,
   useSubscriptionTransactionController,
   useSubscriptionTransactionRepo,
+  useTagController,
+  useTagRepo,
+  useTagService,
   useTaxController,
   useTaxRepo,
   useUserController,