monorise 0.0.4 → 0.1.0

package/dist/core/index.d.ts

@@ -53,6 +53,19 @@ declare abstract class Repository {
         ExpressionAttributeNames: Record<string, string>;
         ExpressionAttributeValues: Record<string, AttributeValue>;
     };
+    toAdjustUpdate(adjustments: Record<string, number>, constraints?: {
+        [field: string]: {
+            min?: number;
+            max?: number;
+            minField?: string;
+            maxField?: string;
+        };
+    }, prefix?: string): {
+        UpdateExpression: string;
+        ConditionExpression?: string;
+        ExpressionAttributeNames: Record<string, string>;
+        ExpressionAttributeValues: Record<string, AttributeValue>;
+    };
 }
 
 declare class Entity$1<T extends Entity$2> extends Item$1 {
@@ -119,6 +132,12 @@ declare class EntityRepository extends Repository {
         ExpressionAttributeNames?: Record<string, string>;
         ExpressionAttributeValues?: Record<string, AttributeValue>;
     }): Promise<Entity$1<T>>;
+    adjustEntity<T extends Entity$2>(entityType: T, entityId: string, adjustments: Record<string, number>, constraints?: {
+        [field: string]: {
+            min?: number;
+            max?: number;
+        };
+    }): Promise<Entity$1<T>>;
     deleteEntity<T extends Entity$2>(entityType: T, entityId: string): Promise<void>;
     queryEntities<T extends Entity$2>(entityType: T, query: string): Promise<{
         items: Entity$1<T>[];
@@ -4452,6 +4471,12 @@ declare class EntityService {
             mutualId?: string;
         };
     }) => Promise<Entity<T>>;
+    adjustEntity: <T extends Entity$2>({ entityType, entityId, adjustments, accountId, }: {
+        entityType: T;
+        entityId: string;
+        adjustments: Record<string, number>;
+        accountId?: string;
+    }) => Promise<Entity<T>>;
     updateEntity: <T extends Entity$2>({ entityType, entityId, entityPayload, accountId, }: {
         entityType: T;
         entityId: string;
@@ -4518,6 +4543,14 @@ declare class UpdateEntityController {
     }, hono_utils_http_status.ContentfulStatusCode, "json">>;
 }
 
+declare class AdjustEntityController {
+    private entityService;
+    constructor(entityService: EntityService);
+    controller: hono.MiddlewareHandler<any, string, {}, Response & hono.TypedResponse<{
+        [x: string]: hono_utils_types.JSONValue;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+}
+
 declare class UpsertEntityController {
     private EntityConfig;
     private entityRepository;
@@ -4673,6 +4706,7 @@ declare class DependencyContainer {
     get createEntityController(): CreateEntityController;
     get upsertEntityController(): UpsertEntityController;
     get updateEntityController(): UpdateEntityController;
+    get adjustEntityController(): AdjustEntityController;
     get deleteEntityController(): DeleteEntityController;
     get listEntitiesByEntityController(): ListEntitiesByEntityController;
     get getMutualController(): GetMutualController;

package/dist/core/index.js

@@ -107,6 +107,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 +254,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
@@ -751,6 +796,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 +2914,7 @@ var CreateEntityController = class {
         const entity = yield this.entityService.createEntity({
           entityType,
           entityPayload: body,
+          entityId: body.entityId,
           accountId,
           options: {
             createAndUpdateDatetime: body.createdAt
@@ -7033,15 +7098,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 +7210,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 +7218,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 +7228,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 +7253,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 +7261,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 +7275,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 +7294,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 +7304,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 +7321,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 +7334,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 +7396,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 +7420,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 +7428,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;
@@ -7375,6 +7488,51 @@ 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,
@@ -7657,7 +7815,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 +7827,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 +8023,12 @@ var DependencyContainer = class {
       this.entityService
     );
   }
+  get adjustEntityController() {
+    return this.createCachedInstance(
+      AdjustEntityController,
+      this.entityService
+    );
+  }
   get deleteEntityController() {
     return this.createCachedInstance(
       DeleteEntityController,