@magek/adapter-session-store-memory 0.0.10

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { MemorySessionStoreAdapter } from './memory-session-store-adapter';
+import { MemorySessionStoreAdapter } from './memory-session-store-adapter';
+export declare const sessionStore: MemorySessionStoreAdapter;

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionStore = exports.MemorySessionStoreAdapter = void 0;
+var memory_session_store_adapter_1 = require("./memory-session-store-adapter");
+Object.defineProperty(exports, "MemorySessionStoreAdapter", { enumerable: true, get: function () { return memory_session_store_adapter_1.MemorySessionStoreAdapter; } });
+// Export a default instance for easy usage
+const memory_session_store_adapter_2 = require("./memory-session-store-adapter");
+exports.sessionStore = new memory_session_store_adapter_2.MemorySessionStoreAdapter();

package/dist/memory-session-store-adapter.d.ts

@@ -0,0 +1,24 @@
+import { SessionStoreAdapter, MagekConfig, UUID, SubscriptionEnvelope } from '@magek/common';
+export declare class MemorySessionStoreAdapter implements SessionStoreAdapter {
+    private connections;
+    private subscriptions;
+    private subscriptionsByConnection;
+    private subscriptionsByClassName;
+    storeConnection(config: MagekConfig, connectionId: UUID, connectionData: Record<string, any>): Promise<void>;
+    fetchConnection(config: MagekConfig, connectionId: UUID): Promise<Record<string, any> | undefined>;
+    deleteConnection(config: MagekConfig, connectionId: UUID): Promise<void>;
+    storeSubscription(config: MagekConfig, connectionId: UUID, subscriptionId: UUID, subscriptionData: Record<string, any>): Promise<void>;
+    fetchSubscription(config: MagekConfig, subscriptionId: UUID): Promise<Record<string, any> | undefined>;
+    deleteSubscription(config: MagekConfig, connectionId: UUID, subscriptionId: UUID): Promise<void>;
+    fetchSubscriptionsForConnection(config: MagekConfig, connectionId: UUID): Promise<Array<Record<string, any>>>;
+    fetchSubscriptionsByClassName(config: MagekConfig, className: string): Promise<Array<SubscriptionEnvelope>>;
+    deleteSubscriptionsForConnection(config: MagekConfig, connectionId: UUID): Promise<void>;
+    healthCheck: {
+        isUp: (config: MagekConfig) => Promise<boolean>;
+        details: (config: MagekConfig) => Promise<unknown>;
+        urls: (config: MagekConfig) => Promise<Array<string>>;
+    };
+    getConnectionsCount(): number;
+    getSubscriptionsCount(): number;
+    clear(): void;
+}

