Merge pull request #2 from MakerXStudio/add-clear-cache

feat: add clear cache

Author: inaie-makerx

.env.sample

@@ -0,0 +1,4 @@
+BUCKET_NAME=
+AWS_REGION=
+ACCESS_KEY=
+SECRET=

.gitignore

@@ -40,3 +40,5 @@ coverage
 # Website & Code docs generation
 code-docs/
 out/
+
+.env

jest.config.ts

@@ -1,4 +1,6 @@
 import type { Config } from '@jest/types'
+import dotenv from 'dotenv'
+dotenv.config()
 
 const config: Config.InitialOptions = {
   preset: 'ts-jest',

package-lock.json

@@ -59,6 +59,7 @@
     "@typescript-eslint/eslint-plugin": "^6.15.0",
     "@typescript-eslint/parser": "^6.15.0",
     "conventional-changelog-conventionalcommits": "^7.0.2",
+    "dotenv": "^16.4.5",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-node": "^11.1.0",

package.json

@@ -57,4 +57,10 @@ export interface ObjectCache {
    * @param mimeType Optional mime type of the data; default = `application/json` or `application/octet-stream` depending on if the data is binary or JSON.
    */
   putBinary(cacheKey: string, data: Uint8Array, mimeType?: string): Promise<void>
+
+  /**
+   * Clear the cache value for the given cache key
+   * @param cacheKey A unique key that identifies the cached value
+   */
+  clearCache(cacheKey: string): void
 }

src/cache.ts

@@ -1,6 +1,7 @@
 import { describe, beforeEach, test } from '@jest/globals'
 import path from 'node:path'
 import * as fs from 'node:fs/promises'
+import * as fsSync from 'node:fs'
 import { FileSystemObjectCache } from './fileSystemObjectCache'
 
 const testDir = path.join(__dirname, '..', '.cache')
@@ -30,6 +31,37 @@ describe('FileSystemObjectCache', () => {
     `)
   })
 
+  test('Clear json file cache', async () => {
+    const cache = new FileSystemObjectCache(testDir, true)
+
+    await cache.put('test', { test: 1 })
+
+    const data = await fs.readFile(path.join(testDir, 'test.json'), { encoding: 'utf-8' })
+    expect(data).toMatchInlineSnapshot(`
+      "{
+        "test": 1
+      }"
+    `)
+
+    await cache.clearCache('test')
+    const fileExist = fsSync.existsSync(path.join(testDir, 'test.json'))
+    expect(fileExist).toBe(false)
+  })
+
+  test('Clear binary cache', async () => {
+    const cache = new FileSystemObjectCache(testDir, true)
+    const fileData = Uint8Array.from(atob('test'), (c) => c.charCodeAt(0))
+
+    await cache.put('test', fileData)
+
+    const data = await fs.readFile(path.join(testDir, 'test'))
+    expect(data.compare(fileData)).toBe(0)
+
+    await cache.clearCache('test')
+    const fileExist = fsSync.existsSync(path.join(testDir, 'test'))
+    expect(fileExist).toBe(false)
+  })
+
   test("Get an object from cache if it didn't exist", async () => {
     const cache = new FileSystemObjectCache(testDir, true)
 

src/fileSystemObjectCache.spec.ts

@@ -23,6 +23,17 @@ export class FileSystemObjectCache implements ObjectCache {
     }
   }
 
+  /**
+   * Clear the cache value for te given cache key
+   * @param cacheKey A unique key that identifies the cached value
+   */
+  async clearCache(cacheKey: string): Promise<void> {
+    if (fsSync.existsSync(path.join(this.cacheDirectory, cacheKey))) await fs.unlink(path.join(this.cacheDirectory, cacheKey))
+
+    if (fsSync.existsSync(path.join(this.cacheDirectory, `${cacheKey}.json`)))
+      await fs.unlink(path.join(this.cacheDirectory, `${cacheKey}.json`))
+  }
+
   /** Adds the given value to the cache for the given cache key
    * @param cacheKey A unique key that identifies the cached value
    * @param data The data to cache

src/fileSystemObjectCache.ts

@@ -0,0 +1,154 @@
+import { GetObjectCommand, HeadObjectCommand, S3Client } from '@aws-sdk/client-s3'
+import { describe, test } from '@jest/globals'
+import { S3ObjectCache } from './s3ObjectCache'
+
+const maybe = process.env.BUCKET_NAME && process.env.AWS_REGION && process.env.ACCESS_KEY && process.env.SECRET ? describe : describe.skip
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const zlib = require('zlib')
+
+maybe('S3ObjectCache', () => {
+  const s3Client = new S3Client({
+    region: process.env.AWS_REGION,
+    credentials: {
+      accessKeyId: process.env.ACCESS_KEY!,
+      secretAccessKey: process.env.SECRET!,
+    },
+  })
+  const bucketName = process.env.BUCKET_NAME
+
+  const checkFileExist = async (key: string) => {
+    const bucketAndKey = {
+      Bucket: bucketName,
+      Key: key,
+    }
+
+    const fileExist = await s3Client
+      .send(new HeadObjectCommand(bucketAndKey))
+      .then(() => true)
+      .catch(() => false)
+
+    return fileExist
+  }
+
+  test('Puts an object in cache as json', async () => {
+    const cache = new S3ObjectCache(s3Client, bucketName!)
+    await cache.put('test', { test: 1 })
+
+    const bucketAndKey = {
+      Bucket: bucketName,
+      Key: 'test.json.gz',
+    }
+
+    const data = await s3Client
+      .send(new GetObjectCommand(bucketAndKey))
+      .then(async (x) => ({ Body: await x.Body!.transformToByteArray(), LastModified: x.LastModified, ContentType: x.ContentType }))
+      .catch(() => undefined)
+
+    const json = data ? zlib.gunzipSync(data.Body!).toString('utf-8') : undefined
+    expect(json).toMatchInlineSnapshot(`
+      "{
+        "test": 1
+      }"
+    `)
+  })
+
+  test('Clear json file cache', async () => {
+    const cache = new S3ObjectCache(s3Client, bucketName!)
+    const key = 'test.json.gz'
+
+    await cache.put('test', { test: 1 })
+    let fileExist = await checkFileExist(key)
+    expect(fileExist).toBe(true)
+
+    await cache.clearCache('test')
+    fileExist = await checkFileExist(key)
+    expect(fileExist).toBe(false)
+  })
+
+  test('Clear binary cache', async () => {
+    const cache = new S3ObjectCache(s3Client, bucketName!)
+    const fileData = Uint8Array.from(atob('test'), (c) => c.charCodeAt(0))
+    const key = 'test.gz'
+
+    await cache.put('test', fileData)
+    let fileExist = await checkFileExist(key)
+    expect(fileExist).toBe(true)
+
+    await cache.clearCache('test')
+    fileExist = await checkFileExist(key)
+    expect(fileExist).toBe(false)
+  })
+
+  test("Get an object from cache if it didn't exist", async () => {
+    const cache = new S3ObjectCache(s3Client, bucketName!)
+
+    const cached = await cache.getAndCache<{ test: number }>('test', async (_) => ({
+      test: 1,
+    }))
+
+    expect(cached.test).toBe(1)
+  })
+
+  test('Get an object from cache if it did exist', async () => {
+    const cache = new S3ObjectCache(s3Client, bucketName!)
+    await cache.put('test', { test: 1 })
+
+    const cached = await cache.getAndCache<{ test: number }>('test', async (_) => ({
+      test: 2,
+    }))
+
+    expect(cached.test).toBe(1)
+  })
+
+  test('Get an object from cache if it is not yet stale', async () => {
+    const cache = new S3ObjectCache(s3Client, bucketName!)
+    await cache.put('test', { test: 1 })
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    const cached = await cache.getAndCache<{ test: number }>(
+      'test',
+      async (_) => ({
+        test: 2,
+      }),
+      { staleAfterSeconds: 2 },
+    )
+
+    expect(cached.test).toBe(1)
+  })
+
+  test('Get a fresh object if it is stale', async () => {
+    const cache = new S3ObjectCache(s3Client, bucketName!)
+    await cache.put('test', { test: 1 })
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+
+    const cached = await cache.getAndCache<{ test: number }>(
+      'test',
+      async (_) => ({
+        test: 2,
+      }),
+      { staleAfterSeconds: 0 },
+    )
+
+    expect(cached.test).toBe(2)
+  })
+
+  test('Get an object from cache if it is stale but there is an error and returnStaleOnError is set', async () => {
+    const cache = new S3ObjectCache(s3Client, bucketName!)
+    await cache.put('test', { test: 1 })
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    const cached = await cache.getAndCache<{ test: number }>(
+      'test',
+      async (_) => {
+        throw new Error('error')
+      },
+      {
+        staleAfterSeconds: 0,
+        returnStaleResultOnError: true,
+      },
+    )
+
+    expect(cached.test).toBe(1)
+  })
+})

src/s3ObjectCache.spec.ts

@@ -1,4 +1,4 @@
-import { GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3'
+import { DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3'
 import { BinaryCacheOptions, BinaryWithMetadata, CacheOptions, ObjectCache } from './cache'
 import * as path from 'node:path'
 
@@ -22,6 +22,35 @@ export class S3ObjectCache implements ObjectCache {
     this.keyPrefix = keyPrefix
   }
 
+  /**
+   * Clear the cache value for te given cache key
+   * @param cacheKey A unique key that identifies the cached value
+   */
+  async clearCache(cacheKey: string): Promise<void> {
+    const deleteFile = async (key: string) => {
+      const bucketAndKey = {
+        Bucket: this.bucket,
+        Key: key,
+      }
+
+      const fileExist = await this.s3Client
+        .send(new HeadObjectCommand(bucketAndKey))
+        .then(() => true)
+        .catch(() => false)
+
+      if (fileExist) {
+        await this.s3Client.send(
+          new DeleteObjectCommand({
+            ...bucketAndKey,
+          }),
+        )
+      }
+    }
+
+    await deleteFile(this.keyPrefix ? path.join(this.keyPrefix, `${cacheKey}.gz`) : `${cacheKey}.gz`)
+    await deleteFile(this.keyPrefix ? path.join(this.keyPrefix, `${cacheKey}.json.gz`) : `${cacheKey}.json.gz`)
+  }
+
   /** Adds the given value to the cache for the given cache key
    * @param cacheKey A unique key that identifies the cached value
    * @param data The data to cache