@reactionary/core 0.10.32 → 0.10.33

package/cache/memory-cache.js

@@ -1,50 +1,48 @@
 import { getReactionaryCacheMeter } from "../metrics/metrics.js";
-import { error, NotFoundErrorSchema, success } from "../schemas/index.js";
 class MemoryCache {
-  entries = new Array();
+  entries = /* @__PURE__ */ new Map();
   meter = getReactionaryCacheMeter();
   async get(key, schema) {
-    const c = this.entries.find((x) => x.key === key);
-    if (!c) {
+    const entry = this.entries.get(key);
+    if (!entry || entry.expiresAt <= Date.now()) {
+      if (entry) {
+        this.entries.delete(key);
+      }
       this.meter.misses.add(1, {
         "labels.cache_type": "memory"
       });
       return null;
     }
-    const parsed = schema.parse(c.value);
+    const parsed = schema.parse(entry.value);
     this.meter.hits.add(1, {
       "labels.cache_type": "memory"
     });
     return parsed;
   }
   async put(key, value, options) {
-    this.entries.push({
-      key,
+    this.entries.set(key, {
       value,
-      options
+      options,
+      expiresAt: Date.now() + options.ttlSeconds * 1e3
     });
-    this.meter.items.record(this.entries.length, {
+    this.meter.items.record(this.entries.size, {
       "labels.cache_type": "memory"
     });
     return;
   }
   async invalidate(dependencyIds) {
-    let index = 0;
-    for (const entry of this.entries) {
-      for (const entryDependency of entry.options.dependencyIds) {
-        if (dependencyIds.indexOf(entryDependency) > -1) {
-          this.entries.splice(index, 1);
-        }
+    for (const [key, entry] of this.entries) {
+      if (entry.options.dependencyIds.some((dependencyId) => dependencyIds.includes(dependencyId))) {
+        this.entries.delete(key);
       }
-      index++;
     }
-    this.meter.items.record(this.entries.length, {
+    this.meter.items.record(this.entries.size, {
       "labels.cache_type": "memory"
     });
   }
   async clear() {
-    this.entries = [];
-    this.meter.items.record(this.entries.length, {
+    this.entries = /* @__PURE__ */ new Map();
+    this.meter.items.record(this.entries.size, {
       "labels.cache_type": "memory"
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.10.32",
+  "version": "0.10.33",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",

package/src/cache/memory-cache.d.ts

@@ -1,20 +1,21 @@
 import type { BaseModel } from '../schemas/models/index.js';
-import type { Result } from '../schemas/result.js';
 import type { Cache, CacheEntryOptions } from './cache.interface.js';
 import type * as z from 'zod';
+interface MemoryCacheEntry {
+    value: unknown;
+    options: CacheEntryOptions;
+    expiresAt: number;
+}
 /**
  * Memory version of the cache. Primarily useful for local development.
  * This is NOT suited for production use.
  */
 export declare class MemoryCache implements Cache {
-    protected entries: {
-        key: string;
-        value: unknown;
-        options: CacheEntryOptions;
-    }[];
+    protected entries: Map<string, MemoryCacheEntry>;
     protected meter: import("../metrics/metrics.js").ReactionaryCacheMetrics;
     get<T extends BaseModel>(key: string, schema: z.ZodType<T>): Promise<T | null>;
-    put(key: string, value: Result<unknown>, options: CacheEntryOptions): Promise<void>;
+    put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;
     invalidate(dependencyIds: Array<string>): Promise<void>;
     clear(): Promise<void>;
 }
+export {};