monorise 1.0.0 → 1.1.0-dev.1

package/dist/core/index.d.ts

@@ -1,4 +1,4 @@
-import { Entity as Entity$2, EntitySchemaMap, createEntityConfig } from '../base/index';
+import { Entity as Entity$2, EntitySchemaMap, createEntityConfig, WhereConditions } from '../base/index';
 import * as hono from 'hono';
 import { Hono } from 'hono';
 import { DynamoDB, TransactWriteItemsInput, AttributeValue, TransactWriteItem, UpdateItemCommandInput } from '@aws-sdk/client-dynamodb';
@@ -9,7 +9,7 @@ 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';
-import { SQSEvent, SQSBatchItemFailure, DynamoDBBatchItemFailure } from 'aws-lambda';
+import { SQSEvent, SQSBatchItemFailure, DynamoDBBatchItemFailure, APIGatewayProxyWebsocketEventV2, APIGatewayProxyResultV2, DynamoDBStreamEvent } from 'aws-lambda';
 import { _Record } from '@aws-sdk/client-dynamodb-streams';
 
 type EventDetail = {
@@ -88,7 +88,7 @@ declare class Entity$1<T extends Entity$2> extends Item$1 {
 }
 declare class EntityRepository extends Repository {
     private EntityConfig;
-    private readonly TABLE_NAME;
+    readonly TABLE_NAME: string;
     private readonly dynamodbClient;
     private readonly EmailAuthEnabledEntities;
     constructor(EntityConfig: Record<Entity$2, ReturnType<typeof createEntityConfig>>, TABLE_NAME: string, dynamodbClient: DynamoDB, EmailAuthEnabledEntities: Entity$2[]);
@@ -132,11 +132,10 @@ 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;
-        };
+    adjustEntity<T extends Entity$2>(entityType: T, entityId: string, adjustments: Record<string, number>, opts?: {
+        ConditionExpression?: string;
+        ExpressionAttributeNames?: Record<string, string>;
+        ExpressionAttributeValues?: Record<string, AttributeValue>;
     }): 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<{
@@ -317,6 +316,47 @@ declare class TagRepository extends Repository {
     }): Promise<void>;
 }
 
+interface ConnectionRecord {
+    connectionId: string;
+    entityType?: string;
+    entityId?: string;
+    connectedAt?: string;
+    expiresAt?: number;
+}
+interface SubscriptionRecord {
+    PK: string;
+    SK: string;
+    connectionId: string;
+    subscriptionType: string;
+    feedTypes?: string[];
+    [key: string]: unknown;
+}
+interface TicketData {
+    entityType: string;
+    entityId: string;
+    feedTypes: string[];
+}
+declare class WebSocketRepository extends Repository {
+    private tableName;
+    private dynamodbClient;
+    private docClient;
+    constructor(tableName: string, dynamodbClient: DynamoDB);
+    createConnection(connectionId: string, metadata: Record<string, unknown>, expiresAt: number): Promise<void>;
+    getConnection(connectionId: string): Promise<ConnectionRecord | undefined>;
+    deleteConnection(connectionId: string): Promise<void>;
+    createSubscription(subKey: string, connectionId: string, data: Record<string, unknown>): Promise<void>;
+    deleteSubscription(subKey: string, connectionId: string): Promise<void>;
+    querySubscriptionsByKey(subKey: string): Promise<SubscriptionRecord[]>;
+    querySubscriptionsByConnectionId(connectionId: string): Promise<SubscriptionRecord[]>;
+    createTicket(ticket: string, entityType: string, entityId: string, feedTypes: string[], expiresAt: number): Promise<void>;
+    consumeTicket(ticket: string): Promise<TicketData | null>;
+    queryMutualConnections(byEntityType: string, byEntityId: string): Promise<{
+        entityType: string;
+        entityId: string;
+    }[]>;
+    queryFeedSubscriptions(entityType: string, entityId: string): Promise<SubscriptionRecord[]>;
+}
+
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -361,6 +401,10 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// configs/service.config.ts
+process.env.CORE_TABLE || "";
+process.env.CORE_EVENT_BUS || "";
+
 // errors/standard-error.ts
 var StandardError$1 = class StandardError extends Error {
   constructor(errorCode, message, lastError, context) {
@@ -474,10 +518,6 @@ factory.createMiddleware((c, next) => __async(null, null, function* () {
   return yield next();
 }));
 
-// configs/service.config.ts
-process.env.CORE_TABLE || "";
-process.env.CORE_EVENT_BUS || "";
-
 // helpers/event.ts
 new EventBridgeClient();
 
@@ -4446,26 +4486,6 @@ 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;
@@ -4491,19 +4511,24 @@ declare class EntityService {
             mutualId?: string;
         };
     }) => Promise<Entity<T>>;
