@monorise/core 3.1.0 → 4.0.0

package/dist/index.d.ts

@@ -5,7 +5,7 @@ import { DynamoDB, TransactWriteItemsInput, AttributeValue, TransactWriteItem, U
 import * as hono_utils_http_status from 'hono/utils/http-status';
 import * as hono_utils_types from 'hono/utils/types';
 import { createFactory } from 'hono/factory';
-import httpStatus4 from 'http-status';
+import httpStatus8 from 'http-status';
 import { unmarshall, marshall } from '@aws-sdk/util-dynamodb';
 import { EventBridgeClient } from '@aws-sdk/client-eventbridge';
 import * as hono_aws_lambda from 'hono/aws-lambda';
@@ -465,10 +465,10 @@ factory.createMiddleware((c, next) => __async(null, null, function* () {
     return yield next();
   }
   if (!xApiKey || Array.isArray(xApiKey) || !API_KEYS.includes(xApiKey)) {
-    c.status(httpStatus4.UNAUTHORIZED);
+    c.status(httpStatus8.UNAUTHORIZED);
     return c.json({
-      status: httpStatus4.UNAUTHORIZED,
-      message: httpStatus4["401_MESSAGE"]
+      status: httpStatus8.UNAUTHORIZED,
+      message: httpStatus8["401_MESSAGE"]
     });
   }
   return yield next();
@@ -4446,6 +4446,26 @@ external_exports.object({
   lastKey: external_exports.string().optional()
 });
 
+type WhereOperator = {
+    $eq: string | number | boolean;
+} | {
+    $ne: string | number | boolean;
+} | {
+    $gt: number;
+} | {
+    $lt: number;
+} | {
+    $gte: number;
+} | {
+    $lte: number;
+} | {
+    $exists: boolean;
+} | {
+    $beginsWith: string;
+};
+type WhereClause = WhereOperator | string | number | boolean;
+type WhereConditions = Record<string, WhereClause>;
+
 declare class EntityServiceLifeCycle {
     private EntityConfig;
     private publishEvent;
@@ -4477,11 +4497,12 @@ declare class EntityService {
         adjustments: Record<string, number>;
         accountId?: string;
     }) => Promise<Entity<T>>;
-    updateEntity: <T extends Entity$2>({ entityType, entityId, entityPayload, accountId, }: {
+    updateEntity: <T extends Entity$2>({ entityType, entityId, entityPayload, accountId, where, }: {
         entityType: T;
         entityId: string;
         entityPayload: Partial<EntitySchemaMap[T]>;
         accountId?: string | string[];
+        where?: WhereConditions;
     }) => Promise<Entity<T>>;
     deleteEntity: <T extends Entity$2>({ entityType, entityId, accountId, }: {
         entityType: T;

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 });
@@ -762,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)];
@@ -782,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",
@@ -7051,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(),
@@ -7064,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",
@@ -7087,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,
@@ -7437,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) {
@@ -7537,7 +7640,8 @@ var EntityService = class {
       entityType,
       entityId,
       entityPayload,
-      accountId
+      accountId,
+      where
     }) {
       var _a, _b;
       const errorContext = {};
@@ -7553,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) {