@extra-memoize/memory-cache 0.2.8 → 0.2.9

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@extra-memoize/memory-cache",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "",
   "keywords": [],
   "files": [
     "lib",
-    "dist"
+    "src"
   ],
   "main": "lib/es2018/index.js",
   "types": "lib/es2018/index.d.ts",

package/src/caches/expirable-cache-with-stale-if-error.ts

@@ -0,0 +1,39 @@
+import { ExpirableCache } from './expirable-cache'
+import { IStaleIfErrorCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class ExpirableCacheWithStaleIfError<T> implements IStaleIfErrorCache<T> {
+  private cache: ExpirableCache<IRecord<T>>
+
+  constructor(private timeToLive: number, private staleIfError: number) {
+    this.cache = new ExpirableCache(timeToLive + staleIfError)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss] | [State.Hit | State.StaleIfError, T] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      const elapsed = Date.now() - record.updatedAt
+      if (elapsed <= this.timeToLive) {
+        return [State.Hit, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleIfError) {
+        return [State.StaleIfError, record.value]
+      } else {
+        // just in case
+        return [State.Miss]
+      }
+    }
+  }
+}

package/src/caches/expirable-cache-with-stale-while-revalidate-and-stale-if-error.ts

@@ -0,0 +1,51 @@
+import { ExpirableCache } from './expirable-cache'
+import { IStaleWhileRevalidateAndStaleIfErrorCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class ExpirableCacheWithStaleWhileRevalidateAndStaleIfError<T> implements IStaleWhileRevalidateAndStaleIfErrorCache<T> {
+  private cache: ExpirableCache<IRecord<T>>
+
+  constructor(
+    private timeToLive: number
+  , private staleWhileRevalidate: number
+  , private staleIfError: number
+  ) {
+    this.cache = new ExpirableCache(timeToLive + staleWhileRevalidate + staleIfError)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss]
+                  | [
+                    | State.Hit
+                    | State.StaleWhileRevalidate
+                    | State.StaleIfError
+                    , T
+                    ] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      const elapsed = Date.now() - record.updatedAt
+      if (elapsed <= this.timeToLive) {
+        return [State.Hit, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleWhileRevalidate) {
+        return [State.StaleWhileRevalidate, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleWhileRevalidate + this.staleIfError) {
+        return [State.StaleIfError, record.value]
+      } else {
+        // just in case
+        return [State.Miss]
+      }
+    }
+  }
+}

package/src/caches/expirable-cache-with-stale-while-revalidate.ts

@@ -0,0 +1,40 @@
+import { ExpirableCache } from './expirable-cache'
+import { IStaleWhileRevalidateCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class ExpirableCacheWithStaleWhileRevalidate<T> implements IStaleWhileRevalidateCache<T> {
+  private cache: ExpirableCache<IRecord<T>>
+
+  constructor(private timeToLive: number, private staleWhileRevalidate: number) {
+    this.cache = new ExpirableCache(timeToLive + staleWhileRevalidate)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss] | [State.Hit | State.StaleWhileRevalidate, T] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      if (this.isStaleWhileRevalidate(record)) {
+        return [State.StaleWhileRevalidate, record.value]
+      } else {
+        return [State.Hit, record.value]
+      }
+    }
+  }
+
+  private isStaleWhileRevalidate(record: IRecord<T>): boolean {
+    return Date.now() - record.updatedAt > this.timeToLive
+        && Date.now() - record.updatedAt <= this.timeToLive + this.staleWhileRevalidate
+  }
+}

package/src/caches/expirable-cache.ts

