@goweekdays/core 1.3.0 → 1.3.2

package/dist/index.js

@@ -11596,10 +11596,15 @@ __export(src_exports, {
   XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
   addressSchema: () => addressSchema,
   isDev: () => isDev,
+  modelInventory: () => modelInventory,
   modelProperty: () => modelProperty,
+  modelUnitType: () => modelUnitType,
   schema: () => schema,
+  schemaInventory: () => schemaInventory,
   schemaProperty: () => schemaProperty,
   schemaPropertyUpdate: () => schemaPropertyUpdate,
+  schemaUnitType: () => schemaUnitType,
+  schemaUnitTypeUpdate: () => schemaUnitTypeUpdate,
   useAddressController: () => useAddressController,
   useAddressRepo: () => useAddressRepo,
   useAuthController: () => useAuthController,
@@ -11611,6 +11616,8 @@ __export(src_exports, {
   useFileController: () => useFileController,
   useFileRepo: () => useFileRepo,
   useFileService: () => useFileService,
+  useInventoryController: () => useInventoryController,
+  useInventoryRepo: () => useInventoryRepo,
   useInvoiceController: () => useInvoiceController,
   useInvoiceModel: () => useInvoiceModel,
   useInvoiceRepo: () => useInvoiceRepo,
@@ -11642,6 +11649,8 @@ __export(src_exports, {
   useSubscriptionRepo: () => useSubscriptionRepo,
   useSubscriptionService: () => useSubscriptionService,
   useTokenRepo: () => useTokenRepo,
+  useUnitTypeController: () => useUnitTypeController,
+  useUnitTypeRepo: () => useUnitTypeRepo,
   useUserController: () => useUserController,
   useUserRepo: () => useUserRepo,
   useUserService: () => useUserService,
@@ -25735,8 +25744,8 @@ var schemaProperty = import_joi28.default.object({
   amenities: import_joi28.default.array().items(import_joi28.default.string().trim()).optional(),
   numberOfFloors: import_joi28.default.string().trim().required(),
   floorLabels: import_joi28.default.string().optional().allow(""),
-  coverPhoto: import_joi28.default.object({}),
-  photoGallery: import_joi28.default.array().items(import_joi28.default.object({})),
+  coverPhoto: import_joi28.default.string().optional().allow("", null),
+  photoGallery: import_joi28.default.array().items(import_joi28.default.string()),
   stayType: import_joi28.default.string().trim().required(),
   createdAt: import_joi28.default.date().optional(),
   updatedAt: import_joi28.default.date().optional(),
@@ -25777,6 +25786,7 @@ function modelProperty(value) {
     coverPhoto: value.coverPhoto,
     photoGallery: value.photoGallery ?? [],
     stayType: value.stayType,
+    status: value.status ?? "active",
     createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
     updatedAt: value.updatedAt,
     deletedAt: value.deletedAt
@@ -25946,7 +25956,7 @@ function usePropertyRepo() {
         });
         return cached;
       }
-      const property = await collection.findOne({});
+      const property = await collection.findOne({ _id });
       if (!property) {
         throw new import_utils84.BadRequestError("Property not found.");
       }
@@ -26085,11 +26095,737 @@ function usePropertyController() {
   };
 }
 
-// src/controllers/util.controller.ts
+// src/models/unit-type.model.ts
+var import_utils86 = require("@goweekdays/utils");
 var import_joi30 = __toESM(require("joi"));
+var import_mongodb36 = require("mongodb");
+var schemaUnitType = import_joi30.default.object({
+  unitName: import_joi30.default.string().trim().required(),
+  unitDescription: import_joi30.default.string().trim().required(),
+  maxOccupants: import_joi30.default.number().required(),
+  amenities: import_joi30.default.array().items(import_joi30.default.string().trim()).optional(),
+  pricePerNight: import_joi30.default.string().trim().required(),
+  pricePerMonth: import_joi30.default.string().trim().required(),
+  imageGallery: import_joi30.default.array().items(import_joi30.default.string()),
+  propertyId: import_joi30.default.string().trim().required(),
+  createdAt: import_joi30.default.date().optional(),
+  updatedAt: import_joi30.default.date().optional(),
+  deletedAt: import_joi30.default.date().optional()
+});
+var schemaUnitTypeUpdate = import_joi30.default.object({
+  unitName: import_joi30.default.string().trim().required(),
+  unitDescription: import_joi30.default.string().trim().required(),
+  maxOccupants: import_joi30.default.number().required(),
+  amenities: import_joi30.default.array().items(import_joi30.default.string().trim()).optional(),
+  pricePerNight: import_joi30.default.string().trim().required(),
+  pricePerMonth: import_joi30.default.string().trim().required(),
+  imageGallery: import_joi30.default.array().items(import_joi30.default.string()),
+  propertyId: import_joi30.default.string().trim().required(),
+  createdAt: import_joi30.default.date().optional(),
+  updatedAt: import_joi30.default.date().optional(),
+  deletedAt: import_joi30.default.date().optional()
+});
+function modelUnitType(value) {
+  const { error } = schemaUnitType.validate(value);
+  if (error) {
+    throw new import_utils86.BadRequestError(`Invalid unit type data: ${error.message}`);
+  }
+  if (!value._id) {
+    try {
+      value._id = new import_mongodb36.ObjectId();
+    } catch (error2) {
+      throw new import_utils86.BadRequestError("Invalid unit type ID.");
+    }
+  }
+  try {
+    value.propertyId = new import_mongodb36.ObjectId(value.propertyId);
+  } catch (error2) {
+    throw new import_utils86.BadRequestError("Invalid Property ID");
+  }
+  return {
+    _id: value._id,
+    unitName: value.unitName,
+    unitDescription: value.unitDescription,
+    maxOccupants: value.maxOccupants,
+    amenities: value.amenities ?? [],
+    pricePerNight: value.pricePerNight,
+    pricePerMonth: value.pricePerMonth,
+    imageGallery: value.imageGallery,
+    propertyId: value.propertyId,
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt,
+    deletedAt: value.deletedAt
+  };
+}
+
+// src/repositories/unit-type.repository.ts
+var import_utils87 = require("@goweekdays/utils");
+var import_mongodb37 = require("mongodb");
+function useUnitTypeRepo() {
+  const db = import_utils87.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils87.BadRequestError("Unable to connect to server.");
+  }
+  const namespace_collection = "unitTypes";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils87.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils87.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils87.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { unitName: 1 } },
+        { key: { maxOccupants: 1 } },
+        { key: { propertyId: 1 } },
+        {
+          key: {
+            unitName: "text",
+            maxOccupants: "text",
+            propertyId: "text"
+          },
+          name: "unitTypeTextSearch"
+        }
+      ]);
+    } catch (error) {
+      throw new import_utils87.BadRequestError(
+        `Failed to create index on unit types: ${error.message}`
+      );
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelUnitType(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      throw new import_utils87.BadRequestError(`Failed to create unit type: ${error.message}`);
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new import_mongodb37.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils87.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.deleteOne({ _id });
+      delCachedData();
+      return res;
+    } catch (error) {
+      throw new import_utils87.InternalServerError("Failed to delete unit type.");
+    }
+  }
+  async function getAll({
+    page = 1,
+    limit = 20,
+    status = "active",
+    search = ""
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { status };
+    const cacheKeyOptions = {
+      action: "getAll",
+      page,
+      limit,
+      status
+    };
+    if (search) {
+      query.$text = { $search: search };
+      cacheKeyOptions.search = search;
+    }
+    const cacheKey = (0, import_utils87.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils87.logger.log({
+          level: "info",
+          message: `Cache hit for getAll: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils87.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 300).then(() => {
+        import_utils87.logger.log({
+          level: "info",
+          message: `Cache set for getAll: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils87.logger.log({
+          level: "error",
+          message: `Failed to set cache: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new import_utils87.InternalServerError(
+        `Failed to fetch unit-types: ${error.message}`
+      );
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb37.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils87.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_utils87.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils87.logger.log({
+          level: "info",
+          message: `Cache hit for getById: ${cacheKey}`
+        });
+        return cached;
+      }
+      const unitType = await collection.findOne({ _id });
+      if (!unitType) {
+        throw new import_utils87.BadRequestError("Unit-type not found.");
+      }
+      setCache(cacheKey, unitType, 300).then(() => {
+        import_utils87.logger.log({
+          level: "info",
+          message: `Cache set for getById: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils87.logger.log({
+          level: "error",
+          message: `Failed to set cache: ${err.message}`
+        });
+      });
+      return unitType;
+    } catch (error) {
+      if (error instanceof import_utils87.BadRequestError) {
+        throw error;
+      }
+      throw new import_utils87.InternalServerError(
+        `Failed to fetch unit-type: ${error.message}`
+      );
+    }
+  }
+  async function getByPropertyId(propertyId) {
+    try {
+      const unitTypes = await collection.find({ propertyId, status: "active" }).toArray();
+      return unitTypes;
+    } catch (error) {
+      throw new import_utils87.InternalServerError(
+        `Failed to fetch unit types: ${error.message}`
+      );
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb37.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils87.BadRequestError("Invalid ID.");
+    }
+    const { error } = schemaUnitTypeUpdate.validate(value);
+    if (error) {
+      throw new import_utils87.BadRequestError(
+        `Invalid unit type data: ${error.message}. Repository validation.`
+      );
+    }
+    try {
+      value.updatedAt = /* @__PURE__ */ new Date();
+      const res = await collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error2) {
+      throw new import_utils87.InternalServerError("Failed to update unit-type.");
+    }
+  }
+  return {
+    createIndex,
+    add,
+    getAll,
+    getById,
+    getByPropertyId,
+    deleteById,
+    updateById
+  };
+}
+
+// src/controllers/unit-type.controller.ts
+var import_utils88 = require("@goweekdays/utils");
+var import_joi31 = __toESM(require("joi"));
+function useUnitTypeController() {
+  const { add: _add, getAll: _getAll, getById: _getById, updateById: _updateById, getByPropertyId: _getByPropertyId, deleteById: _deleteById } = useUnitTypeRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaUnitType.validate(value);
+    if (error) {
+      next(new import_utils88.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _add(value);
+      res.json({ message: "Successfully added unit type.", id });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const validation = import_joi31.default.object({
+      page: import_joi31.default.number().integer().min(1).default(1),
+      limit: import_joi31.default.number().integer().min(1).max(100).default(10),
+      search: import_joi31.default.string().trim().allow("").default(""),
+      status: import_joi31.default.string().default("active")
+    });
+    const { error, value } = validation.validate(req.query);
+    if (error) {
+      next(new import_utils88.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const unitType = await _getAll(value);
+      res.json(unitType);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const { id } = req.params;
+    if (!id) {
+      next(new import_utils88.BadRequestError("Unit Type ID is required."));
+      return;
+    }
+    try {
+      const unitType = await _getById(id);
+      res.json(unitType);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function getByPropertyId(req, res, next) {
+    const { id } = req.params;
+    if (!id) {
+      next(new import_utils88.BadRequestError("Property ID is required."));
+      return;
+    }
+    try {
+      const unitType = await _getByPropertyId(id);
+      res.json(unitType);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function updateById(req, res, next) {
+    const _id = req.params.id ?? "";
+    const idValidation = import_joi31.default.object({
+      _id: import_joi31.default.string().required()
+    });
+    const { error: idValidationError } = idValidation.validate({ _id });
+    if (idValidationError) {
+      throw new import_utils88.BadRequestError(`Invalid ID`);
+    }
+    const value = req.body;
+    const { error } = schemaUnitTypeUpdate.validate(value);
+    if (error) {
+      throw new import_utils88.BadRequestError(`Invalid unit type data: ${error.message}`);
+    }
+    try {
+      const result = await _updateById(_id, req.body);
+      res.json({ message: "Successfully updated unit type.", result });
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    if (!id) {
+      next(new import_utils88.BadRequestError("Unit Type ID is required."));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById,
+    getByPropertyId
+  };
+}
+
+// src/models/units-inventory.model.ts
+var import_utils89 = require("@goweekdays/utils");
+var import_joi32 = __toESM(require("joi"));
+var import_mongodb38 = require("mongodb");
+var schemaInventory = import_joi32.default.object({
+  unitNumber: import_joi32.default.string().trim().required(),
+  floorNumber: import_joi32.default.string().trim().required(),
+  propertyId: import_joi32.default.string().trim().required(),
+  unitTypeId: import_joi32.default.string().trim().required(),
+  ownerId: import_joi32.default.string().trim().required(),
+  pricePerNight: import_joi32.default.string().trim().required(),
+  pricePerMonth: import_joi32.default.string().trim().required(),
+  status: import_joi32.default.string().valid("available", "reserved", "occupied", "maintenance", "blocked").optional().default("available"),
+  availableDays: import_joi32.default.array().items(import_joi32.default.string().trim()).required(),
+  createdAt: import_joi32.default.date().optional().allow(null, ""),
+  updatedAt: import_joi32.default.date().optional().allow(null, ""),
+  deletedAt: import_joi32.default.date().optional().allow(null, "")
+});
+function modelInventory(value) {
+  const { error } = schemaInventory.validate(value);
+  if (error) {
+    throw new import_utils89.BadRequestError(`Invalid inventory data: ${error.message}`);
+  }
+  if (!value._id) {
+    try {
+      value._id = new import_mongodb38.ObjectId();
+    } catch (error2) {
+      throw new import_utils89.BadRequestError("Invalid inventory ID.");
+    }
+  }
+  try {
+    value.propertyId = new import_mongodb38.ObjectId(value.propertyId);
+  } catch (error2) {
+    throw new import_utils89.BadRequestError("Invalid Property ID");
+  }
+  try {
+    value.unitTypeId = new import_mongodb38.ObjectId(value.unitTypeId);
+  } catch (error2) {
+    throw new import_utils89.BadRequestError("Invalid Unit Type ID");
+  }
+  return {
+    _id: value._id,
+    unitNumber: value.unitNumber,
+    floorNumber: value.floorNumber,
+    propertyId: value.propertyId,
+    unitTypeId: value.unitTypeId,
+    ownerId: value.ownerId,
+    pricePerNight: value.pricePerNight,
+    pricePerMonth: value.pricePerMonth,
+    status: value.status ?? "available",
+    availableDays: value.availableDays,
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt,
+    deletedAt: value.deletedAt
+  };
+}
+
+// src/repositories/units-inventory.repository.ts
+var import_utils90 = require("@goweekdays/utils");
+var import_mongodb39 = require("mongodb");
+function useInventoryRepo() {
+  const db = import_utils90.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils90.BadRequestError("Unable to connect to server.");
+  }
+  const namespace_collection = "inventories";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils90.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils90.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils90.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function getAll({
+    page = 1,
+    limit = 20,
+    status = "available",
+    search = ""
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { status };
+    const cacheKeyOptions = {
+      action: "getAll",
+      page,
+      limit,
+      status
+    };
+    if (search) {
+      query.$text = { $search: search };
+      cacheKeyOptions.search = search;
+    }
+    const cacheKey = (0, import_utils90.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache hit for getAll: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils90.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 300).then(() => {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache set for getAll: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils90.logger.log({
+          level: "error",
+          message: `Failed to set cache: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new import_utils90.InternalServerError(
+        `Failed to fetch inventories: ${error.message}`
+      );
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb39.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils90.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_utils90.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache hit for getById: ${cacheKey}`
+        });
+        return cached;
+      }
+      const inventory = await collection.findOne({});
+      if (!inventory) {
+        throw new import_utils90.BadRequestError("Inventory not found.");
+      }
+      setCache(cacheKey, inventory, 300).then(() => {
+        import_utils90.logger.log({
+          level: "info",
+          message: `Cache set for getById: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils90.logger.log({
+          level: "error",
+          message: `Failed to set cache: ${err.message}`
+        });
+      });
+      return inventory;
+    } catch (error) {
+      if (error instanceof import_utils90.BadRequestError) {
+        throw error;
+      }
+      throw new import_utils90.InternalServerError(
+        `Failed to fetch inventory: ${error.message}`
+      );
+    }
+  }
+  async function createIndex() {
+  }
+  async function add(value, session) {
+    try {
+      value = modelInventory(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      throw new import_utils90.BadRequestError(`Failed to create inventory: ${error.message}`);
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb39.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils90.BadRequestError("Invalid ID.");
+    }
+    const { error } = schemaInventory.validate(value);
+    if (error) {
+      throw new import_utils90.BadRequestError(
+        `Invalid unit-inventory data: ${error.message}. Repository validation.`
+      );
+    }
+    try {
+      value.updatedAt = /* @__PURE__ */ new Date();
+      const res = await collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error2) {
+      throw new import_utils90.InternalServerError("Failed to update unit-inventory.");
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new import_mongodb39.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils90.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.deleteOne({ _id });
+      delCachedData();
+      return res;
+    } catch (error) {
+      throw new import_utils90.InternalServerError("Failed to delete unit-inventory.");
+    }
+  }
+  return {
+    createIndex,
+    add,
+    getAll,
+    getById,
+    deleteById,
+    updateById
+  };
+}
+
+// src/controllers/units-inventory.controller.ts
+var import_utils91 = require("@goweekdays/utils");
+var import_joi33 = __toESM(require("joi"));
+function useInventoryController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById,
+    updateById: _updateById,
+    deleteById: _deleteById
+  } = useInventoryRepo();
+  async function getAll(req, res, next) {
+    const validation = import_joi33.default.object({
+      page: import_joi33.default.number().integer().min(1).default(1),
+      limit: import_joi33.default.number().integer().min(1).max(100).default(10),
+      search: import_joi33.default.string().trim().allow("").default(""),
+      status: import_joi33.default.string().default("available")
+    });
+    const { error, value } = validation.validate(req.query);
+    if (error) {
+      next(new import_utils91.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const inventory = await _getAll(value);
+      res.json(inventory);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const { id } = req.params;
+    if (!id) {
+      next(new import_utils91.BadRequestError("Inventory ID is required."));
+      return;
+    }
+    try {
+      const inventory = await _getById(id);
+      res.json(inventory);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaInventory.validate(value);
+    if (error) {
+      next(new import_utils91.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _add(value);
+      res.json({ message: "Successfully added inventory.", id });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const _id = req.params.id ?? "";
+    const idValidation = import_joi33.default.object({
+      _id: import_joi33.default.string().required()
+    });
+    const { error: idValidationError } = idValidation.validate({ _id });
+    if (idValidationError) {
+      throw new import_utils91.BadRequestError(`Invalid ID`);
+    }
+    const value = req.body;
+    const { error } = schemaInventory.validate(value);
+    if (error) {
+      throw new import_utils91.BadRequestError(`Invalid inventory data: ${error.message}`);
+    }
+    try {
+      const result = await _updateById(_id, req.body);
+      res.json({ message: "Successfully updated inventory.", result });
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    if (!id) {
+      next(new import_utils91.BadRequestError("Inventory  ID is required."));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error) {
+      next(error);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/controllers/util.controller.ts
+var import_joi34 = __toESM(require("joi"));
 
 // src/services/github.service.ts
-var import_utils86 = require("@goweekdays/utils");
+var import_utils92 = require("@goweekdays/utils");
 var import_rest = require("@octokit/rest");
 var import_libsodium_wrappers = __toESM(require("libsodium-wrappers"));
 function useGitHubService() {
@@ -26103,23 +26839,23 @@ function useGitHubService() {
     try {
       const { data: repoData } = await octokit.repos.get({ owner, repo });
       if (!repoData.permissions?.admin) {
-        throw new import_utils86.BadRequestError(
+        throw new import_utils92.BadRequestError(
           "You do not have admin access to this repository."
         );
       }
     } catch (error) {
       if (error.status === 404) {
-        throw new import_utils86.BadRequestError(
+        throw new import_utils92.BadRequestError(
           "Repository not found or you don't have access to it."
         );
       } else if (error.status === 401) {
-        throw new import_utils86.BadRequestError(
+        throw new import_utils92.BadRequestError(
           "Invalid GitHub token or insufficient permissions."
         );
       } else if (error.message.includes("admin access")) {
         throw error;
       } else {
-        throw new import_utils86.BadRequestError(
+        throw new import_utils92.BadRequestError(
           `Failed to check repository permissions: ${error.message}`
         );
       }
@@ -26168,7 +26904,7 @@ function useGitHubService() {
               key_id: publicKeyRes.key_id
             });
           } catch (encryptionError) {
-            throw new import_utils86.BadRequestError(
+            throw new import_utils92.BadRequestError(
               `Failed to encrypt secret '${key}': ${encryptionError.message}`
             );
           }
@@ -26198,22 +26934,22 @@ function useGitHubService() {
       }
       return `Successfully set ${lines.length} ${type} variables/secrets in environment '${environment}'`;
     } catch (error) {
-      if (error instanceof import_utils86.AppError)
+      if (error instanceof import_utils92.AppError)
         throw error;
       if (error.status === 422) {
-        throw new import_utils86.BadRequestError(
+        throw new import_utils92.BadRequestError(
           `GitHub API validation error: ${error.message}`
         );
       } else if (error.status === 404) {
-        throw new import_utils86.BadRequestError("Environment or repository not found.");
+        throw new import_utils92.BadRequestError("Environment or repository not found.");
       } else if (error.status === 403) {
-        throw new import_utils86.BadRequestError(
+        throw new import_utils92.BadRequestError(
           "Forbidden: Insufficient permissions or rate limit exceeded."
         );
       } else if (error.message.includes("admin access") || error.message.includes("permissions")) {
         throw error;
       } else {
-        throw new import_utils86.BadRequestError(
+        throw new import_utils92.BadRequestError(
           `Failed to set GitHub variables: ${error.message}`
         );
       }
@@ -26225,7 +26961,7 @@ function useGitHubService() {
 }
 
 // src/controllers/util.controller.ts
-var import_utils87 = require("@goweekdays/utils");
+var import_utils93 = require("@goweekdays/utils");
 function useUtilController() {
   async function healthCheck(req, res, next) {
     try {
@@ -26241,32 +26977,32 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_utils87.logger.error("Health check failed", { error: error.message });
-      next(new import_utils87.InternalServerError("Health check failed"));
+      import_utils93.logger.error("Health check failed", { error: error.message });
+      next(new import_utils93.InternalServerError("Health check failed"));
     }
   }
   async function setGitHubVariables(req, res, next) {
     try {
       const { githubToken, repoUrl, environment, type, keyValues } = req.body;
-      const validation = import_joi30.default.object({
-        githubToken: import_joi30.default.string().required().messages({
+      const validation = import_joi34.default.object({
+        githubToken: import_joi34.default.string().required().messages({
           "string.empty": "GitHub token is required",
           "any.required": "GitHub token is required"
         }),
-        repoUrl: import_joi30.default.string().uri().required().messages({
+        repoUrl: import_joi34.default.string().uri().required().messages({
           "string.empty": "Repository URL is required",
           "string.uri": "Repository URL must be a valid URL",
           "any.required": "Repository URL is required"
         }),
-        environment: import_joi30.default.string().required().messages({
+        environment: import_joi34.default.string().required().messages({
           "string.empty": "Environment name is required",
           "any.required": "Environment name is required"
         }),
-        type: import_joi30.default.string().valid("env", "secret").required().messages({
+        type: import_joi34.default.string().valid("env", "secret").required().messages({
           "any.only": 'Type must be either "env" or "secret"',
           "any.required": "Type is required"
         }),
-        keyValues: import_joi30.default.string().required().messages({
+        keyValues: import_joi34.default.string().required().messages({
           "string.empty": "Key-value pairs are required",
           "any.required": "Key-value pairs are required"
         })
@@ -26279,13 +27015,13 @@ function useUtilController() {
         keyValues
       });
       if (error) {
-        next(new import_utils87.BadRequestError(error.message));
+        next(new import_utils93.BadRequestError(error.message));
         return;
       }
       const repoUrlPattern = /github\.com[:\/]([^\/]+)\/(.+)\.git$/;
       if (!repoUrlPattern.test(repoUrl)) {
         next(
-          new import_utils87.BadRequestError(
+          new import_utils93.BadRequestError(
             "Invalid GitHub repository URL format. Expected format: https://github.com/owner/repo.git"
           )
         );
@@ -26297,7 +27033,7 @@ function useUtilController() {
       );
       if (invalidLines.length > 0) {
         next(
-          new import_utils87.BadRequestError(
+          new import_utils93.BadRequestError(
             "Invalid key-value format. Each pair should be in format: KEY=value. Pairs can be separated by newlines, spaces, or tabs."
           )
         );
@@ -26311,7 +27047,7 @@ function useUtilController() {
         type,
         keyValues
       });
-      import_utils87.logger.info(`GitHub variables set successfully`, {
+      import_utils93.logger.info(`GitHub variables set successfully`, {
         repoUrl,
         environment,
         type,
@@ -26328,15 +27064,15 @@ function useUtilController() {
         }
       });
     } catch (error) {
-      import_utils87.logger.error("Failed to set GitHub variables", {
+      import_utils93.logger.error("Failed to set GitHub variables", {
         error: error.message,
         stack: error.stack
       });
-      if (error instanceof import_utils87.AppError) {
+      if (error instanceof import_utils93.AppError) {
         next(error);
       } else {
         next(
-          new import_utils87.InternalServerError(
+          new import_utils93.InternalServerError(
             `Failed to set GitHub variables: ${error.message}`
           )
         );
@@ -26404,10 +27140,15 @@ function useUtilController() {
   XENDIT_SECRET_KEY,
   addressSchema,
   isDev,
+  modelInventory,
   modelProperty,
+  modelUnitType,
   schema,
+  schemaInventory,
   schemaProperty,
   schemaPropertyUpdate,
+  schemaUnitType,
+  schemaUnitTypeUpdate,
   useAddressController,
   useAddressRepo,
   useAuthController,
@@ -26419,6 +27160,8 @@ function useUtilController() {
   useFileController,
   useFileRepo,
   useFileService,
+  useInventoryController,
+  useInventoryRepo,
   useInvoiceController,
   useInvoiceModel,
   useInvoiceRepo,
@@ -26450,6 +27193,8 @@ function useUtilController() {
   useSubscriptionRepo,
   useSubscriptionService,
   useTokenRepo,
+  useUnitTypeController,
+  useUnitTypeRepo,
   useUserController,
   useUserRepo,
   useUserService,