@skein-js/storage-memory 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,8 +1,11 @@
-import { SkeinStore, AssistantRepo, ThreadRepo, RunRepo, StoreRepo, SkeinStoreSnapshot, RunEventBus, RunFrame, RunQueue, QueuedRun, RunProcessor, RunConsumerOptions, RunConsumer } from '@skein-js/core';
+import { SkeinStore, StoreTtlConfig, AssistantRepo, ThreadRepo, RunRepo, StoreRepo, SkeinStoreSnapshot, RunEventBus, RunFrame, RunQueue, QueuedRun, RunProcessor, RunConsumerOptions, RunConsumer } from '@skein-js/core';
 
 /** In-process SkeinStore for development and tests. */
 declare class MemorySkeinStore implements SkeinStore {
     #private;
+    constructor(options?: {
+        ttl?: StoreTtlConfig;
+    });
     readonly assistants: AssistantRepo;
     readonly threads: ThreadRepo;
     readonly runs: RunRepo;

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/memory-skein-store.ts
 import { randomUUID } from "crypto";
 import {
+  isMetadataSubset,
   isTerminalRunStatus,
   SkeinHttpError
 } from "@skein-js/core";
@@ -33,6 +34,37 @@ var MemorySkeinStore = class {
   // The opaque execution payload lives beside the run row (it is not part of the wire `Run`).
   #runKwargs = /* @__PURE__ */ new Map();
   #items = /* @__PURE__ */ new Map();
+  // Item expiry lives beside the item (never on the wire `Item`), keyed the same way as #items:
+  // `expiresAt` is epoch-ms (null = never expires), `ttlMinutes` is what a refresh-on-read extends by.
+  #itemExpiry = /* @__PURE__ */ new Map();
+  #ttl;
+  constructor(options) {
+    this.#ttl = options?.ttl;
+  }
+  /** Record (or clear) an item's expiry from a resolved per-item TTL in minutes. */
+  #setExpiry(id, ttlMinutes) {
+    if (ttlMinutes === null || ttlMinutes === void 0) {
+      this.#itemExpiry.delete(id);
+      return;
+    }
+    this.#itemExpiry.set(id, { expiresAt: Date.now() + ttlMinutes * 6e4, ttlMinutes });
+  }
+  /** True if the item has expired and should read as absent. */
+  #isExpired(id) {
+    const entry = this.#itemExpiry.get(id);
+    return entry?.expiresAt != null && entry.expiresAt <= Date.now();
+  }
+  /**
+   * Extend a live item's expiry on read when TTL is configured and `refresh_on_read` isn't disabled
+   * (it defaults on). With no configured TTL we never refresh, matching the Postgres driver.
+   */
+  #maybeRefresh(id) {
+    if (this.#ttl === void 0 || this.#ttl.refreshOnRead === false) return;
+    const entry = this.#itemExpiry.get(id);
+    if (entry?.ttlMinutes != null) {
+      this.#itemExpiry.set(id, { ...entry, expiresAt: Date.now() + entry.ttlMinutes * 6e4 });
+    }
+  }
   assistants = {
     list: async () => readAll(this.#assistants),
     get: async (assistantId) => readOne(this.#assistants, assistantId),
@@ -58,6 +90,22 @@ var MemorySkeinStore = class {
   };
   threads = {
     list: async () => readAll(this.#threads),
+    search: async (query) => {
+      const matched = readAll(this.#threads).filter(
+        (thread) => (!query.ids || query.ids.includes(thread.thread_id)) && (!query.status || thread.status === query.status) && isMetadataSubset(thread.metadata, query.metadata) && isMetadataSubset(thread.values, query.values)
+      );
+      const sortBy = query.sortBy ?? "created_at";
+      const direction = query.sortOrder === "asc" ? 1 : -1;
+      const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+      matched.sort((a, b) => {
+        const primary = compare(String(a[sortBy] ?? ""), String(b[sortBy] ?? ""));
+        const ordered = primary !== 0 ? primary : compare(a.thread_id, b.thread_id);
+        return direction * ordered;
+      });
+      const offset = query.offset ?? 0;
+      const limit = query.limit ?? matched.length;
+      return matched.slice(offset, offset + limit);
+    },
     get: async (threadId) => readOne(this.#threads, threadId),
     create: async (input) => {
       const at = nowIso();
@@ -88,6 +136,19 @@ var MemorySkeinStore = class {
       };
       return write(this.#threads, threadId, updated);
     },
+    copy: async (threadId) => {
+      const existing = this.#threads.get(threadId);
+      if (!existing) throw SkeinHttpError.notFound(`Thread "${threadId}" not found.`);
+      const at = nowIso();
+      const copy = {
+        ...clone(existing),
+        thread_id: randomUUID(),
+        created_at: at,
+        updated_at: at,
+        state_updated_at: at
+      };
+      return write(this.#threads, copy.thread_id, copy);
+    },
     delete: async (threadId) => {
       this.#threads.delete(threadId);
       for (const [runId, run] of this.#runs) {
@@ -139,10 +200,18 @@ var MemorySkeinStore = class {
   };
   store = {
     get: async (namespace, key) => {
-      const found = this.#items.get(itemKey(namespace, key));
-      return found ? clone(found) : null;
+      const id = itemKey(namespace, key);
+      const found = this.#items.get(id);
+      if (!found) return null;
+      if (this.#isExpired(id)) {
+        this.#items.delete(id);
+        this.#itemExpiry.delete(id);
+        return null;
+      }
+      this.#maybeRefresh(id);
+      return clone(found);
     },
-    put: async (namespace, key, value) => {
+    put: async (namespace, key, value, options) => {
       const id = itemKey(namespace, key);
       const at = nowIso();
       const existing = this.#items.get(id);
@@ -155,14 +224,17 @@ var MemorySkeinStore = class {
       };
       const stored = clone(item);
       this.#items.set(id, stored);
+      this.#setExpiry(id, options?.ttl ?? this.#ttl?.defaultTtl ?? null);
       return clone(stored);
     },
     delete: async (namespace, key) => {
-      this.#items.delete(itemKey(namespace, key));
+      const id = itemKey(namespace, key);
+      this.#items.delete(id);
+      this.#itemExpiry.delete(id);
     },
     search: async (query) => {
       const needle = query.query?.toLowerCase();
-      const matches = [...this.#items.values()].filter((item) => hasPrefix(item.namespace, query.prefix)).filter(
+      const matches = [...this.#items.entries()].filter(([id]) => !this.#isExpired(id)).map(([, item]) => item).filter((item) => hasPrefix(item.namespace, query.prefix)).filter(
         (item) => needle ? JSON.stringify(item.value).toLowerCase().includes(needle) : true
       ).map((item) => {
         const result = clone(item);
@@ -174,12 +246,24 @@ var MemorySkeinStore = class {
     },
     listNamespaces: async (prefix) => {
       const seen = /* @__PURE__ */ new Map();
-      for (const item of this.#items.values()) {
+      for (const [id, item] of this.#items.entries()) {
+        if (this.#isExpired(id)) continue;
         if (hasPrefix(item.namespace, prefix)) {
           seen.set(JSON.stringify(item.namespace), item.namespace);
         }
       }
       return [...seen.values()].map((namespace) => [...namespace]);
+    },
+    sweepExpired: async () => {
+      let removed = 0;
+      for (const id of [...this.#itemExpiry.keys()]) {
+        if (this.#isExpired(id)) {
+          this.#items.delete(id);
+          this.#itemExpiry.delete(id);
+          removed += 1;
+        }
+      }
+      return removed;
     }
   };
   /**
@@ -207,6 +291,7 @@ var MemorySkeinStore = class {
     fill(this.#runs, snapshot.runs);
     fill(this.#runKwargs, snapshot.runKwargs);
     fill(this.#items, snapshot.items);
+    this.#itemExpiry.clear();
   }
   /**
    * Bulk-load rows from a snapshot, preserving ids + timestamps and *without* clearing what's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skein-js/storage-memory",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "In-memory SkeinStore + queue driver for development and tests.",
   "license": "Apache-2.0",
   "author": "Maina Wycliffe <wmmaina7@gmail.com>",
@@ -40,10 +40,10 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@skein-js/core": "0.3.0"
+    "@skein-js/core": "0.5.0"
   },
   "devDependencies": {
-    "@skein-js/test-support": "0.3.0"
+    "@skein-js/test-support": "0.5.0"
   },
   "publishConfig": {
     "access": "public"