@chat-adapter/state-memory 4.0.0

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { StateAdapter, Lock } from 'chat';
+
+/**
+ * In-memory state adapter for development and testing.
+ *
+ * WARNING: State is not persisted across restarts.
+ * Use RedisStateAdapter for production.
+ */
+declare class MemoryStateAdapter implements StateAdapter {
+    private subscriptions;
+    private locks;
+    private cache;
+    private connected;
+    private connectPromise;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    subscribe(threadId: string): Promise<void>;
+    unsubscribe(threadId: string): Promise<void>;
+    isSubscribed(threadId: string): Promise<boolean>;
+    listSubscriptions(adapterName?: string): AsyncIterable<string>;
+    acquireLock(threadId: string, ttlMs: number): Promise<Lock | null>;
+    releaseLock(lock: Lock): Promise<void>;
+    extendLock(lock: Lock, ttlMs: number): Promise<boolean>;
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttlMs?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    private ensureConnected;
+    private cleanExpiredLocks;
+    _getSubscriptionCount(): number;
+    _getLockCount(): number;
+}
+declare function createMemoryState(): MemoryStateAdapter;
+
+export { MemoryStateAdapter, createMemoryState };

package/dist/index.js

@@ -0,0 +1,146 @@
+// src/index.ts
+var MemoryStateAdapter = class {
+  subscriptions = /* @__PURE__ */ new Set();
+  locks = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  connected = false;
+  connectPromise = null;
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    if (!this.connectPromise) {
+      this.connectPromise = Promise.resolve().then(() => {
+        if (process.env.NODE_ENV === "production") {
+          console.warn(
+            "[chat] MemoryStateAdapter is not recommended for production. Consider using @chat-adapter/state-redis instead."
+          );
+        }
+        this.connected = true;
+      });
+    }
+    await this.connectPromise;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.connectPromise = null;
+    this.subscriptions.clear();
+    this.locks.clear();
+  }
+  async subscribe(threadId) {
+    this.ensureConnected();
+    this.subscriptions.add(threadId);
+  }
+  async unsubscribe(threadId) {
+    this.ensureConnected();
+    this.subscriptions.delete(threadId);
+  }
+  async isSubscribed(threadId) {
+    this.ensureConnected();
+    return this.subscriptions.has(threadId);
+  }
+  async *listSubscriptions(adapterName) {
+    this.ensureConnected();
+    for (const threadId of this.subscriptions) {
+      if (adapterName) {
+        if (threadId.startsWith(`${adapterName}:`)) {
+          yield threadId;
+        }
+      } else {
+        yield threadId;
+      }
+    }
+  }
+  async acquireLock(threadId, ttlMs) {
+    this.ensureConnected();
+    this.cleanExpiredLocks();
+    const existingLock = this.locks.get(threadId);
+    if (existingLock && existingLock.expiresAt > Date.now()) {
+      return null;
+    }
+    const lock = {
+      threadId,
+      token: generateToken(),
+      expiresAt: Date.now() + ttlMs
+    };
+    this.locks.set(threadId, lock);
+    return lock;
+  }
+  async releaseLock(lock) {
+    this.ensureConnected();
+    const existingLock = this.locks.get(lock.threadId);
+    if (existingLock && existingLock.token === lock.token) {
+      this.locks.delete(lock.threadId);
+    }
+  }
+  async extendLock(lock, ttlMs) {
+    this.ensureConnected();
+    const existingLock = this.locks.get(lock.threadId);
+    if (!existingLock || existingLock.token !== lock.token) {
+      return false;
+    }
+    if (existingLock.expiresAt < Date.now()) {
+      this.locks.delete(lock.threadId);
+      return false;
+    }
+    existingLock.expiresAt = Date.now() + ttlMs;
+    return true;
+  }
+  async get(key) {
+    this.ensureConnected();
+    const cached = this.cache.get(key);
+    if (!cached) {
+      return null;
+    }
+    if (cached.expiresAt !== null && cached.expiresAt <= Date.now()) {
+      this.cache.delete(key);
+      return null;
+    }
+    return cached.value;
+  }
+  async set(key, value, ttlMs) {
+    this.ensureConnected();
+    this.cache.set(key, {
+      value,
+      expiresAt: ttlMs ? Date.now() + ttlMs : null
+    });
+  }
+  async delete(key) {
+    this.ensureConnected();
+    this.cache.delete(key);
+  }
+  ensureConnected() {
+    if (!this.connected) {
+      throw new Error(
+        "MemoryStateAdapter is not connected. Call connect() first."
+      );
+    }
+  }
+  cleanExpiredLocks() {
+    const now = Date.now();
+    for (const [threadId, lock] of this.locks) {
+      if (lock.expiresAt <= now) {
+        this.locks.delete(threadId);
+      }
+    }
+  }
+  // For testing purposes
+  _getSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  _getLockCount() {
+    this.cleanExpiredLocks();
+    return this.locks.size;
+  }
+};
+function generateToken() {
+  return `mem_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+}
+function createMemoryState() {
+  return new MemoryStateAdapter();
+}
+export {
+  MemoryStateAdapter,
+  createMemoryState
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { Lock, StateAdapter } from \"chat\";\n\ninterface MemoryLock extends Lock {\n  threadId: string;\n  token: string;\n  expiresAt: number;\n}\n\ninterface CachedValue<T = unknown> {\n  value: T;\n  expiresAt: number | null; // null = no expiry\n}\n\n/**\n * In-memory state adapter for development and testing.\n *\n * WARNING: State is not persisted across restarts.\n * Use RedisStateAdapter for production.\n */\nexport class MemoryStateAdapter implements StateAdapter {\n  private subscriptions = new Set<string>();\n  private locks = new Map<string, MemoryLock>();\n  private cache = new Map<string, CachedValue>();\n  private connected = false;\n  private connectPromise: Promise<void> | null = null;\n\n  async connect(): Promise<void> {\n    if (this.connected) {\n      return;\n    }\n\n    // Reuse existing connection attempt to avoid race conditions\n    if (!this.connectPromise) {\n      this.connectPromise = Promise.resolve().then(() => {\n        if (process.env.NODE_ENV === \"production\") {\n          console.warn(\n            \"[chat] MemoryStateAdapter is not recommended for production. \" +\n              \"Consider using @chat-adapter/state-redis instead.\",\n          );\n        }\n        this.connected = true;\n      });\n    }\n\n    await this.connectPromise;\n  }\n\n  async disconnect(): Promise<void> {\n    this.connected = false;\n    this.connectPromise = null;\n    this.subscriptions.clear();\n    this.locks.clear();\n  }\n\n  async subscribe(threadId: string): Promise<void> {\n    this.ensureConnected();\n    this.subscriptions.add(threadId);\n  }\n\n  async unsubscribe(threadId: string): Promise<void> {\n    this.ensureConnected();\n    this.subscriptions.delete(threadId);\n  }\n\n  async isSubscribed(threadId: string): Promise<boolean> {\n    this.ensureConnected();\n    return this.subscriptions.has(threadId);\n  }\n\n  async *listSubscriptions(adapterName?: string): AsyncIterable<string> {\n    this.ensureConnected();\n\n    for (const threadId of this.subscriptions) {\n      if (adapterName) {\n        // Thread ID format: \"adapter:channel:thread\"\n        if (threadId.startsWith(`${adapterName}:`)) {\n          yield threadId;\n        }\n      } else {\n        yield threadId;\n      }\n    }\n  }\n\n  async acquireLock(threadId: string, ttlMs: number): Promise<Lock | null> {\n    this.ensureConnected();\n    this.cleanExpiredLocks();\n\n    // Check if already locked\n    const existingLock = this.locks.get(threadId);\n    if (existingLock && existingLock.expiresAt > Date.now()) {\n      return null;\n    }\n\n    // Create new lock\n    const lock: MemoryLock = {\n      threadId,\n      token: generateToken(),\n      expiresAt: Date.now() + ttlMs,\n    };\n\n    this.locks.set(threadId, lock);\n    return lock;\n  }\n\n  async releaseLock(lock: Lock): Promise<void> {\n    this.ensureConnected();\n\n    const existingLock = this.locks.get(lock.threadId);\n    if (existingLock && existingLock.token === lock.token) {\n      this.locks.delete(lock.threadId);\n    }\n  }\n\n  async extendLock(lock: Lock, ttlMs: number): Promise<boolean> {\n    this.ensureConnected();\n\n    const existingLock = this.locks.get(lock.threadId);\n    if (!existingLock || existingLock.token !== lock.token) {\n      return false;\n    }\n\n    if (existingLock.expiresAt < Date.now()) {\n      // Lock has already expired\n      this.locks.delete(lock.threadId);\n      return false;\n    }\n\n    // Extend the lock\n    existingLock.expiresAt = Date.now() + ttlMs;\n    return true;\n  }\n\n  async get<T = unknown>(key: string): Promise<T | null> {\n    this.ensureConnected();\n\n    const cached = this.cache.get(key);\n    if (!cached) {\n      return null;\n    }\n\n    // Check if expired\n    if (cached.expiresAt !== null && cached.expiresAt <= Date.now()) {\n      this.cache.delete(key);\n      return null;\n    }\n\n    return cached.value as T;\n  }\n\n  async set<T = unknown>(key: string, value: T, ttlMs?: number): Promise<void> {\n    this.ensureConnected();\n\n    this.cache.set(key, {\n      value,\n      expiresAt: ttlMs ? Date.now() + ttlMs : null,\n    });\n  }\n\n  async delete(key: string): Promise<void> {\n    this.ensureConnected();\n    this.cache.delete(key);\n  }\n\n  private ensureConnected(): void {\n    if (!this.connected) {\n      throw new Error(\n        \"MemoryStateAdapter is not connected. Call connect() first.\",\n      );\n    }\n  }\n\n  private cleanExpiredLocks(): void {\n    const now = Date.now();\n    for (const [threadId, lock] of this.locks) {\n      if (lock.expiresAt <= now) {\n        this.locks.delete(threadId);\n      }\n    }\n  }\n\n  // For testing purposes\n  _getSubscriptionCount(): number {\n    return this.subscriptions.size;\n  }\n\n  _getLockCount(): number {\n    this.cleanExpiredLocks();\n    return this.locks.size;\n  }\n}\n\nfunction generateToken(): string {\n  return `mem_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;\n}\n\nexport function createMemoryState(): MemoryStateAdapter {\n  return new MemoryStateAdapter();\n}\n"],"mappings":";AAmBO,IAAM,qBAAN,MAAiD;AAAA,EAC9C,gBAAgB,oBAAI,IAAY;AAAA,EAChC,QAAQ,oBAAI,IAAwB;AAAA,EACpC,QAAQ,oBAAI,IAAyB;AAAA,EACrC,YAAY;AAAA,EACZ,iBAAuC;AAAA,EAE/C,MAAM,UAAyB;AAC7B,QAAI,KAAK,WAAW;AAClB;AAAA,IACF;AAGA,QAAI,CAAC,KAAK,gBAAgB;AACxB,WAAK,iBAAiB,QAAQ,QAAQ,EAAE,KAAK,MAAM;AACjD,YAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,kBAAQ;AAAA,YACN;AAAA,UAEF;AAAA,QACF;AACA,aAAK,YAAY;AAAA,MACnB,CAAC;AAAA,IACH;AAEA,UAAM,KAAK;AAAA,EACb;AAAA,EAEA,MAAM,aAA4B;AAChC,SAAK,YAAY;AACjB,SAAK,iBAAiB;AACtB,SAAK,cAAc,MAAM;AACzB,SAAK,MAAM,MAAM;AAAA,EACnB;AAAA,EAEA,MAAM,UAAU,UAAiC;AAC/C,SAAK,gBAAgB;AACrB,SAAK,cAAc,IAAI,QAAQ;AAAA,EACjC;AAAA,EAEA,MAAM,YAAY,UAAiC;AACjD,SAAK,gBAAgB;AACrB,SAAK,cAAc,OAAO,QAAQ;AAAA,EACpC;AAAA,EAEA,MAAM,aAAa,UAAoC;AACrD,SAAK,gBAAgB;AACrB,WAAO,KAAK,cAAc,IAAI,QAAQ;AAAA,EACxC;AAAA,EAEA,OAAO,kBAAkB,aAA6C;AACpE,SAAK,gBAAgB;AAErB,eAAW,YAAY,KAAK,eAAe;AACzC,UAAI,aAAa;AAEf,YAAI,SAAS,WAAW,GAAG,WAAW,GAAG,GAAG;AAC1C,gBAAM;AAAA,QACR;AAAA,MACF,OAAO;AACL,cAAM;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,YAAY,UAAkB,OAAqC;AACvE,SAAK,gBAAgB;AACrB,SAAK,kBAAkB;AAGvB,UAAM,eAAe,KAAK,MAAM,IAAI,QAAQ;AAC5C,QAAI,gBAAgB,aAAa,YAAY,KAAK,IAAI,GAAG;AACvD,aAAO;AAAA,IACT;AAGA,UAAM,OAAmB;AAAA,MACvB;AAAA,MACA,OAAO,cAAc;AAAA,MACrB,WAAW,KAAK,IAAI,IAAI;AAAA,IAC1B;AAEA,SAAK,MAAM,IAAI,UAAU,IAAI;AAC7B,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,YAAY,MAA2B;AAC3C,SAAK,gBAAgB;AAErB,UAAM,eAAe,KAAK,MAAM,IAAI,KAAK,QAAQ;AACjD,QAAI,gBAAgB,aAAa,UAAU,KAAK,OAAO;AACrD,WAAK,MAAM,OAAO,KAAK,QAAQ;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,MAAY,OAAiC;AAC5D,SAAK,gBAAgB;AAErB,UAAM,eAAe,KAAK,MAAM,IAAI,KAAK,QAAQ;AACjD,QAAI,CAAC,gBAAgB,aAAa,UAAU,KAAK,OAAO;AACtD,aAAO;AAAA,IACT;AAEA,QAAI,aAAa,YAAY,KAAK,IAAI,GAAG;AAEvC,WAAK,MAAM,OAAO,KAAK,QAAQ;AAC/B,aAAO;AAAA,IACT;AAGA,iBAAa,YAAY,KAAK,IAAI,IAAI;AACtC,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,IAAiB,KAAgC;AACrD,SAAK,gBAAgB;AAErB,UAAM,SAAS,KAAK,MAAM,IAAI,GAAG;AACjC,QAAI,CAAC,QAAQ;AACX,aAAO;AAAA,IACT;AAGA,QAAI,OAAO,cAAc,QAAQ,OAAO,aAAa,KAAK,IAAI,GAAG;AAC/D,WAAK,MAAM,OAAO,GAAG;AACrB,aAAO;AAAA,IACT;AAEA,WAAO,OAAO;AAAA,EAChB;AAAA,EAEA,MAAM,IAAiB,KAAa,OAAU,OAA+B;AAC3E,SAAK,gBAAgB;AAErB,SAAK,MAAM,IAAI,KAAK;AAAA,MAClB;AAAA,MACA,WAAW,QAAQ,KAAK,IAAI,IAAI,QAAQ;AAAA,IAC1C,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,SAAK,gBAAgB;AACrB,SAAK,MAAM,OAAO,GAAG;AAAA,EACvB;AAAA,EAEQ,kBAAwB;AAC9B,QAAI,CAAC,KAAK,WAAW;AACnB,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,oBAA0B;AAChC,UAAM,MAAM,KAAK,IAAI;AACrB,eAAW,CAAC,UAAU,IAAI,KAAK,KAAK,OAAO;AACzC,UAAI,KAAK,aAAa,KAAK;AACzB,aAAK,MAAM,OAAO,QAAQ;AAAA,MAC5B;AAAA,IACF;AAAA,EACF;AAAA;AAAA,EAGA,wBAAgC;AAC9B,WAAO,KAAK,cAAc;AAAA,EAC5B;AAAA,EAEA,gBAAwB;AACtB,SAAK,kBAAkB;AACvB,WAAO,KAAK,MAAM;AAAA,EACpB;AACF;AAEA,SAAS,gBAAwB;AAC/B,SAAO,OAAO,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,UAAU,GAAG,EAAE,CAAC;AACzE;AAEO,SAAS,oBAAwC;AACtD,SAAO,IAAI,mBAAmB;AAChC;","names":[]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@chat-adapter/state-memory",
+  "version": "4.0.0",
+  "description": "In-memory state adapter for chat (development/testing)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chat": "4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "keywords": [
+    "chat",
+    "state",
+    "memory",
+    "testing"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src",
+    "clean": "rm -rf dist"
+  }
+}