-    adjustEntity: <T extends Entity$2>({ entityType, entityId, adjustments, accountId, }: {
+    adjustEntity: <T extends Entity$2>({ entityType, entityId, adjustments, accountId, condition, }: {
         entityType: T;
         entityId: string;
         adjustments: Record<string, number>;
         accountId?: string;
+        condition?: string;
     }) => Promise<Entity<T>>;
-    updateEntity: <T extends Entity$2>({ entityType, entityId, entityPayload, accountId, where, }: {
+    updateEntity: <T extends Entity$2>({ entityType, entityId, entityPayload, accountId, condition, where, }: {
         entityType: T;
         entityId: string;
         entityPayload: Partial<EntitySchemaMap[T]>;
         accountId?: string | string[];
+        condition?: string;
+        /** @deprecated Use `condition` (named condition) instead of raw `where`. */
         where?: WhereConditions;
     }) => Promise<Entity<T>>;
+    /** @deprecated Converts legacy adjustmentConstraints to condition expression opts. */
+    private buildLegacyAdjustCondition;
     deleteEntity: <T extends Entity$2>({ entityType, entityId, accountId, }: {
         entityType: T;
         entityId: string;
@@ -4583,12 +4608,14 @@ declare class UpsertEntityController {
 }
 
 declare class MutualService {
+    private EntityConfig;
     private entityRepository;
     private mutualRepository;
     private publishEvent;
     private ddbUtils;
     private entityServiceLifeCycle;
-    constructor(entityRepository: EntityRepository, mutualRepository: MutualRepository, publishEvent: typeof publishEvent, ddbUtils: DbUtils, entityServiceLifeCycle: EntityServiceLifeCycle);
+    constructor(EntityConfig: Record<Entity$2, ReturnType<typeof createEntityConfig>>, entityRepository: EntityRepository, mutualRepository: MutualRepository, publishEvent: typeof publishEvent, ddbUtils: DbUtils, entityServiceLifeCycle: EntityServiceLifeCycle);
+    private getMutualDataSchema;
     createMutual: <B extends Entity$2, T extends Entity$2, A extends Entity$2>({ byEntityType, byEntityId, entityType, entityId, mutualPayload, accountId, options, }: {
         byEntityType: B;
         byEntityId: string;
@@ -4607,13 +4634,17 @@ declare class MutualService {
             ExpressionAttributeValues?: Record<string, AttributeValue>;
         };
     }) => Promise<{
-        mutual: Mutual<B, T, Record<string, any>>;
+        mutual: Mutual<B, T, {
+            [x: string]: any;
+        }>;
         eventPayload: {
             byEntityType: B;
             byEntityId: string;
             entityType: T;
             entityId: string;
-            parsedMutualPayload: Record<string, any>;
+            parsedMutualPayload: {
+                [x: string]: any;
+            };
             accountId: string | string[] | undefined;
             publishedAt: string;
         };
@@ -4693,6 +4724,78 @@ declare class ListTagsController {
     }, hono_utils_http_status.ContentfulStatusCode, "json">>;
 }
 
+type TransactionCreateEntity<T extends Entity$2 = Entity$2> = {
+    operation: 'createEntity';
+    entityType: T;
+    entityId?: string;
+    payload: EntitySchemaMap[T];
+};
+type TransactionUpdateEntity<T extends Entity$2 = Entity$2> = {
+    operation: 'updateEntity';
+    entityType: T;
+    entityId: string;
+    payload: Partial<EntitySchemaMap[T]>;
+    accountId?: string;
+    condition?: string;
+};
+type TransactionAdjustEntity<T extends Entity$2 = Entity$2> = {
+    operation: 'adjustEntity';
+    entityType: T;
+    entityId: string;
+    adjustments: Record<string, number>;
+    accountId?: string;
+    condition?: string;
+};
+type TransactionDeleteEntity<T extends Entity$2 = Entity$2> = {
+    operation: 'deleteEntity';
+    entityType: T;
+    entityId: string;
+};
+type TransactionOperation = TransactionCreateEntity | TransactionUpdateEntity | TransactionAdjustEntity | TransactionDeleteEntity;
+type TransactionResultEntry = {
+    operation: string;
+    entityType: Entity$2;
+    entityId: string;
+    data?: Record<string, unknown>;
+};
+type TransactionResult = {
+    results: TransactionResultEntry[];
+};
+
+declare class TransactionService {
+    private EntityConfig;
+    private EmailAuthEnabledEntities;
+    private entityRepository;
+    private dynamodbClient;
+    private publishEvent;
+    private entityServiceLifeCycle;
+    private eventUtils;
+    constructor(EntityConfig: Record<Entity$2, ReturnType<typeof createEntityConfig>>, EmailAuthEnabledEntities: Entity$2[], entityRepository: EntityRepository, dynamodbClient: DynamoDB, publishEvent: typeof publishEvent, entityServiceLifeCycle: EntityServiceLifeCycle, eventUtils: EventUtils);
+    executeTransaction: (operations: TransactionOperation[], accountId?: string) => Promise<TransactionResult>;
+    private buildCreateItems;
+    private buildUpdateItem;
+    private buildAdjustItem;
+    private buildDeleteItem;
+    private collectCreateEvents;
+    private collectUpdateEvents;
+}
+
+declare class ExecuteTransactionController {
+    private transactionService;
+    constructor(transactionService: TransactionService);
+    controller: hono.MiddlewareHandler<any, string, {}, any>;
+}
+
+declare class CreateTicketController {
+    private container;
+    constructor(container: DependencyContainer);
+    controller: hono.MiddlewareHandler<any, string, {}, Response & hono.TypedResponse<{
+        ticket: string;
+        wsUrl: string;
+        expiresIn: number;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+}
+
 declare class DependencyContainer {
     config: {
         EntityConfig: Record<Entity$2, ReturnType<typeof createEntityConfig>>;
@@ -4721,6 +4824,7 @@ declare class DependencyContainer {
     get entityService(): EntityService;
     get mutualService(): MutualService;
     get tagRepository(): TagRepository;
+    get websocketRepository(): WebSocketRepository;
     get getEntityController(): GetEntityController;
     get getEntityByUniqueFieldController(): GetEntityByUniqueFieldValueController;
     get listEntitiesController(): ListEntitiesController;
@@ -4735,6 +4839,9 @@ declare class DependencyContainer {
     get updateMutualController(): UpdateMutualController;
     get deleteMutualController(): DeleteMutualController;
     get listTagsController(): ListTagsController;
+    get transactionService(): TransactionService;
+    get executeTransactionController(): ExecuteTransactionController;
+    get createTicketController(): CreateTicketController;
 }
 
 declare const setupCommonRoutes: (container: DependencyContainer) => Hono;
@@ -4755,6 +4862,7 @@ declare const StandardErrorCode: {
     readonly ENTITY_ID_IS_UNDEFINED: "ENTITY_ID_IS_UNDEFINED";
     readonly ENTITY_IS_UNDEFINED: "ENTITY_IS_UNDEFINED";
     readonly ENTITY_NOT_FOUND: "ENTITY_NOT_FOUND";
+    readonly INVALID_CONDITION: "INVALID_CONDITION";
     readonly INVALID_ENTITY_TYPE: "INVALID_ENTITY_TYPE";
     readonly INVALID_MUTUAL: "INVALID_MUTUAL";
     readonly INVALID_QUERY: "INVALID_QUERY";
@@ -4767,7 +4875,10 @@ declare const StandardErrorCode: {
     readonly REPLICATION_ERROR: "REPLICATION_ERROR";
     readonly RETRYABLE_MUTUAL_LOCK_CONFLICT: "RETRYABLE_MUTUAL_LOCK_CONFLICT";
     readonly TAG_IS_UNDEFINED: "TAG_IS_UNDEFINED";
+    readonly TRANSACTION_EMPTY: "TRANSACTION_EMPTY";
     readonly TRANSACTION_FAILED: "TRANSACTION_FAILED";
+    readonly TRANSACTION_ITEM_LIMIT_EXCEEDED: "TRANSACTION_ITEM_LIMIT_EXCEEDED";
+    readonly TRANSACTION_UNIQUE_FIELD_UPDATE: "TRANSACTION_UNIQUE_FIELD_UPDATE";
     readonly UNIQUE_VALUE_EXISTS: "UNIQUE_VALUE_EXISTS";
 };
 type StandardErrorCode = typeof StandardErrorCode[keyof typeof StandardErrorCode];
@@ -4807,6 +4918,44 @@ declare const handler: (container: DependencyContainer) => (ev: SQSEvent) => Pro
     batchItemFailures: SQSBatchItemFailure[];
 }>;
 
+type WebSocketConnectEvent = APIGatewayProxyWebsocketEventV2 & {
+    queryStringParameters?: Record<string, string | undefined>;
+    headers?: Record<string, string | undefined>;
+};
+/**
+ * $connect handler
+ * Supports two auth modes:
+ * - ticket: ?ticket=abc123 (issued via /ws/ticket/:entityType/:entityId)
+ * - token: ?token=userId (simplified direct auth)
+ */
+declare const connect: (container: DependencyContainer) => (event: WebSocketConnectEvent) => Promise<APIGatewayProxyResultV2>;
+/**
+ * $disconnect handler
+ * Cleans up connection record and all associated subscription records.
+ */
+declare const disconnect: (container: DependencyContainer) => (event: APIGatewayProxyWebsocketEventV2) => Promise<APIGatewayProxyResultV2>;
+/**
+ * $default handler - route messages
+ */
+declare const $default: (container: DependencyContainer) => (event: APIGatewayProxyWebsocketEventV2) => Promise<APIGatewayProxyResultV2>;
+/**
+ * Broadcast handler - triggered by DynamoDB Streams
+ */
+declare const broadcast: (container: DependencyContainer) => (event: DynamoDBStreamEvent) => Promise<void>;
+
+declare const transactional: {
+    createEntity: <T extends Entity$2>(entityType: T, payload: EntitySchemaMap[T] & {
+        entityId?: string;
+    }) => TransactionCreateEntity<T>;
+    updateEntity: <T extends Entity$2>(entityType: T, entityId: string, payload: Partial<EntitySchemaMap[T]> & {
+        $condition?: string;
+    }) => TransactionUpdateEntity<T>;
+    adjustEntity: <T extends Entity$2>(entityType: T, entityId: string, adjustments: Record<string, number> & {
+        $condition?: string;
+    }) => TransactionAdjustEntity<T>;
+    deleteEntity: <T extends Entity$2>(entityType: T, entityId: string) => TransactionDeleteEntity<T>;
+};
+
 declare class CoreFactory {
     private config;
     setupCommonRoutes: ReturnType<typeof setupCommonRoutes>;
@@ -4816,6 +4965,10 @@ declare class CoreFactory {
     prejoinProcessor: ReturnType<typeof handler$2>;
     tagProcessor: ReturnType<typeof handler>;
     appHandler: ReturnType<typeof appHandler>;
+    wsConnect: ReturnType<typeof connect>;
+    wsDisconnect: ReturnType<typeof disconnect>;
+    wsDefault: ReturnType<typeof $default>;
+    wsBroadcast: ReturnType<typeof broadcast>;
     dependencyContainer: DependencyContainer;
     constructor(config: {
         EntityConfig: Record<Entity$2, ReturnType<typeof createEntityConfig>>;
@@ -4824,4 +4977,4 @@ declare class CoreFactory {
     });
 }
 
-export { DependencyContainer, Entity$1 as Entity, EntityRepository, EntityService, Mutual, MutualRepository, MutualService, PROJECTION_EXPRESSION, StandardError, StandardErrorCode, TagRepository, appHandler, handler$4 as createEntityProcessor, CoreFactory as default, handler$3 as mutualProcessor, handler$2 as prejoinProcessor, handler$1 as replicationProcessor, setupCommonRoutes, handler as tagProcessor };
+export { DependencyContainer, Entity$1 as Entity, EntityRepository, EntityService, Mutual, MutualRepository, MutualService, PROJECTION_EXPRESSION, StandardError, StandardErrorCode, TagRepository, TransactionService, WebSocketRepository, appHandler, handler$4 as createEntityProcessor, CoreFactory as default, handler$3 as mutualProcessor, handler$2 as prejoinProcessor, handler$1 as replicationProcessor, setupCommonRoutes, handler as tagProcessor, transactional, broadcast as wsBroadcast, connect as wsConnect, $default as wsDefault, disconnect as wsDisconnect };