@graphql-mesh/cache-inmemory-lru 0.6.18 → 0.7.0

package/cjs/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@graphql-mesh/utils");
+const disposablestack_1 = require("@whatwg-node/disposablestack");
+class InMemoryLRUCache {
+    constructor(options) {
+        this.timeouts = new Set();
+        this.lru = (0, utils_1.createLruCache)(options?.max, options?.ttl);
+        const subId = options?.pubsub?.subscribe?.('destroy', () => {
+            options?.pubsub?.unsubscribe(subId);
+            this[disposablestack_1.DisposableSymbols.dispose]();
+        });
+    }
+    get(key) {
+        return this.lru.get(key);
+    }
+    set(key, value, options) {
+        this.lru.set(key, value);
+        if (options?.ttl && options.ttl > 0) {
+            const timeout = setTimeout(() => {
+                this.timeouts.delete(timeout);
+                this.lru.delete(key);
+            }, options.ttl * 1000);
+            this.timeouts.add(timeout);
+        }
+    }
+    delete(key) {
+        try {
+            this.lru.delete(key);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    getKeysByPrefix(prefix) {
+        const keysWithPrefix = [];
+        for (const key of this.lru.keys()) {
+            if (key.startsWith(prefix)) {
+                keysWithPrefix.push(key);
+            }
+        }
+        return keysWithPrefix;
+    }
+    [disposablestack_1.DisposableSymbols.dispose]() {
+        for (const timeout of this.timeouts) {
+            clearTimeout(timeout);
+            this.timeouts.delete(timeout);
+        }
+    }
+}
+exports.default = InMemoryLRUCache;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/esm/index.js

@@ -0,0 +1,49 @@
+import { createLruCache } from '@graphql-mesh/utils';
+import { DisposableSymbols } from '@whatwg-node/disposablestack';
+export default class InMemoryLRUCache {
+    constructor(options) {
+        this.timeouts = new Set();
+        this.lru = createLruCache(options?.max, options?.ttl);
+        const subId = options?.pubsub?.subscribe?.('destroy', () => {
+            options?.pubsub?.unsubscribe(subId);
+            this[DisposableSymbols.dispose]();
+        });
+    }
+    get(key) {
+        return this.lru.get(key);
+    }
+    set(key, value, options) {
+        this.lru.set(key, value);
+        if (options?.ttl && options.ttl > 0) {
+            const timeout = setTimeout(() => {
+                this.timeouts.delete(timeout);
+                this.lru.delete(key);
+            }, options.ttl * 1000);
+            this.timeouts.add(timeout);
+        }
+    }
+    delete(key) {
+        try {
+            this.lru.delete(key);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    getKeysByPrefix(prefix) {
+        const keysWithPrefix = [];
+        for (const key of this.lru.keys()) {
+            if (key.startsWith(prefix)) {
+                keysWithPrefix.push(key);
+            }
+        }
+        return keysWithPrefix;
+    }
+    [DisposableSymbols.dispose]() {
+        for (const timeout of this.timeouts) {
+            clearTimeout(timeout);
+            this.timeouts.delete(timeout);
+        }
+    }
+}

package/package.json

@@ -1,36 +1,47 @@
 {
   "name": "@graphql-mesh/cache-inmemory-lru",
-  "version": "0.6.18",
+  "version": "0.7.0",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "*"
   },
   "dependencies": {
-    "@graphql-mesh/types": "0.71.4",
-    "@graphql-mesh/utils": "0.34.4",
-    "tslib": "^2.3.1"
+    "@graphql-mesh/types": "^0.103.19",
+    "@graphql-mesh/utils": "^0.103.19",
+    "@whatwg-node/disposablestack": "^0.0.5",
+    "tslib": "^2.4.0"
   },
   "repository": {
     "type": "git",
-    "url": "Urigo/graphql-mesh",
+    "url": "ardatan/graphql-mesh",
     "directory": "packages/cache/inmemory-lru"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/index.d.cts

@@ -0,0 +1,17 @@
+import type { KeyValueCache, KeyValueCacheSetOptions, MeshPubSub } from '@graphql-mesh/types';
+import { DisposableSymbols } from '@whatwg-node/disposablestack';
+export interface InMemoryLRUCacheOptions {
+    max?: number;
+    ttl?: number;
+    pubsub?: MeshPubSub;
+}
+export default class InMemoryLRUCache<V = any> implements KeyValueCache<V>, Disposable {
+    private lru;
+    private timeouts;
+    constructor(options?: InMemoryLRUCacheOptions);
+    get(key: string): any;
+    set(key: string, value: any, options?: KeyValueCacheSetOptions): void;
+    delete(key: string): boolean;
+    getKeysByPrefix(prefix: string): any[];
+    [DisposableSymbols.dispose](): void;
+}

package/typings/index.d.ts

@@ -0,0 +1,17 @@
+import type { KeyValueCache, KeyValueCacheSetOptions, MeshPubSub } from '@graphql-mesh/types';
+import { DisposableSymbols } from '@whatwg-node/disposablestack';
+export interface InMemoryLRUCacheOptions {
+    max?: number;
+    ttl?: number;
+    pubsub?: MeshPubSub;
+}
+export default class InMemoryLRUCache<V = any> implements KeyValueCache<V>, Disposable {
+    private lru;
+    private timeouts;
+    constructor(options?: InMemoryLRUCacheOptions);
+    get(key: string): any;
+    set(key: string, value: any, options?: KeyValueCacheSetOptions): void;
+    delete(key: string): boolean;
+    getKeysByPrefix(prefix: string): any[];
+    [DisposableSymbols.dispose](): void;
+}

package/index.d.ts

@@ -1,10 +0,0 @@
-import { KeyValueCache, KeyValueCacheSetOptions, YamlConfig } from '@graphql-mesh/types';
-export default class InMemoryLRUCache<V = any> implements KeyValueCache<V> {
-    private cacheIdentifier;
-    private lruCache;
-    constructor(options?: YamlConfig.InMemoryLRUConfig);
-    private nextTick;
-    get(key: string): Promise<V>;
-    set(key: string, value: V, options?: KeyValueCacheSetOptions): Promise<void>;
-    delete(key: string): Promise<void>;
-}

package/index.js

@@ -1,37 +0,0 @@
-'use strict';
-
-const utils = require('@graphql-mesh/utils');
-
-class InMemoryLRUCache {
-    constructor(options) {
-        this.cacheIdentifier = Date.now();
-        this.lruCache = utils.createLruCache(options === null || options === void 0 ? void 0 : options.max, options === null || options === void 0 ? void 0 : options.ttl);
-    }
-    nextTick() {
-        // Make sure this is scheduled for next tick because LRU Cache is synchronous
-        // This helps for testing multiple Mesh instances pointing to the same cache
-        return new Promise(resolve => setTimeout(resolve));
-    }
-    async get(key) {
-        await this.nextTick();
-        const entry = this.lruCache.get(`${this.cacheIdentifier}-${key}`);
-        if ((entry === null || entry === void 0 ? void 0 : entry.expiresAt) && Date.now() > entry.expiresAt) {
-            this.lruCache.delete(key);
-            return undefined;
-        }
-        return entry === null || entry === void 0 ? void 0 : entry.value;
-    }
-    async set(key, value, options) {
-        await this.nextTick();
-        this.lruCache.set(`${this.cacheIdentifier}-${key}`, {
-            expiresAt: (options === null || options === void 0 ? void 0 : options.ttl) ? Date.now() + options.ttl * 1000 : Infinity,
-            value,
-        });
-    }
-    async delete(key) {
-        await this.nextTick();
-        this.lruCache.delete(`${this.cacheIdentifier}-${key}`);
-    }
-}
-
-module.exports = InMemoryLRUCache;

package/index.mjs

@@ -1,35 +0,0 @@
-import { createLruCache } from '@graphql-mesh/utils';
-
-class InMemoryLRUCache {
-    constructor(options) {
-        this.cacheIdentifier = Date.now();
-        this.lruCache = createLruCache(options === null || options === void 0 ? void 0 : options.max, options === null || options === void 0 ? void 0 : options.ttl);
-    }
-    nextTick() {
-        // Make sure this is scheduled for next tick because LRU Cache is synchronous
-        // This helps for testing multiple Mesh instances pointing to the same cache
-        return new Promise(resolve => setTimeout(resolve));
-    }
-    async get(key) {
-        await this.nextTick();
-        const entry = this.lruCache.get(`${this.cacheIdentifier}-${key}`);
-        if ((entry === null || entry === void 0 ? void 0 : entry.expiresAt) && Date.now() > entry.expiresAt) {
-            this.lruCache.delete(key);
-            return undefined;
-        }
-        return entry === null || entry === void 0 ? void 0 : entry.value;
-    }
-    async set(key, value, options) {
-        await this.nextTick();
-        this.lruCache.set(`${this.cacheIdentifier}-${key}`, {
-            expiresAt: (options === null || options === void 0 ? void 0 : options.ttl) ? Date.now() + options.ttl * 1000 : Infinity,
-            value,
-        });
-    }
-    async delete(key) {
-        await this.nextTick();
-        this.lruCache.delete(`${this.cacheIdentifier}-${key}`);
-    }
-}
-
-export default InMemoryLRUCache;