@nlabs/reaktor 1.17.0 → 1.18.0

package/lib/durableChat/errors.d.ts

@@ -0,0 +1,6 @@
+export type ChatErrorCode = 'conflict' | 'forbidden' | 'invalid_request' | 'rate_limited' | 'unavailable';
+export declare class DurableChatError extends Error {
+    readonly code: ChatErrorCode;
+    constructor(code: ChatErrorCode);
+}
+export { DurableChatError as ChatError };

package/lib/durableChat/errors.js

@@ -0,0 +1,11 @@
+export class DurableChatError extends Error {
+    code;
+    constructor(code){
+        super(code);
+        this.code = code;
+        this.name = 'ChatError';
+    }
+}
+export { DurableChatError as ChatError };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3IvcGFja2FnZXMvcmVha3Rvci9zcmMvZHVyYWJsZUNoYXQvZXJyb3JzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIENoYXRFcnJvckNvZGUgPSAnY29uZmxpY3QnIHwgJ2ZvcmJpZGRlbicgfCAnaW52YWxpZF9yZXF1ZXN0JyB8ICdyYXRlX2xpbWl0ZWQnIHwgJ3VuYXZhaWxhYmxlJztcblxuZXhwb3J0IGNsYXNzIER1cmFibGVDaGF0RXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIHJlYWRvbmx5IGNvZGU6IENoYXRFcnJvckNvZGU7XG5cbiAgY29uc3RydWN0b3IoY29kZTogQ2hhdEVycm9yQ29kZSkge1xuICAgIHN1cGVyKGNvZGUpO1xuICAgIHRoaXMuY29kZSA9IGNvZGU7XG4gICAgdGhpcy5uYW1lID0gJ0NoYXRFcnJvcic7XG4gIH1cbn1cblxuZXhwb3J0IHtEdXJhYmxlQ2hhdEVycm9yIGFzIENoYXRFcnJvcn07XG4iXSwibmFtZXMiOlsiRHVyYWJsZUNoYXRFcnJvciIsIkVycm9yIiwiY29kZSIsIm5hbWUiLCJDaGF0RXJyb3IiXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sTUFBTUEseUJBQXlCQztJQUMzQkMsS0FBb0I7SUFFN0IsWUFBWUEsSUFBbUIsQ0FBRTtRQUMvQixLQUFLLENBQUNBO1FBQ04sSUFBSSxDQUFDQSxJQUFJLEdBQUdBO1FBQ1osSUFBSSxDQUFDQyxJQUFJLEdBQUc7SUFDZDtBQUNGO0FBRUEsU0FBUUgsb0JBQW9CSSxTQUFTLEdBQUUifQ==

package/lib/durableChat/events.d.ts

@@ -0,0 +1,22 @@
+import type { ChatQuery } from './membership.js';
+import type { ChatEvent } from './types.js';
+export interface AppendChatEventInput {
+    readonly actorPersonaId: string;
+    readonly conversationId: string;
+    readonly kind: ChatEvent['kind'];
+    readonly membershipEpoch?: string;
+    readonly resourceId: string;
+    readonly revision: number;
+}
+export interface StoredChatEvent extends ChatEvent {
+    readonly _key: string;
+    readonly actorPersonaId: string;
+    readonly createdAt: number;
+    readonly leaseUntil: number;
+    readonly membershipEpoch?: string;
+    readonly nextAttemptAt: number;
+    readonly status: 'pending';
+    readonly type: ChatEvent['kind'];
+}
+/** Requires the caller's exclusive conversations/chatOutbox locks; never commits independently. */
+export declare const appendChatEvent: (read: ChatQuery, input: AppendChatEventInput) => Promise<StoredChatEvent>;

package/lib/durableChat/events.js

