@magek/adapter-session-store-nedb 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { NedbSessionStoreAdapter } from './nedb-session-store-adapter';
+export { WebSocketRegistry } from './web-socket-registry';
+export { connectionsDatabase, subscriptionsDatabase } from './paths';
+import { NedbSessionStoreAdapter } from './nedb-session-store-adapter';
+export declare const sessionStore: NedbSessionStoreAdapter;

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionStore = exports.subscriptionsDatabase = exports.connectionsDatabase = exports.WebSocketRegistry = exports.NedbSessionStoreAdapter = void 0;
+var nedb_session_store_adapter_1 = require("./nedb-session-store-adapter");
+Object.defineProperty(exports, "NedbSessionStoreAdapter", { enumerable: true, get: function () { return nedb_session_store_adapter_1.NedbSessionStoreAdapter; } });
+var web_socket_registry_1 = require("./web-socket-registry");
+Object.defineProperty(exports, "WebSocketRegistry", { enumerable: true, get: function () { return web_socket_registry_1.WebSocketRegistry; } });
+var paths_1 = require("./paths");
+Object.defineProperty(exports, "connectionsDatabase", { enumerable: true, get: function () { return paths_1.connectionsDatabase; } });
+Object.defineProperty(exports, "subscriptionsDatabase", { enumerable: true, get: function () { return paths_1.subscriptionsDatabase; } });
+// Export a default instance for easy usage  
+const nedb_session_store_adapter_2 = require("./nedb-session-store-adapter");
+exports.sessionStore = new nedb_session_store_adapter_2.NedbSessionStoreAdapter();

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

