@nlabs/reaktor 1.16.0 → 1.18.0

package/lib/durableChat/messages.js

@@ -0,0 +1,257 @@
+/* eslint-disable no-await-in-loop, no-underscore-dangle -- Ordered checks and Arango document identities. */ import { createHash, randomUUID } from 'node:crypto';
+import { ChatError } from './errors.js';
+import { isChatIdentifier } from './membership.js';
+const defaultHash = (value)=>createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const validText = (content)=>typeof content === 'string' && Array.from(content).length <= 4000 && !/[\u0000\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(content);
+const requireValid = (valid)=>{
+    if (!valid) {
+        throw new ChatError('invalid_request');
+    }
+};
+export const readDurableMessage = async (read, conversationId, messageId)=>{
+    const message = await read('RETURN DOCUMENT("messages", @messageId)', {
+        messageId
+    });
+    if (!message || message.conversationId !== conversationId || message.chatSchemaVersion !== 1) {
+        throw new ChatError('forbidden');
+    }
+    return message;
+};
+export const createDurableMessagePersistence = (hooks)=>{
+    const hash = hooks.hash || defaultHash;
+    const now = hooks.now || Date.now;
+    const uuid = hooks.uuid || randomUUID;
+    const authorize = async (read, conversationId, purpose = 'history')=>{
+        const membership = await hooks.authorizeMembership(read, hooks.identity, conversationId, purpose);
+        const legacy = await read(`RETURN FIRST(FOR message IN messages
+      FILTER message.conversationId == @conversationId
+        AND (message.chatSchemaVersion != 1 OR !IS_NUMBER(message.sequence) OR message.sequence < 1)
+      LIMIT 1 RETURN true)`, {
+            conversationId
+        });
+        if (legacy === true) {
+            throw new ChatError('conflict');
+        }
+        return membership;
+    };
+    const receipt = async (read, action, conversationId, key, payload)=>{
+        const requestId = hash([
+            action,
+            conversationId,
+            hooks.identity.personaId,
+            key
+        ]);
+        const payloadHash = hash(payload);
+        const record = await read('RETURN DOCUMENT("chatMessageRequests", @key)', {
+            key: requestId
+        });
+        if (record && (record.payloadHash !== payloadHash || record.userId !== hooks.identity.userId)) {
+            throw new ChatError('conflict');
+        }
+        return {
+            prior: record?.result,
+            save: (result)=>read('INSERT @record IN chatMessageRequests RETURN true', {
+                    record: {
+                        _key: requestId,
+                        added: now(),
+                        conversationId,
+                        payloadHash,
+                        personaId: hooks.identity.personaId,
+                        result,
+                        userId: hooks.identity.userId
+                    }
+                })
+        };
+    };
+    const rateLimit = async (read, action, limit, interval = 60000)=>{
+        const key = hash([
+            hooks.identity.userId,
+            hooks.identity.personaId,
+            action,
+            Math.floor(now() / interval)
+        ]);
+        const allowed = await read(`LET bucket = DOCUMENT('chatRateLimits', @key)
+      FILTER bucket == null OR bucket.count < @limit
+      UPSERT {_key: @key} INSERT {_key: @key, count: 1, personaId: @personaId, userId: @userId}
+      UPDATE {count: OLD.count + 1, personaId: @personaId, userId: @userId}
+      IN chatRateLimits RETURN true`, {
+            key,
+            limit,
+            personaId: hooks.identity.personaId,
+            userId: hooks.identity.userId
+        });
+        if (allowed !== true) {
+            throw new ChatError('rate_limited');
+        }
+    };
+    const run = (operation, write = true)=>hooks.run(async (read)=>{
+            await hooks.authorizeIdentity(read, hooks.identity);
+            return operation(read);
+        }, write);
+    const sendMessage = (input)=>run(async (read)=>{
+            requireValid(Boolean(input) && isChatIdentifier(input.conversationId) && isChatIdentifier(input.clientMessageId) && input.senderPersonaId === hooks.identity.personaId && validText(input.content) && Array.isArray(input.attachmentIds) && input.attachmentIds.length <= 4 && input.attachmentIds.every(isChatIdentifier) && new Set(input.attachmentIds).size === input.attachmentIds.length && (input.content.trim().length > 0 || input.attachmentIds.length > 0) && (input.replyToMessageId === undefined || isChatIdentifier(input.replyToMessageId)));
+            const request = await receipt(read, 'send', input.conversationId, input.clientMessageId, input);
+            if (request.prior) {
+                return request.prior;
+            }
+            const membership = await authorize(read, input.conversationId, 'send');
+            await rateLimit(read, 'send', 60);
+            const attachments = [];
+            for (const imageId of input.attachmentIds){
+                attachments.push(await hooks.authorizeAttachment(read, imageId));
+            }
+            if (input.replyToMessageId) {
+                const quoted = await readDurableMessage(read, input.conversationId, input.replyToMessageId);
+                await hooks.authorizeMessageVisible(read, hooks.identity, quoted, membership);
+                if (quoted.deleted || quoted.mobilePlatformDisposition !== 'allowed') {
+                    throw new ChatError('forbidden');
+                }
+            }
+            const timestamp = now();
+            const sequence = await read(`FOR conversation IN conversations FILTER conversation._key == @id
+      AND conversation.chatSchemaVersion == 1 AND conversation.state == 'active'
+      AND IS_NUMBER(conversation.lastSequence) AND conversation.lastSequence < 9007199254740991
+      UPDATE conversation WITH {lastSequence: conversation.lastSequence + 1, modified: @now}
+      IN conversations RETURN NEW.lastSequence`, {
+                id: input.conversationId,
+                now: timestamp
+            });
+            if (!Number.isSafeInteger(sequence) || Number(sequence) < 1) {
+                throw new ChatError('unavailable');
+            }
+            const messageId = uuid();
+            const contentVersion = hash([
+                messageId,
+                1,
+                input.content
+            ]);
+            const projection = await hooks.classifyContent({
+                content: input.content || ' ',
+                contentVersion
+            });
+            const record = {
+                _key: messageId,
+                added: timestamp,
+                attachmentIds: input.attachmentIds,
+                attachments,
+                chatSchemaVersion: 1,
+                clientMessageId: input.clientMessageId,
+                content: input.content,
+                contentRevision: 1,
+                conversationId: input.conversationId,
+                deleted: false,
+                mobileContentVersion: contentVersion,
+                mobileDecision: projection.decision,
+                mobilePlatformDisposition: projection.platformDisposition || 'allowed',
+                modified: timestamp,
+                replyToMessageId: input.replyToMessageId,
+                revision: 1,
+                senderPersonaId: hooks.identity.personaId,
+                sequence: sequence,
+                userId: hooks.identity.userId
+            };
+            if (await read('INSERT @record IN messages RETURN true', {
+                record
+            }) !== true) {
+                throw new ChatError('unavailable');
+            }
+            await hooks.appendEvent(read, {
+                actorPersonaId: hooks.identity.personaId,
+                conversationId: input.conversationId,
+                kind: 'message.changed',
+                membershipEpoch: membership.epoch,
+                resourceId: messageId,
+                revision: 1
+            });
+            const result = {
+                clientMessageId: input.clientMessageId,
+                messageId,
+                revision: 1,
+                sequence: sequence
+            };
+            if (await request.save(result) !== true) {
+                throw new ChatError('unavailable');
+            }
+            return result;
+        });
+    const mutateMessage = (input, remove)=>run(async (read)=>{
+            requireValid(Boolean(input) && isChatIdentifier(input.conversationId) && isChatIdentifier(input.messageId) && isChatIdentifier(input.idempotencyKey) && Number.isSafeInteger(input.expectedRevision) && input.expectedRevision >= 1 && (remove || 'content' in input && validText(input.content)));
+            const request = await receipt(read, remove ? 'delete' : 'edit', input.conversationId, input.idempotencyKey, input);
+            if (request.prior) {
+                return request.prior;
+            }
+            const membership = await authorize(read, input.conversationId, 'send');
+            const message = await readDurableMessage(read, input.conversationId, input.messageId);
+            if (message.senderPersonaId !== hooks.identity.personaId || message.userId !== hooks.identity.userId || message.sequence < membership.joinSequence || message.deleted || message.mobilePlatformDisposition !== 'allowed') {
+                throw new ChatError('forbidden');
+            }
+            if (message.revision !== input.expectedRevision || !remove && now() - message.added > 15 * 60000) {
+                throw new ChatError('conflict');
+            }
+            await rateLimit(read, remove ? 'delete' : 'edit', 60);
+            const content = !remove && 'content' in input ? input.content : '';
+            const revision = message.revision + 1;
+            const contentRevision = message.contentRevision + 1;
+            const contentVersion = hash([
+                message._key,
+                contentRevision,
+                content
+            ]);
+            const projection = await hooks.classifyContent({
+                content: content || ' ',
+                contentVersion
+            });
+            const updated = await read(`FOR current IN messages
+      FILTER current._key == @id AND current.revision == @expectedRevision
+      UPDATE current WITH {content: @content, contentRevision: @contentRevision, deleted: @deleted,
+        attachmentIds: @attachmentIds, attachments: @attachments, replyToMessageId: @reply,
+        mobileContentVersion: @contentVersion, mobileDecision: @decision,
+        mobilePlatformDisposition: @platformDisposition, modified: @now, revision: @revision}
+      IN messages RETURN true`, {
+                attachmentIds: remove ? [] : message.attachmentIds,
+                attachments: remove ? [] : message.attachments,
+                content,
+                contentRevision,
+                contentVersion,
+                decision: projection.decision,
+                deleted: remove,
+                expectedRevision: input.expectedRevision,
+                id: message._key,
+                now: now(),
+                platformDisposition: projection.platformDisposition || 'allowed',
+                reply: remove ? null : message.replyToMessageId || null,
+                revision
+            });
+            if (updated !== true) {
+                throw new ChatError('conflict');
+            }
+            await hooks.appendEvent(read, {
+                actorPersonaId: hooks.identity.personaId,
+                conversationId: input.conversationId,
+                kind: 'message.changed',
+                membershipEpoch: membership.epoch,
+                resourceId: message._key,
+                revision
+            });
+            const result = {
+                messageId: message._key,
+                revision,
+                sequence: message.sequence
+            };
+            if (await request.save(result) !== true) {
+                throw new ChatError('unavailable');
+            }
+            return result;
+        });
+    return {
+        authorize,
+        deleteMessage: (input)=>mutateMessage(input, true),
+        editMessage: (input)=>mutateMessage(input, false),
+        rateLimit,
+        receipt,
+        run,
+        sendMessage
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/durableChat/messages.ts"],"sourcesContent":["/* eslint-disable no-await-in-loop, no-underscore-dangle -- Ordered checks and Arango document identities. */\nimport {createHash, randomUUID} from 'node:crypto';\n\nimport {ChatError} from './errors.js';\nimport {isChatIdentifier} from './membership.js';\n\nimport type {ChatQuery} from './membership.js';\nimport type {\n  DurableChatAttachment, DurableChatMessage, DurableDeleteMessageInput, DurableEditMessageInput,\n  DurableMessageAcknowledgement, DurableMessageHooks, DurableMessageMutationResult, DurableSendMessageInput\n} from './messageTypes.js';\n\nconst defaultHash = (value: unknown): string => createHash('sha256').update(JSON.stringify(value)).digest('hex');\nconst validText = (content: unknown): content is string => typeof content === 'string'\n  && Array.from(content).length <= 4000\n  && !/[\\u0000\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/u.test(content);\nconst requireValid = (valid: boolean): void => {\n  if(!valid) {\n    throw new ChatError('invalid_request');\n  }\n};\n\nexport const readDurableMessage = async <TDecision>(\n  read: ChatQuery, conversationId: string, messageId: string\n): Promise<DurableChatMessage<TDecision>> => {\n  const message = await read<DurableChatMessage<TDecision>>('RETURN DOCUMENT(\"messages\", @messageId)', {messageId});\n  if(!message || message.conversationId !== conversationId || message.chatSchemaVersion !== 1) {\n    throw new ChatError('forbidden');\n  }\n  return message;\n};\n\nexport const createDurableMessagePersistence = <TDecision>(hooks: DurableMessageHooks<TDecision>) => {\n  const hash = hooks.hash || defaultHash;\n  const now = hooks.now || Date.now;\n  const uuid = hooks.uuid || randomUUID;\n  const authorize = async (read: ChatQuery, conversationId: string, purpose: 'history' | 'send' = 'history') => {\n    const membership = await hooks.authorizeMembership(read, hooks.identity, conversationId, purpose);\n    const legacy = await read<boolean>(`RETURN FIRST(FOR message IN messages\n      FILTER message.conversationId == @conversationId\n        AND (message.chatSchemaVersion != 1 OR !IS_NUMBER(message.sequence) OR message.sequence < 1)\n      LIMIT 1 RETURN true)`, {conversationId});\n    if(legacy === true) {\n      throw new ChatError('conflict');\n    }\n    return membership;\n  };\n  const receipt = async <T>(\n    read: ChatQuery, action: string, conversationId: string, key: string, payload: unknown\n  ) => {\n    const requestId = hash([action, conversationId, hooks.identity.personaId, key]);\n    const payloadHash = hash(payload);\n    const record = await read<{readonly payloadHash: string; readonly result: T; readonly userId: string}>(\n      'RETURN DOCUMENT(\"chatMessageRequests\", @key)', {key: requestId});\n    if(record && (record.payloadHash !== payloadHash || record.userId !== hooks.identity.userId)) {\n      throw new ChatError('conflict');\n    }\n    return {prior: record?.result, save: (result: T) => read<boolean>(\n      'INSERT @record IN chatMessageRequests RETURN true', {record: {_key: requestId, added: now(), conversationId,\n        payloadHash, personaId: hooks.identity.personaId, result, userId: hooks.identity.userId}})};\n  };\n  const rateLimit = async (read: ChatQuery, action: string, limit: number, interval = 60000): Promise<void> => {\n    const key = hash([hooks.identity.userId, hooks.identity.personaId, action, Math.floor(now() / interval)]);\n    const allowed = await read<boolean>(`LET bucket = DOCUMENT('chatRateLimits', @key)\n      FILTER bucket == null OR bucket.count < @limit\n      UPSERT {_key: @key} INSERT {_key: @key, count: 1, personaId: @personaId, userId: @userId}\n      UPDATE {count: OLD.count + 1, personaId: @personaId, userId: @userId}\n      IN chatRateLimits RETURN true`, {key, limit, personaId: hooks.identity.personaId, userId: hooks.identity.userId});\n    if(allowed !== true) {\n      throw new ChatError('rate_limited');\n    }\n  };\n  const run = <T>(operation: (read: ChatQuery) => Promise<T>, write = true): Promise<T> => hooks.run(async (read) => {\n    await hooks.authorizeIdentity(read, hooks.identity);\n    return operation(read);\n  }, write);\n  const sendMessage = (input: DurableSendMessageInput): Promise<DurableMessageAcknowledgement> => run(async (read) => {\n    requireValid(Boolean(input) && isChatIdentifier(input.conversationId) && isChatIdentifier(input.clientMessageId)\n      && input.senderPersonaId === hooks.identity.personaId && validText(input.content)\n      && Array.isArray(input.attachmentIds) && input.attachmentIds.length <= 4\n      && input.attachmentIds.every(isChatIdentifier) && new Set(input.attachmentIds).size === input.attachmentIds.length\n      && (input.content.trim().length > 0 || input.attachmentIds.length > 0)\n      && (input.replyToMessageId === undefined || isChatIdentifier(input.replyToMessageId)));\n    const request = await receipt<DurableMessageAcknowledgement>(\n      read, 'send', input.conversationId, input.clientMessageId, input);\n    if(request.prior) {\n      return request.prior;\n    }\n    const membership = await authorize(read, input.conversationId, 'send');\n    await rateLimit(read, 'send', 60);\n    const attachments: DurableChatAttachment[] = [];\n    for(const imageId of input.attachmentIds) {\n      attachments.push(await hooks.authorizeAttachment(read, imageId));\n    }\n    if(input.replyToMessageId) {\n      const quoted = await readDurableMessage<TDecision>(read, input.conversationId, input.replyToMessageId);\n      await hooks.authorizeMessageVisible(read, hooks.identity, quoted, membership);\n      if(quoted.deleted || quoted.mobilePlatformDisposition !== 'allowed') {\n        throw new ChatError('forbidden');\n      }\n    }\n    const timestamp = now();\n    const sequence = await read<number>(`FOR conversation IN conversations FILTER conversation._key == @id\n      AND conversation.chatSchemaVersion == 1 AND conversation.state == 'active'\n      AND IS_NUMBER(conversation.lastSequence) AND conversation.lastSequence < 9007199254740991\n      UPDATE conversation WITH {lastSequence: conversation.lastSequence + 1, modified: @now}\n      IN conversations RETURN NEW.lastSequence`, {id: input.conversationId, now: timestamp});\n    if(!Number.isSafeInteger(sequence) || Number(sequence) < 1) {\n      throw new ChatError('unavailable');\n    }\n    const messageId = uuid();\n    const contentVersion = hash([messageId, 1, input.content]);\n    const projection = await hooks.classifyContent({content: input.content || ' ', contentVersion});\n    const record: DurableChatMessage<TDecision> = {_key: messageId, added: timestamp,\n      attachmentIds: input.attachmentIds, attachments, chatSchemaVersion: 1, clientMessageId: input.clientMessageId,\n      content: input.content, contentRevision: 1, conversationId: input.conversationId, deleted: false,\n      mobileContentVersion: contentVersion, mobileDecision: projection.decision,\n      mobilePlatformDisposition: projection.platformDisposition || 'allowed', modified: timestamp,\n      replyToMessageId: input.replyToMessageId, revision: 1, senderPersonaId: hooks.identity.personaId,\n      sequence: sequence!, userId: hooks.identity.userId};\n    if(await read<boolean>('INSERT @record IN messages RETURN true', {record}) !== true) {\n      throw new ChatError('unavailable');\n    }\n    await hooks.appendEvent(read, {actorPersonaId: hooks.identity.personaId, conversationId: input.conversationId,\n      kind: 'message.changed', membershipEpoch: membership.epoch, resourceId: messageId, revision: 1});\n    const result = {clientMessageId: input.clientMessageId, messageId, revision: 1, sequence: sequence!};\n    if(await request.save(result) !== true) {\n      throw new ChatError('unavailable');\n    }\n    return result;\n  });\n  const mutateMessage = (\n    input: DurableEditMessageInput | DurableDeleteMessageInput, remove: boolean\n  ): Promise<DurableMessageMutationResult> => run(async (read) => {\n    requireValid(Boolean(input) && isChatIdentifier(input.conversationId) && isChatIdentifier(input.messageId)\n      && isChatIdentifier(input.idempotencyKey) && Number.isSafeInteger(input.expectedRevision)\n      && input.expectedRevision >= 1 && (remove || ('content' in input && validText(input.content))));\n    const request = await receipt<DurableMessageMutationResult>(read, remove ? 'delete' : 'edit',\n      input.conversationId, input.idempotencyKey, input);\n    if(request.prior) {\n      return request.prior;\n    }\n    const membership = await authorize(read, input.conversationId, 'send');\n    const message = await readDurableMessage<TDecision>(read, input.conversationId, input.messageId);\n    if(message.senderPersonaId !== hooks.identity.personaId || message.userId !== hooks.identity.userId\n      || message.sequence < membership.joinSequence || message.deleted || message.mobilePlatformDisposition !== 'allowed') {\n      throw new ChatError('forbidden');\n    }\n    if(message.revision !== input.expectedRevision || (!remove && now() - message.added > 15 * 60000)) {\n      throw new ChatError('conflict');\n    }\n    await rateLimit(read, remove ? 'delete' : 'edit', 60);\n    const content = !remove && 'content' in input ? input.content : '';\n    const revision = message.revision + 1;\n    const contentRevision = message.contentRevision + 1;\n    const contentVersion = hash([message._key, contentRevision, content]);\n    const projection = await hooks.classifyContent({content: content || ' ', contentVersion});\n    const updated = await read<boolean>(`FOR current IN messages\n      FILTER current._key == @id AND current.revision == @expectedRevision\n      UPDATE current WITH {content: @content, contentRevision: @contentRevision, deleted: @deleted,\n        attachmentIds: @attachmentIds, attachments: @attachments, replyToMessageId: @reply,\n        mobileContentVersion: @contentVersion, mobileDecision: @decision,\n        mobilePlatformDisposition: @platformDisposition, modified: @now, revision: @revision}\n      IN messages RETURN true`, {attachmentIds: remove ? [] : message.attachmentIds,\n      attachments: remove ? [] : message.attachments, content, contentRevision, contentVersion,\n      decision: projection.decision, deleted: remove, expectedRevision: input.expectedRevision, id: message._key,\n      now: now(), platformDisposition: projection.platformDisposition || 'allowed',\n      reply: remove ? null : message.replyToMessageId || null, revision});\n    if(updated !== true) {\n      throw new ChatError('conflict');\n    }\n    await hooks.appendEvent(read, {actorPersonaId: hooks.identity.personaId, conversationId: input.conversationId,\n      kind: 'message.changed', membershipEpoch: membership.epoch, resourceId: message._key, revision});\n    const result = {messageId: message._key, revision, sequence: message.sequence};\n    if(await request.save(result) !== true) {\n      throw new ChatError('unavailable');\n    }\n    return result;\n  });\n  return {authorize, deleteMessage: (input: DurableDeleteMessageInput) => mutateMessage(input, true),\n    editMessage: (input: DurableEditMessageInput) => mutateMessage(input, false), rateLimit, receipt, run, sendMessage};\n};\n\nexport type DurableMessagePersistence<TDecision = unknown> =\n  ReturnType<typeof createDurableMessagePersistence<TDecision>>;\n"],"names":["createHash","randomUUID","ChatError","isChatIdentifier","defaultHash","value","update","JSON","stringify","digest","validText","content","Array","from","length","test","requireValid","valid","readDurableMessage","read","conversationId","messageId","message","chatSchemaVersion","createDurableMessagePersistence","hooks","hash","now","Date","uuid","authorize","purpose","membership","authorizeMembership","identity","legacy","receipt","action","key","payload","requestId","personaId","payloadHash","record","userId","prior","result","save","_key","added","rateLimit","limit","interval","Math","floor","allowed","run","operation","write","authorizeIdentity","sendMessage","input","Boolean","clientMessageId","senderPersonaId","isArray","attachmentIds","every","Set","size","trim","replyToMessageId","undefined","request","attachments","imageId","push","authorizeAttachment","quoted","authorizeMessageVisible","deleted","mobilePlatformDisposition","timestamp","sequence","id","Number","isSafeInteger","contentVersion","projection","classifyContent","contentRevision","mobileContentVersion","mobileDecision","decision","platformDisposition","modified","revision","appendEvent","actorPersonaId","kind","membershipEpoch","epoch","resourceId","mutateMessage","remove","idempotencyKey","expectedRevision","joinSequence","updated","reply","deleteMessage","editMessage"],"mappings":"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"}

package/lib/durableChat/transaction.d.ts

@@ -0,0 +1,10 @@
+import type { ApiContext } from '../types/auth.types.js';
+import type { ChatQuery } from './membership.js';
+export interface DurableTransactionCollections {
+    readonly exclusive?: readonly string[];
+    readonly read?: readonly string[];
+    readonly write?: readonly string[];
+}
+export declare const createDurableQuery: (context: ApiContext) => ChatQuery;
+/** Injected queries retain caller-owned transaction lifecycle; never fall back to another connection. */
+export declare const createDurableTransaction: (context: ApiContext, collections: DurableTransactionCollections, query?: ChatQuery) => <T>(operation: (read: ChatQuery) => Promise<T>) => Promise<T>;

package/lib/durableChat/transaction.js

@@ -0,0 +1,53 @@
+import { useDb } from '../utils/arangodbUtils.js';
+export const createDurableQuery = (context)=>{
+    const db = useDb(context.databaseName);
+    return async (query, bindVars)=>{
+        const cursor = await db.query({
+            bindVars,
+            query
+        });
+        return cursor.next();
+    };
+};
+/** Injected queries retain caller-owned transaction lifecycle; never fall back to another connection. */ export const createDurableTransaction = (context, collections, query)=>{
+    if (query) {
+        return (operation)=>operation(query);
+    }
+    const db = useDb(context.databaseName);
+    return async (operation)=>{
+        const transaction = await db.beginTransaction({
+            exclusive: [
+                ...collections.exclusive || []
+            ],
+            read: [
+                ...collections.read || []
+            ],
+            write: [
+                ...collections.write || []
+            ]
+        }, {
+            allowImplicit: false,
+            lockTimeout: 5,
+            waitForSync: true
+        });
+        const read = async (query, bindVars)=>{
+            const cursor = await transaction.step(()=>db.query({
+                    bindVars,
+                    query
+                }));
+            return cursor.next();
+        };
+        try {
+            const result = await operation(read);
+            await transaction.commit();
+            return result;
+        } catch (error) {
+            try {
+                await transaction.abort();
+            } catch  {}
+            throw error;
+        }
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/durableChat/types.d.ts

@@ -0,0 +1,81 @@
+export type ConversationKind = 'direct' | 'group';
+export type ConversationState = 'active' | 'closed' | 'forming';
+export type MembershipRole = 'admin' | 'member' | 'owner';
+export type MembershipState = 'active' | 'left' | 'removed';
+/** An epoch is a grant for a bounded history interval, never a client-selected identity. */
+export interface ConversationMembership {
+    readonly conversationId: string;
+    readonly epoch: string;
+    readonly joinSequence: number;
+    readonly leftSequence?: number;
+    readonly personaId: string;
+    readonly revision: number;
+    readonly role: MembershipRole;
+    readonly state: MembershipState;
+}
+/** Names must pass the caller's audience projection before being serialized. */
+export interface ConversationSummary {
+    readonly activeMemberCount: number;
+    readonly conversationId: string;
+    readonly kind: ConversationKind;
+    readonly membership: ConversationMembership;
+    readonly membershipRevision: number;
+    readonly name?: string;
+    readonly state: ConversationState;
+}
+export interface ConversationInvite {
+    readonly conversationId: string;
+    readonly expiresAt: number;
+    readonly inviteId: string;
+    readonly invitedByPersonaId: string;
+    readonly revision: number;
+    readonly state: 'accepted' | 'declined' | 'expired' | 'pending' | 'revoked';
+}
+export interface CreateDirectInput {
+    readonly participantPersonaId: string;
+}
+export interface CreateGroupInput {
+    readonly idempotencyKey: string;
+    readonly memberPersonaIds: readonly string[];
+    readonly name: string;
+}
+export interface InviteMemberInput {
+    readonly conversationId: string;
+    readonly expectedRevision: number;
+    readonly idempotencyKey: string;
+    readonly personaId: string;
+}
+export interface AcceptInviteInput {
+    readonly expectedRevision: number;
+    readonly idempotencyKey: string;
+    readonly inviteId: string;
+}
+export type DeclineInviteInput = AcceptInviteInput;
+export interface ChangeMemberRoleInput {
+    readonly conversationId: string;
+    readonly expectedRevision: number;
+    readonly idempotencyKey: string;
+    readonly personaId: string;
+    readonly role: Exclude<MembershipRole, 'owner'>;
+}
+export interface RemoveMemberInput {
+    readonly conversationId: string;
+    readonly expectedRevision: number;
+    readonly idempotencyKey: string;
+    readonly personaId: string;
+}
+export interface LeaveConversationInput {
+    readonly conversationId: string;
+    readonly expectedRevision: number;
+    readonly idempotencyKey: string;
+}
+export type TransferOwnershipInput = RemoveMemberInput;
+export interface ChatEvent {
+    readonly conversationId: string;
+    readonly eventId: string;
+    readonly eventSequence: number;
+    readonly kind: 'membership.changed' | 'message.changed' | 'receipt.changed';
+    readonly resourceId: string;
+    readonly revision: number;
+}
+export type { AuthorizedMembership, ChatIdentity, ChatQuery, MembershipAccessInput } from './membership.js';

package/lib/durableChat/types.js

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

package/lib/index.d.ts

@@ -1,7 +1,3 @@
-/**
- * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
- * All rights reserved. Use is subject to the accompanying commercial LICENSE.
- */
 export { graphql, GraphQLBoolean, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, graphqlSync, printSchema } from 'graphql';
 export type { ExecutionResult } from 'graphql';
 export type { InputTypeComposer, ObjectTypeComposer } from 'graphql-compose';
@@ -9,6 +5,8 @@ export { schemaComposer } from 'graphql-compose';
 export * from './actions/index.js';
 export * from './adapters/index.js';
 export * from './config.js';
+export * from './durableChat/index.js';
+export type { MembershipRole as DurableChatMembershipRole } from './durableChat/types.js';
 export type { DatabaseConnectionMetadata, DatabaseCredentialIdentity, DatabaseCredentialRequest, DatabaseCredentialSecret, DatabaseEnvironment, DatabaseProvisioningLease } from './types/databaseCredentials.types.js';
 export { getAppDatabaseName, getDatabaseCredentialIdentity, parseDatabaseCredentialSecret, toDatabaseConnectionMetadata } from './utils/databaseCredentials.js';
 export { COLLECTIONS, ConnectionType as ConnectionTypes, DEFAULT_DOCUMENT_COLLECTIONS, DEFAULT_EDGE_COLLECTIONS, EDGES, PrivacyLevel, ReactionType } from './constants/collections.js';
@@ -28,3 +26,5 @@ export declare const reaktorSchema = "";
 export declare const reaktorResolvers: import("graphql-compose/lib/SchemaComposer.js").GraphQLToolsResolveMethods<any>;
 export * from './adapters/higgsfieldModelCatalog.js';
 export * from './adapters/higgsfieldModels.js';
+export * from './organizations/index.js';
+export type { MembershipRole } from './organizations/types.js';

package/lib/index.js

@@ -1,12 +1,13 @@
 /**
  * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
  * All rights reserved. Use is subject to the accompanying commercial LICENSE.
- */ export { graphql, GraphQLBoolean, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, graphqlSync, printSchema } from 'graphql';
-import { schemaComposer } from 'graphql-compose';
+ */ import { schemaComposer } from 'graphql-compose';
+export { graphql, GraphQLBoolean, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, graphqlSync, printSchema } from 'graphql';
 export { schemaComposer } from 'graphql-compose';
 export * from './actions/index.js';
 export * from './adapters/index.js';
 export * from './config.js';
+export * from './durableChat/index.js';
 export { getAppDatabaseName, getDatabaseCredentialIdentity, parseDatabaseCredentialSecret, toDatabaseConnectionMetadata } from './utils/databaseCredentials.js';
 export { COLLECTIONS, ConnectionType as ConnectionTypes, DEFAULT_DOCUMENT_COLLECTIONS, DEFAULT_EDGE_COLLECTIONS, EDGES, PrivacyLevel, ReactionType } from './constants/collections.js';
 export { notifyUser } from './lambdas/actions/websockets.js';
@@ -24,5 +25,6 @@ export const reaktorSchema = ''; // printSchema(schemaComposer.buildSchema());
 export const reaktorResolvers = schemaComposer.getResolveMethods();
 export * from './adapters/higgsfieldModelCatalog.js';
 export * from './adapters/higgsfieldModels.js';
+export * from './organizations/index.js';
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas/actions/websockets.js

@@ -1,8 +1,8 @@
 /**
  * Copyright (c) 2021-Present, Nitrogen Labs, Inc.
  * All rights reserved. Use is subject to the accompanying commercial LICENSE.
- */ import { aql } from 'arangojs';
-import { createHash, parseId, parseString } from '@nlabs/utils/parsers/strings';
+ */ import { createHash, parseId, parseString } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
 import { useDb } from '../../utils/arangodbUtils.js';
 import { wsClient } from '../utils/websocket.js';
 const { ARANGODB_DATABASE: databaseName } = process.env;
@@ -97,7 +97,7 @@ export const getConnectionByConversation = (context, conversationId)=>{
     const conversationDocId = `conversations/${parseId(conversationId)}`;
     const db = useDb(databaseName);
     const aqlQry = aql`FOR c, e IN 1..1 OUTBOUND ${sessionDocId} hasConversation
-    FILTER c._id == ${conversationDocId}
+    FILTER c._id == ${conversationDocId} AND c.chatSchemaVersion != 1
     LIMIT 1
     LET u = (
       FOR inUser, inEdge IN 1..1 INBOUND ${conversationDocId} hasConversation
@@ -137,4 +137,4 @@ export const notifyUser = async (_context, { data, event, userId })=>{
     });
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/lambdas/actions/websockets.ts"],"sourcesContent":["/**\n * Copyright (c) 2021-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {aql, Database} from 'arangojs';\n\nimport {createHash, parseId, parseString} from '@nlabs/utils/parsers/strings';\nimport {useDb} from '../../utils/arangodbUtils.js';\nimport {wsClient} from '../utils/websocket.js';\n\nimport type {AqlQuery} from 'arangojs/aql';\nimport type {ApiContext} from '../../types/auth.types.js';\nimport type {WebsocketConnection} from '../../types/websockets.types.js';\n\nconst {ARANGODB_DATABASE: databaseName} = process.env;\n\nexport const addConnection = (\n  connectionId: string,\n  userId: string,\n  personaId = '',\n  clientId = ''\n): Promise<WebsocketConnection> => {\n  const formatClientId = parseString(clientId, 64);\n  const formatConnId = parseString(connectionId, 32);\n  const formatUserId = parseId(userId);\n  const formatPersonaId = parseId(personaId);\n  const db: Database = useDb(databaseName);\n  const timestamp = Date.now();\n  const upsert = formatClientId\n    ? {clientId: formatClientId}\n    : {connectionId: formatConnId};\n  const insert = {\n    _key: createHash(`connection-${formatClientId || formatConnId}`),\n    ...(formatClientId && {clientId: formatClientId}),\n    connectionId: formatConnId,\n    modified: timestamp,\n    ...(formatPersonaId && {personaId: formatPersonaId}),\n    userId: formatUserId\n  };\n  const update = {\n    ...(formatClientId && {clientId: formatClientId}),\n    ...(formatPersonaId && {personaId: formatPersonaId}),\n    connectionId: formatConnId,\n    modified: timestamp,\n    userId: formatUserId\n  };\n  const aqlQry: AqlQuery = aql`UPSERT ${upsert}\n    INSERT ${insert}\n    UPDATE ${update} IN connections\n    RETURN NEW`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionsByUser = (userId: string): Promise<WebsocketConnection[]> => {\n  const formatUserId = parseId(userId);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.userId == ${formatUserId}\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionsByPersona = (personaId: string): Promise<WebsocketConnection[]> => {\n  const formatPersonaId = parseId(personaId);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.personaId == ${formatPersonaId}\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionByUserId = (userId = ''): Promise<WebsocketConnection | null> => {\n  const formatUserId = parseId(userId);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.userId == ${formatUserId}\n    LIMIT 1\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionById = (connectionId: string): Promise<WebsocketConnection | null> => {\n  const formatConnId = parseString(connectionId, 32);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.connectionId == ${formatConnId}\n    LIMIT 1\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionByConversation = (context: ApiContext, conversationId: string): Promise<string[][]> => {\n  const {session: {userId: sessionId = ''} = {}} = context;\n  const sessionDocId = `users/${parseId(sessionId)}`;\n  const conversationDocId = `conversations/${parseId(conversationId)}`;\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c, e IN 1..1 OUTBOUND ${sessionDocId} hasConversation\n    FILTER c._id == ${conversationDocId}\n    LIMIT 1\n    LET u = (\n      FOR inUser, inEdge IN 1..1 INBOUND ${conversationDocId} hasConversation\n        FOR n IN connections\n          FILTER inUser.userId == n.userId\n          RETURN n.connectionId\n    )\n    RETURN u`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const removeConnection = (connectionId: string): Promise<WebsocketConnection | null> => {\n  const formatConnId = parseString(connectionId, 32);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.connectionId == ${formatConnId}\n    LIMIT 1\n    REMOVE c IN connections\n    RETURN OLD`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const notifyUser = async (\n  _context: ApiContext, {data, event, userId}: {data?: unknown; event: string; userId: string}\n): Promise<boolean> => {\n  const connections = await getConnectionsByUser(userId);\n  const connectionIds = connections\n    .map((connection) => connection.socketId || connection.connectionId)\n    .filter((connectionId): connectionId is string => Boolean(connectionId));\n\n  if(!connectionIds.length) {\n    return false;\n  }\n\n  await wsClient.setupClient({requestContext: {}});\n  return wsClient.send(connectionIds, {action: event, data});\n};\n"],"names":["aql","createHash","parseId","parseString","useDb","wsClient","ARANGODB_DATABASE","databaseName","process","env","addConnection","connectionId","userId","personaId","clientId","formatClientId","formatConnId","formatUserId","formatPersonaId","db","timestamp","Date","now","upsert","insert","_key","modified","update","aqlQry","query","then","cursor","next","catch","error","getConnectionsByUser","all","getConnectionsByPersona","getConnectionByUserId","getConnectionById","getConnectionByConversation","context","conversationId","session","sessionId","sessionDocId","conversationDocId","removeConnection","notifyUser","_context","data","event","connections","connectionIds","map","connection","socketId","filter","Boolean","length","setupClient","requestContext","send","action"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/lambdas/actions/websockets.ts"],"sourcesContent":["/**\n * Copyright (c) 2021-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {createHash, parseId, parseString} from '@nlabs/utils/parsers/strings';\nimport {aql, Database} from 'arangojs';\n\nimport {useDb} from '../../utils/arangodbUtils.js';\nimport {wsClient} from '../utils/websocket.js';\n\nimport type {AqlQuery} from 'arangojs/aql';\nimport type {ApiContext} from '../../types/auth.types.js';\nimport type {WebsocketConnection} from '../../types/websockets.types.js';\n\nconst {ARANGODB_DATABASE: databaseName} = process.env;\n\nexport const addConnection = (\n  connectionId: string,\n  userId: string,\n  personaId = '',\n  clientId = ''\n): Promise<WebsocketConnection> => {\n  const formatClientId = parseString(clientId, 64);\n  const formatConnId = parseString(connectionId, 32);\n  const formatUserId = parseId(userId);\n  const formatPersonaId = parseId(personaId);\n  const db: Database = useDb(databaseName);\n  const timestamp = Date.now();\n  const upsert = formatClientId\n    ? {clientId: formatClientId}\n    : {connectionId: formatConnId};\n  const insert = {\n    _key: createHash(`connection-${formatClientId || formatConnId}`),\n    ...(formatClientId && {clientId: formatClientId}),\n    connectionId: formatConnId,\n    modified: timestamp,\n    ...(formatPersonaId && {personaId: formatPersonaId}),\n    userId: formatUserId\n  };\n  const update = {\n    ...(formatClientId && {clientId: formatClientId}),\n    ...(formatPersonaId && {personaId: formatPersonaId}),\n    connectionId: formatConnId,\n    modified: timestamp,\n    userId: formatUserId\n  };\n  const aqlQry: AqlQuery = aql`UPSERT ${upsert}\n    INSERT ${insert}\n    UPDATE ${update} IN connections\n    RETURN NEW`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionsByUser = (userId: string): Promise<WebsocketConnection[]> => {\n  const formatUserId = parseId(userId);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.userId == ${formatUserId}\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionsByPersona = (personaId: string): Promise<WebsocketConnection[]> => {\n  const formatPersonaId = parseId(personaId);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.personaId == ${formatPersonaId}\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionByUserId = (userId = ''): Promise<WebsocketConnection | null> => {\n  const formatUserId = parseId(userId);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.userId == ${formatUserId}\n    LIMIT 1\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionById = (connectionId: string): Promise<WebsocketConnection | null> => {\n  const formatConnId = parseString(connectionId, 32);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.connectionId == ${formatConnId}\n    LIMIT 1\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionByConversation = (context: ApiContext, conversationId: string): Promise<string[][]> => {\n  const {session: {userId: sessionId = ''} = {}} = context;\n  const sessionDocId = `users/${parseId(sessionId)}`;\n  const conversationDocId = `conversations/${parseId(conversationId)}`;\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c, e IN 1..1 OUTBOUND ${sessionDocId} hasConversation\n    FILTER c._id == ${conversationDocId} AND c.chatSchemaVersion != 1\n    LIMIT 1\n    LET u = (\n      FOR inUser, inEdge IN 1..1 INBOUND ${conversationDocId} hasConversation\n        FOR n IN connections\n          FILTER inUser.userId == n.userId\n          RETURN n.connectionId\n    )\n    RETURN u`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const removeConnection = (connectionId: string): Promise<WebsocketConnection | null> => {\n  const formatConnId = parseString(connectionId, 32);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.connectionId == ${formatConnId}\n    LIMIT 1\n    REMOVE c IN connections\n    RETURN OLD`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const notifyUser = async (\n  _context: ApiContext, {data, event, userId}: {data?: unknown; event: string; userId: string}\n): Promise<boolean> => {\n  const connections = await getConnectionsByUser(userId);\n  const connectionIds = connections\n    .map((connection) => connection.socketId || connection.connectionId)\n    .filter((connectionId): connectionId is string => Boolean(connectionId));\n\n  if(!connectionIds.length) {\n    return false;\n  }\n\n  await wsClient.setupClient({requestContext: {}});\n  return wsClient.send(connectionIds, {action: event, data});\n};\n"],"names":["createHash","parseId","parseString","aql","useDb","wsClient","ARANGODB_DATABASE","databaseName","process","env","addConnection","connectionId","userId","personaId","clientId","formatClientId","formatConnId","formatUserId","formatPersonaId","db","timestamp","Date","now","upsert","insert","_key","modified","update","aqlQry","query","then","cursor","next","catch","error","getConnectionsByUser","all","getConnectionsByPersona","getConnectionByUserId","getConnectionById","getConnectionByConversation","context","conversationId","session","sessionId","sessionDocId","conversationDocId","removeConnection","notifyUser","_context","data","event","connections","connectionIds","map","connection","socketId","filter","Boolean","length","setupClient","requestContext","send","action"],"mappings":"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"}