@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/actions/websocketActions/websocketActions.d.ts

@@ -4,28 +4,27 @@
  */
 import Sockette from 'sockette';
 import type { FluxFramework } from '@nlabs/arkhamjs';
-interface WebSocketMessage {
-    type: string;
-    payload?: Record<string, unknown>;
+import type { NotificationType } from '../../stores/notificationStore.js';
+export interface WebSocketMessage {
+    readonly action: string;
+    readonly data?: Record<string, unknown>;
 }
 export interface WebsocketActions {
-    wsSend: (message: WebSocketMessage) => void;
-    onReceive: (event: any) => void;
-    onClose: (event: any) => void;
-    onError: (event: any) => void;
-    onOpen: (event: any) => void;
-    wsInit: (token?: string) => Sockette | null;
+    readonly sendNotification: (notification: NotificationType) => NotificationType | null;
+    readonly sendTyping: (conversationId: string, isTyping: boolean, options?: {
+        readonly name?: string;
+        readonly personaId?: string;
+        readonly userId?: string;
+        readonly username?: string;
+        readonly users?: Array<Record<string, unknown>>;
+    }) => void;
+    readonly wsSend: (message: WebSocketMessage) => void;
+    readonly wsClose: () => void;
+    readonly onReceive: (event: any) => void;
+    readonly onClose: (event: any) => void;
+    readonly onError: (event: any) => void;
+    readonly onOpen: (event: any) => void;
+    readonly wsInit: (token?: string, personaId?: string) => Sockette | null;
 }
-/**
- * Factory function to create WebsocketActions.
- *
- * @example
- * // Basic usage
- * const websocketActions = createWebsocketActions(flux);
- *
- * @example
- * // Initialize websocket connection
- * const ws = websocketActions.wsInit(token);
- */
 export declare const createWebsocketActions: (flux: FluxFramework) => WebsocketActions;
-export {};
+//# sourceMappingURL=websocketActions.d.ts.map

package/lib/actions/websocketActions/websocketActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocketActions.d.ts","sourceRoot":"","sources":["../../../src/actions/websocketActions/websocketActions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,QAAQ,MAAM,UAAU,CAAC;AAQhC,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,mCAAmC,CAAC;AAExE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,CAAC,YAAY,EAAE,gBAAgB,KAAK,gBAAgB,GAAG,IAAI,CAAC;IACvF,QAAQ,CAAC,UAAU,EAAE,CACnB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,OAAO,EACjB,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;KACjD,KACE,IAAI,CAAC;IACV,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,QAAQ,GAAG,IAAI,CAAC;CAC1E;AAWD,eAAO,MAAM,sBAAsB,GAAI,MAAM,aAAa,KAAG,gBAwY5D,CAAC"}

package/lib/actions/websocketActions/websocketActions.js

@@ -1,2 +1,377 @@
-import g from"sockette";import{Config as l}from"../../config";import{WEBSOCKET_CONSTANTS as a}from"../../stores/websocketStore";const y=n=>{let o;const k=e=>{o&&o.json(e)},r=e=>{const{data:t,timeStamp:s}=e,c=JSON.parse(t);n.dispatch({data:c,timestamp:s,type:a.MESSAGE})},i=e=>{const{timeStamp:t}=e;n.dispatch({timestamp:t,type:a.CLOSE})},m=e=>{const{timeStamp:t}=e;n.dispatch({timestamp:t,type:a.ERROR})},p=e=>{const{timeStamp:t}=e;n.dispatch({timestamp:t,type:a.OPEN})};return{wsSend:k,onReceive:r,onClose:i,onError:m,onOpen:p,wsInit:e=>{if(o)return o;const t=l.get("app.urls.websocket"),s=e||n.getState("user.session.token");if(s){const c=`${t}?token=${s}`;return o=new g(c,{maxAttempts:5,onclose:i,onerror:m,onmessage:r,onopen:p,timeout:6e4}),o}return null}}};export{y as createWebsocketActions};
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import Sockette from 'sockette';
+import { MESSAGE_CONSTANTS } from '../../stores/messageStore.js';
+import { NOTIFICATION_CONSTANTS } from '../../stores/notificationStore.js';
+import { VIDEO_CONSTANTS } from '../../stores/videoStore.js';
+import { WEBSOCKET_CONSTANTS } from '../../stores/websocketStore.js';
+import { getConfigFromFlux } from '../../utils/configUtils.js';
+const WEBSOCKET_CLIENT_ID_KEY = 'metropolis.websocket.clientId';
+const createWebsocketClientId = ()=>{
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return `ws-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+};
+export const createWebsocketActions = (flux)=>{
+    let ws = null;
+    let activeClientId = '';
+    let activeToken = '';
+    let activePersonaId = '';
+    let socketIsOpen = false;
+    let socketIsConnecting = false;
+    let closeRequested = false;
+    const pendingMessages = [];
+    const typingTimeouts = new Map();
+    const createNotificationId = ()=>`notification-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    const getTypingIdentity = (typing)=>String(typing?.personaId || typing?.userId || '');
+    const getClientId = ()=>{
+        if (activeClientId) {
+            return activeClientId;
+        }
+        if (typeof window === 'undefined') {
+            activeClientId = createWebsocketClientId();
+            return activeClientId;
+        }
+        try {
+            const storedClientId = window.sessionStorage.getItem(WEBSOCKET_CLIENT_ID_KEY);
+            if (storedClientId) {
+                activeClientId = storedClientId;
+                return activeClientId;
+            }
+            activeClientId = createWebsocketClientId();
+            window.sessionStorage.setItem(WEBSOCKET_CLIENT_ID_KEY, activeClientId);
+            return activeClientId;
+        } catch (error) {
+            activeClientId = createWebsocketClientId();
+            return activeClientId;
+        }
+    };
+    const sendRegistration = ()=>{
+        if (!ws || !socketIsOpen) {
+            return;
+        }
+        ws.json({
+            action: 'websocketConnect',
+            data: {
+                clientId: getClientId(),
+                personaId: String(activePersonaId || flux.getState('user.session.personaId') || ''),
+                token: String(activeToken || flux.getState('user.session.token') || ''),
+                userId: String(flux.getState('user.session.userId') || '')
+            }
+        });
+    };
+    const flushPendingMessages = ()=>{
+        if (!ws || !pendingMessages.length) {
+            return;
+        }
+        const queuedMessages = pendingMessages.splice(0, pendingMessages.length);
+        queuedMessages.forEach((message)=>{
+            ws?.json(message);
+        });
+    };
+    const clearTypingTimeout = (conversationId, typingId)=>{
+        const typingKey = `${conversationId}:${typingId}`;
+        const timeoutId = typingTimeouts.get(typingKey);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            typingTimeouts.delete(typingKey);
+        }
+    };
+    const scheduleTypingClear = (typing)=>{
+        const conversationId = String(typing?.conversationId || '');
+        const typingId = getTypingIdentity(typing);
+        if (!conversationId || !typingId) {
+            return;
+        }
+        clearTypingTimeout(conversationId, typingId);
+        const timeoutId = setTimeout(()=>{
+            flux.dispatch({
+                type: MESSAGE_CONSTANTS.TYPING_STATUS_UPDATE,
+                typing: {
+                    conversationId,
+                    isTyping: false,
+                    personaId: String(typing?.personaId || ''),
+                    userId: String(typing?.userId || '')
+                }
+            });
+            typingTimeouts.delete(`${conversationId}:${typingId}`);
+        }, 60000);
+        typingTimeouts.set(`${conversationId}:${typingId}`, timeoutId);
+    };
+    const wsSend = (message)=>{
+        console.log('websockets::onOpen::message', {
+            ws,
+            message
+        });
+        if (ws && socketIsOpen) {
+            ws.json(message);
+            return;
+        }
+        pendingMessages.push(message);
+        const sessionToken = String(activeToken || flux.getState('user.session.token') || '');
+        if (sessionToken && !ws && !socketIsConnecting) {
+            wsInit(sessionToken);
+        }
+    };
+    const wsClose = ()=>{
+        for (const timeoutId of typingTimeouts.values()){
+            clearTimeout(timeoutId);
+        }
+        typingTimeouts.clear();
+        pendingMessages.length = 0;
+        socketIsOpen = false;
+        socketIsConnecting = false;
+        if (ws) {
+            const previousSocket = ws;
+            closeRequested = true;
+            ws = null;
+            activeClientId = '';
+            activePersonaId = '';
+            activeToken = '';
+            previousSocket.close(1000, 'metropolis_close');
+        }
+    };
+    const sendTyping = (conversationId, isTyping, options = {})=>{
+        if (!conversationId) {
+            return;
+        }
+        wsSend({
+            action: 'messageTyping',
+            data: {
+                conversationId,
+                isTyping,
+                name: String(options?.name || ''),
+                personaId: String(options?.personaId || ''),
+                userId: String(options?.userId || ''),
+                username: String(options?.username || ''),
+                users: Array.isArray(options?.users) ? options.users : []
+            }
+        });
+    };
+    const sendNotification = (notification)=>{
+        if (!notification || typeof notification !== 'object') {
+            return null;
+        }
+        const nextNotification = {
+            ...notification,
+            added: Number(notification?.added || Date.now()),
+            modified: Number(notification?.modified || Date.now()),
+            notificationId: String(notification?.notificationId || createNotificationId())
+        };
+        flux.dispatch({
+            notification: nextNotification,
+            type: NOTIFICATION_CONSTANTS.ADD_ITEM_SUCCESS
+        });
+        wsSend({
+            action: 'notification.created',
+            data: {
+                notification: nextNotification
+            }
+        });
+        return nextNotification;
+    };
+    const onReceive = (event)=>{
+        const { data: eventData, timeStamp: timestamp } = event;
+        const rawData = typeof eventData === 'string' ? eventData.trim() : '';
+        if (!rawData) {
+            return;
+        }
+        let data;
+        try {
+            data = JSON.parse(rawData);
+        } catch (parseError) {
+            console.warn('websockets::onReceive::invalidJson', rawData, parseError);
+            return;
+        }
+        console.log('websockets::onRecieve::data', data);
+        flux.dispatch({
+            data,
+            timestamp,
+            type: WEBSOCKET_CONSTANTS.MESSAGE
+        });
+        if (String(data?.action || '') === 'message.created') {
+            const message = data?.data?.message;
+            const conversation = data?.data?.conversation || (message?.conversationId ? {
+                added: Number(message?.added || Date.now()),
+                content: String(message?.content || ''),
+                conversationId: String(message?.conversationId || ''),
+                modified: Number(message?.modified || message?.added || Date.now())
+            } : undefined);
+            if (message?.conversationId) {
+                if (conversation) {
+                    flux.dispatch({
+                        conversation,
+                        type: MESSAGE_CONSTANTS.GET_CONVO_LIST_SUCCESS
+                    });
+                }
+                flux.dispatch({
+                    message,
+                    type: MESSAGE_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+                const typingPersonaId = String(message?.user?.personaId || '');
+                const typingUserId = String(message?.userId || '');
+                const typingId = typingPersonaId || typingUserId;
+                if (typingId) {
+                    clearTypingTimeout(String(message.conversationId || ''), typingId);
+                    flux.dispatch({
+                        type: MESSAGE_CONSTANTS.TYPING_STATUS_UPDATE,
+                        typing: {
+                            conversationId: String(message.conversationId || ''),
+                            isTyping: false,
+                            personaId: typingPersonaId,
+                            userId: typingUserId
+                        }
+                    });
+                }
+            }
+        }
+        if (String(data?.action || '') === 'message.typing') {
+            const typing = data?.data?.typing;
+            if (typing?.conversationId && getTypingIdentity(typing)) {
+                flux.dispatch({
+                    type: MESSAGE_CONSTANTS.TYPING_STATUS_UPDATE,
+                    typing
+                });
+                if (typing?.isTyping) {
+                    scheduleTypingClear(typing);
+                } else {
+                    clearTypingTimeout(String(typing.conversationId || ''), getTypingIdentity(typing));
+                }
+            }
+        }
+        if (String(data?.action || '') === 'notification.created') {
+            const notification = data?.data?.notification;
+            if (notification && typeof notification === 'object') {
+                flux.dispatch({
+                    notification: notification,
+                    type: NOTIFICATION_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            }
+        }
+        if (String(data?.action || '') === 'video.processing.completed') {
+            const video = data?.data?.video;
+            if (video && typeof video === 'object') {
+                flux.dispatch({
+                    type: VIDEO_CONSTANTS.UPDATE_ITEM_SUCCESS,
+                    video
+                });
+                flux.dispatch({
+                    type: VIDEO_CONSTANTS.PROCESSING_COMPLETE,
+                    video
+                });
+            }
+        }
+    };
+    const onClose = (event)=>{
+        console.log('websockets::onOpen::message', event);
+        const { timeStamp: timestamp } = event;
+        socketIsOpen = false;
+        socketIsConnecting = Boolean(activeToken) && !closeRequested;
+        closeRequested = false;
+        flux.dispatch({
+            timestamp,
+            type: WEBSOCKET_CONSTANTS.CLOSE
+        });
+    };
+    const onError = (event)=>{
+        const { timeStamp: timestamp } = event;
+        socketIsOpen = false;
+        flux.dispatch({
+            timestamp,
+            type: WEBSOCKET_CONSTANTS.ERROR
+        });
+    };
+    const onOpen = (event)=>{
+        console.log('websockets::onOpen::event', event);
+        const { timeStamp: timestamp } = event;
+        socketIsOpen = true;
+        socketIsConnecting = false;
+        closeRequested = false;
+        sendRegistration();
+        flushPendingMessages();
+        flux.dispatch({
+            timestamp,
+            type: WEBSOCKET_CONSTANTS.OPEN
+        });
+    };
+    const wsInit = (token, personaId)=>{
+        const config = getConfigFromFlux(flux);
+        const websocketUrl = config.app?.urls?.websocket || '';
+        const sessionClientId = getClientId();
+        const sessionToken = String(token || flux.getState('user.session.token') || '');
+        const sessionPersonaId = String(personaId || flux.getState('user.session.personaId') || '');
+        if (!sessionToken || !websocketUrl) {
+            console.log('websockets::wsInit::skipped', {
+                hasPersonaId: Boolean(sessionPersonaId),
+                hasToken: Boolean(sessionToken),
+                websocketUrl
+            });
+            return null;
+        }
+        if (ws && activeToken === sessionToken && activePersonaId === sessionPersonaId && activeClientId === sessionClientId) {
+            console.log('websockets::wsInit::reuse', {
+                activeClientId,
+                activePersonaId,
+                activeToken,
+                sessionClientId,
+                sessionPersonaId
+            });
+            return ws;
+        }
+        if (ws && (activeToken !== sessionToken || activePersonaId !== sessionPersonaId || activeClientId !== sessionClientId)) {
+            console.log('websockets::wsInit::reconnect', {
+                activeClientId,
+                activePersonaId,
+                activeToken,
+                sessionClientId,
+                sessionPersonaId
+            });
+            wsClose();
+        }
+        activeClientId = sessionClientId;
+        activeToken = sessionToken;
+        activePersonaId = sessionPersonaId;
+        socketIsOpen = false;
+        socketIsConnecting = true;
+        closeRequested = false;
+        const websocketParams = new URLSearchParams({
+            token: sessionToken
+        });
+        if (sessionPersonaId) {
+            websocketParams.set('personaId', sessionPersonaId);
+        }
+        if (sessionClientId) {
+            websocketParams.set('clientId', sessionClientId);
+        }
+        console.log('websockets::wsInit::connect', {
+            sessionClientId,
+            sessionPersonaId,
+            sessionToken,
+            url: `${websocketUrl}?${websocketParams.toString()}`
+        });
+        ws = new Sockette(`${websocketUrl}?${websocketParams.toString()}`, {
+            maxAttempts: 5,
+            onclose: onClose,
+            onerror: onError,
+            onmessage: onReceive,
+            onopen: onOpen,
+            timeout: 60000
+        });
+        return ws;
+    };
+    return {
+        onClose,
+        onError,
+        onOpen,
+        onReceive,
+        sendNotification,
+        sendTyping,
+        wsClose,
+        wsInit,
+        wsSend
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/websocketActions/websocketActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport Sockette from 'sockette';\n\nimport {MESSAGE_CONSTANTS} from '../../stores/messageStore.js';\nimport {NOTIFICATION_CONSTANTS} from '../../stores/notificationStore.js';\nimport {VIDEO_CONSTANTS} from '../../stores/videoStore.js';\nimport {WEBSOCKET_CONSTANTS} from '../../stores/websocketStore.js';\nimport {getConfigFromFlux} from '../../utils/configUtils.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {MessageTypingStatus} from '../../stores/messageStore.js';\nimport type {NotificationType} from '../../stores/notificationStore.js';\n\nexport interface WebSocketMessage {\n  readonly action: string;\n  readonly data?: Record<string, unknown>;\n}\n\nexport interface WebsocketActions {\n  readonly sendNotification: (notification: NotificationType) => NotificationType | null;\n  readonly sendTyping: (\n    conversationId: string,\n    isTyping: boolean,\n    options?: {\n      readonly name?: string;\n      readonly personaId?: string;\n      readonly userId?: string;\n      readonly username?: string;\n      readonly users?: Array<Record<string, unknown>>;\n    }\n  ) => void;\n  readonly wsSend: (message: WebSocketMessage) => void;\n  readonly wsClose: () => void;\n  readonly onReceive: (event: any) => void;\n  readonly onClose: (event: any) => void;\n  readonly onError: (event: any) => void;\n  readonly onOpen: (event: any) => void;\n  readonly wsInit: (token?: string, personaId?: string) => Sockette | null;\n}\n\nconst WEBSOCKET_CLIENT_ID_KEY = 'metropolis.websocket.clientId';\nconst createWebsocketClientId = (): string => {\n  if(typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {\n    return crypto.randomUUID();\n  }\n\n  return `ws-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;\n};\n\nexport const createWebsocketActions = (flux: FluxFramework): WebsocketActions => {\n  let ws: Sockette | null = null;\n  let activeClientId = '';\n  let activeToken = '';\n  let activePersonaId = '';\n  let socketIsOpen = false;\n  let socketIsConnecting = false;\n  let closeRequested = false;\n  const pendingMessages: WebSocketMessage[] = [];\n  const typingTimeouts = new Map<string, ReturnType<typeof setTimeout>>();\n  const createNotificationId = () => `notification-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;\n  const getTypingIdentity = (typing?: MessageTypingStatus | Record<string, unknown>) => String((typing as any)?.personaId || (typing as any)?.userId || '');\n  const getClientId = (): string => {\n    if(activeClientId) {\n      return activeClientId;\n    }\n\n    if(typeof window === 'undefined') {\n      activeClientId = createWebsocketClientId();\n      return activeClientId;\n    }\n\n    try {\n      const storedClientId = window.sessionStorage.getItem(WEBSOCKET_CLIENT_ID_KEY);\n\n      if(storedClientId) {\n        activeClientId = storedClientId;\n        return activeClientId;\n      }\n\n      activeClientId = createWebsocketClientId();\n      window.sessionStorage.setItem(WEBSOCKET_CLIENT_ID_KEY, activeClientId);\n      return activeClientId;\n    } catch(error) {\n      activeClientId = createWebsocketClientId();\n      return activeClientId;\n    }\n  };\n  const sendRegistration = () => {\n    if(!ws || !socketIsOpen) {\n      return;\n    }\n\n    ws.json({\n      action: 'websocketConnect',\n      data: {\n        clientId: getClientId(),\n        personaId: String(activePersonaId || flux.getState('user.session.personaId') || ''),\n        token: String(activeToken || flux.getState('user.session.token') || ''),\n        userId: String(flux.getState('user.session.userId') || '')\n      }\n    });\n  };\n\n  const flushPendingMessages = () => {\n    if(!ws || !pendingMessages.length) {\n      return;\n    }\n\n    const queuedMessages = pendingMessages.splice(0, pendingMessages.length);\n\n    queuedMessages.forEach((message) => {\n      ws?.json(message);\n    });\n  };\n\n  const clearTypingTimeout = (conversationId: string, typingId: string) => {\n    const typingKey = `${conversationId}:${typingId}`;\n    const timeoutId = typingTimeouts.get(typingKey);\n\n    if(timeoutId) {\n      clearTimeout(timeoutId);\n      typingTimeouts.delete(typingKey);\n    }\n  };\n\n  const scheduleTypingClear = (typing: MessageTypingStatus) => {\n    const conversationId = String(typing?.conversationId || '');\n    const typingId = getTypingIdentity(typing);\n\n    if(!conversationId || !typingId) {\n      return;\n    }\n\n    clearTypingTimeout(conversationId, typingId);\n\n    const timeoutId = setTimeout(() => {\n      flux.dispatch({\n        type: MESSAGE_CONSTANTS.TYPING_STATUS_UPDATE,\n        typing: {\n          conversationId,\n          isTyping: false,\n          personaId: String(typing?.personaId || ''),\n          userId: String(typing?.userId || '')\n        }\n      });\n      typingTimeouts.delete(`${conversationId}:${typingId}`);\n    }, 60000);\n\n    typingTimeouts.set(`${conversationId}:${typingId}`, timeoutId);\n  };\n\n  const wsSend = (message: WebSocketMessage) => {\n    console.log('websockets::onOpen::message', {ws, message});\n    if(ws && socketIsOpen) {\n      ws.json(message);\n      return;\n    }\n\n    pendingMessages.push(message);\n\n    const sessionToken = String(activeToken || flux.getState('user.session.token') || '');\n\n    if(sessionToken && !ws && !socketIsConnecting) {\n      wsInit(sessionToken);\n    }\n  };\n\n  const wsClose = () => {\n    for(const timeoutId of typingTimeouts.values()) {\n      clearTimeout(timeoutId);\n    }\n    typingTimeouts.clear();\n    pendingMessages.length = 0;\n    socketIsOpen = false;\n    socketIsConnecting = false;\n\n    if(ws) {\n      const previousSocket = ws;\n\n      closeRequested = true;\n      ws = null;\n      activeClientId = '';\n      activePersonaId = '';\n      activeToken = '';\n      previousSocket.close(1000, 'metropolis_close');\n    }\n  };\n\n  const sendTyping = (\n    conversationId: string,\n    isTyping: boolean,\n    options: {\n      readonly name?: string;\n      readonly personaId?: string;\n      readonly userId?: string;\n      readonly username?: string;\n      readonly users?: Array<Record<string, unknown>>;\n    } = {}\n  ) => {\n    if(!conversationId) {\n      return;\n    }\n\n    wsSend({\n      action: 'messageTyping',\n      data: {\n        conversationId,\n        isTyping,\n        name: String(options?.name || ''),\n        personaId: String(options?.personaId || ''),\n        userId: String(options?.userId || ''),\n        username: String(options?.username || ''),\n        users: Array.isArray(options?.users) ? options.users : []\n      }\n    });\n  };\n\n  const sendNotification = (notification: NotificationType): NotificationType | null => {\n    if(!notification || typeof notification !== 'object') {\n      return null;\n    }\n\n    const nextNotification: NotificationType = {\n      ...notification,\n      added: Number(notification?.added || Date.now()),\n      modified: Number(notification?.modified || Date.now()),\n      notificationId: String(notification?.notificationId || createNotificationId())\n    };\n\n    flux.dispatch({notification: nextNotification, type: NOTIFICATION_CONSTANTS.ADD_ITEM_SUCCESS});\n    wsSend({\n      action: 'notification.created',\n      data: {\n        notification: nextNotification\n      }\n    });\n\n    return nextNotification;\n  };\n\n  const onReceive = (event: any) => {\n    const {data: eventData, timeStamp: timestamp} = event;\n    const rawData = typeof eventData === 'string' ? eventData.trim() : '';\n\n    if(!rawData) {\n      return;\n    }\n\n    let data;\n\n    try {\n      data = JSON.parse(rawData);\n    } catch(parseError) {\n      console.warn('websockets::onReceive::invalidJson', rawData, parseError);\n      return;\n    }\n\n    console.log('websockets::onRecieve::data', data);\n    flux.dispatch({data, timestamp, type: WEBSOCKET_CONSTANTS.MESSAGE});\n\n    if(String(data?.action || '') === 'message.created') {\n      const message = data?.data?.message;\n      const conversation = data?.data?.conversation || (message?.conversationId\n        ? {\n          added: Number(message?.added || Date.now()),\n          content: String(message?.content || ''),\n          conversationId: String(message?.conversationId || ''),\n          modified: Number(message?.modified || message?.added || Date.now())\n        }\n        : undefined);\n\n      if(message?.conversationId) {\n        if(conversation) {\n          flux.dispatch({conversation, type: MESSAGE_CONSTANTS.GET_CONVO_LIST_SUCCESS});\n        }\n\n        flux.dispatch({message, type: MESSAGE_CONSTANTS.ADD_ITEM_SUCCESS});\n\n        const typingPersonaId = String(message?.user?.personaId || '');\n        const typingUserId = String(message?.userId || '');\n        const typingId = typingPersonaId || typingUserId;\n\n        if(typingId) {\n          clearTypingTimeout(String(message.conversationId || ''), typingId);\n          flux.dispatch({\n            type: MESSAGE_CONSTANTS.TYPING_STATUS_UPDATE,\n            typing: {\n              conversationId: String(message.conversationId || ''),\n              isTyping: false,\n              personaId: typingPersonaId,\n              userId: typingUserId\n            }\n          });\n        }\n      }\n    }\n\n    if(String(data?.action || '') === 'message.typing') {\n      const typing = data?.data?.typing;\n\n      if(typing?.conversationId && getTypingIdentity(typing)) {\n        flux.dispatch({type: MESSAGE_CONSTANTS.TYPING_STATUS_UPDATE, typing});\n\n        if(typing?.isTyping) {\n          scheduleTypingClear(typing);\n        } else {\n          clearTypingTimeout(String(typing.conversationId || ''), getTypingIdentity(typing));\n        }\n      }\n    }\n\n    if(String(data?.action || '') === 'notification.created') {\n      const notification = data?.data?.notification;\n\n      if(notification && typeof notification === 'object') {\n        flux.dispatch({\n          notification: notification as NotificationType,\n          type: NOTIFICATION_CONSTANTS.ADD_ITEM_SUCCESS\n        });\n      }\n    }\n\n    if(String(data?.action || '') === 'video.processing.completed') {\n      const video = data?.data?.video;\n\n      if(video && typeof video === 'object') {\n        flux.dispatch({type: VIDEO_CONSTANTS.UPDATE_ITEM_SUCCESS, video});\n        flux.dispatch({type: VIDEO_CONSTANTS.PROCESSING_COMPLETE, video});\n      }\n    }\n  };\n\n  const onClose = (event: any) => {\n    console.log('websockets::onOpen::message', event);\n    const {timeStamp: timestamp} = event;\n    socketIsOpen = false;\n    socketIsConnecting = Boolean(activeToken) && !closeRequested;\n    closeRequested = false;\n    flux.dispatch({timestamp, type: WEBSOCKET_CONSTANTS.CLOSE});\n  };\n\n  const onError = (event: any) => {\n    const {timeStamp: timestamp} = event;\n    socketIsOpen = false;\n    flux.dispatch({timestamp, type: WEBSOCKET_CONSTANTS.ERROR});\n  };\n\n  const onOpen = (event: any) => {\n    console.log('websockets::onOpen::event', event);\n    const {timeStamp: timestamp} = event;\n    socketIsOpen = true;\n    socketIsConnecting = false;\n    closeRequested = false;\n    sendRegistration();\n    flushPendingMessages();\n    flux.dispatch({timestamp, type: WEBSOCKET_CONSTANTS.OPEN});\n  };\n\n  const wsInit = (token?: string, personaId?: string): Sockette | null => {\n    const config = getConfigFromFlux(flux);\n    const websocketUrl = config.app?.urls?.websocket || '';\n    const sessionClientId = getClientId();\n    const sessionToken = String(token || flux.getState('user.session.token') || '');\n    const sessionPersonaId = String(personaId || flux.getState('user.session.personaId') || '');\n\n    if(!sessionToken || !websocketUrl) {\n      console.log('websockets::wsInit::skipped', {\n        hasPersonaId: Boolean(sessionPersonaId),\n        hasToken: Boolean(sessionToken),\n        websocketUrl\n      });\n      return null;\n    }\n\n    if(ws && activeToken === sessionToken && activePersonaId === sessionPersonaId && activeClientId === sessionClientId) {\n      console.log('websockets::wsInit::reuse', {\n        activeClientId,\n        activePersonaId,\n        activeToken,\n        sessionClientId,\n        sessionPersonaId\n      });\n      return ws;\n    }\n\n    if(ws && (activeToken !== sessionToken || activePersonaId !== sessionPersonaId || activeClientId !== sessionClientId)) {\n      console.log('websockets::wsInit::reconnect', {\n        activeClientId,\n        activePersonaId,\n        activeToken,\n        sessionClientId,\n        sessionPersonaId\n      });\n      wsClose();\n    }\n\n    activeClientId = sessionClientId;\n    activeToken = sessionToken;\n    activePersonaId = sessionPersonaId;\n    socketIsOpen = false;\n    socketIsConnecting = true;\n    closeRequested = false;\n    const websocketParams = new URLSearchParams({token: sessionToken});\n\n    if(sessionPersonaId) {\n      websocketParams.set('personaId', sessionPersonaId);\n    }\n    if(sessionClientId) {\n      websocketParams.set('clientId', sessionClientId);\n    }\n\n    console.log('websockets::wsInit::connect', {\n      sessionClientId,\n      sessionPersonaId,\n      sessionToken,\n      url: `${websocketUrl}?${websocketParams.toString()}`\n    });\n\n    ws = new Sockette(`${websocketUrl}?${websocketParams.toString()}`, {\n      maxAttempts: 5,\n      onclose: onClose,\n      onerror: onError,\n      onmessage: onReceive,\n      onopen: onOpen,\n      timeout: 60000\n    });\n\n    return ws;\n  };\n\n  return {\n    onClose,\n    onError,\n    onOpen,\n    onReceive,\n    sendNotification,\n    sendTyping,\n    wsClose,\n    wsInit,\n    wsSend\n  };\n};\n"],"names":["Sockette","MESSAGE_CONSTANTS","NOTIFICATION_CONSTANTS","VIDEO_CONSTANTS","WEBSOCKET_CONSTANTS","getConfigFromFlux","WEBSOCKET_CLIENT_ID_KEY","createWebsocketClientId","crypto","randomUUID","Date","now","Math","random","toString","slice","createWebsocketActions","flux","ws","activeClientId","activeToken","activePersonaId","socketIsOpen","socketIsConnecting","closeRequested","pendingMessages","typingTimeouts","Map","createNotificationId","getTypingIdentity","typing","String","personaId","userId","getClientId","window","storedClientId","sessionStorage","getItem","setItem","error","sendRegistration","json","action","data","clientId","getState","token","flushPendingMessages","length","queuedMessages","splice","forEach","message","clearTypingTimeout","conversationId","typingId","typingKey","timeoutId","get","clearTimeout","delete","scheduleTypingClear","setTimeout","dispatch","type","TYPING_STATUS_UPDATE","isTyping","set","wsSend","console","log","push","sessionToken","wsInit","wsClose","values","clear","previousSocket","close","sendTyping","options","name","username","users","Array","isArray","sendNotification","notification","nextNotification","added","Number","modified","notificationId","ADD_ITEM_SUCCESS","onReceive","event","eventData","timeStamp","timestamp","rawData","trim","JSON","parse","parseError","warn","MESSAGE","conversation","content","undefined","GET_CONVO_LIST_SUCCESS","typingPersonaId","user","typingUserId","video","UPDATE_ITEM_SUCCESS","PROCESSING_COMPLETE","onClose","Boolean","CLOSE","onError","ERROR","onOpen","OPEN","config","websocketUrl","app","urls","websocket","sessionClientId","sessionPersonaId","hasPersonaId","hasToken","websocketParams","URLSearchParams","url","maxAttempts","onclose","onerror","onmessage","onopen","timeout"],"mappings":"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"}

package/lib/adapters/appAdapter/appAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { AppType } from '../../types/apps.types.js';
+export declare class AppValidationError extends Error {
+    field?: string;
+    constructor(message: string, field?: string);
+}
+export declare const validateAppInput: (app: unknown) => AppType;
+export declare const parseApp: (app: AppType) => AppType;
+//# sourceMappingURL=appAdapter.d.ts.map

package/lib/adapters/appAdapter/appAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/appAdapter/appAdapter.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,2BAA2B,CAAC;AAEvD,qBAAa,kBAAmB,SAAQ,KAAK;IACP,KAAK,CAAC,EAAE,MAAM;gBAAtC,OAAO,EAAE,MAAM,EAAS,KAAK,CAAC,EAAE,MAAM;CAInD;AAiBD,eAAO,MAAM,gBAAgB,GAAI,KAAK,OAAO,KAAG,OAW/C,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,KAAK,OAAO,KAAG,OAUvC,CAAC"}

package/lib/adapters/appAdapter/appAdapter.js

@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseArangoId, parseId, parseString } from '@nlabs/utils';
+import { z } from 'zod';
+import { parseDocument, removeEmptyKeys } from '../arangoAdapter/arangoAdapter.js';
+import { parseReaktorName } from '../reaktorAdapter/reaktorAdapter.js';
+export class AppValidationError extends Error {
+    field;
+    constructor(message, field){
+        super(message), this.field = field;
+        this.name = 'AppValidationError';
+    }
+}
+const AppInputSchema = z.object({
+    _id: z.string().optional(),
+    _key: z.string().optional(),
+    apiKey: z.string().optional(),
+    appId: z.string().optional(),
+    description: z.string().optional(),
+    imageUrl: z.string().optional(),
+    isActive: z.boolean().optional(),
+    name: z.string().optional(),
+    settings: z.record(z.string(), z.any()).optional(),
+    type: z.string().optional(),
+    url: z.string().optional(),
+    userId: z.string().optional()
+}).loose();
+export const validateAppInput = (app)=>{
+    try {
+        const validated = AppInputSchema.parse(app);
+        return validated;
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const fieldErrors = error.issues.map((e)=>`${e.path.join('.')}: ${e.message}`).join(', ');
+            throw new AppValidationError(`App validation failed: ${fieldErrors}`);
+        }
+        throw error;
+    }
+};
+export const parseApp = (app)=>{
+    try {
+        const parsed = performAppTransformation(app);
+        return parsed;
+    } catch (error) {
+        if (error instanceof AppValidationError) {
+            throw error;
+        }
+        throw new AppValidationError(`App parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+const performAppTransformation = (app)=>{
+    const { _id, _key, apiKey, appId, description, imageUrl, isActive, name, settings, url, userId } = app;
+    const transformed = removeEmptyKeys({
+        ...parseDocument(app),
+        ...apiKey && {
+            apiKey: parseString(apiKey, 255)
+        },
+        ...(_id || _key || appId) && {
+            id: parseArangoId(_id || `apps/${_key || appId}`)
+        },
+        ...(_key || appId) && {
+            appId: parseId(_key || appId || '')
+        },
+        ...description && {
+            description: parseString(description, 1000)
+        },
+        ...imageUrl && {
+            imageUrl: parseString(imageUrl, 500)
+        },
+        ...isActive !== undefined && {
+            isActive: !!isActive
+        },
+        ...name && {
+            name: parseReaktorName(name)
+        },
+        ...settings && {
+            settings
+        },
+        ...url && {
+            url: parseString(url, 500)
+        },
+        ...userId && {
+            userId: parseId(userId)
+        }
+    });
+    return transformed;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/adapters/arangoAdapter/arangoAdapter.d.ts

@@ -11,10 +11,11 @@ export interface DocumentType {
     [key: string]: any;
 }
 export declare class ArangoValidationError extends Error {
-    field?: string | undefined;
-    constructor(message: string, field?: string | undefined);
+    field?: string;
+    constructor(message: string, field?: string);
 }
 export declare const validateDocumentInput: (doc: unknown) => DocumentType;
 export declare const formatDocumentOutput: (doc: DocumentType) => DocumentType;
 export declare const parseDocument: (doc: DocumentType) => DocumentType;
 export declare const removeEmptyKeys: <T extends Record<string, any>>(obj: T) => T;
+//# sourceMappingURL=arangoAdapter.d.ts.map

package/lib/adapters/arangoAdapter/arangoAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arangoAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/arangoAdapter/arangoAdapter.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,qBAAa,qBAAsB,SAAQ,KAAK;IACV,KAAK,CAAC,EAAE,MAAM;gBAAtC,OAAO,EAAE,MAAM,EAAS,KAAK,CAAC,EAAE,MAAM;CAInD;AAcD,eAAO,MAAM,qBAAqB,GAAI,KAAK,OAAO,KAAG,YAWpD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,KAAK,YAAY,KAAG,YAAmB,CAAC;AAE7E,eAAO,MAAM,aAAa,GAAI,KAAK,YAAY,KAAG,YAUjD,CAAC;AAuBF,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,KAAG,CAQvE,CAAC"}