@@ -0,0 +1,24 @@
+import { SessionStoreAdapter, MagekConfig, UUID, SubscriptionEnvelope } from '@magek/common';
+export declare class NedbSessionStoreAdapter implements SessionStoreAdapter {
+    private connectionRegistry;
+    private subscriptionRegistry;
+    constructor();
+    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>>>;
+    /**
+     * Additional method to support fetching subscriptions by className (for read model type)
+     * This is needed for the existing subscription system that queries by read model name
+     */
+    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>>;
+    };
+}

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NedbSessionStoreAdapter = void 0;
+const common_1 = require("@magek/common");
+const web_socket_registry_1 = require("./web-socket-registry");
+const paths_1 = require("./paths");
+class NedbSessionStoreAdapter {
+    constructor() {
+        this.healthCheck = {
+            isUp: async (config) => {
+                try {
+                    // Test both registries by doing a simple count operation
+                    await this.connectionRegistry.count();
+                    await this.subscriptionRegistry.count();
+                    return true;
+                }
+                catch (error) {
+                    return false;
+                }
+            },
+            details: async (config) => {
+                try {
+                    const connectionsCount = await this.connectionRegistry.count();
+                    const subscriptionsCount = await this.subscriptionRegistry.count();
+                    return {
+                        status: 'healthy',
+                        connections: {
+                            count: connectionsCount,
+                            database: (0, paths_1.connectionsDatabase)()
+                        },
+                        subscriptions: {
+                            count: subscriptionsCount,
+                            database: (0, paths_1.subscriptionsDatabase)()
+                        }
+                    };
+                }
+                catch (error) {
+                    return {
+                        status: 'unhealthy',
+                        error: error instanceof Error ? error.message : 'Unknown error'
+                    };
+                }
+            },
+            urls: async (config) => {
+                return [
+                    `file://${(0, paths_1.connectionsDatabase)()}`,
+                    `file://${(0, paths_1.subscriptionsDatabase)()}`
+                ];
+            }
+        };
+        this.connectionRegistry = new web_socket_registry_1.WebSocketRegistry((0, paths_1.connectionsDatabase)());
+        this.subscriptionRegistry = new web_socket_registry_1.WebSocketRegistry((0, paths_1.subscriptionsDatabase)());
+    }
+    async storeConnection(config, connectionId, connectionData) {
+        const logger = (0, common_1.getLogger)(config, 'NedbSessionStoreAdapter#storeConnection');
+        logger.debug('Storing connection data:', { connectionId, connectionData });
+        await this.connectionRegistry.store({
+            ...connectionData,
+            connectionID: connectionId,
+        });
+    }
+    async fetchConnection(config, connectionId) {
+        const results = (await this.connectionRegistry.query({
+            connectionID: connectionId,
+        }));
+        if (!results || results.length === 0) {
+            return undefined;
+        }
+        // Remove the internal connectionID and NeDB _id fields before returning
+        const { connectionID, _id, ...connectionData } = results[0];
+        return connectionData;
+    }
+    async deleteConnection(config, connectionId) {
+        const logger = (0, common_1.getLogger)(config, 'NedbSessionStoreAdapter#deleteConnection');
+        const removed = await this.connectionRegistry.delete({ connectionID: connectionId });
+        if (removed === 0) {
+            logger.info(`No connections found with connectionID=${connectionId}`);
+            return;
+        }
+        logger.debug('Deleted connection:', connectionId);
+    }
+    async storeSubscription(config, connectionId, subscriptionId, subscriptionData) {
+        const logger = (0, common_1.getLogger)(config, 'NedbSessionStoreAdapter#storeSubscription');
+        logger.debug('Storing subscription data:', { connectionId, subscriptionId, subscriptionData });
+        await this.subscriptionRegistry.store({
+            ...subscriptionData,
+            connectionID: connectionId,
+            subscriptionID: subscriptionId,
+        });
+    }
+    async fetchSubscription(config, subscriptionId) {
+        const results = (await this.subscriptionRegistry.query({
+            subscriptionID: subscriptionId,
+        }));
+        if (!results || results.length === 0) {
+            return undefined;
+        }
+        // Remove internal fields and NeDB _id before returning
+        const { connectionID, subscriptionID, _id, ...subscriptionData } = results[0];
+        return subscriptionData;
+    }
+    async deleteSubscription(config, connectionId, subscriptionId) {
+        const logger = (0, common_1.getLogger)(config, 'NedbSessionStoreAdapter#deleteSubscription');
+        const removed = await this.subscriptionRegistry.delete({
+            connectionID: connectionId,
+            subscriptionID: subscriptionId
+        });
+        if (removed === 0) {
+            logger.info(`No subscription found with connectionID=${connectionId} and subscriptionID=${subscriptionId}`);
+            return;
+        }
+        logger.debug('Deleted subscription:', { connectionId, subscriptionId });
+    }
+    async fetchSubscriptionsForConnection(config, connectionId) {
+        const results = (await this.subscriptionRegistry.query({
+            connectionID: connectionId,
+        }));
+        // Remove internal fields and NeDB _id from each subscription
+        return results.map(({ connectionID, subscriptionID, _id, ...subscriptionData }) => subscriptionData);
+    }
+    /**
+     * Additional method to support fetching subscriptions by className (for read model type)
+     * This is needed for the existing subscription system that queries by read model name
+     */
+    async fetchSubscriptionsByClassName(config, className) {
+        const results = (await this.subscriptionRegistry.query({
+            className: className,
+        }));
+        // Remove internal fields and NeDB _id from each subscription
+        return results.map(({ _id, ...subscriptionData }) => subscriptionData);
+    }
+    async deleteSubscriptionsForConnection(config, connectionId) {
+        const logger = (0, common_1.getLogger)(config, 'NedbSessionStoreAdapter#deleteSubscriptionsForConnection');
+        const removed = await this.subscriptionRegistry.delete({ connectionID: connectionId });
+        logger.debug(`Deleted ${removed} subscriptions for connection:`, connectionId);
+    }
+}
+exports.NedbSessionStoreAdapter = NedbSessionStoreAdapter;

package/dist/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function connectionsDatabase(): string;
+export declare function subscriptionsDatabase(): string;

package/dist/paths.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectionsDatabase = connectionsDatabase;
+exports.subscriptionsDatabase = subscriptionsDatabase;
+// Path helpers for NeDB session store databases
+const path = require("path");
+function connectionsDatabase() {
+    return internalPath('connections.json');
+}
+function subscriptionsDatabase() {
+    return internalPath('subscriptions.json');
+}
+function internalPath(filename) {
+    return path.normalize(path.join('.', '.magek', filename));
+}