@@ -0,0 +1,26 @@
+import { ExpirableMap } from '@blackglory/structures'
+import { ICache, State } from 'extra-memoize'
+
+export class ExpirableCache<T> implements ICache<T> {
+  private map: ExpirableMap<string, T>
+
+  constructor(private timeToLive: number) {
+    this.map = new ExpirableMap()
+  }
+
+  get(key: string): [State.Miss] | [State.Hit, T] {
+    if (this.map.has(key)) {
+      return [State.Hit, this.map.get(key)!]
+    } else {
+      return [State.Miss]
+    }
+  }
+
+  set(key: string, value: T): void {
+    this.map.set(key, value, this.timeToLive)
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+}

package/src/caches/index.ts

@@ -0,0 +1,11 @@
+export * from './lru-cache'
+
+export * from './expirable-cache'
+export * from './expirable-cache-with-stale-while-revalidate'
+export * from './expirable-cache-with-stale-if-error'
+export * from './expirable-cache-with-stale-while-revalidate-and-stale-if-error'
+
+export * from './tlru-cache'
+export * from './tlru-cache-with-stale-while-revalidate'
+export * from './tlru-cache-with-stale-if-error'
+export * from './tlru-cache-with-stale-while-revalidate-and-stale-if-error'

package/src/caches/lru-cache.ts

@@ -0,0 +1,26 @@
+import { LRUMap } from '@blackglory/structures'
+import { ICache, State } from 'extra-memoize'
+
+export class LRUCache<T> implements ICache<T> {
+  private map: LRUMap<string, T> 
+
+  constructor(limit: number) {
+    this.map = new LRUMap(limit)
+  }
+
+  set(key: string, value: T): void {
+    this.map.set(key, value)
+  }
+
+  get(key: string): [State.Miss] | [State.Hit, T] {
+    if (this.map.has(key)) {
+      return [State.Hit, this.map.get(key)!]
+    } else {
+      return [State.Miss]
+    }
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+}

package/src/caches/tlru-cache-with-stale-if-error.ts

@@ -0,0 +1,43 @@
+import { TLRUCache } from './tlru-cache'
+import { IStaleIfErrorCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class TLRUCacheWithStaleIfError<T> implements IStaleIfErrorCache<T> {
+  private cache: TLRUCache<IRecord<T>>
+
+  constructor(
+    limit: number
+  , private timeToLive: number
+  , private staleIfError: number
+  ) {
+    this.cache = new TLRUCache(limit, timeToLive + staleIfError)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss] | [State.Hit | State.StaleIfError, T] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      const elapsed = Date.now() - record.updatedAt
+      if (elapsed <= this.timeToLive) {
+        return [State.Hit, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleIfError) {
+        return [State.StaleIfError, record.value]
+      } else {
+        // just in case
+        return [State.Miss]
+      }
+    }
+  }
+}

package/src/caches/tlru-cache-with-stale-while-revalidate-and-stale-if-error.ts

@@ -0,0 +1,52 @@
+import { TLRUCache } from './tlru-cache'
+import { IStaleWhileRevalidateAndStaleIfErrorCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class TLRUCacheWithStaleWhileRevalidateAndStaleIfError<T> implements IStaleWhileRevalidateAndStaleIfErrorCache<T> {
+  private cache: TLRUCache<IRecord<T>>
+
+  constructor(
+    limit: number
+  , private timeToLive: number
+  , private staleWhileRevalidate: number
+  , private staleIfError: number
+  ) {
+    this.cache = new TLRUCache(limit, timeToLive + staleWhileRevalidate + staleIfError)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss]
+                  | [
+                    | State.Hit
+                    | State.StaleWhileRevalidate
+                    | State.StaleIfError
+                    , T
+                    ] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      const elapsed = Date.now() - record.updatedAt
+      if (elapsed <= this.timeToLive) {
+        return [State.Hit, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleWhileRevalidate) {
+        return [State.StaleWhileRevalidate, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleWhileRevalidate + this.staleIfError) {
+        return [State.StaleIfError, record.value]
+      } else {
+        // just in case
+        return [State.Miss]
+      }
+    }
+  }
+}

package/src/caches/tlru-cache-with-stale-while-revalidate.ts

@@ -0,0 +1,44 @@
+import { TLRUCache } from './tlru-cache'
+import { IStaleWhileRevalidateCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class TLRUCacheWithStaleWhileRevalidate<T> implements IStaleWhileRevalidateCache<T> {
+  private cache: TLRUCache<IRecord<T>>
+
+  constructor(
+    limit: number
+  , private timeToLive: number
+  , private staleWhileRevalidate: number
+  ) {
+    this.cache = new TLRUCache(limit, timeToLive + staleWhileRevalidate)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss] | [State.Hit | State.StaleWhileRevalidate, T] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      if (this.isStaleWhileRevalidate(record)) {
+        return [State.StaleWhileRevalidate, record.value]
+      } else {
+        return [State.Hit, record.value]
+      }
+    }
+  }
+
+  isStaleWhileRevalidate(record: IRecord<T>): boolean {
+    return Date.now() - record.updatedAt > this.timeToLive
+        && Date.now() - record.updatedAt <= this.timeToLive + this.staleWhileRevalidate
+  }
+}

package/src/caches/tlru-cache.ts

@@ -0,0 +1,26 @@
+import { TLRUMap } from '@blackglory/structures'
+import { ICache, State } from 'extra-memoize'
+
+export class TLRUCache<T> implements ICache<T> {
+  private map: TLRUMap<string, T> 
+
+  constructor(limit: number, private timeToLive: number) {
+    this.map = new TLRUMap(limit)
+  }
+
+  set(key: string, value: T): void {
+    this.map.set(key, value, this.timeToLive)
+  }
+
+  get(key: string): [State.Miss] | [State.Hit, T] {
+    if (this.map.has(key)) {
+      return [State.Hit, this.map.get(key)!]
+    } else {
+      return [State.Miss]
+    }
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from '@caches'

package/CHANGELOG.md

@@ -1,42 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
-
-### [0.2.8](https://github.com/extra-memoize/memory-cache/compare/v0.2.7...v0.2.8) (2023-01-28)
-
-
-### Bug Fixes
-
-* dependencies ([814b9df](https://github.com/extra-memoize/memory-cache/commit/814b9df8512f4b4dc6470b1fa1ec1ed31dbd3f83))
-
-### [0.2.7](https://github.com/extra-memoize/memory-cache/compare/v0.2.6...v0.2.7) (2023-01-28)
-
-### [0.2.6](https://github.com/extra-memoize/memory-cache/compare/v0.2.5...v0.2.6) (2023-01-21)
-
-### [0.2.5](https://github.com/extra-memoize/memory-cache/compare/v0.2.4...v0.2.5) (2022-11-03)
-
-### [0.2.4](https://github.com/extra-memoize/memory-cache/compare/v0.2.3...v0.2.4) (2022-09-09)
-
-### [0.2.3](https://github.com/extra-memoize/memory-cache/compare/v0.2.2...v0.2.3) (2022-08-06)
-
-### [0.2.2](https://github.com/extra-memoize/memory-cache/compare/v0.2.1...v0.2.2) (2022-08-04)
-
-### [0.2.1](https://github.com/extra-memoize/memory-cache/compare/v0.2.0...v0.2.1) (2022-06-26)
-
-## [0.2.0](https://github.com/extra-memoize/memory-cache/compare/v0.1.0...v0.2.0) (2022-05-10)
-
-
-### ⚠ BREAKING CHANGES
-
-* use extra-memoize@0.6
-
-### Features
-
-* use extra-memoize@0.6 ([9e72236](https://github.com/extra-memoize/memory-cache/commit/9e72236114a1764166d479afe384193081c727b3))
-
-## 0.1.0 (2022-04-08)
-
-
-### Features
-
-* init ([5c4d170](https://github.com/extra-memoize/memory-cache/commit/5c4d170569bb5aec61987ebac77f770d45a6cff7))