@monorise/core 3.0.4 → 3.2.0

package/dist/index.js

@@ -17,6 +17,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -107,6 +119,10 @@ var setupCommonRoutes = (container) => {
     "/entity/:entityType/unique/:uniqueField/:uniqueFieldValue",
     container.getEntityByUniqueFieldController.controller
   );
+  app.post(
+    "/entity/:entityType/:entityId/adjust",
+    container.adjustEntityController.controller
+  );
   app.get(
     "/entity/:entityType/:entityId",
     container.getEntityController.controller
@@ -250,6 +266,47 @@ var Repository = class {
     };
     return updateAttributes;
   }
+  toAdjustUpdate(adjustments, constraints, prefix = "data") {
+    const parts = [];
+    const conditionParts = [];
+    const expressionAttributeNames = {};
+    const expressionAttributeValues = {};
+    expressionAttributeNames[`#${prefix}`] = prefix;
+    for (const field of Object.keys(adjustments)) {
+      const namePlaceholder = `#${field}`;
+      const valuePlaceholder = `:${field}`;
+      const fieldExpr = `if_not_exists(#${prefix}.${namePlaceholder}, :zero)`;
+      parts.push(
+        `#${prefix}.${namePlaceholder} = ${fieldExpr} + ${valuePlaceholder}`
+      );
+      expressionAttributeNames[namePlaceholder] = field;
+      expressionAttributeValues[valuePlaceholder] = adjustments[field];
+      if (constraints == null ? void 0 : constraints[field]) {
+        const constraint = constraints[field];
+        const delta = adjustments[field];
+        const currentFieldRef = `#${prefix}.${namePlaceholder}`;
+        if (constraint.min !== void 0 && delta < 0) {
+          const thresholdPlaceholder = `:${field}_min_threshold`;
+          conditionParts.push(`${currentFieldRef} >= ${thresholdPlaceholder}`);
+          expressionAttributeValues[thresholdPlaceholder] = constraint.min - delta;
+        }
+        if (constraint.max !== void 0 && delta > 0) {
+          const thresholdPlaceholder = `:${field}_max_threshold`;
+          conditionParts.push(`${currentFieldRef} <= ${thresholdPlaceholder}`);
+          expressionAttributeValues[thresholdPlaceholder] = constraint.max - delta;
+        }
+      }
+    }
+    expressionAttributeValues[":zero"] = 0;
+    return __spreadProps(__spreadValues({
+      UpdateExpression: `SET ${parts.join(", ")}`
+    }, conditionParts.length > 0 && {
+      ConditionExpression: conditionParts.join(" AND ")
+    }), {
+      ExpressionAttributeNames: expressionAttributeNames,
+      ExpressionAttributeValues: marshall(expressionAttributeValues)
+    });
+  }
 };
 
 // data/Entity.ts