package/dist/web-socket-registry.d.ts

@@ -0,0 +1,24 @@
+import { UUID } from '@magek/common';
+export interface ConnectionRecord {
+    connectionID: UUID;
+    [key: string]: any;
+}
+export interface SubscriptionRecord {
+    connectionID: UUID;
+    subscriptionID: UUID;
+    [key: string]: any;
+}
+export type RegistryRecord = ConnectionRecord | SubscriptionRecord;
+export declare class WebSocketRegistry {
+    datastore: any;
+    isLoaded: boolean;
+    constructor(databasePath: string);
+    loadDatabaseIfNeeded(): Promise<void>;
+    addIndexes(): Promise<void>;
+    getCursor(query: object, createdAt?: number, projections?: unknown): any;
+    query(query: object, createdAt?: number, limit?: number, projections?: unknown): Promise<unknown>;
+    store(envelope: Record<string, any>): Promise<void>;
+    delete(query: unknown): Promise<number>;
+    deleteAll(): Promise<number>;
+    count(query?: object): Promise<number>;
+}

package/dist/web-socket-registry.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketRegistry = void 0;
+const DataStore = require('@seald-io/nedb');
+class WebSocketRegistry {
+    constructor(databasePath) {
+        this.isLoaded = false;
+        this.datastore = new DataStore({ filename: databasePath });
+    }
+    async loadDatabaseIfNeeded() {
+        if (!this.isLoaded) {
+            this.isLoaded = true;
+            await this.datastore.loadDatabaseAsync();
+            await this.addIndexes();
+        }
+    }
+    async addIndexes() {
+        const maxDurationInSeconds = 2 * 24 * 60 * 60; // 2 days
+        this.datastore.ensureIndexAsync({ fieldName: 'expirationTime', expireAfterSeconds: maxDurationInSeconds });
+    }
+    getCursor(query, createdAt = 1, projections) {
+        return this.datastore.findAsync(query, projections).sort({ createdAt: createdAt });
+    }
+    async query(query, createdAt = 1, limit, projections) {
+        await this.loadDatabaseIfNeeded();
+        let cursor = this.getCursor(query, createdAt, projections);
+        if (limit) {
+            cursor = cursor.limit(Number(limit));
+        }
+        return await cursor.execAsync();
+    }
+    async store(envelope) {
+        await this.loadDatabaseIfNeeded();
+        await this.datastore.insertAsync(envelope);
+    }
+    async delete(query) {
+        await this.loadDatabaseIfNeeded();
+        return await this.datastore.removeAsync(query, { multi: true });
+    }
+    async deleteAll() {
+        await this.loadDatabaseIfNeeded();
+        return await this.datastore.removeAsync({}, { multi: true });
+    }
+    async count(query) {
+        await this.loadDatabaseIfNeeded();
+        return await this.datastore.countAsync(query);
+    }
+}
+exports.WebSocketRegistry = WebSocketRegistry;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@magek/adapter-session-store-nedb",
+  "version": "0.0.1",
+  "description": "Nedb-based session store adapter for the Magek framework",
+  "keywords": [
+    "session-store",
+    "nedb",
+    "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": "^0.0.1",
+    "@seald-io/nedb": "4.1.2",
+    "tslib": "2.8.1"
+  },
+  "bugs": {
+    "url": "https://github.com/theam/magek/issues"
+  },
+  "devDependencies": {
+    "@magek/eslint-config": "^0.0.1",
+    "@types/chai": "5.2.3",
+    "@types/chai-as-promised": "8.0.2",
+    "@types/mocha": "10.0.10",
+    "@types/node": "22.19.3",
+    "@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",
+    "memfs": "~4.36.0"
+  },
+  "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",
+    "test": "tsc --noEmit -p tsconfig.test.json && c8 mocha --forbid-only \"test/**/*.test.ts\""
+  }
+}