@@ -0,0 +1,50 @@
+import { randomUUID } from 'node:crypto';
+import { ChatError } from './errors.js';
+import { isChatIdentifier } from './membership.js';
+/** Requires the caller's exclusive conversations/chatOutbox locks; never commits independently. */ export const appendChatEvent = async (read, input)=>{
+    if (!input || !isChatIdentifier(input.actorPersonaId) || !isChatIdentifier(input.conversationId) || !isChatIdentifier(input.resourceId) || !Number.isSafeInteger(input.revision) || input.revision < 1 || input.membershipEpoch !== undefined && !isChatIdentifier(input.membershipEpoch) || ![
+        'membership.changed',
+        'message.changed',
+        'receipt.changed'
+    ].includes(input.kind)) {
+        throw new ChatError('invalid_request');
+    }
+    const sequence = await read(`LET conversation = DOCUMENT('conversations', @id)
+    FILTER conversation != null AND conversation.chatSchemaVersion == 1
+      AND (conversation.lastEventSequence == null OR
+        (IS_NUMBER(conversation.lastEventSequence) AND conversation.lastEventSequence >= 0
+          AND FLOOR(conversation.lastEventSequence) == conversation.lastEventSequence
+          AND conversation.lastEventSequence < 9007199254740991))
+    UPDATE @id WITH {lastEventSequence: (conversation.lastEventSequence == null ? 0 : conversation.lastEventSequence) + 1}
+      IN conversations RETURN NEW.lastEventSequence`, {
+        id: input.conversationId
+    });
+    if (!Number.isSafeInteger(sequence) || Number(sequence) < 1) {
+        throw new ChatError('unavailable');
+    }
+    const id = randomUUID();
+    const record = {
+        _key: id,
+        actorPersonaId: input.actorPersonaId,
+        conversationId: input.conversationId,
+        createdAt: Date.now(),
+        eventId: id,
+        eventSequence: sequence,
+        kind: input.kind,
+        leaseUntil: 0,
+        membershipEpoch: input.membershipEpoch,
+        nextAttemptAt: 0,
+        resourceId: input.resourceId,
+        revision: input.revision,
+        status: 'pending',
+        type: input.kind
+    };
+    if (await read('INSERT @record IN chatOutbox RETURN true', {
+        record
+    }) !== true) {
+        throw new ChatError('unavailable');
+    }
+    return record;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/durableChat/index.d.ts

@@ -0,0 +1,8 @@
+export * from './conversations.js';
+export * from './errors.js';
+export * from './events.js';
+export * from './membership.js';
+export * from './transaction.js';
+export * from './types.js';
+export * from './messages.js';
+export * from './messageTypes.js';

package/lib/durableChat/index.js

@@ -0,0 +1,10 @@
+export * from './conversations.js';
+export * from './errors.js';
+export * from './events.js';
+export * from './membership.js';
+export * from './transaction.js';
+export * from './types.js';
+export * from './messages.js';
+export * from './messageTypes.js';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3IvcGFja2FnZXMvcmVha3Rvci9zcmMvZHVyYWJsZUNoYXQvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb252ZXJzYXRpb25zLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3JzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZXZlbnRzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbWVtYmVyc2hpcC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3RyYW5zYWN0aW9uLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXNzYWdlcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL21lc3NhZ2VUeXBlcy5qcyc7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUI7QUFDbkMsY0FBYyxjQUFjO0FBQzVCLGNBQWMsY0FBYztBQUM1QixjQUFjLGtCQUFrQjtBQUNoQyxjQUFjLG1CQUFtQjtBQUNqQyxjQUFjLGFBQWE7QUFDM0IsY0FBYyxnQkFBZ0I7QUFDOUIsY0FBYyxvQkFBb0IifQ==

package/lib/durableChat/membership.d.ts

@@ -0,0 +1,24 @@
+import type { ApiContext } from '../types/auth.types.js';
+import type { ConversationKind, ConversationMembership, ConversationState } from './types.js';
+export interface ChatIdentity {
+    readonly personaId: string;
+    readonly userId: string;
+}
+export interface MembershipAccessInput {
+    readonly conversationId: string;
+    readonly membershipEpoch?: string;
+    readonly messageSequence?: number;
+    readonly purpose: 'history' | 'invite' | 'participants' | 'report' | 'send' | 'socket';
+}
+export interface AuthorizedMembership extends ConversationMembership {
+    readonly activeMemberCount: number;
+    readonly conversationState: ConversationState;
+    readonly kind: ConversationKind;
+    readonly lastSequence: number;
+    readonly membershipRevision: number;
+}
+/** Inject the transaction's query adapter when this check guards a write. */
+export type ChatQuery = <T>(query: string, bindVars: Record<string, unknown>) => Promise<T | undefined>;
+export declare const isChatIdentifier: (value: unknown) => value is string;
+export declare const createMembershipAuthorizer: (read: ChatQuery) => (identity: ChatIdentity, input: MembershipAccessInput) => Promise<AuthorizedMembership>;
+export declare const authorizeConversationAccess: (context: ApiContext, identity: ChatIdentity, input: MembershipAccessInput) => Promise<AuthorizedMembership>;

package/lib/durableChat/membership.js

@@ -0,0 +1,85 @@
+import { ChatError } from './errors.js';
+import { createDurableQuery } from './transaction.js';
+export const isChatIdentifier = (value)=>typeof value === 'string' && /^[a-zA-Z0-9_-]{1,128}$/.test(value);
+const purposes = [
+    'history',
+    'invite',
+    'participants',
+    'report',
+    'send',
+    'socket'
+];
+export const createMembershipAuthorizer = (read)=>async (identity, input)=>{
+        if (!identity || !isChatIdentifier(identity.userId) || !isChatIdentifier(identity.personaId)) {
+            throw new ChatError('forbidden');
+        }
+        if (!input || !isChatIdentifier(input.conversationId) || !purposes.includes(input.purpose) || input.membershipEpoch !== undefined && !isChatIdentifier(input.membershipEpoch) || input.messageSequence !== undefined && (!Number.isSafeInteger(input.messageSequence) || input.messageSequence < 1) || input.purpose === 'report' && input.messageSequence === undefined) {
+            throw new ChatError('invalid_request');
+        }
+        const result = await read(`
+    LET user = DOCUMENT('users', @userId)
+    LET persona = DOCUMENT('personas', @personaId)
+    LET conversation = DOCUMENT('conversations', @conversationId)
+    FILTER user != null AND user.active != false AND persona != null AND persona.active != false
+      AND persona.userId == @userId AND conversation != null AND conversation.chatSchemaVersion == 1
+      AND conversation.kind IN ['direct', 'group'] AND conversation.state IN ['active', 'forming', 'closed']
+    LET membership = FIRST(FOR member IN hasChatMembership
+      FILTER member.conversationId == @conversationId AND member.personaId == @personaId
+        AND member.userId == @userId AND member._from == CONCAT('personas/', @personaId)
+        AND member._to == CONCAT('conversations/', @conversationId)
+        AND (@epoch == null OR member.epoch == @epoch)
+        AND (@purpose == 'report' ? member.state IN ['active', 'left', 'removed'] : member.state == 'active')
+        AND (@sequence == null OR (IS_NUMBER(member.joinSequence) AND @sequence >= member.joinSequence
+          AND @sequence <= conversation.lastSequence
+          AND (member.state == 'active' OR (IS_NUMBER(member.leftSequence) AND @sequence <= member.leftSequence))))
+      SORT member.acceptedAt DESC, member._key DESC LIMIT 1 RETURN member)
+    FILTER membership != null
+    LET peers = (FOR member IN hasChatMembership
+      FILTER member.conversationId == @conversationId AND member.state == 'active'
+        AND member.personaId != @personaId RETURN member)
+    LET peer = FIRST(peers)
+    LET peerPersona = peer == null ? null : DOCUMENT('personas', peer.personaId)
+    LET peerUser = peer == null ? null : DOCUMENT('users', peer.userId)
+    LET blocked = peer == null ? false : FIRST(FOR edge IN hasConnection FILTER edge.type == 'block'
+      AND ((edge._from IN [CONCAT('personas/', @personaId), CONCAT('users/', @userId)]
+        AND edge._to IN [CONCAT('personas/', peer.personaId), CONCAT('users/', peer.userId)])
+        OR (edge._to IN [CONCAT('personas/', @personaId), CONCAT('users/', @userId)]
+        AND edge._from IN [CONCAT('personas/', peer.personaId), CONCAT('users/', peer.userId)])) LIMIT 1 RETURN true)
+    LET following = peer == null ? false : FIRST(FOR edge IN hasConnection
+      FILTER edge.type == 'follow' AND edge.active != false AND edge._from == CONCAT('personas/', @personaId)
+        AND edge._to == CONCAT('personas/', peer.personaId) LIMIT 1 RETURN true)
+    LET followed = peer == null ? false : FIRST(FOR edge IN hasConnection
+      FILTER edge.type == 'follow' AND edge.active != false AND edge._to == CONCAT('personas/', @personaId)
+        AND edge._from == CONCAT('personas/', peer.personaId) LIMIT 1 RETURN true)
+    FILTER @purpose NOT IN ['send', 'socket'] OR (conversation.state == 'active'
+      AND (conversation.kind != 'direct' OR (LENGTH(peers) == 1 AND peerPersona != null AND peerUser != null
+        AND peerPersona.active != false AND peerUser.active != false AND peerPersona.userId == peer.userId
+        AND blocked != true AND following == true AND followed == true)))
+    FILTER @purpose != 'invite' OR (conversation.kind == 'group' AND conversation.state != 'closed'
+      AND membership.role IN ['owner', 'admin'])
+    FILTER @purpose == 'report' OR conversation.state != 'closed'
+    RETURN {activeMemberCount: conversation.activeMemberCount, conversationId: @conversationId,
+      conversationState: conversation.state, epoch: membership.epoch, joinSequence: membership.joinSequence,
+      kind: conversation.kind, lastSequence: conversation.lastSequence, leftSequence: membership.leftSequence,
+      membershipRevision: conversation.membershipRevision, personaId: @personaId, revision: membership.revision,
+      role: membership.role, state: membership.state}
+  `, {
+            conversationId: input.conversationId,
+            epoch: input.membershipEpoch ?? null,
+            personaId: identity.personaId,
+            purpose: input.purpose,
+            sequence: input.messageSequence ?? null,
+            userId: identity.userId
+        });
+        if (!result || !isChatIdentifier(result.epoch) || !Number.isSafeInteger(result.joinSequence) || result.joinSequence < 0 || !Number.isSafeInteger(result.lastSequence) || result.lastSequence < 0 || !Number.isSafeInteger(result.revision) || result.revision < 1 || !Number.isSafeInteger(result.membershipRevision) || result.membershipRevision < 1 || !Number.isSafeInteger(result.activeMemberCount) || result.activeMemberCount < 0 || result.activeMemberCount > 25 || ![
+            'owner',
+            'admin',
+            'member'
+        ].includes(result.role)) {
+            throw new ChatError('forbidden');
+        }
+        return result;
+    };
+export const authorizeConversationAccess = (context, identity, input)=>createMembershipAuthorizer(createDurableQuery(context))(identity, input);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/durableChat/membership.ts"],"sourcesContent":["import {ChatError} from './errors.js';\nimport {createDurableQuery} from './transaction.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {ConversationKind, ConversationMembership, ConversationState} from './types.js';\n\nexport interface ChatIdentity {\n  readonly personaId: string;\n  readonly userId: string;\n}\n\nexport interface MembershipAccessInput {\n  readonly conversationId: string;\n  readonly membershipEpoch?: string;\n  readonly messageSequence?: number;\n  readonly purpose: 'history' | 'invite' | 'participants' | 'report' | 'send' | 'socket';\n}\n\nexport interface AuthorizedMembership extends ConversationMembership {\n  readonly activeMemberCount: number;\n  readonly conversationState: ConversationState;\n  readonly kind: ConversationKind;\n  readonly lastSequence: number;\n  readonly membershipRevision: number;\n}\n\n/** Inject the transaction's query adapter when this check guards a write. */\nexport type ChatQuery = <T>(query: string, bindVars: Record<string, unknown>) => Promise<T | undefined>;\n\nexport const isChatIdentifier = (value: unknown): value is string =>\n  typeof value === 'string' && /^[a-zA-Z0-9_-]{1,128}$/.test(value);\n\nconst purposes: readonly MembershipAccessInput['purpose'][] = ['history', 'invite', 'participants', 'report', 'send', 'socket'];\n\nexport const createMembershipAuthorizer = (read: ChatQuery) => async (\n  identity: ChatIdentity, input: MembershipAccessInput\n): Promise<AuthorizedMembership> => {\n  if(!identity || !isChatIdentifier(identity.userId) || !isChatIdentifier(identity.personaId)) {\n    throw new ChatError('forbidden');\n  }\n  if(!input || !isChatIdentifier(input.conversationId) || !purposes.includes(input.purpose)\n    || (input.membershipEpoch !== undefined && !isChatIdentifier(input.membershipEpoch))\n    || (input.messageSequence !== undefined\n      && (!Number.isSafeInteger(input.messageSequence) || input.messageSequence < 1))\n    || (input.purpose === 'report' && input.messageSequence === undefined)) {\n    throw new ChatError('invalid_request');\n  }\n  const result = await read<AuthorizedMembership>(`\n    LET user = DOCUMENT('users', @userId)\n    LET persona = DOCUMENT('personas', @personaId)\n    LET conversation = DOCUMENT('conversations', @conversationId)\n    FILTER user != null AND user.active != false AND persona != null AND persona.active != false\n      AND persona.userId == @userId AND conversation != null AND conversation.chatSchemaVersion == 1\n      AND conversation.kind IN ['direct', 'group'] AND conversation.state IN ['active', 'forming', 'closed']\n    LET membership = FIRST(FOR member IN hasChatMembership\n      FILTER member.conversationId == @conversationId AND member.personaId == @personaId\n        AND member.userId == @userId AND member._from == CONCAT('personas/', @personaId)\n        AND member._to == CONCAT('conversations/', @conversationId)\n        AND (@epoch == null OR member.epoch == @epoch)\n        AND (@purpose == 'report' ? member.state IN ['active', 'left', 'removed'] : member.state == 'active')\n        AND (@sequence == null OR (IS_NUMBER(member.joinSequence) AND @sequence >= member.joinSequence\n          AND @sequence <= conversation.lastSequence\n          AND (member.state == 'active' OR (IS_NUMBER(member.leftSequence) AND @sequence <= member.leftSequence))))\n      SORT member.acceptedAt DESC, member._key DESC LIMIT 1 RETURN member)\n    FILTER membership != null\n    LET peers = (FOR member IN hasChatMembership\n      FILTER member.conversationId == @conversationId AND member.state == 'active'\n        AND member.personaId != @personaId RETURN member)\n    LET peer = FIRST(peers)\n    LET peerPersona = peer == null ? null : DOCUMENT('personas', peer.personaId)\n    LET peerUser = peer == null ? null : DOCUMENT('users', peer.userId)\n    LET blocked = peer == null ? false : FIRST(FOR edge IN hasConnection FILTER edge.type == 'block'\n      AND ((edge._from IN [CONCAT('personas/', @personaId), CONCAT('users/', @userId)]\n        AND edge._to IN [CONCAT('personas/', peer.personaId), CONCAT('users/', peer.userId)])\n        OR (edge._to IN [CONCAT('personas/', @personaId), CONCAT('users/', @userId)]\n        AND edge._from IN [CONCAT('personas/', peer.personaId), CONCAT('users/', peer.userId)])) LIMIT 1 RETURN true)\n    LET following = peer == null ? false : FIRST(FOR edge IN hasConnection\n      FILTER edge.type == 'follow' AND edge.active != false AND edge._from == CONCAT('personas/', @personaId)\n        AND edge._to == CONCAT('personas/', peer.personaId) LIMIT 1 RETURN true)\n    LET followed = peer == null ? false : FIRST(FOR edge IN hasConnection\n      FILTER edge.type == 'follow' AND edge.active != false AND edge._to == CONCAT('personas/', @personaId)\n        AND edge._from == CONCAT('personas/', peer.personaId) LIMIT 1 RETURN true)\n    FILTER @purpose NOT IN ['send', 'socket'] OR (conversation.state == 'active'\n      AND (conversation.kind != 'direct' OR (LENGTH(peers) == 1 AND peerPersona != null AND peerUser != null\n        AND peerPersona.active != false AND peerUser.active != false AND peerPersona.userId == peer.userId\n        AND blocked != true AND following == true AND followed == true)))\n    FILTER @purpose != 'invite' OR (conversation.kind == 'group' AND conversation.state != 'closed'\n      AND membership.role IN ['owner', 'admin'])\n    FILTER @purpose == 'report' OR conversation.state != 'closed'\n    RETURN {activeMemberCount: conversation.activeMemberCount, conversationId: @conversationId,\n      conversationState: conversation.state, epoch: membership.epoch, joinSequence: membership.joinSequence,\n      kind: conversation.kind, lastSequence: conversation.lastSequence, leftSequence: membership.leftSequence,\n      membershipRevision: conversation.membershipRevision, personaId: @personaId, revision: membership.revision,\n      role: membership.role, state: membership.state}\n  `, {\n    conversationId: input.conversationId, epoch: input.membershipEpoch ?? null, personaId: identity.personaId,\n    purpose: input.purpose, sequence: input.messageSequence ?? null, userId: identity.userId\n  });\n  if(!result || !isChatIdentifier(result.epoch) || !Number.isSafeInteger(result.joinSequence)\n    || result.joinSequence < 0 || !Number.isSafeInteger(result.lastSequence) || result.lastSequence < 0\n    || !Number.isSafeInteger(result.revision) || result.revision < 1\n    || !Number.isSafeInteger(result.membershipRevision) || result.membershipRevision < 1\n    || !Number.isSafeInteger(result.activeMemberCount) || result.activeMemberCount < 0\n    || result.activeMemberCount > 25 || !['owner', 'admin', 'member'].includes(result.role)) {\n    throw new ChatError('forbidden');\n  }\n  return result;\n};\n\nexport const authorizeConversationAccess = (\n  context: ApiContext, identity: ChatIdentity, input: MembershipAccessInput\n): Promise<AuthorizedMembership> => createMembershipAuthorizer(\n  createDurableQuery(context)\n)(identity, input);\n"],"names":["ChatError","createDurableQuery","isChatIdentifier","value","test","purposes","createMembershipAuthorizer","read","identity","input","userId","personaId","conversationId","includes","purpose","membershipEpoch","undefined","messageSequence","Number","isSafeInteger","result","epoch","sequence","joinSequence","lastSequence","revision","membershipRevision","activeMemberCount","role","authorizeConversationAccess","context"],"mappings":"AAAA,SAAQA,SAAS,QAAO,cAAc;AACtC,SAAQC,kBAAkB,QAAO,mBAAmB;AA4BpD,OAAO,MAAMC,mBAAmB,CAACC,QAC/B,OAAOA,UAAU,YAAY,yBAAyBC,IAAI,CAACD,OAAO;AAEpE,MAAME,WAAwD;IAAC;IAAW;IAAU;IAAgB;IAAU;IAAQ;CAAS;AAE/H,OAAO,MAAMC,6BAA6B,CAACC,OAAoB,OAC7DC,UAAwBC;QAExB,IAAG,CAACD,YAAY,CAACN,iBAAiBM,SAASE,MAAM,KAAK,CAACR,iBAAiBM,SAASG,SAAS,GAAG;YAC3F,MAAM,IAAIX,UAAU;QACtB;QACA,IAAG,CAACS,SAAS,CAACP,iBAAiBO,MAAMG,cAAc,KAAK,CAACP,SAASQ,QAAQ,CAACJ,MAAMK,OAAO,KAClFL,MAAMM,eAAe,KAAKC,aAAa,CAACd,iBAAiBO,MAAMM,eAAe,KAC9EN,MAAMQ,eAAe,KAAKD,aACxB,CAAA,CAACE,OAAOC,aAAa,CAACV,MAAMQ,eAAe,KAAKR,MAAMQ,eAAe,GAAG,CAAA,KAC1ER,MAAMK,OAAO,KAAK,YAAYL,MAAMQ,eAAe,KAAKD,WAAY;YACxE,MAAM,IAAIhB,UAAU;QACtB;QACA,MAAMoB,SAAS,MAAMb,KAA2B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+CjD,CAAC,EAAE;YACDK,gBAAgBH,MAAMG,cAAc;YAAES,OAAOZ,MAAMM,eAAe,IAAI;YAAMJ,WAAWH,SAASG,SAAS;YACzGG,SAASL,MAAMK,OAAO;YAAEQ,UAAUb,MAAMQ,eAAe,IAAI;YAAMP,QAAQF,SAASE,MAAM;QAC1F;QACA,IAAG,CAACU,UAAU,CAAClB,iBAAiBkB,OAAOC,KAAK,KAAK,CAACH,OAAOC,aAAa,CAACC,OAAOG,YAAY,KACrFH,OAAOG,YAAY,GAAG,KAAK,CAACL,OAAOC,aAAa,CAACC,OAAOI,YAAY,KAAKJ,OAAOI,YAAY,GAAG,KAC/F,CAACN,OAAOC,aAAa,CAACC,OAAOK,QAAQ,KAAKL,OAAOK,QAAQ,GAAG,KAC5D,CAACP,OAAOC,aAAa,CAACC,OAAOM,kBAAkB,KAAKN,OAAOM,kBAAkB,GAAG,KAChF,CAACR,OAAOC,aAAa,CAACC,OAAOO,iBAAiB,KAAKP,OAAOO,iBAAiB,GAAG,KAC9EP,OAAOO,iBAAiB,GAAG,MAAM,CAAC;YAAC;YAAS;YAAS;SAAS,CAACd,QAAQ,CAACO,OAAOQ,IAAI,GAAG;YACzF,MAAM,IAAI5B,UAAU;QACtB;QACA,OAAOoB;IACT,EAAE;AAEF,OAAO,MAAMS,8BAA8B,CACzCC,SAAqBtB,UAAwBC,QACXH,2BAClCL,mBAAmB6B,UACnBtB,UAAUC,OAAO"}

package/lib/durableChat/messageTypes.d.ts

@@ -0,0 +1,76 @@
+import type { AppendChatEventInput } from './events.js';
+import type { AuthorizedMembership, ChatIdentity, ChatQuery } from './membership.js';
+export interface DurableChatAttachment {
+    readonly contentVersion: string;
+    readonly imageId: string;
+}
+export interface DurableChatMessage<TDecision = unknown> {
+    readonly _key: string;
+    readonly added: number;
+    readonly attachmentIds: readonly string[];
+    readonly attachments: readonly DurableChatAttachment[];
+    readonly chatSchemaVersion: 1;
+    readonly clientMessageId: string;
+    readonly content: string;
+    readonly contentRevision: number;
+    readonly conversationId: string;
+    readonly deleted: boolean;
+    readonly deletedAuthorProofId?: string;
+    readonly mobileContentVersion: string;
+    readonly mobileDecision: TDecision;
+    readonly mobilePlatformDisposition: string;
+    readonly modified: number;
+    readonly replyToMessageId?: string;
+    readonly revision: number;
+    readonly senderPersonaId: string;
+    readonly sequence: number;
+    readonly userId: string;
+}
+export interface DurableSendMessageInput {
+    readonly attachmentIds: readonly string[];
+    readonly clientMessageId: string;
+    readonly content: string;
+    readonly conversationId: string;
+    readonly replyToMessageId?: string;
+    readonly senderPersonaId: string;
+}
+export interface DurableEditMessageInput {
+    readonly content: string;
+    readonly conversationId: string;
+    readonly expectedRevision: number;
+    readonly idempotencyKey: string;
+    readonly messageId: string;
+}
+export type DurableDeleteMessageInput = Omit<DurableEditMessageInput, 'content'>;
+export interface DurableMessageAcknowledgement {
+    readonly clientMessageId: string;
+    readonly messageId: string;
+    readonly revision: number;
+    readonly sequence: number;
+}
+export interface DurableMessageMutationResult {
+    readonly messageId: string;
+    readonly revision: number;
+    readonly sequence: number;
+}
+export interface DurableContentProjection<TDecision> {
+    readonly decision: TDecision;
+    readonly platformDisposition?: string;
+}
+export type DurableMessageRun = <T>(operation: (read: ChatQuery) => Promise<T>, write?: boolean) => Promise<T>;
+export interface DurableMessageHooks<TDecision> {
+    readonly appendEvent: (read: ChatQuery, input: AppendChatEventInput) => Promise<unknown>;
+    readonly authorizeAttachment: (read: ChatQuery, imageId: string) => Promise<DurableChatAttachment>;
+    readonly authorizeIdentity: (read: ChatQuery, identity: ChatIdentity) => Promise<void>;
+    readonly authorizeMembership: (read: ChatQuery, identity: ChatIdentity, conversationId: string, purpose: 'history' | 'send') => Promise<AuthorizedMembership>;
+    readonly authorizeMessageVisible: (read: ChatQuery, identity: ChatIdentity, message: DurableChatMessage<TDecision>, membership: AuthorizedMembership) => Promise<void>;
+    readonly classifyContent: (input: {
+        readonly content: string;
+        readonly contentVersion: string;
+    }) => DurableContentProjection<TDecision> | Promise<DurableContentProjection<TDecision>>;
+    readonly hash?: (value: unknown) => string;
+    readonly identity: ChatIdentity;
+    readonly now?: () => number;
+    readonly run: DurableMessageRun;
+    readonly uuid?: () => string;
+}

package/lib/durableChat/messageTypes.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/durableChat/messages.d.ts

@@ -0,0 +1,16 @@
+import type { ChatQuery } from './membership.js';
+import type { DurableChatMessage, DurableDeleteMessageInput, DurableEditMessageInput, DurableMessageAcknowledgement, DurableMessageHooks, DurableMessageMutationResult, DurableSendMessageInput } from './messageTypes.js';
+export declare const readDurableMessage: <TDecision>(read: ChatQuery, conversationId: string, messageId: string) => Promise<DurableChatMessage<TDecision>>;
+export declare const createDurableMessagePersistence: <TDecision>(hooks: DurableMessageHooks<TDecision>) => {
+    authorize: (read: ChatQuery, conversationId: string, purpose?: 'history' | 'send') => Promise<import("./membership.js").AuthorizedMembership>;
+    deleteMessage: (input: DurableDeleteMessageInput) => Promise<DurableMessageMutationResult>;
+    editMessage: (input: DurableEditMessageInput) => Promise<DurableMessageMutationResult>;
+    rateLimit: (read: ChatQuery, action: string, limit: number, interval?: number) => Promise<void>;
+    receipt: <T>(read: ChatQuery, action: string, conversationId: string, key: string, payload: unknown) => Promise<{
+        prior: T;
+        save: (result: T) => Promise<boolean>;
+    }>;
+    run: <T>(operation: (read: ChatQuery) => Promise<T>, write?: boolean) => Promise<T>;
+    sendMessage: (input: DurableSendMessageInput) => Promise<DurableMessageAcknowledgement>;
+};
+export type DurableMessagePersistence<TDecision = unknown> = ReturnType<typeof createDurableMessagePersistence<TDecision>>;