@nlabs/reaktor 1.8.0 → 1.9.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/.codex-worktrees/reaktor-phantaze-chat/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/handlers/graphqlHandler.js

@@ -166,4 +166,4 @@ const applyMiddleware = (tc, middlewares)=>{
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/reaktor/reaktor/packages/reaktor/src/handlers/graphqlHandler.ts"],"sourcesContent":["import {graphql} from 'graphql';\nimport {schemaComposer} from 'graphql-compose';\nimport type {ObjectTypeComposer, SchemaComposer} from 'graphql-compose';\n\nimport {Config} from '../config.js';\nimport {registerDefaultMutations} from '../mutations/index.js';\nimport {registerDefaultQueries} from '../queries/index.js';\nimport {extractLanguageContext} from '../utils/contextUtils.js';\nimport {createContext, getGqlFields, getLambdaData, type LambdaData} from '../utils/index.js';\n\nimport type {APIGatewayProxyEventV2} from 'aws-lambda';\nimport type {ExecutionResult} from 'graphql';\nimport type {ApiContext} from '../types/auth.types.js';\n\nexport type GraphqlResolverMiddleware = (\n  resolve: (source: unknown, args: unknown, context: ApiContext, info: unknown) => Promise<unknown> | unknown,\n  source: unknown,\n  args: unknown,\n  context: ApiContext,\n  info: unknown\n) => Promise<unknown> | unknown;\n\ntype GraphqlFieldConfigMap = Record<string, unknown>;\n\nexport type GraphqlHandlerOptions = {\n  composer?: SchemaComposer<any>;\n  context?: ApiContext;\n  extraMutations?: GraphqlFieldConfigMap;\n  extraQueries?: GraphqlFieldConfigMap;\n  includeDefaults?: boolean;\n  middleware?: GraphqlResolverMiddleware | GraphqlResolverMiddleware[];\n};\n\nconst addFieldsMiddleware: GraphqlResolverMiddleware = (resolve, source, args, context: ApiContext, info) => {\n  const enhancedContext = {\n    ...context,\n    fields: getGqlFields(info)\n  };\n\n  return resolve(source, args, enhancedContext, info);\n};\n\nconst addMissingFields = (tc: ObjectTypeComposer<unknown, unknown>, fields: GraphqlFieldConfigMap): void => {\n  Object.entries(fields).forEach(([fieldName, fieldConfig]) => {\n    if(!tc.hasField(fieldName)) {\n      tc.setField(fieldName, fieldConfig as any);\n    }\n  });\n};\n\nconst applyMiddleware = (\n  tc: ObjectTypeComposer<unknown, unknown>,\n  middlewares: GraphqlResolverMiddleware[]\n): void => {\n  if(middlewares.length === 0) {\n    return;\n  }\n\n  Object.keys(tc.getFields()).forEach((fieldName) => {\n    try {\n      if(tc.hasResolver(fieldName)) {\n        middlewares.forEach((middleware) => tc.wrapResolver(fieldName, middleware as any));\n      }\n    } catch(error: any) {\n      console.warn(`Skipping field ${fieldName} - not a resolver:`, error.message);\n    }\n  });\n};\n\n/**\n * Creates an API Gateway-compatible GraphQL handler for Reaktor.\n *\n * Request expectations:\n * - `event.body.query` is a GraphQL operation string.\n * - `event.body.variables` is optional operation variables.\n *\n * Runtime behavior:\n * - Builds per-request context (`config`, auth/session context, language context, request).\n * - Applies resolver middleware to expose selected GraphQL fields on `context.fields`.\n * - Executes operation using the composed schema.\n *\n * Response contract:\n * - Returns `{statusCode, headers, body}` with JSON body.\n * - Returns `200` for GraphQL responses (including GraphQL errors in `errors`).\n * - Returns `500` only for handler/runtime failures.\n *\n * See README: \"GraphQL Handler Usage\" for integration examples.\n */\nexport const createGraphqlHandler = (options: GraphqlHandlerOptions = {}) => {\n  const composer = options.composer || schemaComposer;\n  const initialContext = (options.context || {}) as ApiContext;\n  const shouldIncludeDefaults = options.includeDefaults !== false;\n  const middlewareList = [\n    addFieldsMiddleware,\n    ...(Array.isArray(options.middleware)\n      ? options.middleware\n      : options.middleware ? [options.middleware] : [])\n  ];\n\n  if(shouldIncludeDefaults) {\n    registerDefaultQueries(composer);\n    registerDefaultMutations(composer);\n  }\n\n  if(options.extraQueries) {\n    addMissingFields(composer.Query, options.extraQueries);\n  }\n\n  if(options.extraMutations) {\n    addMissingFields(composer.Mutation, options.extraMutations);\n  }\n\n  applyMiddleware(composer.Query, middlewareList);\n  applyMiddleware(composer.Mutation, middlewareList);\n\n  const schema = composer.buildSchema();\n\n  return async (event: APIGatewayProxyEventV2): Promise<ExecutionResult | Record<string, unknown>> => {\n    try {\n      const updatedContext: ApiContext = await createContext(initialContext, event);\n      const languageContext = extractLanguageContext(event);\n\n      const contextWithLanguage = {\n        config: Config.get(),\n        ...updatedContext,\n        languageContext,\n        request: event\n      };\n\n      const parseData = getLambdaData(event as unknown as LambdaData);\n      const {body} = parseData;\n\n      if(!body?.query) {\n        console.warn('No GraphQL query found in request body');\n\n        return {\n          body: JSON.stringify({\n            data: null,\n            errors: [{\n              message: 'No GraphQL query found in request body'\n            }]\n          }),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 200\n        };\n      }\n\n      try {\n        const result = await Promise.resolve(graphql({\n          contextValue: contextWithLanguage,\n          schema,\n          source: body.query,\n          variableValues: body.variables\n        }));\n\n        if(result.errors && result.errors.length > 0) {\n          console.error('GraphQL execution errors:', result.errors);\n        }\n\n        return {\n          body: JSON.stringify(result),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 200\n        };\n      } catch(graphqlError: unknown) {\n        console.error('Error during GraphQL execution:', graphqlError);\n\n        const errorMessage = graphqlError instanceof Error ? graphqlError.message : 'GraphQL execution error';\n        const errorStack = graphqlError instanceof Error ? graphqlError.stack : undefined;\n\n        return {\n          body: JSON.stringify({\n            data: null,\n            errors: [{\n              message: errorMessage,\n              stack: process.env.NODE_ENV === 'development' ? errorStack : undefined\n            }]\n          }),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 500\n        };\n      }\n    } catch(err: unknown) {\n      console.error('Handler error:', {\n        message: err instanceof Error ? err.message : 'Unknown error',\n        stack: err instanceof Error ? err.stack : undefined\n      });\n\n      const errorMessage = err instanceof Error ? err.message : 'An unknown error occurred in the handler';\n      const errorStack = err instanceof Error ? err.stack : undefined;\n\n      return {\n        body: JSON.stringify({\n          data: null,\n          errors: [{\n            message: errorMessage,\n            stack: process.env.NODE_ENV === 'development' ? errorStack : undefined\n          }]\n        }),\n        headers: {\n          'Content-Type': 'application/json'\n        },\n        statusCode: 500\n      };\n    }\n  };\n};\n"],"names":["graphql","schemaComposer","Config","registerDefaultMutations","registerDefaultQueries","extractLanguageContext","createContext","getGqlFields","getLambdaData","addFieldsMiddleware","resolve","source","args","context","info","enhancedContext","fields","addMissingFields","tc","Object","entries","forEach","fieldName","fieldConfig","hasField","setField","applyMiddleware","middlewares","length","keys","getFields","hasResolver","middleware","wrapResolver","error","console","warn","message","createGraphqlHandler","options","composer","initialContext","shouldIncludeDefaults","includeDefaults","middlewareList","Array","isArray","extraQueries","Query","extraMutations","Mutation","schema","buildSchema","event","updatedContext","languageContext","contextWithLanguage","config","get","request","parseData","body","query","JSON","stringify","data","errors","headers","statusCode","result","Promise","contextValue","variableValues","variables","graphqlError","errorMessage","Error","errorStack","stack","undefined","process","env","NODE_ENV","err"],"mappings":"AAAA,SAAQA,OAAO,QAAO,UAAU;AAChC,SAAQC,cAAc,QAAO,kBAAkB;AAG/C,SAAQC,MAAM,QAAO,eAAe;AACpC,SAAQC,wBAAwB,QAAO,wBAAwB;AAC/D,SAAQC,sBAAsB,QAAO,sBAAsB;AAC3D,SAAQC,sBAAsB,QAAO,2BAA2B;AAChE,SAAQC,aAAa,EAAEC,YAAY,EAAEC,aAAa,QAAwB,oBAAoB;AAyB9F,MAAMC,sBAAiD,CAACC,SAASC,QAAQC,MAAMC,SAAqBC;IAClG,MAAMC,kBAAkB;QACtB,GAAGF,OAAO;QACVG,QAAQT,aAAaO;IACvB;IAEA,OAAOJ,QAAQC,QAAQC,MAAMG,iBAAiBD;AAChD;AAEA,MAAMG,mBAAmB,CAACC,IAA0CF;IAClEG,OAAOC,OAAO,CAACJ,QAAQK,OAAO,CAAC,CAAC,CAACC,WAAWC,YAAY;QACtD,IAAG,CAACL,GAAGM,QAAQ,CAACF,YAAY;YAC1BJ,GAAGO,QAAQ,CAACH,WAAWC;QACzB;IACF;AACF;AAEA,MAAMG,kBAAkB,CACtBR,IACAS;IAEA,IAAGA,YAAYC,MAAM,KAAK,GAAG;QAC3B;IACF;IAEAT,OAAOU,IAAI,CAACX,GAAGY,SAAS,IAAIT,OAAO,CAAC,CAACC;QACnC,IAAI;YACF,IAAGJ,GAAGa,WAAW,CAACT,YAAY;gBAC5BK,YAAYN,OAAO,CAAC,CAACW,aAAed,GAAGe,YAAY,CAACX,WAAWU;YACjE;QACF,EAAE,OAAME,OAAY;YAClBC,QAAQC,IAAI,CAAC,CAAC,eAAe,EAAEd,UAAU,kBAAkB,CAAC,EAAEY,MAAMG,OAAO;QAC7E;IACF;AACF;AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,MAAMC,uBAAuB,CAACC,UAAiC,CAAC,CAAC;IACtE,MAAMC,WAAWD,QAAQC,QAAQ,IAAIvC;IACrC,MAAMwC,iBAAkBF,QAAQ1B,OAAO,IAAI,CAAC;IAC5C,MAAM6B,wBAAwBH,QAAQI,eAAe,KAAK;IAC1D,MAAMC,iBAAiB;QACrBnC;WACIoC,MAAMC,OAAO,CAACP,QAAQP,UAAU,IAChCO,QAAQP,UAAU,GAClBO,QAAQP,UAAU,GAAG;YAACO,QAAQP,UAAU;SAAC,GAAG,EAAE;KACnD;IAED,IAAGU,uBAAuB;QACxBtC,uBAAuBoC;QACvBrC,yBAAyBqC;IAC3B;IAEA,IAAGD,QAAQQ,YAAY,EAAE;QACvB9B,iBAAiBuB,SAASQ,KAAK,EAAET,QAAQQ,YAAY;IACvD;IAEA,IAAGR,QAAQU,cAAc,EAAE;QACzBhC,iBAAiBuB,SAASU,QAAQ,EAAEX,QAAQU,cAAc;IAC5D;IAEAvB,gBAAgBc,SAASQ,KAAK,EAAEJ;IAChClB,gBAAgBc,SAASU,QAAQ,EAAEN;IAEnC,MAAMO,SAASX,SAASY,WAAW;IAEnC,OAAO,OAAOC;QACZ,IAAI;YACF,MAAMC,iBAA6B,MAAMhD,cAAcmC,gBAAgBY;YACvE,MAAME,kBAAkBlD,uBAAuBgD;YAE/C,MAAMG,sBAAsB;gBAC1BC,QAAQvD,OAAOwD,GAAG;gBAClB,GAAGJ,cAAc;gBACjBC;gBACAI,SAASN;YACX;YAEA,MAAMO,YAAYpD,cAAc6C;YAChC,MAAM,EAACQ,IAAI,EAAC,GAAGD;YAEf,IAAG,CAACC,MAAMC,OAAO;gBACf3B,QAAQC,IAAI,CAAC;gBAEb,OAAO;oBACLyB,MAAME,KAAKC,SAAS,CAAC;wBACnBC,MAAM;wBACNC,QAAQ;4BAAC;gCACP7B,SAAS;4BACX;yBAAE;oBACJ;oBACA8B,SAAS;wBACP,gBAAgB;oBAClB;oBACAC,YAAY;gBACd;YACF;YAEA,IAAI;gBACF,MAAMC,SAAS,MAAMC,QAAQ5D,OAAO,CAACV,QAAQ;oBAC3CuE,cAAcf;oBACdL;oBACAxC,QAAQkD,KAAKC,KAAK;oBAClBU,gBAAgBX,KAAKY,SAAS;gBAChC;gBAEA,IAAGJ,OAAOH,MAAM,IAAIG,OAAOH,MAAM,CAACtC,MAAM,GAAG,GAAG;oBAC5CO,QAAQD,KAAK,CAAC,6BAA6BmC,OAAOH,MAAM;gBAC1D;gBAEA,OAAO;oBACLL,MAAME,KAAKC,SAAS,CAACK;oBACrBF,SAAS;wBACP,gBAAgB;oBAClB;oBACAC,YAAY;gBACd;YACF,EAAE,OAAMM,cAAuB;gBAC7BvC,QAAQD,KAAK,CAAC,mCAAmCwC;gBAEjD,MAAMC,eAAeD,wBAAwBE,QAAQF,aAAarC,OAAO,GAAG;gBAC5E,MAAMwC,aAAaH,wBAAwBE,QAAQF,aAAaI,KAAK,GAAGC;gBAExE,OAAO;oBACLlB,MAAME,KAAKC,SAAS,CAAC;wBACnBC,MAAM;wBACNC,QAAQ;4BAAC;gCACP7B,SAASsC;gCACTG,OAAOE,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAAgBL,aAAaE;4BAC/D;yBAAE;oBACJ;oBACAZ,SAAS;wBACP,gBAAgB;oBAClB;oBACAC,YAAY;gBACd;YACF;QACF,EAAE,OAAMe,KAAc;YACpBhD,QAAQD,KAAK,CAAC,kBAAkB;gBAC9BG,SAAS8C,eAAeP,QAAQO,IAAI9C,OAAO,GAAG;gBAC9CyC,OAAOK,eAAeP,QAAQO,IAAIL,KAAK,GAAGC;YAC5C;YAEA,MAAMJ,eAAeQ,eAAeP,QAAQO,IAAI9C,OAAO,GAAG;YAC1D,MAAMwC,aAAaM,eAAeP,QAAQO,IAAIL,KAAK,GAAGC;YAEtD,OAAO;gBACLlB,MAAME,KAAKC,SAAS,CAAC;oBACnBC,MAAM;oBACNC,QAAQ;wBAAC;4BACP7B,SAASsC;4BACTG,OAAOE,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAAgBL,aAAaE;wBAC/D;qBAAE;gBACJ;gBACAZ,SAAS;oBACP,gBAAgB;gBAClB;gBACAC,YAAY;YACd;QACF;IACF;AACF,EAAE"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/.codex-worktrees/reaktor-phantaze-chat/packages/reaktor/src/handlers/graphqlHandler.ts"],"sourcesContent":["import {graphql} from 'graphql';\nimport {schemaComposer} from 'graphql-compose';\nimport type {ObjectTypeComposer, SchemaComposer} from 'graphql-compose';\n\nimport {Config} from '../config.js';\nimport {registerDefaultMutations} from '../mutations/index.js';\nimport {registerDefaultQueries} from '../queries/index.js';\nimport {extractLanguageContext} from '../utils/contextUtils.js';\nimport {createContext, getGqlFields, getLambdaData, type LambdaData} from '../utils/index.js';\n\nimport type {APIGatewayProxyEventV2} from 'aws-lambda';\nimport type {ExecutionResult} from 'graphql';\nimport type {ApiContext} from '../types/auth.types.js';\n\nexport type GraphqlResolverMiddleware = (\n  resolve: (source: unknown, args: unknown, context: ApiContext, info: unknown) => Promise<unknown> | unknown,\n  source: unknown,\n  args: unknown,\n  context: ApiContext,\n  info: unknown\n) => Promise<unknown> | unknown;\n\ntype GraphqlFieldConfigMap = Record<string, unknown>;\n\nexport type GraphqlHandlerOptions = {\n  composer?: SchemaComposer<any>;\n  context?: ApiContext;\n  extraMutations?: GraphqlFieldConfigMap;\n  extraQueries?: GraphqlFieldConfigMap;\n  includeDefaults?: boolean;\n  middleware?: GraphqlResolverMiddleware | GraphqlResolverMiddleware[];\n};\n\nconst addFieldsMiddleware: GraphqlResolverMiddleware = (resolve, source, args, context: ApiContext, info) => {\n  const enhancedContext = {\n    ...context,\n    fields: getGqlFields(info)\n  };\n\n  return resolve(source, args, enhancedContext, info);\n};\n\nconst addMissingFields = (tc: ObjectTypeComposer<unknown, unknown>, fields: GraphqlFieldConfigMap): void => {\n  Object.entries(fields).forEach(([fieldName, fieldConfig]) => {\n    if(!tc.hasField(fieldName)) {\n      tc.setField(fieldName, fieldConfig as any);\n    }\n  });\n};\n\nconst applyMiddleware = (\n  tc: ObjectTypeComposer<unknown, unknown>,\n  middlewares: GraphqlResolverMiddleware[]\n): void => {\n  if(middlewares.length === 0) {\n    return;\n  }\n\n  Object.keys(tc.getFields()).forEach((fieldName) => {\n    try {\n      if(tc.hasResolver(fieldName)) {\n        middlewares.forEach((middleware) => tc.wrapResolver(fieldName, middleware as any));\n      }\n    } catch(error: any) {\n      console.warn(`Skipping field ${fieldName} - not a resolver:`, error.message);\n    }\n  });\n};\n\n/**\n * Creates an API Gateway-compatible GraphQL handler for Reaktor.\n *\n * Request expectations:\n * - `event.body.query` is a GraphQL operation string.\n * - `event.body.variables` is optional operation variables.\n *\n * Runtime behavior:\n * - Builds per-request context (`config`, auth/session context, language context, request).\n * - Applies resolver middleware to expose selected GraphQL fields on `context.fields`.\n * - Executes operation using the composed schema.\n *\n * Response contract:\n * - Returns `{statusCode, headers, body}` with JSON body.\n * - Returns `200` for GraphQL responses (including GraphQL errors in `errors`).\n * - Returns `500` only for handler/runtime failures.\n *\n * See README: \"GraphQL Handler Usage\" for integration examples.\n */\nexport const createGraphqlHandler = (options: GraphqlHandlerOptions = {}) => {\n  const composer = options.composer || schemaComposer;\n  const initialContext = (options.context || {}) as ApiContext;\n  const shouldIncludeDefaults = options.includeDefaults !== false;\n  const middlewareList = [\n    addFieldsMiddleware,\n    ...(Array.isArray(options.middleware)\n      ? options.middleware\n      : options.middleware ? [options.middleware] : [])\n  ];\n\n  if(shouldIncludeDefaults) {\n    registerDefaultQueries(composer);\n    registerDefaultMutations(composer);\n  }\n\n  if(options.extraQueries) {\n    addMissingFields(composer.Query, options.extraQueries);\n  }\n\n  if(options.extraMutations) {\n    addMissingFields(composer.Mutation, options.extraMutations);\n  }\n\n  applyMiddleware(composer.Query, middlewareList);\n  applyMiddleware(composer.Mutation, middlewareList);\n\n  const schema = composer.buildSchema();\n\n  return async (event: APIGatewayProxyEventV2): Promise<ExecutionResult | Record<string, unknown>> => {\n    try {\n      const updatedContext: ApiContext = await createContext(initialContext, event);\n      const languageContext = extractLanguageContext(event);\n\n      const contextWithLanguage = {\n        config: Config.get(),\n        ...updatedContext,\n        languageContext,\n        request: event\n      };\n\n      const parseData = getLambdaData(event as unknown as LambdaData);\n      const {body} = parseData;\n\n      if(!body?.query) {\n        console.warn('No GraphQL query found in request body');\n\n        return {\n          body: JSON.stringify({\n            data: null,\n            errors: [{\n              message: 'No GraphQL query found in request body'\n            }]\n          }),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 200\n        };\n      }\n\n      try {\n        const result = await Promise.resolve(graphql({\n          contextValue: contextWithLanguage,\n          schema,\n          source: body.query,\n          variableValues: body.variables\n        }));\n\n        if(result.errors && result.errors.length > 0) {\n          console.error('GraphQL execution errors:', result.errors);\n        }\n\n        return {\n          body: JSON.stringify(result),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 200\n        };\n      } catch(graphqlError: unknown) {\n        console.error('Error during GraphQL execution:', graphqlError);\n\n        const errorMessage = graphqlError instanceof Error ? graphqlError.message : 'GraphQL execution error';\n        const errorStack = graphqlError instanceof Error ? graphqlError.stack : undefined;\n\n        return {\n          body: JSON.stringify({\n            data: null,\n            errors: [{\n              message: errorMessage,\n              stack: process.env.NODE_ENV === 'development' ? errorStack : undefined\n            }]\n          }),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 500\n        };\n      }\n    } catch(err: unknown) {\n      console.error('Handler error:', {\n        message: err instanceof Error ? err.message : 'Unknown error',\n        stack: err instanceof Error ? err.stack : undefined\n      });\n\n      const errorMessage = err instanceof Error ? err.message : 'An unknown error occurred in the handler';\n      const errorStack = err instanceof Error ? err.stack : undefined;\n\n      return {\n        body: JSON.stringify({\n          data: null,\n          errors: [{\n            message: errorMessage,\n            stack: process.env.NODE_ENV === 'development' ? errorStack : undefined\n          }]\n        }),\n        headers: {\n          'Content-Type': 'application/json'\n        },\n        statusCode: 500\n      };\n    }\n  };\n};\n"],"names":["graphql","schemaComposer","Config","registerDefaultMutations","registerDefaultQueries","extractLanguageContext","createContext","getGqlFields","getLambdaData","addFieldsMiddleware","resolve","source","args","context","info","enhancedContext","fields","addMissingFields","tc","Object","entries","forEach","fieldName","fieldConfig","hasField","setField","applyMiddleware","middlewares","length","keys","getFields","hasResolver","middleware","wrapResolver","error","console","warn","message","createGraphqlHandler","options","composer","initialContext","shouldIncludeDefaults","includeDefaults","middlewareList","Array","isArray","extraQueries","Query","extraMutations","Mutation","schema","buildSchema","event","updatedContext","languageContext","contextWithLanguage","config","get","request","parseData","body","query","JSON","stringify","data","errors","headers","statusCode","result","Promise","contextValue","variableValues","variables","graphqlError","errorMessage","Error","errorStack","stack","undefined","process","env","NODE_ENV","err"],"mappings":"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"}

package/lib/index.d.ts

@@ -9,6 +9,7 @@ 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 { COLLECTIONS, ConnectionType as ConnectionTypes, DEFAULT_DOCUMENT_COLLECTIONS, DEFAULT_EDGE_COLLECTIONS, EDGES, PrivacyLevel, ReactionType } from './constants/collections.js';
 export type { ConnectionTypeType as ConnectionTypeValue, PrivacyLevelType, ReactionTypeType } from './constants/collections.js';
 export * from './handlers/graphqlHandler.js';

package/lib/index.js

@@ -7,6 +7,7 @@ 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 { COLLECTIONS, ConnectionType as ConnectionTypes, DEFAULT_DOCUMENT_COLLECTIONS, DEFAULT_EDGE_COLLECTIONS, EDGES, PrivacyLevel, ReactionType } from './constants/collections.js';
 export * from './handlers/graphqlHandler.js';
 export * from './lambdas/authorizer.js';
@@ -21,4 +22,4 @@ export * from './videoProcessing.js';
 export const reaktorSchema = ''; // printSchema(schemaComposer.buildSchema());
 export const reaktorResolvers = schemaComposer.getResolveMethods();
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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