package/dist/memory-session-store-adapter.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySessionStoreAdapter = void 0;
+const common_1 = require("@magek/common");
+class MemorySessionStoreAdapter {
+    connections = new Map();
+    subscriptions = new Map();
+    subscriptionsByConnection = new Map();
+    subscriptionsByClassName = new Map();
+    async storeConnection(config, connectionId, connectionData) {
+        const logger = (0, common_1.getLogger)(config, 'MemorySessionStoreAdapter#storeConnection');
+        logger.debug('Storing connection data:', { connectionId, connectionData });
+        this.connections.set(connectionId, {
+            ...connectionData,
+            connectionID: connectionId,
+        });
+    }
+    async fetchConnection(config, connectionId) {
+        const data = this.connections.get(connectionId);
+        if (!data) {
+            return undefined;
+        }
+        // Remove internal fields before returning
+        const { connectionID, ...connectionData } = data;
+        return connectionData;
+    }
+    async deleteConnection(config, connectionId) {
+        const logger = (0, common_1.getLogger)(config, 'MemorySessionStoreAdapter#deleteConnection');
+        if (!this.connections.has(connectionId)) {
+            logger.info(`No connections found with connectionID=${connectionId}`);
+            return;
+        }
+        this.connections.delete(connectionId);
+        logger.debug('Deleted connection:', connectionId);
+    }
+    async storeSubscription(config, connectionId, subscriptionId, subscriptionData) {
+        const logger = (0, common_1.getLogger)(config, 'MemorySessionStoreAdapter#storeSubscription');
+        logger.debug('Storing subscription data:', { connectionId, subscriptionId, subscriptionData });
+        const data = {
+            ...subscriptionData,
+            connectionID: connectionId,
+            subscriptionID: subscriptionId,
+        };
+        this.subscriptions.set(subscriptionId, data);
+        // Index by connection
+        if (!this.subscriptionsByConnection.has(connectionId)) {
+            this.subscriptionsByConnection.set(connectionId, new Set());
+        }
+        this.subscriptionsByConnection.get(connectionId).add(subscriptionId);
+        // Index by className if present
+        const className = subscriptionData.className;
+        if (className) {
+            if (!this.subscriptionsByClassName.has(className)) {
+                this.subscriptionsByClassName.set(className, new Set());
+            }
+            this.subscriptionsByClassName.get(className).add(subscriptionId);
+        }
+    }
+    async fetchSubscription(config, subscriptionId) {
+        const data = this.subscriptions.get(subscriptionId);
+        if (!data) {
+            return undefined;
+        }
+        // Remove internal fields before returning
+        const { connectionID, subscriptionID, ...subscriptionData } = data;
+        return subscriptionData;
+    }
+    async deleteSubscription(config, connectionId, subscriptionId) {
+        const logger = (0, common_1.getLogger)(config, 'MemorySessionStoreAdapter#deleteSubscription');
+        const data = this.subscriptions.get(subscriptionId);
+        if (!data) {
+            logger.info(`No subscription found with connectionID=${connectionId} and subscriptionID=${subscriptionId}`);
+            return;
+        }
+        // Remove from className index
+        const className = data.className;
+        if (className) {
+            this.subscriptionsByClassName.get(className)?.delete(subscriptionId);
+        }
+        // Remove from connection index
+        this.subscriptionsByConnection.get(connectionId)?.delete(subscriptionId);
+        // Remove subscription
+        this.subscriptions.delete(subscriptionId);
+        logger.debug('Deleted subscription:', { connectionId, subscriptionId });
+    }
+    async fetchSubscriptionsForConnection(config, connectionId) {
+        const subscriptionIds = this.subscriptionsByConnection.get(connectionId);
+        if (!subscriptionIds) {
+            return [];
+        }
+        const results = [];
+        for (const subscriptionId of Array.from(subscriptionIds)) {
+            const data = this.subscriptions.get(subscriptionId);
+            if (data) {
+                const { connectionID, subscriptionID, ...subscriptionData } = data;
+                results.push(subscriptionData);
+            }
+        }
+        return results;
+    }
+    async fetchSubscriptionsByClassName(config, className) {
+        const subscriptionIds = this.subscriptionsByClassName.get(className);
+        if (!subscriptionIds) {
+            return [];
+        }
+        const results = [];
+        for (const subscriptionId of Array.from(subscriptionIds)) {
+            const data = this.subscriptions.get(subscriptionId);
+            if (data) {
+                results.push(data);
+            }
+        }
+        return results;
+    }
+    async deleteSubscriptionsForConnection(config, connectionId) {
+        const logger = (0, common_1.getLogger)(config, 'MemorySessionStoreAdapter#deleteSubscriptionsForConnection');
+        const subscriptionIds = this.subscriptionsByConnection.get(connectionId);
+        if (!subscriptionIds || subscriptionIds.size === 0) {
+            logger.debug(`No subscriptions found for connection: ${connectionId}`);
+            return;
+        }
+        let removed = 0;
+        for (const subscriptionId of Array.from(subscriptionIds)) {
+            const data = this.subscriptions.get(subscriptionId);
+            if (data) {
+                // Remove from className index
+                const className = data.className;
+                if (className) {
+                    this.subscriptionsByClassName.get(className)?.delete(subscriptionId);
+                }
+                this.subscriptions.delete(subscriptionId);
+                removed++;
+            }
+        }
+        // Clear the connection's subscription set
+        this.subscriptionsByConnection.delete(connectionId);
+        logger.debug(`Deleted ${removed} subscriptions for connection:`, connectionId);
+    }
+    healthCheck = {
+        isUp: async (config) => {
+            // In-memory store is always up if the process is running
+            return true;
+        },
+        details: async (config) => {
+            return {
+                type: 'memory',
+                status: 'healthy',
+                connections: {
+                    count: this.connections.size,
+                },
+                subscriptions: {
+                    count: this.subscriptions.size,
+                },
+            };
+        },
+        urls: async (config) => {
+            return ['memory://in-memory-session-store'];
+        },
+    };
+    // Helper methods for testing
+    getConnectionsCount() {
+        return this.connections.size;
+    }
+    getSubscriptionsCount() {
+        return this.subscriptions.size;
+    }
+    clear() {
+        this.connections.clear();
+        this.subscriptions.clear();
+        this.subscriptionsByConnection.clear();
+        this.subscriptionsByClassName.clear();
+    }
+}
+exports.MemorySessionStoreAdapter = MemorySessionStoreAdapter;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@magek/adapter-session-store-memory",
+  "version": "0.0.10",
+  "description": "In-memory session store adapter for the Magek framework",
+  "keywords": [
+    "session-store",
+    "memory",
+    "in-memory",
+    "websocket",
+    "connections",
+    "subscriptions"
+  ],
+  "author": "Boosterin Labs SLU",
+  "homepage": "https://magek.ai",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theam/magek.git"
+  },
+  "engines": {
+    "node": ">=22.0.0 <23.0.0"
+  },
+  "dependencies": {
+    "@magek/common": "workspace:^0.0.10",
+    "tslib": "2.8.1"
+  },
+  "scripts": {
+    "format": "prettier --write --ext '.js,.ts' **/*.ts **/*/*.ts",
+    "lint:check": "eslint \"**/*.ts\"",
+    "lint:fix": "eslint --quiet --fix \"**/*.ts\"",
+    "build": "tsc -b tsconfig.json",
+    "clean": "rimraf ./dist tsconfig.tsbuildinfo",
+    "prepack": "tsc -b tsconfig.json",
+    "test": "tsc --noEmit -p tsconfig.test.json && c8 mocha --forbid-only \"test/**/*.test.ts\""
+  },
+  "bugs": {
+    "url": "https://github.com/theam/magek/issues"
+  },
+  "devDependencies": {
+    "@magek/eslint-config": "workspace:^0.0.10",
+    "@types/chai": "5.2.3",
+    "@types/chai-as-promised": "8.0.2",
+    "@types/mocha": "10.0.10",
+    "@types/node": "22.19.8",
+    "@types/sinon": "21.0.0",
+    "@types/sinon-chai": "4.0.0",
+    "chai": "6.2.2",
+    "chai-as-promised": "8.0.2",
+    "@faker-js/faker": "10.2.0",
+    "mocha": "11.7.5",
+    "c8": "^10.1.3",
+    "rimraf": "6.1.2",
+    "sinon": "21.0.1",
+    "sinon-chai": "4.0.1",
+    "tsx": "^4.19.2",
+    "typescript": "5.9.3"
+  }
+}