monorise 0.1.0 → 1.1.0-dev.0

package/dist/core/index.js

@@ -1,46 +1,14 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
+import {
+  CORE_EVENT_BUS,
+  CORE_TABLE,
+  ENTITY_REPLICATION_INDEX,
+  MUTUAL_REPLICATION_INDEX,
+  __async,
+  __export,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-QV4Q5377.js";
 
 // controllers/setupRoutes.ts
 import { Hono } from "hono";
@@ -128,6 +96,11 @@ var setupCommonRoutes = (container) => {
     container.deleteEntityController.controller
   );
   app.get("/tag/:entityType/:tagName", container.listTagsController.controller);
+  app.post("/transaction", container.executeTransactionController.controller);
+  app.post(
+    "/ws/ticket/:entityType/:entityId",
+    container.createTicketController.controller
+  );
   return app;
 };
 
@@ -163,6 +136,7 @@ var StandardErrorCode = {
   ENTITY_ID_IS_UNDEFINED: "ENTITY_ID_IS_UNDEFINED",
   ENTITY_IS_UNDEFINED: "ENTITY_IS_UNDEFINED",
   ENTITY_NOT_FOUND: "ENTITY_NOT_FOUND",
+  INVALID_CONDITION: "INVALID_CONDITION",
   INVALID_ENTITY_TYPE: "INVALID_ENTITY_TYPE",
   INVALID_MUTUAL: "INVALID_MUTUAL",
   INVALID_QUERY: "INVALID_QUERY",
@@ -175,7 +149,10 @@ var StandardErrorCode = {
   REPLICATION_ERROR: "REPLICATION_ERROR",
   RETRYABLE_MUTUAL_LOCK_CONFLICT: "RETRYABLE_MUTUAL_LOCK_CONFLICT",
   TAG_IS_UNDEFINED: "TAG_IS_UNDEFINED",
+  TRANSACTION_EMPTY: "TRANSACTION_EMPTY",
   TRANSACTION_FAILED: "TRANSACTION_FAILED",
+  TRANSACTION_ITEM_LIMIT_EXCEEDED: "TRANSACTION_ITEM_LIMIT_EXCEEDED",
+  TRANSACTION_UNIQUE_FIELD_UPDATE: "TRANSACTION_UNIQUE_FIELD_UPDATE",
   UNIQUE_VALUE_EXISTS: "UNIQUE_VALUE_EXISTS"
 };
 
@@ -762,6 +739,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 +775,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",
@@ -796,22 +797,22 @@ var EntityRepository = class extends Repository {
       }
     });
   }
-  adjustEntity(entityType, entityId, adjustments, constraints) {
+  adjustEntity(entityType, entityId, adjustments, opts) {
     return __async(this, null, function* () {
       const entity = new Entity(entityType, entityId);
-      const { UpdateExpression, ConditionExpression, ExpressionAttributeNames, ExpressionAttributeValues } = this.toAdjustUpdate(adjustments, constraints);
+      const { UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues } = this.toAdjustUpdate(adjustments);
       const updatedAtExpression = ", #updatedAt = :updatedAt";
       ExpressionAttributeNames["#updatedAt"] = "updatedAt";
       ExpressionAttributeValues[":updatedAt"] = { S: (/* @__PURE__ */ new Date()).toISOString() };
-      const resp = yield this.dynamodbClient.updateItem(__spreadProps(__spreadValues({
+      const resp = yield this.dynamodbClient.updateItem({
         TableName: this.TABLE_NAME,
         Key: entity.keys(),
-        UpdateExpression: UpdateExpression + updatedAtExpression
-      }, ConditionExpression && { ConditionExpression }), {
-        ExpressionAttributeNames,
-        ExpressionAttributeValues,
+        UpdateExpression: UpdateExpression + updatedAtExpression,
+        ConditionExpression: (opts == null ? void 0 : opts.ConditionExpression) || "attribute_exists(PK)",
+        ExpressionAttributeNames: __spreadValues(__spreadValues({}, ExpressionAttributeNames), opts == null ? void 0 : opts.ExpressionAttributeNames),
+        ExpressionAttributeValues: __spreadValues(__spreadValues({}, ExpressionAttributeValues), opts == null ? void 0 : opts.ExpressionAttributeValues),
         ReturnValues: "ALL_NEW"
-      }));
+      });
       return Entity.fromItem(resp.Attributes);
     });
   }
@@ -1821,6 +1822,217 @@ var TagRepository = class extends Repository {
   }
 };
 
+// data/WebSocket.ts
+import {
+  DeleteCommand,
+  DynamoDBDocumentClient,
+  PutCommand,
+  QueryCommand
+} from "@aws-sdk/lib-dynamodb";
+var WebSocketRepository = class extends Repository {
+  constructor(tableName, dynamodbClient) {
+    super();
+    this.tableName = tableName;
+    this.dynamodbClient = dynamodbClient;
+    this.docClient = DynamoDBDocumentClient.from(dynamodbClient);
+  }
+  createConnection(connectionId, metadata, expiresAt) {
+    return __async(this, null, function* () {
+      yield this.docClient.send(
+        new PutCommand({
+          TableName: this.tableName,
+          Item: __spreadProps(__spreadValues({
+            PK: `CONN#${connectionId}`,
+            SK: "#METADATA#",
+            connectionId
+          }, metadata), {
+            expiresAt
+          })
+        })
+      );
+    });
+  }
+  getConnection(connectionId) {
+    return __async(this, null, function* () {
+      var _a;
+      const result = yield this.docClient.send(
+        new QueryCommand({
+          TableName: this.tableName,
+          KeyConditionExpression: "PK = :pk",
+          ExpressionAttributeValues: {
+            ":pk": `CONN#${connectionId}`
+          }
+        })
+      );
+      return (_a = result.Items) == null ? void 0 : _a[0];
+    });
+  }
+  deleteConnection(connectionId) {
+    return __async(this, null, function* () {
+      yield this.docClient.send(
+        new DeleteCommand({
+          TableName: this.tableName,
+          Key: {
+            PK: `CONN#${connectionId}`,
+            SK: "#METADATA#"
+          }
+        })
+      );
+    });
+  }
+  createSubscription(subKey, connectionId, data) {
+    return __async(this, null, function* () {
+      yield this.docClient.send(
+        new PutCommand({
+          TableName: this.tableName,
+          Item: __spreadValues({
+            PK: subKey,
+            SK: `CONN#${connectionId}`,
+            R1PK: `CONN#${connectionId}`,
+            R1SK: subKey,
+            connectionId
+          }, data)
+        })
+      );
+    });
+  }
+  deleteSubscription(subKey, connectionId) {
+    return __async(this, null, function* () {
+      yield this.docClient.send(
+        new DeleteCommand({
+          TableName: this.tableName,
+          Key: {
+            PK: subKey,
+            SK: `CONN#${connectionId}`
+          }
+        })
+      );
+    });
+  }
+  querySubscriptionsByKey(subKey) {
+    return __async(this, null, function* () {
+      const result = yield this.docClient.send(
+        new QueryCommand({
+          TableName: this.tableName,
+          KeyConditionExpression: "PK = :pk",
+          ExpressionAttributeValues: {
+            ":pk": subKey
+          },
+          ConsistentRead: true
+        })
+      );
+      return result.Items || [];
+    });
+  }
+  querySubscriptionsByConnectionId(connectionId) {
+    return __async(this, null, function* () {
+      const { ENTITY_REPLICATION_INDEX: ENTITY_REPLICATION_INDEX2 } = yield import("./service.config-ZJEZ6EKA.js");
+      const result = yield this.docClient.send(
+        new QueryCommand({
+          TableName: this.tableName,
+          IndexName: ENTITY_REPLICATION_INDEX2,
+          KeyConditionExpression: "R1PK = :r1pk",
+          ExpressionAttributeValues: {
+            ":r1pk": `CONN#${connectionId}`
+          }
+        })
+      );
+      return result.Items || [];
+    });
+  }
+  createTicket(ticket, entityType, entityId, feedTypes, expiresAt) {
+    return __async(this, null, function* () {
+      yield this.docClient.send(
+        new PutCommand({
+          TableName: this.tableName,
+          Item: {
+            PK: `TICKET#${ticket}`,
+            SK: "#METADATA#",
+            entityType,
+            entityId,
+            feedTypes,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            expiresAt
+          }
+        })
+      );
+    });
+  }
+  consumeTicket(ticket) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.docClient.send(
+          new DeleteCommand({
+            TableName: this.tableName,
+            Key: {
+              PK: `TICKET#${ticket}`,
+              SK: "#METADATA#"
+            },
+            ConditionExpression: "attribute_exists(PK)",
+            ReturnValues: "ALL_OLD"
+          })
+        );
+        const item = result.Attributes;
+        if (!item) return null;
+        const expiresAt = item.expiresAt;
+        if (expiresAt && expiresAt < Math.floor(Date.now() / 1e3)) {
+          return null;
+        }
+        return {
+          entityType: item.entityType,
+          entityId: item.entityId,
+          feedTypes: item.feedTypes || []
+        };
+      } catch (error) {
+        if (error instanceof Error && error.name === "ConditionalCheckFailedException") {
+          return null;
+        }
+        throw error;
+      }
+    });
+  }
+  queryMutualConnections(byEntityType, byEntityId) {
+    return __async(this, null, function* () {
+      const result = yield this.docClient.send(
+        new QueryCommand({
+          TableName: this.tableName,
+          KeyConditionExpression: "PK = :pk",
+          ExpressionAttributeValues: {
+            ":pk": `${byEntityType}#${byEntityId}`
+          },
+          ProjectionExpression: "SK",
+          ConsistentRead: true
+        })
+      );
+      const connections = [];
+      for (const item of result.Items || []) {
+        const sk = item.SK;
+        if (!sk || sk === "#METADATA#" || sk.startsWith("#")) continue;
+        const parts = sk.split("#");
+        if (parts.length >= 2) {
+          connections.push({ entityType: parts[0], entityId: parts[1] });
+        }
+      }
+      return connections;
+    });
+  }
+  queryFeedSubscriptions(entityType, entityId) {
+    return __async(this, null, function* () {
+      const result = yield this.docClient.send(
+        new QueryCommand({
+          TableName: this.tableName,
+          KeyConditionExpression: "PK = :pk",
+          ExpressionAttributeValues: {
+            ":pk": `SUB#FEED#${entityType}#${entityId}`
+          },
+          ConsistentRead: true
+        })
+      );
+      return result.Items || [];
+    });
+  }
+};
+
 // handles/app.ts
 import { Hono as Hono2 } from "hono";
 import { handle } from "hono/aws-lambda";