@@ -717,6 +774,22 @@ var EntityRepository = class extends Repository {
             } catch (err) {
               if (err instanceof TransactionCanceledException) {
                 const [updateErr, ...uniqueFieldErr] = err.CancellationReasons || [];
+                if ((updateErr == null ? void 0 : updateErr.Code) === BatchStatementErrorCodeEnum.ConditionalCheckFailed) {
+                  if (opts == null ? void 0 : opts.ConditionExpression) {
+                    throw new StandardError(
+                      StandardErrorCode.CONDITIONAL_CHECK_FAILED,
+                      "Conditional check failed",
+                      err,
+                      { entityId, toUpdate }
+                    );
+                  }
+                  throw new StandardError(
+                    StandardErrorCode.ENTITY_NOT_FOUND,
+                    "Entity not found",
+                    err,
+                    { entityId, toUpdate }
+                  );
+                }
                 for (let i = 0; i < uniqueFieldErr.length; i++) {
                   if (i % 2 === 1 && uniqueFieldErr[i].Code === BatchStatementErrorCodeEnum.ConditionalCheckFailed) {
                     const field = updatedUniqueFields[Math.floor(i / 2)];
@@ -737,6 +810,14 @@ var EntityRepository = class extends Repository {
         return updatedEntity;
       } catch (err) {
         if (err instanceof ConditionalCheckFailedException) {
+          if (opts == null ? void 0 : opts.ConditionExpression) {
+            throw new StandardError(
+              StandardErrorCode.CONDITIONAL_CHECK_FAILED,
+              "Conditional check failed",
+              err,
+              { entityId, toUpdate }
+            );
+          }
           throw new StandardError(
             StandardErrorCode.ENTITY_NOT_FOUND,
             "Entity not found",
@@ -751,6 +832,25 @@ var EntityRepository = class extends Repository {
       }
     });
   }
+  adjustEntity(entityType, entityId, adjustments, constraints) {
+    return __async(this, null, function* () {
+      const entity = new Entity(entityType, entityId);
+      const { UpdateExpression, ConditionExpression, ExpressionAttributeNames, ExpressionAttributeValues } = this.toAdjustUpdate(adjustments, constraints);
+      const updatedAtExpression = ", #updatedAt = :updatedAt";
+      ExpressionAttributeNames["#updatedAt"] = "updatedAt";
+      ExpressionAttributeValues[":updatedAt"] = { S: (/* @__PURE__ */ new Date()).toISOString() };
+      const resp = yield this.dynamodbClient.updateItem(__spreadProps(__spreadValues({
+        TableName: this.TABLE_NAME,
+        Key: entity.keys(),
+        UpdateExpression: UpdateExpression + updatedAtExpression
+      }, ConditionExpression && { ConditionExpression }), {
+        ExpressionAttributeNames,
+        ExpressionAttributeValues,
+        ReturnValues: "ALL_NEW"
+      }));
+      return Entity.fromItem(resp.Attributes);
+    });
+  }
   deleteEntity(entityType, entityId) {
     return __async(this, null, function* () {
       try {
@@ -2850,6 +2950,7 @@ var CreateEntityController = class {
         const entity = yield this.entityService.createEntity({
           entityType,
           entityPayload: body,
+          entityId: body.entityId,
           accountId,
           options: {
             createAndUpdateDatetime: body.createdAt
@@ -6986,10 +7087,11 @@ var UpdateEntityController = class {
   constructor(entityService) {
     this.entityService = entityService;
     this.controller = createMiddleware8((c) => __async(this, null, function* () {
-      var _a;
+      var _b;
       const accountId = c.req.header("account-id");
       const { entityType, entityId } = c.req.param();
       const body = yield c.req.json();
+      const _a = body, { $where: where } = _a, entityPayload = __objRest(_a, ["$where"]);
       const errorContext = {
         accountId,
         "req.params": c.req.param(),
@@ -6999,14 +7101,15 @@ var UpdateEntityController = class {
         const entity = yield this.entityService.updateEntity({
           entityType,
           entityId,
-          entityPayload: body,
-          accountId
+          entityPayload,
+          accountId,
+          where
         });
         errorContext.entity = entity;
         c.status(httpStatus8.OK);
         return c.json(entity);
       } catch (err) {
-        if (((_a = err.constructor) == null ? void 0 : _a.name) === "ZodError") {
+        if (((_b = err.constructor) == null ? void 0 : _b.name) === "ZodError") {
           c.status(httpStatus8.BAD_REQUEST);
           return c.json({
             code: "API_VALIDATION_ERROR",
@@ -7022,6 +7125,10 @@ var UpdateEntityController = class {
           c.status(httpStatus8.BAD_REQUEST);
           return c.json(__spreadValues({}, err.toJSON()));
         }
+        if (err instanceof StandardError && err.code === StandardErrorCode.CONDITIONAL_CHECK_FAILED) {
+          c.status(httpStatus8.CONFLICT);
+          return c.json(__spreadValues({}, err.toJSON()));
+        }
         console.log(
           "====UPDATE_ENTITY_CONTROLLER_ERROR",
           err,
@@ -7033,15 +7140,63 @@ var UpdateEntityController = class {
   }
 };
 
-// controllers/entity/upsert-entity.controller.ts
+// controllers/entity/adjust-entity.controller.ts
 import { createMiddleware as createMiddleware9 } from "hono/factory";
 import httpStatus9 from "http-status";
+var AdjustEntityController = class {
+  constructor(entityService) {
+    this.entityService = entityService;
+    this.controller = createMiddleware9((c) => __async(this, null, function* () {
+      var _a;
+      const accountId = c.req.header("account-id") || "";
+      const { entityType, entityId } = c.req.param();
+      const body = yield c.req.json();
+      for (const [key, value] of Object.entries(body)) {
+        if (typeof value !== "number") {
+          c.status(httpStatus9.BAD_REQUEST);
+          return c.json({
+            code: "API_VALIDATION_ERROR",
+            message: `Field "${key}" must be a number, got ${typeof value}`
+          });
+        }
+      }
+      try {
+        const entity = yield this.entityService.adjustEntity({
+          entityType,
+          entityId,
+          adjustments: body,
+          accountId
+        });
+        c.status(httpStatus9.OK);
+        return c.json(entity.toJSON());
+      } catch (err) {
+        if (err instanceof StandardError && err.code === StandardErrorCode.ENTITY_IS_UNDEFINED) {
+          c.status(httpStatus9.NOT_FOUND);
+          return c.json(__spreadValues({}, err.toJSON()));
+        }
+        if ((err == null ? void 0 : err.name) === "ConditionalCheckFailedException" || ((_a = err == null ? void 0 : err.__type) == null ? void 0 : _a.includes("ConditionalCheckFailed"))) {
+          c.status(httpStatus9.CONFLICT);
+          return c.json({
+            code: "ADJUSTMENT_CONSTRAINT_VIOLATED",
+            message: "Adjustment would violate entity constraints"
+          });
+        }
+        console.log("====ADJUST_ENTITY_CONTROLLER_ERROR", err);
+        throw err;
+      }
+    }));
+  }
+};
+
+// controllers/entity/upsert-entity.controller.ts
+import { createMiddleware as createMiddleware10 } from "hono/factory";
+import httpStatus10 from "http-status";
 var UpsertEntityController = class {
   constructor(EntityConfig, entityRepository, publishEvent2) {
     this.EntityConfig = EntityConfig;
     this.entityRepository = entityRepository;
     this.publishEvent = publishEvent2;
-    this.controller = createMiddleware9((c) => __async(this, null, function* () {
+    this.controller = createMiddleware10((c) => __async(this, null, function* () {
       var _a, _b;
       const accountId = c.req.header("account-id");
       const { entityType, entityId } = c.req.param();
@@ -7097,7 +7252,7 @@ var UpsertEntityController = class {
         return c.json(entity);
       } catch (err) {
         if (err instanceof ZodError) {
-          c.status(httpStatus9.BAD_REQUEST);
+          c.status(httpStatus10.BAD_REQUEST);
           return c.json({
             code: "API_VALIDATION_ERROR",
             message: "API validation failed",
@@ -7105,7 +7260,7 @@ var UpsertEntityController = class {
           });
         }
         if (err instanceof StandardError && err.code === StandardErrorCode.EMAIL_EXISTS) {
-          c.status(httpStatus9.BAD_REQUEST);
+          c.status(httpStatus10.BAD_REQUEST);
           return c.json(__spreadValues({}, err.toJSON()));
         }
         throw err;
@@ -7115,12 +7270,12 @@ var UpsertEntityController = class {
 };
 
 // controllers/mutual/create-mutual.controller.ts
-import { createMiddleware as createMiddleware10 } from "hono/factory";
-import httpStatus10 from "http-status";
+import { createMiddleware as createMiddleware11 } from "hono/factory";
+import httpStatus11 from "http-status";
 var CreateMutualController = class {
   constructor(mutualService) {
     this.mutualService = mutualService;
-    this.controller = createMiddleware10((c) => __async(this, null, function* () {
+    this.controller = createMiddleware11((c) => __async(this, null, function* () {
       const accountId = c.req.header("account-id");
       const { byEntityType, byEntityId, entityType, entityId } = c.req.param();
       const asEntity = c.req.query("asEntity");
@@ -7140,7 +7295,7 @@ var CreateMutualController = class {
         return c.json(mutual);
       } catch (err) {
         if (err instanceof ZodError) {
-          c.status(httpStatus10.BAD_REQUEST);
+          c.status(httpStatus11.BAD_REQUEST);
           return c.json({
             code: "API_VALIDATION_ERROR",
             message: "API validation failed",
@@ -7148,11 +7303,11 @@ var CreateMutualController = class {
           });
         }
         if (err instanceof StandardError && err.code === StandardErrorCode.MUTUAL_EXISTS) {
-          c.status(httpStatus10.BAD_REQUEST);
+          c.status(httpStatus11.BAD_REQUEST);
           return c.json(__spreadValues({}, err.toJSON()));
         }
         if (err instanceof StandardError && err.code === StandardErrorCode.ENTITY_IS_UNDEFINED) {
-          c.status(httpStatus10.BAD_REQUEST);
+          c.status(httpStatus11.BAD_REQUEST);
           return c.json(__spreadValues({}, err.toJSON()));
         }
         throw err;
@@ -7162,12 +7317,12 @@ var CreateMutualController = class {
 };
 
 // controllers/mutual/delete-mutual.controller.ts
-import { createMiddleware as createMiddleware11 } from "hono/factory";
-import httpStatus11 from "http-status";
+import { createMiddleware as createMiddleware12 } from "hono/factory";
+import httpStatus12 from "http-status";
 var DeleteMutualController = class {
   constructor(mutualService) {
     this.mutualService = mutualService;
-    this.controller = createMiddleware11((c) => __async(this, null, function* () {
+    this.controller = createMiddleware12((c) => __async(this, null, function* () {
       const accountId = c.req.header("account-id");
       const { byEntityType, byEntityId, entityType, entityId } = c.req.param();
       try {
@@ -7181,7 +7336,7 @@ var DeleteMutualController = class {
         return c.json(mutual);
       } catch (err) {
         if (err instanceof StandardError && err.code === StandardErrorCode.MUTUAL_NOT_FOUND) {
-          c.status(httpStatus11.BAD_REQUEST);
+          c.status(httpStatus12.BAD_REQUEST);
           return c.json(__spreadValues({}, err.toJSON()));
         }
         throw err;
@@ -7191,12 +7346,12 @@ var DeleteMutualController = class {
 };
 
 // controllers/mutual/get-mutual.controller.ts
-import { createMiddleware as createMiddleware12 } from "hono/factory";
-import httpStatus12 from "http-status";
+import { createMiddleware as createMiddleware13 } from "hono/factory";
+import httpStatus13 from "http-status";
 var GetMutualController = class {
   constructor(associateRepository) {
     this.associateRepository = associateRepository;
-    this.controller = createMiddleware12((c) => __async(this, null, function* () {
+    this.controller = createMiddleware13((c) => __async(this, null, function* () {
       const { byEntityType, byEntityId, entityType, entityId } = c.req.param();
       try {
         const associate = yield this.associateRepository.getMutual(
@@ -7208,7 +7363,7 @@ var GetMutualController = class {
         return c.json(associate);
       } catch (err) {
         if (err instanceof StandardError && err.code === StandardErrorCode.MUTUAL_IS_UNDEFINED) {
-          c.status(httpStatus12.NOT_FOUND);
+          c.status(httpStatus13.NOT_FOUND);
           return c.json({
             code: "MUTUAL_NOT_FOUND",
             message: "Mutual not found"
@@ -7221,11 +7376,11 @@ var GetMutualController = class {
 };
 
 // controllers/mutual/list-entities-by-entity.controller.ts
-import { createMiddleware as createMiddleware13 } from "hono/factory";
+import { createMiddleware as createMiddleware14 } from "hono/factory";
 var ListEntitiesByEntityController = class {
   constructor(associateRepository) {
     this.associateRepository = associateRepository;
-    this.controller = createMiddleware13((c) => __async(this, null, function* () {
+    this.controller = createMiddleware14((c) => __async(this, null, function* () {
       const { byEntityType, byEntityId, entityType } = c.req.param();
       const querySchema3 = external_exports.object({
         chainEntityQuery: external_exports.string().optional(),
@@ -7283,12 +7438,12 @@ var ListEntitiesByEntityController = class {
 };
 
 // controllers/mutual/update-mutual.controller.ts
-import { createMiddleware as createMiddleware14 } from "hono/factory";
-import httpStatus13 from "http-status";
+import { createMiddleware as createMiddleware15 } from "hono/factory";
+import httpStatus14 from "http-status";
 var UpdateMutualController = class {
   constructor(mutualService) {
     this.mutualService = mutualService;
-    this.controller = createMiddleware14((c) => __async(this, null, function* () {
+    this.controller = createMiddleware15((c) => __async(this, null, function* () {
       const accountId = c.req.header("account-id");
       const { byEntityType, byEntityId, entityType, entityId } = c.req.param();
       const body = yield c.req.json();
@@ -7307,7 +7462,7 @@ var UpdateMutualController = class {
         return c.json(mutual);
       } catch (err) {
         if (err instanceof ZodError) {
-          c.status(httpStatus13.BAD_REQUEST);
+          c.status(httpStatus14.BAD_REQUEST);
           return c.json({
             code: "API_VALIDATION_ERROR",
             message: "API validation failed",
@@ -7315,7 +7470,7 @@ var UpdateMutualController = class {
           });
         }
         if (err instanceof StandardError && err.code === StandardErrorCode.MUTUAL_NOT_FOUND) {
-          c.status(httpStatus13.BAD_REQUEST);
+          c.status(httpStatus14.BAD_REQUEST);
           return c.json(__spreadValues({}, err.toJSON()));
         }
         throw err;
@@ -7324,6 +7479,67 @@ var UpdateMutualController = class {
   }
 };
 
+// data/utils/build-condition-expression.ts
+import { marshall as marshall5 } from "@aws-sdk/util-dynamodb";
+function buildConditionExpression(where) {
+  const conditions = ["attribute_exists(PK)"];
+  const expressionAttributeNames = { "#data": "data" };
+  const expressionAttributeValues = {};
+  for (const [field, clause] of Object.entries(where)) {
+    const namePlaceholder = `#where_${field}`;
+    expressionAttributeNames[namePlaceholder] = field;
+    const fieldRef = `#data.${namePlaceholder}`;
+    if (clause === null || clause === void 0) continue;
+    if (typeof clause !== "object") {
+      const valPlaceholder = `:where_${field}`;
+      expressionAttributeValues[valPlaceholder] = clause;
+      conditions.push(`${fieldRef} = ${valPlaceholder}`);
+      continue;
+    }
+    const op = clause;
+    if ("$eq" in op) {
+      const valPlaceholder = `:where_${field}_eq`;
+      expressionAttributeValues[valPlaceholder] = op.$eq;
+      conditions.push(`${fieldRef} = ${valPlaceholder}`);
+    } else if ("$ne" in op) {
+      const valPlaceholder = `:where_${field}_ne`;
+      expressionAttributeValues[valPlaceholder] = op.$ne;
+      conditions.push(`${fieldRef} <> ${valPlaceholder}`);
+    } else if ("$gt" in op) {
+      const valPlaceholder = `:where_${field}_gt`;
+      expressionAttributeValues[valPlaceholder] = op.$gt;
+      conditions.push(`${fieldRef} > ${valPlaceholder}`);
+    } else if ("$lt" in op) {
+      const valPlaceholder = `:where_${field}_lt`;
+      expressionAttributeValues[valPlaceholder] = op.$lt;
+      conditions.push(`${fieldRef} < ${valPlaceholder}`);
+    } else if ("$gte" in op) {
+      const valPlaceholder = `:where_${field}_gte`;
+      expressionAttributeValues[valPlaceholder] = op.$gte;
+      conditions.push(`${fieldRef} >= ${valPlaceholder}`);
+    } else if ("$lte" in op) {
+      const valPlaceholder = `:where_${field}_lte`;
+      expressionAttributeValues[valPlaceholder] = op.$lte;
+      conditions.push(`${fieldRef} <= ${valPlaceholder}`);
+    } else if ("$exists" in op) {
+      if (op.$exists) {
+        conditions.push(`attribute_exists(${fieldRef})`);
+      } else {
+        conditions.push(`attribute_not_exists(${fieldRef})`);
+      }
+    } else if ("$beginsWith" in op) {
+      const valPlaceholder = `:where_${field}_beginsWith`;
+      expressionAttributeValues[valPlaceholder] = op.$beginsWith;
+      conditions.push(`begins_with(${fieldRef}, ${valPlaceholder})`);
+    }
+  }
+  return {
+    ConditionExpression: conditions.join(" AND "),
+    ExpressionAttributeNames: expressionAttributeNames,
+    ExpressionAttributeValues: marshall5(expressionAttributeValues)
+  };
+}
+
 // services/entity.service.ts
 var EntityService = class {
   constructor(EntityConfig, EmailAuthEnabledEntities, entityRepository, publishEvent2, entityServiceLifeCycle) {
@@ -7375,11 +7591,57 @@ var EntityService = class {
       );
       return entity;
     });
+    this.adjustEntity = (_0) => __async(this, [_0], function* ({
+      entityType,
+      entityId,
+      adjustments,
+      accountId
+    }) {
+      var _a, _b, _c, _d;
+      const rawConstraints = (_a = this.EntityConfig[entityType]) == null ? void 0 : _a.adjustmentConstraints;
+      let resolvedConstraints = rawConstraints;
+      if (rawConstraints) {
+        const hasDynamicFields = Object.values(rawConstraints).some(
+          (c) => c.minField || c.maxField
+        );
+        if (hasDynamicFields) {
+          const currentEntity = yield this.entityRepository.getEntity(entityType, entityId);
+          const data = (_b = currentEntity == null ? void 0 : currentEntity.data) != null ? _b : {};
+          resolvedConstraints = {};
+          for (const [field, constraint] of Object.entries(rawConstraints)) {
+            const resolved = {};
+            if (constraint.min !== void 0) resolved.min = constraint.min;
+            if (constraint.max !== void 0) resolved.max = constraint.max;
+            if (constraint.minField) resolved.min = (_c = data[constraint.minField]) != null ? _c : 0;
+            if (constraint.maxField) resolved.max = (_d = data[constraint.maxField]) != null ? _d : Number.MAX_SAFE_INTEGER;
+            resolvedConstraints[field] = resolved;
+          }
+        }
+      }
+      const entity = yield this.entityRepository.adjustEntity(
+        entityType,
+        entityId,
+        adjustments,
+        resolvedConstraints
+      );
+      yield this.publishEvent({
+        event: EVENT.CORE.ENTITY_UPDATED,
+        payload: {
+          entityType,
+          entityId,
+          data: entity.data,
+          updatedByAccountId: accountId,
+          publishedAt: entity.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      return entity;
+    });
     this.updateEntity = (_0) => __async(this, [_0], function* ({
       entityType,
       entityId,
       entityPayload,
-      accountId
+      accountId,
+      where
     }) {
       var _a, _b;
       const errorContext = {};
@@ -7395,10 +7657,12 @@ var EntityService = class {
         const parsedEntityPayload = entitySchema.parse(entityPayload);
         const parsedMutualPayload = mutualSchema == null ? void 0 : mutualSchema.parse(entityPayload);
         errorContext.parsedMutualPayload = parsedMutualPayload;
+        const opts = where && Object.keys(where).length > 0 ? buildConditionExpression(where) : void 0;
         const entity = yield this.entityRepository.updateEntity(
           entityType,
           entityId,
-          { data: parsedEntityPayload }
+          { data: parsedEntityPayload },
+          opts
         );
         errorContext.entity = entity;
         if (parsedMutualPayload) {
@@ -7657,7 +7921,7 @@ var MutualService = class {
 };
 
 // controllers/tag/list-tags.controller.ts
-import { createMiddleware as createMiddleware15 } from "hono/factory";
+import { createMiddleware as createMiddleware16 } from "hono/factory";
 var querySchema2 = external_exports.object({
   group: external_exports.string().optional(),
   query: external_exports.string().optional(),
@@ -7669,7 +7933,7 @@ var querySchema2 = external_exports.object({
 var ListTagsController = class {
   constructor(tagRepository) {
     this.tagRepository = tagRepository;
-    this.controller = createMiddleware15((c) => __async(this, null, function* () {
+    this.controller = createMiddleware16((c) => __async(this, null, function* () {
       const errorContext = {};
       try {
         errorContext.params = c.req.param();
@@ -7865,6 +8129,12 @@ var DependencyContainer = class {
       this.entityService
     );
   }
+  get adjustEntityController() {
+    return this.createCachedInstance(
+      AdjustEntityController,
+      this.entityService
+    );
+  }
   get deleteEntityController() {
     return this.createCachedInstance(
       DeleteEntityController,