@@ -1860,14 +2072,6 @@ import {
   PutEventsCommand
 } from "@aws-sdk/client-eventbridge";
 
-// constants/table.ts
-var ENTITY_REPLICATION_INDEX = "ENTITY_REPLICATION_INDEX";
-var MUTUAL_REPLICATION_INDEX = "MUTUAL_REPLICATION_INDEX";
-
-// configs/service.config.ts
-var CORE_TABLE = process.env.CORE_TABLE || "";
-var CORE_EVENT_BUS = process.env.CORE_EVENT_BUS || "";
-
 // types/event.ts
 var SOURCE = {
   CORE: "core-service",
@@ -2819,6 +3023,458 @@ var handler5 = (container) => (ev) => __async(null, null, function* () {
   return { batchItemFailures };
 });
 
+// processors/websocket-processor.ts
+import {
+  ApiGatewayManagementApiClient,
+  PostToConnectionCommand
+} from "@aws-sdk/client-apigatewaymanagementapi";
+import { unmarshall as unmarshall4 } from "@aws-sdk/util-dynamodb";
+import { ulid as ulid3 } from "ulid";
+var SUB_ENTITY_TYPE = "SUB#ENTITY#";
+var SUB_MUTUAL_TYPE = "SUB#MUTUAL#";
+var SUB_EPHEMERAL = "SUB#EPHEMERAL#";
+var SUB_FEED = "SUB#FEED#";
+var getWsEndpoint = () => process.env.WEBSOCKET_MANAGEMENT_ENDPOINT || "";
+var connect = (container) => (event) => __async(null, null, function* () {
+  var _a, _b, _c, _d;
+  const connectionId = event.requestContext.connectionId;
+  if (!connectionId) {
+    return { statusCode: 400, body: "Missing connection ID" };
+  }
+  const expiresAt = Math.floor(Date.now() / 1e3) + 2 * 60 * 60;
+  const ticket = (_a = event.queryStringParameters) == null ? void 0 : _a.ticket;
+  const token = ((_b = event.queryStringParameters) == null ? void 0 : _b.token) || ((_c = event.headers) == null ? void 0 : _c.authorization) || ((_d = event.headers) == null ? void 0 : _d.Authorization);
+  if (!ticket && !token) {
+    return { statusCode: 401, body: "Unauthorized" };
+  }
+  const wsRepo = container.websocketRepository;
+  try {
+    let entityType;
+    let entityId;
+    let feedTypes;
+    if (ticket) {
+      const ticketData = yield wsRepo.consumeTicket(ticket);
+      if (!ticketData) {
+        return { statusCode: 401, body: "Invalid or expired ticket" };
+      }
+      entityType = ticketData.entityType;
+      entityId = ticketData.entityId;
+      feedTypes = ticketData.feedTypes;
+    } else {
+      entityId = token;
+    }
+    yield wsRepo.createConnection(
+      connectionId,
+      __spreadProps(__spreadValues(__spreadValues({}, entityType && { entityType }), entityId && { entityId }), {
+        connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }),
+      expiresAt
+    );
+    if (entityType && entityId && feedTypes) {
+      yield wsRepo.createSubscription(
+        `${SUB_FEED}${entityType}#${entityId}`,
+        connectionId,
+        {
+          subscriptionType: "feed",
+          entityType,
+          entityId,
+          feedTypes,
+          subscribedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          expiresAt
+        }
+      );
+    }
+    return { statusCode: 200, body: "Connected" };
+  } catch (error) {
+    console.error("Error in $connect:", error);
+    return { statusCode: 500, body: "Failed to connect" };
+  }
+});
+var disconnect = (container) => (event) => __async(null, null, function* () {
+  const connectionId = event.requestContext.connectionId;
+  if (!connectionId) {
+    return { statusCode: 400, body: "Missing connection ID" };
+  }
+  const wsRepo = container.websocketRepository;
+  try {
+    const subscriptions = yield wsRepo.querySubscriptionsByConnectionId(connectionId);
+    const deletePromises = [];
+    for (const item of subscriptions) {
+      if (item.PK && item.SK) {
+        deletePromises.push(
+          wsRepo.deleteSubscription(item.PK, item.connectionId).catch(
+            (e) => console.warn("Failed to delete subscription on disconnect:", e)
+          )
+        );
+      }
+    }
+    deletePromises.push(wsRepo.deleteConnection(connectionId));
+    yield Promise.all(deletePromises);
+    return { statusCode: 200, body: "Disconnected" };
+  } catch (error) {
+    console.error("Error cleaning up connection:", error);
+    return { statusCode: 500, body: "Failed to disconnect" };
+  }
+});
+var $default = (container) => (event) => __async(null, null, function* () {
+  const connectionId = event.requestContext.connectionId;
+  if (!connectionId || !event.body) {
+    return { statusCode: 400, body: "Invalid message" };
+  }
+  let message;
+  try {
+    message = JSON.parse(event.body);
+  } catch (e) {
+    return { statusCode: 400, body: "Invalid JSON" };
+  }
+  const wsRepo = container.websocketRepository;
+  const wsEndpoint = getWsEndpoint();
+  const managementApi = new ApiGatewayManagementApiClient({
+    endpoint: wsEndpoint
+  });
+  try {
+    switch (message.action) {
+      case "subscribe": {
+        const {
+          entityType,
+          byEntityType,
+          byEntityId,
+          mutualEntityType,
+          channel
+        } = message.payload;
+        if (entityType && !byEntityType) {
+          yield wsRepo.createSubscription(
+            `${SUB_ENTITY_TYPE}${entityType}`,
+            connectionId,
+            {
+              subscriptionType: "entity-type",
+              entityType,
+              subscribedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          );
+        } else if (byEntityType && byEntityId && mutualEntityType) {
+          yield wsRepo.createSubscription(
+            `${SUB_MUTUAL_TYPE}${byEntityType}#${byEntityId}#${mutualEntityType}`,
+            connectionId,
+            {
+              subscriptionType: "mutual-type",
+              byEntityType,
+              byEntityId,
+              entityType: mutualEntityType,
+              subscribedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          );
+        } else if (channel) {
+          yield wsRepo.createSubscription(
+            `${SUB_EPHEMERAL}${channel}`,
+            connectionId,
+            {
+              subscriptionType: "ephemeral",
+              channel,
+              subscribedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          );
+        } else {
+          return { statusCode: 400, body: "Invalid subscription parameters" };
+        }
+        const ackMessage = {
+          type: "ack",
+          id: message.id,
+          payload: { action: "subscribe", success: true }
+        };
+        yield managementApi.send(
+          new PostToConnectionCommand({
+            ConnectionId: connectionId,
+            Data: JSON.stringify(ackMessage)
+          })
+        );
+        return { statusCode: 200, body: "Subscribed" };
+      }
+      case "unsubscribe": {
+        const {
+          entityType,
+          byEntityType,
+          byEntityId,
+          mutualEntityType,
+          channel
+        } = message.payload;
+        if (entityType && !byEntityType) {
+          yield wsRepo.deleteSubscription(
+            `${SUB_ENTITY_TYPE}${entityType}`,
+            connectionId
+          );
+        } else if (byEntityType && byEntityId && mutualEntityType) {
+          yield wsRepo.deleteSubscription(
+            `${SUB_MUTUAL_TYPE}${byEntityType}#${byEntityId}#${mutualEntityType}`,
+            connectionId
+          );
+        } else if (channel) {
+          yield wsRepo.deleteSubscription(
+            `${SUB_EPHEMERAL}${channel}`,
+            connectionId
+          );
+        }
+        const ackMessage = {
+          type: "ack",
+          id: message.id,
+          payload: { action: "unsubscribe", success: true }
+        };
+        yield managementApi.send(
+          new PostToConnectionCommand({
+            ConnectionId: connectionId,
+            Data: JSON.stringify(ackMessage)
+          })
+        );
+        return { statusCode: 200, body: "Unsubscribed" };
+      }
+      case "ping": {
+        const pongMessage = {
+          type: "pong",
+          id: message.id,
+          payload: { timestamp: Date.now() }
+        };
+        yield managementApi.send(
+          new PostToConnectionCommand({
+            ConnectionId: connectionId,
+            Data: JSON.stringify(pongMessage)
+          })
+        );
+        return { statusCode: 200, body: "Pong" };
+      }
+      case "ephemeral": {
+        const { channel, data } = message.payload;
+        if (!channel) {
+          return { statusCode: 400, body: "Missing channel" };
+        }
+        const conn = yield wsRepo.getConnection(connectionId);
+        const senderId = conn == null ? void 0 : conn.entityId;
+        const subKey = `${SUB_EPHEMERAL}${channel}`;
+        const ephemeralMessage = {
+          type: "ephemeral",
+          id: ulid3(),
+          payload: { channel, data, senderId }
+        };
+        yield broadcastToSubscribers(
+          managementApi,
+          wsRepo,
+          subKey,
+          ephemeralMessage,
+          connectionId
+          // Exclude sender
+        );
+        return { statusCode: 200, body: "Broadcasted" };
+      }
+      default:
+        return { statusCode: 400, body: "Unknown action" };
+    }
+  } catch (error) {
+    console.error("Error handling message:", error);
+    try {
+      const errorMessage = {
+        type: "error",
+        id: message.id,
+        payload: { message: "Internal server error" }
+      };
+      yield managementApi.send(
+        new PostToConnectionCommand({
+          ConnectionId: connectionId,
+          Data: JSON.stringify(errorMessage)
+        })
+      );
+    } catch (e) {
+    }
+    return { statusCode: 500, body: "Internal server error" };
+  }
+});
+var broadcast = (container) => (event) => __async(null, null, function* () {
+  var _a, _b, _c, _d;
+  const wsRepo = container.websocketRepository;
+  const wsEndpoint = getWsEndpoint();
+  const managementApi = new ApiGatewayManagementApiClient({
+    endpoint: wsEndpoint
+  });
+  for (const record of event.Records) {
+    const isInsert = record.eventName === "INSERT";
+    const isModify = record.eventName === "MODIFY";
+    const isRemove = record.eventName === "REMOVE";
+    if (!isInsert && !isModify && !isRemove) continue;
+    const newImage = (_a = record.dynamodb) == null ? void 0 : _a.NewImage;
+    const oldImage = (_b = record.dynamodb) == null ? void 0 : _b.OldImage;
+    const image = newImage || oldImage;
+    if (!image) continue;
+    const pk = ((_c = image.PK) == null ? void 0 : _c.S) || "";
+    const sk = ((_d = image.SK) == null ? void 0 : _d.S) || "";
+    const pkParts = pk.split("#");
+    if (pkParts.length < 2) continue;
+    const firstPart = pkParts[0];
+    if (firstPart === firstPart.toUpperCase() || firstPart.includes(":")) {
+      continue;
+    }
+    const entityType = pkParts[0];
+    const entityId = pkParts[1];
+    const isMutual = !sk.startsWith("#METADATA#") && sk.includes("#");
+    try {
+      if (isMutual) {
+        const skParts = sk.split("#");
+        const mutualEntityType = skParts[0];
+        const byEntityId = entityId;
+        const subKey = `${SUB_MUTUAL_TYPE}${entityType}#${byEntityId}#${mutualEntityType}`;
+        const subscribers = yield wsRepo.querySubscriptionsByKey(subKey);
+        if (subscribers.length) {
+          let eventType;
+          if (isInsert) eventType = "mutual.created";
+          else if (isModify) eventType = "mutual.updated";
+          else eventType = "mutual.deleted";
+          const message = {
+            type: eventType,
+            id: ulid3(),
+            payload: {
+              byEntityType: entityType,
+              byEntityId,
+              mutualEntityType,
+              entityId: skParts[1],
+              data: isRemove ? void 0 : unmarshall4(image)
+            }
+          };
+          yield broadcastToSubscribers(
+            managementApi,
+            wsRepo,
+            subKey,
+            message
+          );
+        }
+      } else {
+        const subKey = `${SUB_ENTITY_TYPE}${entityType}`;
+        const subscribers = yield wsRepo.querySubscriptionsByKey(subKey);
+        if (subscribers.length) {
+          let eventType;
+          if (isInsert) eventType = "entity.created";
+          else if (isModify) eventType = "entity.updated";
+          else eventType = "entity.deleted";
+          const message = {
+            type: eventType,
+            id: ulid3(),
+            payload: {
+              entityType,
+              entityId,
+              data: isRemove ? void 0 : unmarshall4(image)
+            }
+          };
+          yield broadcastToSubscribers(
+            managementApi,
+            wsRepo,
+            subKey,
+            message
+          );
+        }
+      }
+      yield broadcastToFeedSubscribers(
+        managementApi,
+        wsRepo,
+        entityType,
+        entityId,
+        isMutual ? sk.split("#")[0] : entityType,
+        // the changed entity type
+        isMutual ? {
+          type: isInsert ? "mutual.created" : isModify ? "mutual.updated" : "mutual.deleted",
+          id: ulid3(),
+          payload: {
+            byEntityType: entityType,
+            byEntityId: entityId,
+            mutualEntityType: sk.split("#")[0],
+            entityId: sk.split("#")[1],
+            data: isRemove ? void 0 : unmarshall4(image)
+          }
+        } : {
+          type: isInsert ? "entity.created" : isModify ? "entity.updated" : "entity.deleted",
+          id: ulid3(),
+          payload: {
+            entityType,
+            entityId,
+            data: isRemove ? void 0 : unmarshall4(image)
+          }
+        }
+      );
+    } catch (error) {
+      console.error("Error broadcasting:", error);
+    }
+  }
+});
+function broadcastToSubscribers(managementApi, wsRepo, subKey, message, excludeConnectionId) {
+  return __async(this, null, function* () {
+    const subscribers = yield wsRepo.querySubscriptionsByKey(subKey);
+    if (!subscribers.length) return;
+    const messageData = JSON.stringify(message);
+    const sends = subscribers.filter((subscriber) => {
+      const id = subscriber.connectionId;
+      return !excludeConnectionId || id !== excludeConnectionId;
+    }).map((subscriber) => __async(null, null, function* () {
+      var _a;
+      try {
+        yield managementApi.send(
+          new PostToConnectionCommand({
+            ConnectionId: subscriber.connectionId,
+            Data: messageData
+          })
+        );
+      } catch (error) {
+        const isGone = (error == null ? void 0 : error.name) === "GoneException" || ((_a = error == null ? void 0 : error.$metadata) == null ? void 0 : _a.httpStatusCode) === 410;
+        if (isGone) {
+          yield wsRepo.deleteSubscription(subKey, subscriber.connectionId).catch(
+            (e) => console.warn("Failed to clean up stale subscription:", e)
+          );
+        }
+      }
+    }));
+    yield Promise.allSettled(sends);
+  });
+}
+function broadcastToFeedSubscribers(managementApi, wsRepo, byEntityType, byEntityId, changedEntityType, message) {
+  return __async(this, null, function* () {
+    var _a;
+    const connections = yield wsRepo.queryMutualConnections(
+      byEntityType,
+      byEntityId
+    );
+    if (!connections.length) return;
+    const connectedEntities = new Set(
+      connections.map((c) => `${c.entityType}:${c.entityId}`)
+    );
+    connectedEntities.add(`${byEntityType}:${byEntityId}`);
+    const sentConnections = /* @__PURE__ */ new Set();
+    for (const connEntity of connectedEntities) {
+      const [entityType, entityId] = connEntity.split(":");
+      const feedSubs = yield wsRepo.queryFeedSubscriptions(entityType, entityId);
+      if (!feedSubs.length) continue;
+      for (const feedSub of feedSubs) {
+        const feedTypes = feedSub.feedTypes;
+        const connectionId = feedSub.connectionId;
+        if (feedTypes && !feedTypes.includes(changedEntityType)) continue;
+        if (sentConnections.has(connectionId)) continue;
+        sentConnections.add(connectionId);
+        try {
+          yield managementApi.send(
+            new PostToConnectionCommand({
+              ConnectionId: connectionId,
+              Data: JSON.stringify(message)
+            })
+          );
+        } catch (error) {
+          const isGone = (error == null ? void 0 : error.name) === "GoneException" || ((_a = error == null ? void 0 : error.$metadata) == null ? void 0 : _a.httpStatusCode) === 410;
+          if (isGone) {
+            yield wsRepo.deleteSubscription(
+              `SUB#FEED#${entityType}#${entityId}`,
+              connectionId
+            ).catch(
+              (e) => console.warn("Failed to clean up stale feed subscription:", e)
+            );
+          }
+        }
+      }
+    }
+  });
+}
+
 // services/DependencyContainer.ts
 import { DynamoDB } from "@aws-sdk/client-dynamodb";
 
@@ -7051,11 +7707,21 @@ 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 errorContext = {
+      const _a = body, { $condition: condition, $where: where } = _a, entityPayload = __objRest(_a, ["$condition", "$where"]);
+      if (condition !== void 0) {
+        if (typeof condition !== "string" || condition.trim().length === 0) {
+          c.status(httpStatus8.BAD_REQUEST);
+          return c.json({
+            code: "API_VALIDATION_ERROR",
+            message: "$condition must be a non-empty string"
+          });
+        }
+      }
+      const errorContext = {
         accountId,
         "req.params": c.req.param(),
         "req.body": body
@@ -7064,14 +7730,16 @@ var UpdateEntityController = class {
         const entity = yield this.entityService.updateEntity({
           entityType,
           entityId,
-          entityPayload: body,
-          accountId
+          entityPayload,
+          accountId,
+          condition,
+          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",
@@ -7083,10 +7751,18 @@ var UpdateEntityController = class {
           c.status(httpStatus8.NOT_FOUND);
           return c.json(__spreadValues({}, err.toJSON()));
         }
+        if (err instanceof StandardError && err.code === StandardErrorCode.INVALID_CONDITION) {
+          c.status(httpStatus8.BAD_REQUEST);
+          return c.json(__spreadValues({}, err.toJSON()));
+        }
         if (err instanceof StandardError && err.code === StandardErrorCode.UNIQUE_VALUE_EXISTS) {
           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,
@@ -7105,11 +7781,21 @@ var AdjustEntityController = class {
   constructor(entityService) {
     this.entityService = entityService;
     this.controller = createMiddleware9((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();
-      for (const [key, value] of Object.entries(body)) {
+      const _a = body, { $condition: condition } = _a, adjustments = __objRest(_a, ["$condition"]);
+      if (condition !== void 0) {
+        if (typeof condition !== "string" || condition.trim().length === 0) {
+          c.status(httpStatus9.BAD_REQUEST);
+          return c.json({
+            code: "API_VALIDATION_ERROR",
+            message: "$condition must be a non-empty string"
+          });
+        }
+      }
+      for (const [key, value] of Object.entries(adjustments)) {
         if (typeof value !== "number") {
           c.status(httpStatus9.BAD_REQUEST);
           return c.json({
@@ -7122,8 +7808,9 @@ var AdjustEntityController = class {
         const entity = yield this.entityService.adjustEntity({
           entityType,
           entityId,
-          adjustments: body,
-          accountId
+          adjustments,
+          accountId,
+          condition
         });
         c.status(httpStatus9.OK);
         return c.json(entity.toJSON());
@@ -7132,7 +7819,11 @@ var AdjustEntityController = class {
           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"))) {
+        if (err instanceof StandardError && err.code === StandardErrorCode.INVALID_CONDITION) {
+          c.status(httpStatus9.BAD_REQUEST);
+          return c.json(__spreadValues({}, err.toJSON()));
+        }
+        if ((err == null ? void 0 : err.name) === "ConditionalCheckFailedException" || ((_b = err == null ? void 0 : err.__type) == null ? void 0 : _b.includes("ConditionalCheckFailed"))) {
           c.status(httpStatus9.CONFLICT);
           return c.json({
             code: "ADJUSTMENT_CONSTRAINT_VIOLATED",
@@ -7437,6 +8128,119 @@ var UpdateMutualController = class {
   }
 };
 
+// services/entity.service.ts
+import { marshall as marshall6 } from "@aws-sdk/util-dynamodb";
+
+// 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/resolve-condition.ts
+function resolveAdjustmentCondition(_0) {
+  return __async(this, arguments, function* ({
+    conditionName,
+    conditions,
+    adjustments,
+    getEntityData
+  }) {
+    if (!Object.hasOwn(conditions, conditionName)) {
+      throw new StandardError(
+        StandardErrorCode.INVALID_CONDITION,
+        `Unknown adjustment condition: '${conditionName}'`
+      );
+    }
+    const condition = conditions[conditionName];
+    let resolved;
+    if (typeof condition === "function") {
+      const data = yield getEntityData();
+      resolved = condition(data, adjustments);
+    } else {
+      resolved = condition;
+    }
+    return buildConditionExpression(resolved);
+  });
+}
+function resolveUpdateCondition(_0) {
+  return __async(this, arguments, function* ({
+    conditionName,
+    conditions,
+    getEntityData
+  }) {
+    if (!Object.hasOwn(conditions, conditionName)) {
+      throw new StandardError(
+        StandardErrorCode.INVALID_CONDITION,
+        `Unknown update condition: '${conditionName}'`
+      );
+    }
+    const condition = conditions[conditionName];
+    let resolved;
+    if (typeof condition === "function") {
+      const data = yield getEntityData();
+      resolved = condition(data);
+    } else {
+      resolved = condition;
+    }
+    return buildConditionExpression(resolved);
+  });
+}
+
 // services/entity.service.ts
 var EntityService = class {
   constructor(EntityConfig, EmailAuthEnabledEntities, entityRepository, publishEvent2, entityServiceLifeCycle) {
@@ -7492,34 +8296,59 @@ var EntityService = class {
       entityType,
       entityId,
       adjustments,
-      accountId
+      accountId,
+      condition
     }) {
-      var _a, _b, _c, _d;
-      const rawConstraints = (_a = this.EntityConfig[entityType]) == null ? void 0 : _a.adjustmentConstraints;
-      let resolvedConstraints = rawConstraints;
-      if (rawConstraints) {
+      var _a, _b, _c;
+      const entityConfig = this.EntityConfig[entityType];
+      const adjustmentConditions = entityConfig == null ? void 0 : entityConfig.adjustmentConditions;
+      const rawConstraints = entityConfig == null ? void 0 : entityConfig.adjustmentConstraints;
+      let opts;
+      if (adjustmentConditions) {
+        if (!condition) {
+          throw new StandardError(
+            StandardErrorCode.INVALID_CONDITION,
+            "Entity has adjustmentConditions defined; $condition is required for adjustEntity"
+          );
+        }
+        opts = yield resolveAdjustmentCondition({
+          conditionName: condition,
+          conditions: adjustmentConditions,
+          adjustments,
+          getEntityData: () => __async(this, null, function* () {
+            var _a2;
+            const entity2 = yield this.entityRepository.getEntity(entityType, entityId);
+            return (_a2 = entity2 == null ? void 0 : entity2.data) != null ? _a2 : {};
+          })
+        });
+      } else if (rawConstraints) {
+        console.warn(
+          "[monorise] adjustmentConstraints is deprecated. Use adjustmentConditions instead."
+        );
+        let resolvedConstraints = 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 : {};
+          const data = (_a = currentEntity == null ? void 0 : currentEntity.data) != null ? _a : {};
           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;
+            if (constraint.minField) resolved.min = (_b = data[constraint.minField]) != null ? _b : 0;
+            if (constraint.maxField) resolved.max = (_c = data[constraint.maxField]) != null ? _c : Number.MAX_SAFE_INTEGER;
             resolvedConstraints[field] = resolved;
           }
         }
+        opts = this.buildLegacyAdjustCondition(adjustments, resolvedConstraints);
       }
       const entity = yield this.entityRepository.adjustEntity(
         entityType,
         entityId,
         adjustments,
-        resolvedConstraints
+        opts
       );
       yield this.publishEvent({
         event: EVENT.CORE.ENTITY_UPDATED,
@@ -7537,9 +8366,11 @@ var EntityService = class {
       entityType,
       entityId,
       entityPayload,
-      accountId
+      accountId,
+      condition,
+      where
     }) {
-      var _a, _b;
+      var _a, _b, _c;
       const errorContext = {};
       try {
         const entitySchema = this.EntityConfig[entityType].baseSchema;
@@ -7553,10 +8384,35 @@ var EntityService = class {
         const parsedEntityPayload = entitySchema.parse(entityPayload);
         const parsedMutualPayload = mutualSchema == null ? void 0 : mutualSchema.parse(entityPayload);
         errorContext.parsedMutualPayload = parsedMutualPayload;
+        let opts;
+        if (condition) {
+          const updateConditions = (_b = this.EntityConfig[entityType]) == null ? void 0 : _b.updateConditions;
+          if (!updateConditions) {
+            throw new StandardError(
+              StandardErrorCode.INVALID_CONDITION,
+              `Entity '${entityType}' has no updateConditions defined`
+            );
+          }
+          opts = yield resolveUpdateCondition({
+            conditionName: condition,
+            conditions: updateConditions,
+            getEntityData: () => __async(this, null, function* () {
+              var _a2;
+              const entity2 = yield this.entityRepository.getEntity(entityType, entityId);
+              return (_a2 = entity2 == null ? void 0 : entity2.data) != null ? _a2 : {};
+            })
+          });
+        } else if (where && Object.keys(where).length > 0) {
+          console.warn(
+            "[monorise] $where is deprecated. Use named conditions via $condition instead."
+          );
+          opts = buildConditionExpression(where);
+        }
         const entity = yield this.entityRepository.updateEntity(
           entityType,
           entityId,
-          { data: parsedEntityPayload }
+          { data: parsedEntityPayload },
+          opts
         );
         errorContext.entity = entity;
         if (parsedMutualPayload) {
@@ -7564,7 +8420,7 @@ var EntityService = class {
           const byEntityId = entityId;
           const publishEventPromises = [];
           for (const [fieldKey, config] of Object.entries(
-            ((_b = this.EntityConfig[entityType].mutual) == null ? void 0 : _b.mutualFields) || {}
+            ((_c = this.EntityConfig[entityType].mutual) == null ? void 0 : _c.mutualFields) || {}
           )) {
             const toMutualIds = config.toMutualIds;
             const mutualPayload = parsedMutualPayload[fieldKey];
@@ -7620,10 +8476,39 @@ var EntityService = class {
       });
     });
   }
+  /** @deprecated Converts legacy adjustmentConstraints to condition expression opts. */
+  buildLegacyAdjustCondition(adjustments, constraints) {
+    const conditionParts = [];
+    const names = { "#data": "data" };
+    const values = {};
+    for (const [field, constraint] of Object.entries(constraints)) {
+      const delta = adjustments[field];
+      if (delta === void 0) continue;
+      const namePlaceholder = `#where_${field}`;
+      names[namePlaceholder] = field;
+      const fieldRef = `#data.${namePlaceholder}`;
+      if (constraint.min !== void 0 && delta < 0) {
+        const valKey = `:where_${field}_min_threshold`;
+        conditionParts.push(`${fieldRef} >= ${valKey}`);
+        values[valKey] = constraint.min - delta;
+      }
+      if (constraint.max !== void 0 && delta > 0) {
+        const valKey = `:where_${field}_max_threshold`;
+        conditionParts.push(`${fieldRef} <= ${valKey}`);
+        values[valKey] = constraint.max - delta;
+      }
+    }
+    if (conditionParts.length === 0) return void 0;
+    return {
+      ConditionExpression: conditionParts.join(" AND "),
+      ExpressionAttributeNames: names,
+      ExpressionAttributeValues: marshall6(values)
+    };
+  }
 };
 
 // services/mutual.service.ts
-import { ulid as ulid3 } from "ulid";
+import { ulid as ulid4 } from "ulid";
 var MutualService = class {
   constructor(entityRepository, mutualRepository, publishEvent2, ddbUtils, entityServiceLifeCycle) {
     this.entityRepository = entityRepository;
@@ -7683,7 +8568,7 @@ var MutualService = class {
         entityId,
         entityData,
         parsedMutualPayload,
-        mutualId || ulid3(),
+        mutualId || ulid4(),
         currentDatetime,
         currentDatetime,
         currentDatetime
@@ -7861,6 +8746,116 @@ var ListTagsController = class {
   }
 };
 
+// controllers/transaction/execute-transaction.controller.ts
+import { createMiddleware as createMiddleware17 } from "hono/factory";
+import httpStatus15 from "http-status";
+var ExecuteTransactionController = class {
+  constructor(transactionService) {
+    this.transactionService = transactionService;
+    // biome-ignore lint/suspicious/noExplicitAny: Hono createMiddleware requires consistent return types
+    this.controller = createMiddleware17((c) => __async(this, null, function* () {
+      var _a;
+      const accountId = c.req.header("account-id") || "";
+      const body = yield c.req.json();
+      if (!body.operations || !Array.isArray(body.operations)) {
+        c.status(httpStatus15.BAD_REQUEST);
+        return c.json({
+          code: "API_VALIDATION_ERROR",
+          message: 'Request body must contain an "operations" array'
+        });
+      }
+      try {
+        const result = yield this.transactionService.executeTransaction(
+          body.operations,
+          accountId
+        );
+        c.status(httpStatus15.OK);
+        return c.json(result);
+      } catch (err) {
+        if (((_a = err.constructor) == null ? void 0 : _a.name) === "ZodError") {
+          c.status(httpStatus15.BAD_REQUEST);
+          return c.json({
+            code: "API_VALIDATION_ERROR",
+            message: "Validation failed",
+            details: err.flatten()
+          });
+        }
+        if (err instanceof StandardError) {
+          const code = err.code;
+          if (code === StandardErrorCode.TRANSACTION_EMPTY || code === StandardErrorCode.TRANSACTION_ITEM_LIMIT_EXCEEDED || code === StandardErrorCode.TRANSACTION_UNIQUE_FIELD_UPDATE || code === StandardErrorCode.INVALID_ENTITY_TYPE || code === StandardErrorCode.INVALID_CONDITION || code === StandardErrorCode.INVALID_UNIQUE_VALUE_TYPE) {
+            c.status(httpStatus15.BAD_REQUEST);
+            return c.json(__spreadValues({}, err.toJSON()));
+          }
+          if (code === StandardErrorCode.TRANSACTION_FAILED || code === StandardErrorCode.CONDITIONAL_CHECK_FAILED || code === StandardErrorCode.UNIQUE_VALUE_EXISTS) {
+            c.status(httpStatus15.CONFLICT);
+            return c.json(__spreadValues({}, err.toJSON()));
+          }
+        }
+        throw err;
+      }
+    }));
+  }
+};
+
+// controllers/ws/create-ticket.controller.ts
+import { createMiddleware as createMiddleware18 } from "hono/factory";
+import { ulid as ulid5 } from "ulid";
+var TICKET_TTL_SECONDS = 30 * 60;
+var CreateTicketController = class {
+  constructor(container) {
+    this.container = container;
+    this.controller = createMiddleware18((c) => __async(this, null, function* () {
+      var _a;
+      const { entityType, entityId } = c.req.param();
+      let feedTypes;
+      try {
+        const body = yield c.req.json();
+        feedTypes = body.feedTypes;
+      } catch (e) {
+      }
+      if (!feedTypes || feedTypes.length === 0) {
+        const allConfigs = this.container.config.EntityConfig;
+        const visited = /* @__PURE__ */ new Set();
+        const queue = [entityType];
+        while (queue.length > 0) {
+          const current = queue.shift();
+          if (!current) continue;
+          if (visited.has(current)) continue;
+          visited.add(current);
+          const config = allConfigs[current];
+          if ((_a = config == null ? void 0 : config.mutual) == null ? void 0 : _a.mutualFields) {
+            for (const field of Object.values(
+              config.mutual.mutualFields
+            )) {
+              if (!visited.has(field.entityType)) {
+                queue.push(field.entityType);
+              }
+            }
+          }
+        }
+        visited.delete(entityType);
+        feedTypes = Array.from(visited);
+      }
+      const ticket = ulid5();
+      const now = Math.floor(Date.now() / 1e3);
+      const expiresAt = now + TICKET_TTL_SECONDS;
+      yield this.container.websocketRepository.createTicket(
+        ticket,
+        entityType,
+        entityId,
+        feedTypes,
+        expiresAt
+      );
+      const wsEndpoint = process.env.WEBSOCKET_URL || "";
+      return c.json({
+        ticket,
+        wsUrl: wsEndpoint,
+        expiresIn: TICKET_TTL_SECONDS
+      });
+    }));
+  }
+};
+
 // services/entity-service-lifecycle.ts
 var EntityServiceLifeCycle = class {
   constructor(EntityConfig, publishEvent2, eventUtils) {
@@ -7893,6 +8888,435 @@ var EntityServiceLifeCycle = class {
   }
 };
 
+// services/transaction.service.ts
+import { TransactionCanceledException as TransactionCanceledException5 } from "@aws-sdk/client-dynamodb";
+import { ulid as ulid6 } from "ulid";
+var MAX_TRANSACTION_ITEMS = 100;
+var TransactionService = class {
+  constructor(EntityConfig, EmailAuthEnabledEntities, entityRepository, dynamodbClient, publishEvent2, entityServiceLifeCycle, eventUtils) {
+    this.EntityConfig = EntityConfig;
+    this.EmailAuthEnabledEntities = EmailAuthEnabledEntities;
+    this.entityRepository = entityRepository;
+    this.dynamodbClient = dynamodbClient;
+    this.publishEvent = publishEvent2;
+    this.entityServiceLifeCycle = entityServiceLifeCycle;
+    this.eventUtils = eventUtils;
+    this.executeTransaction = (operations, accountId) => __async(this, null, function* () {
+      var _a;
+      if (!operations || operations.length === 0) {
+        throw new StandardError(
+          StandardErrorCode.TRANSACTION_EMPTY,
+          "Transaction must contain at least one operation"
+        );
+      }
+      const allTransactItems = [];
+      const pendingEvents = [];
+      const resultEntries = [];
+      for (const op of operations) {
+        switch (op.operation) {
+          case "createEntity": {
+            const { items, entity } = yield this.buildCreateItems(op);
+            allTransactItems.push(...items);
+            pendingEvents.push(
+              ...this.collectCreateEvents(
+                entity,
+                op.payload,
+                accountId
+              )
+            );
+            resultEntries.push({
+              operation: "createEntity",
+              entityType: op.entityType,
+              entityId: entity.entityId,
+              data: entity.data
+            });
+            break;
+          }
+          case "updateEntity": {
+            const { item, updatedAt } = yield this.buildUpdateItem(op);
+            allTransactItems.push(item);
+            pendingEvents.push(
+              ...this.collectUpdateEvents(
+                op,
+                updatedAt,
+                accountId
+              )
+            );
+            resultEntries.push({
+              operation: "updateEntity",
+              entityType: op.entityType,
+              entityId: op.entityId
+            });
+            break;
+          }
+          case "adjustEntity": {
+            const { item, updatedAt } = yield this.buildAdjustItem(op);
+            allTransactItems.push(item);
+            pendingEvents.push({
+              event: EVENT.CORE.ENTITY_UPDATED,
+              payload: {
+                entityType: op.entityType,
+                entityId: op.entityId,
+                updatedByAccountId: accountId,
+                publishedAt: updatedAt
+              }
+            });
+            resultEntries.push({
+              operation: "adjustEntity",
+              entityType: op.entityType,
+              entityId: op.entityId
+            });
+            break;
+          }
+          case "deleteEntity": {
+            const item = this.buildDeleteItem(op);
+            allTransactItems.push(item);
+            pendingEvents.push({
+              event: EVENT.CORE.ENTITY_DELETED,
+              payload: {
+                entityType: op.entityType,
+                entityId: op.entityId,
+                deletedByAccountId: accountId
+              }
+            });
+            resultEntries.push({
+              operation: "deleteEntity",
+              entityType: op.entityType,
+              entityId: op.entityId
+            });
+            break;
+          }
+          default:
+            throw new StandardError(
+              StandardErrorCode.INVALID_ENTITY_TYPE,
+              `Unknown operation: '${op.operation}'`
+            );
+        }
+      }
+      if (allTransactItems.length > MAX_TRANSACTION_ITEMS) {
+        throw new StandardError(
+          StandardErrorCode.TRANSACTION_ITEM_LIMIT_EXCEEDED,
+          `Transaction contains ${allTransactItems.length} items, exceeds limit of ${MAX_TRANSACTION_ITEMS}`
+        );
+      }
+      try {
+        yield this.dynamodbClient.transactWriteItems({
+          TransactItems: allTransactItems
+        });
+      } catch (err) {
+        if (err instanceof TransactionCanceledException5) {
+          throw new StandardError(
+            StandardErrorCode.TRANSACTION_FAILED,
+            "Transaction failed",
+            err,
+            {
+              reasons: (_a = err.CancellationReasons) == null ? void 0 : _a.map((r, i) => ({
+                index: i,
+                code: r.Code,
+                message: r.Message
+              }))
+            }
+          );
+        }
+        throw err;
+      }
+      const readPromises = resultEntries.map((entry) => __async(this, null, function* () {
+        if ((entry.operation === "updateEntity" || entry.operation === "adjustEntity") && !entry.data) {
+          try {
+            const entity = yield this.entityRepository.getEntity(
+              entry.entityType,
+              entry.entityId
+            );
+            entry.data = entity.data;
+          } catch (e) {
+          }
+        }
+      }));
+      yield Promise.all(readPromises);
+      yield Promise.allSettled(pendingEvents.map((ev) => this.publishEvent(ev)));
+      return { results: resultEntries };
+    });
+  }
+  buildCreateItems(op) {
+    return __async(this, null, function* () {
+      const config = this.EntityConfig[op.entityType];
+      if (!config) {
+        throw new StandardError(
+          StandardErrorCode.INVALID_ENTITY_TYPE,
+          `Unknown entity type: '${op.entityType}'`
+        );
+      }
+      const entitySchema = config.createSchema || config.baseSchema;
+      if (!entitySchema) {
+        throw new StandardError(
+          StandardErrorCode.INVALID_ENTITY_TYPE,
+          `No schema defined for entity type: '${op.entityType}'`
+        );
+      }
+      if (config.finalSchema) {
+        config.finalSchema.parse(op.payload);
+      }
+      const parsedPayload = entitySchema.parse(
+        op.payload
+      );
+      const currentDatetime = /* @__PURE__ */ new Date();
+      const entity = new Entity(
+        op.entityType,
+        op.entityId || ulid6(),
+        parsedPayload,
+        currentDatetime,
+        currentDatetime
+      );
+      const uniqueFields = config.uniqueFields || [];
+      const uniqueFieldValues = {};
+      for (const field of uniqueFields) {
+        if (!(field in parsedPayload)) continue;
+        const value = parsedPayload[field];
+        if (typeof value !== "string") {
+          throw new StandardError(
+            StandardErrorCode.INVALID_UNIQUE_VALUE_TYPE,
+            `Invalid type. ${field} is not a 'string'.`
+          );
+        }
+        uniqueFieldValues[field] = value;
+      }
+      const items = this.entityRepository.createEntityTransactItems(entity, {
+        uniqueFieldValues
+      });
+      return { items, entity };
+    });
+  }
+  buildUpdateItem(op) {
+    return __async(this, null, function* () {
+      const config = this.EntityConfig[op.entityType];
+      if (!config) {
+        throw new StandardError(
+          StandardErrorCode.INVALID_ENTITY_TYPE,
+          `Unknown entity type: '${op.entityType}'`
+        );
+      }
+      const uniqueFields = config.uniqueFields || [];
+      for (const field of uniqueFields) {
+        if (field in op.payload) {
+          throw new StandardError(
+            StandardErrorCode.TRANSACTION_UNIQUE_FIELD_UPDATE,
+            `Cannot update unique field '${field}' within a transaction. Use a standalone updateEntity call instead.`
+          );
+        }
+      }
+      const entitySchema = config.baseSchema;
+      if (!entitySchema) {
+        throw new StandardError(
+          StandardErrorCode.INVALID_ENTITY_TYPE,
+          `No schema defined for entity type: '${op.entityType}'`
+        );
+      }
+      const parsedPayload = entitySchema.partial().parse(op.payload);
+      const currentDatetime = (/* @__PURE__ */ new Date()).toISOString();
+      const toUpdateExpressions = this.entityRepository.toUpdate({
+        updatedAt: currentDatetime,
+        data: parsedPayload
+      });
+      let conditionOpts;
+      if (op.condition) {
+        const updateConditions = config.updateConditions;
+        if (!updateConditions) {
+          throw new StandardError(
+            StandardErrorCode.INVALID_CONDITION,
+            `Entity '${op.entityType}' has no updateConditions defined`
+          );
+        }
+        conditionOpts = yield resolveUpdateCondition({
+          conditionName: op.condition,
+          conditions: updateConditions,
+          getEntityData: () => __async(this, null, function* () {
+            var _a;
+            const entity2 = yield this.entityRepository.getEntity(
+              op.entityType,
+              op.entityId
+            );
+            return (_a = entity2 == null ? void 0 : entity2.data) != null ? _a : {};
+          })
+        });
+      }
+      const entity = new Entity(op.entityType, op.entityId);
+      const item = {
+        Update: {
+          TableName: this.entityRepository.TABLE_NAME,
+          Key: entity.keys(),
+          ConditionExpression: (conditionOpts == null ? void 0 : conditionOpts.ConditionExpression) || "attribute_exists(PK)",
+          UpdateExpression: toUpdateExpressions.UpdateExpression,
+          ExpressionAttributeNames: __spreadValues(__spreadValues({}, toUpdateExpressions.ExpressionAttributeNames), conditionOpts == null ? void 0 : conditionOpts.ExpressionAttributeNames),
+          ExpressionAttributeValues: __spreadValues(__spreadValues({}, toUpdateExpressions.ExpressionAttributeValues), conditionOpts == null ? void 0 : conditionOpts.ExpressionAttributeValues)
+        }
+      };
+      return { item, updatedAt: currentDatetime };
+    });
+  }
+  buildAdjustItem(op) {
+    return __async(this, null, function* () {
+      const config = this.EntityConfig[op.entityType];
+      if (!config) {
+        throw new StandardError(
+          StandardErrorCode.INVALID_ENTITY_TYPE,
+          `Unknown entity type: '${op.entityType}'`
+        );
+      }
+      for (const [key, value] of Object.entries(op.adjustments)) {
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+          throw new StandardError(
+            StandardErrorCode.INVALID_ENTITY_TYPE,
+            `Adjustment field "${key}" must be a finite number`
+          );
+        }
+      }
+      const {
+        UpdateExpression,
+        ExpressionAttributeNames,
+        ExpressionAttributeValues
+      } = this.entityRepository.toAdjustUpdate(op.adjustments);
+      const currentDatetime = (/* @__PURE__ */ new Date()).toISOString();
+      ExpressionAttributeNames["#updatedAt"] = "updatedAt";
+      ExpressionAttributeValues[":updatedAt"] = { S: currentDatetime };
+      const fullUpdateExpression = `${UpdateExpression}, #updatedAt = :updatedAt`;
+      let conditionOpts;
+      const adjustmentConditions = config.adjustmentConditions;
+      if (adjustmentConditions) {
+        if (!op.condition) {
+          throw new StandardError(
+            StandardErrorCode.INVALID_CONDITION,
+            `Entity '${op.entityType}' has adjustmentConditions defined; condition is required`
+          );
+        }
+        conditionOpts = yield resolveAdjustmentCondition({
+          conditionName: op.condition,
+          conditions: adjustmentConditions,
+          adjustments: op.adjustments,
+          getEntityData: () => __async(this, null, function* () {
+            var _a;
+            const entity2 = yield this.entityRepository.getEntity(
+              op.entityType,
+              op.entityId
+            );
+            return (_a = entity2 == null ? void 0 : entity2.data) != null ? _a : {};
+          })
+        });
+      }
+      const entity = new Entity(op.entityType, op.entityId);
+      const item = {
+        Update: {
+          TableName: this.entityRepository.TABLE_NAME,
+          Key: entity.keys(),
+          UpdateExpression: fullUpdateExpression,
+          ConditionExpression: (conditionOpts == null ? void 0 : conditionOpts.ConditionExpression) || "attribute_exists(PK)",
+          ExpressionAttributeNames: __spreadValues(__spreadValues({}, ExpressionAttributeNames), conditionOpts == null ? void 0 : conditionOpts.ExpressionAttributeNames),
+          ExpressionAttributeValues: __spreadValues(__spreadValues({}, ExpressionAttributeValues), conditionOpts == null ? void 0 : conditionOpts.ExpressionAttributeValues)
+        }
+      };
+      return { item, updatedAt: currentDatetime };
+    });
+  }
+  buildDeleteItem(op) {
+    const config = this.EntityConfig[op.entityType];
+    if (!config) {
+      throw new StandardError(
+        StandardErrorCode.INVALID_ENTITY_TYPE,
+        `Unknown entity type: '${op.entityType}'`
+      );
+    }
+    const entity = new Entity(op.entityType, op.entityId);
+    return {
+      Delete: {
+        TableName: this.entityRepository.TABLE_NAME,
+        Key: entity.keys(),
+        ConditionExpression: "attribute_exists(PK)"
+      }
+    };
+  }
+  collectCreateEvents(entity, payload, accountId) {
+    var _a, _b;
+    const events = [];
+    const publishedAt = entity.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
+    const config = this.EntityConfig[entity.entityType];
+    const mutualSchema = (_a = config == null ? void 0 : config.mutual) == null ? void 0 : _a.mutualSchema;
+    if (mutualSchema) {
+      const parsedMutualPayload = mutualSchema.parse(payload);
+      if (parsedMutualPayload) {
+        for (const [fieldKey, fieldConfig] of Object.entries(
+          ((_b = config.mutual) == null ? void 0 : _b.mutualFields) || {}
+        )) {
+          const toMutualIds = fieldConfig.toMutualIds;
+          const mutualPayload = parsedMutualPayload[fieldKey];
+          if (!mutualPayload) continue;
+          events.push({
+            event: EVENT.CORE.ENTITY_MUTUAL_TO_CREATE,
+            payload: {
+              byEntityType: entity.entityType,
+              byEntityId: entity.entityId,
+              entityType: fieldConfig.entityType,
+              field: fieldKey,
+              mutualIds: toMutualIds ? toMutualIds(mutualPayload) : mutualPayload,
+              customContext: toMutualIds ? mutualPayload : {},
+              publishedAt
+            }
+          });
+        }
+      }
+    }
+    events.push({
+      event: EVENT.CORE.ENTITY_CREATED,
+      payload: {
+        entityType: entity.entityType,
+        entityId: entity.entityId,
+        data: entity.data,
+        createdByAccountId: accountId,
+        publishedAt
+      }
+    });
+    return events;
+  }
+  collectUpdateEvents(op, updatedAt, accountId) {
+    var _a, _b;
+    const events = [];
+    const config = this.EntityConfig[op.entityType];
+    const mutualSchema = (_a = config == null ? void 0 : config.mutual) == null ? void 0 : _a.mutualSchema;
+    if (mutualSchema) {
+      const parsedMutualPayload = mutualSchema.parse(op.payload);
+      if (parsedMutualPayload) {
+        for (const [fieldKey, fieldConfig] of Object.entries(
+          ((_b = config.mutual) == null ? void 0 : _b.mutualFields) || {}
+        )) {
+          const toMutualIds = fieldConfig.toMutualIds;
+          const mutualPayload = parsedMutualPayload[fieldKey];
+          if (!mutualPayload) continue;
+          events.push({
+            event: EVENT.CORE.ENTITY_MUTUAL_TO_UPDATE,
+            payload: {
+              byEntityType: op.entityType,
+              byEntityId: op.entityId,
+              entityType: fieldConfig.entityType,
+              field: fieldKey,
+              mutualIds: toMutualIds ? toMutualIds(mutualPayload) : mutualPayload,
+              customContext: toMutualIds ? mutualPayload : {},
+              publishedAt: updatedAt
+            }
+          });
+        }
+      }
+    }
+    events.push({
+      event: EVENT.CORE.ENTITY_UPDATED,
+      payload: {
+        entityType: op.entityType,
+        entityId: op.entityId,
+        updatedByAccountId: accountId,
+        publishedAt: updatedAt
+      }
+    });
+    return events;
+  }
+};
+
 // services/DependencyContainer.ts
 var DependencyContainer = class {
   constructor(config) {
@@ -7985,6 +9409,13 @@ var DependencyContainer = class {
       this.dynamodbClient
     );
   }
+  get websocketRepository() {
+    return this.createCachedInstance(
+      WebSocketRepository,
+      this.coreTable,
+      this.dynamodbClient
+    );
+  }
   get getEntityController() {
     return this.createCachedInstance(
       GetEntityController,
@@ -8068,6 +9499,62 @@ var DependencyContainer = class {
   get listTagsController() {
     return this.createCachedInstance(ListTagsController, this.tagRepository);
   }
+  get transactionService() {
+    return this.createCachedInstance(
+      TransactionService,
+      this.config.EntityConfig,
+      this.config.EmailAuthEnabledEntities,
+      this.entityRepository,
+      this.dynamodbClient,
+      this.publishEvent,
+      this.entityServiceLifeCycle,
+      this.eventUtils
+    );
+  }
+  get executeTransactionController() {
+    return this.createCachedInstance(
+      ExecuteTransactionController,
+      this.transactionService
+    );
+  }
+  get createTicketController() {
+    return this.createCachedInstance(CreateTicketController, this);
+  }
+};
+
+// helpers/transactional.ts
+var transactional = {
+  createEntity: (entityType, payload) => {
+    const _a = payload, { entityId } = _a, rest = __objRest(_a, ["entityId"]);
+    return __spreadValues({
+      operation: "createEntity",
+      entityType,
+      payload: rest
+    }, entityId && { entityId });
+  },
+  updateEntity: (entityType, entityId, payload) => {
+    const _a = payload, { $condition } = _a, rest = __objRest(_a, ["$condition"]);
+    return __spreadValues({
+      operation: "updateEntity",
+      entityType,
+      entityId,
+      payload: rest
+    }, $condition && { condition: $condition });
+  },
+  adjustEntity: (entityType, entityId, adjustments) => {
+    const _a = adjustments, { $condition } = _a, rest = __objRest(_a, ["$condition"]);
+    return __spreadValues({
+      operation: "adjustEntity",
+      entityType,
+      entityId,
+      adjustments: rest
+    }, $condition && { condition: $condition });
+  },
+  deleteEntity: (entityType, entityId) => ({
+    operation: "deleteEntity",
+    entityType,
+    entityId
+  })
 };
 
 // index.ts
@@ -8083,6 +9570,10 @@ var CoreFactory = class {
     this.prejoinProcessor = handler3(dependencyContainer);
     this.tagProcessor = handler5(dependencyContainer);
     this.appHandler = appHandler(dependencyContainer);
+    this.wsConnect = connect(dependencyContainer);
+    this.wsDisconnect = disconnect(dependencyContainer);
+    this.wsDefault = $default(dependencyContainer);
+    this.wsBroadcast = broadcast(dependencyContainer);
   }
 };
 var index_default = CoreFactory;
@@ -8098,6 +9589,8 @@ export {
   StandardError,
   StandardErrorCode,
   TagRepository,
+  TransactionService,
+  WebSocketRepository,
   appHandler,
   handler as createEntityProcessor,
   index_default as default,
@@ -8105,6 +9598,11 @@ export {
   handler3 as prejoinProcessor,
   handler4 as replicationProcessor,
   setupCommonRoutes,
-  handler5 as tagProcessor
+  handler5 as tagProcessor,
+  transactional,
+  broadcast as wsBroadcast,
+  connect as wsConnect,
+  $default as wsDefault,
+  disconnect as wsDisconnect
 };
 //# sourceMappingURL=index.js.map