@stacksjs/cache 0.64.6 → 0.65.0

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@stacksjs/cache",
   "type": "module",
-  "version": "0.64.6",
+  "version": "0.65.0",
   "description": "Caching the Stacks way.",
   "author": "Chris Breuer",
+  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/cache#readme",
@@ -35,25 +36,20 @@
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
+  "files": ["README.md", "dist", "src"],
   "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "build": "bun build.ts",
+    "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.637.0",
-    "@stacksjs/config": "latest",
-    "bentocache": "^1.0.0-beta.9"
+    "@aws-sdk/client-dynamodb": "^3.668.0",
+    "@stacksjs/config": "0.64.6",
+    "bentocache": "^1.0.0-beta.9",
+    "ioredis": "^5.4.1"
   },
   "devDependencies": {
-    "@stacksjs/development": "latest"
+    "@stacksjs/development": "0.64.6",
+    "dynamodb-tooling": "^0.3.2"
   }
 }

package/src/drivers/dynamodb.ts

@@ -1,104 +1,80 @@
-import type { PutItemCommandInput } from '@aws-sdk/client-dynamodb'
-import { DynamoDB, ListTablesCommand } from '@aws-sdk/client-dynamodb'
-import { cache } from '@stacksjs/config'
 import type { CacheDriver } from './type'
-
-const valueAttribute = 'value'
-const keyAttribute = 'key'
-const tableName = cache.drivers?.dynamodb?.table
-
-const client = new DynamoDB({ region: cache.drivers?.dynamodb?.region })
-
-function getValueType(value: string | number) {
-  if (typeof value === 'string') return 'S'
-  if (typeof value === 'number') return 'N'
-  return 'S'
-}
-
-function serialize(value: string | number) {
-  return String(value)
-}
-
-export const dynamodb: CacheDriver = {
-  async createTable() {
-    const tables = await client.send(new ListTablesCommand({}))
-
-    const tableExists = tables.TableNames?.includes('cache')
-
-    if (tableExists) return
-
-    const params = {
-      AttributeDefinitions: [
-        {
-          AttributeName: 'key',
-          AttributeType: 'S',
+import process from 'node:process'
+import { BentoCache, bentostore } from 'bentocache'
+import { dynamoDbDriver } from 'bentocache/drivers/dynamodb'
+
+const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID || 'dummy'
+const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY || 'dummy'
+const dynamoEndpoint = process.env.AWS_DYNAMODB_ENDPOINT || 'http://localhost:8000'
+const tableName = process.env.AWS_DYNAMODB_TABLE || 'stacks'
+const region = process.env.AWS_REGION || 'us-east-1'
+
+const client = new BentoCache({
+  default: 'dynamo',
+  stores: {
+    dynamo: bentostore().useL2Layer(
+      dynamoDbDriver({
+        endpoint: dynamoEndpoint,
+        region,
+        table: {
+          name: tableName,
         },
-      ],
-      KeySchema: [
-        {
-          AttributeName: 'key',
-          KeyType: 'HASH',
+        credentials: {
+          accessKeyId: awsAccessKeyId,
+          secretAccessKey: awsSecretAccessKey,
         },
-      ],
-      ProvisionedThroughput: {
-        ReadCapacityUnits: 5,
-        WriteCapacityUnits: 5,
-      },
-      TableName: tableName,
-    }
-
-    client.createTable(params)
+      }),
+    ),
   },
+})
 
-  async set(key: string, value: string | number): Promise<void> {
-    const params: PutItemCommandInput = {
-      TableName: tableName,
-      Item: {
-        [keyAttribute]: {
-          S: key,
-        },
-        [valueAttribute]: {
-          [getValueType(value)]: serialize(value),
-        },
-      },
-    }
-
-    await client.putItem(params)
+export const dynamodb: CacheDriver = {
+  async set(key: string, value: string, ttl?: number): Promise<void> {
+    await client.set({
+      key,
+      value,
+      gracePeriod: { enabled: true, duration: '5m' },
+    })
+  },
+  async setForever(key: string, value: string, ttl?: number): Promise<void> {
+    await client.setForever({
+      key,
+      value,
+    })
   },
-
   async get(key: string): Promise<string | undefined | null> {
-    const params = {
-      TableName: tableName,
-      Key: {
-        [keyAttribute]: {
-          S: key,
-        },
-      },
-    }
-
-    const response = await client.getItem(params)
+    const items = await client.get<string>(key)
 
-    if (!response.Item) return null
-
-    return response.Item[valueAttribute].S ?? response.Item[valueAttribute].N
+    return items
   },
+  async getOrSet(key: string, value: string): Promise<string | undefined | null> {
+    const items = await client.getOrSet(key, () => value)
 
+    return items
+  },
+  async del(key: string): Promise<void> {
+    await client.delete({ key })
+  },
+  async deleteMany(keys: string[]): Promise<void> {
+    await client.deleteMany({ keys })
+  },
   async remove(key: string): Promise<void> {
-    const params = {
-      TableName: tableName,
-      Key: {
-        [keyAttribute]: {
-          S: key,
-        },
-      },
-    }
-
-    await client.deleteItem(params)
+    await client.delete({ key })
   },
-
-  del(key: string): Promise<void> {
-    return this.remove(key)
+  async has(key: string): Promise<boolean> {
+    return await client.has({ key })
+  },
+  async missing(key: string): Promise<boolean> {
+    return await client.missing({ key })
+  },
+  async deleteAll(): Promise<void> {
+    await client.clear()
+  },
+  async clear(): Promise<void> {
+    await client.clear()
+  },
+  async disconnect(): Promise<void> {
+    await client.disconnect()
   },
-
   client,
 }

package/src/drivers/filesystem.ts

@@ -0,0 +1,66 @@
+import type { CacheDriver } from './type'
+import { BentoCache, bentostore } from 'bentocache'
+import { fileDriver } from 'bentocache/drivers/file'
+
+const client = new BentoCache({
+  default: 'redis',
+  stores: {
+    redis: bentostore().useL2Layer(
+      fileDriver({
+        directory: './cache',
+        pruneInterval: '1h',
+      }),
+    ),
+  },
+})
+
+export const fileSystem: CacheDriver = {
+  async set(key: string, value: string, ttl?: number): Promise<void> {
+    await client.set({
+      key,
+      value,
+      gracePeriod: { enabled: true, duration: '5m' },
+    })
+  },
+  async setForever(key: string, value: string, ttl?: number): Promise<void> {
+    await client.setForever({
+      key,
+      value,
+    })
+  },
+  async get(key: string): Promise<string | undefined | null> {
+    const items = await client.get<string>(key)
+
+    return items
+  },
+  async getOrSet(key: string, value: string): Promise<string | undefined | null> {
+    const items = await client.getOrSet(key, () => value)
+
+    return items
+  },
+  async del(key: string): Promise<void> {
+    await client.delete({ key })
+  },
+  async deleteMany(keys: string[]): Promise<void> {
+    await client.deleteMany({ keys })
+  },
+  async remove(key: string): Promise<void> {
+    await client.delete({ key })
+  },
+  async has(key: string): Promise<boolean> {
+    return await client.has({ key })
+  },
+  async missing(key: string): Promise<boolean> {
+    return await client.missing({ key })
+  },
+  async deleteAll(): Promise<void> {
+    await client.clear()
+  },
+  async clear(): Promise<void> {
+    await client.clear()
+  },
+  async disconnect(): Promise<void> {
+    await client.disconnect()
+  },
+  client,
+}

package/src/drivers/index.ts

@@ -1 +1,29 @@
-export { dynamodb } from './dynamodb'
+import type { CacheDriver } from './type'
+import { config } from '@stacksjs/config'
+import { dynamodb } from './dynamodb'
+import { fileSystem } from './filesystem'
+import { memory } from './memory'
+
+import { redis } from './redis'
+
+const driver = config.cache.driver || 'memory'
+
+let driverInstance = fileSystem
+
+if (driver === 'redis') {
+  driverInstance = redis
+}
+
+if (driver === 'fileSystem') {
+  driverInstance = fileSystem
+}
+
+if (driver === 'memory') {
+  driverInstance = memory
+}
+
+if (driver === 'dynamodb') {
+  driverInstance = dynamodb
+}
+
+export const cache: CacheDriver = driverInstance

package/src/drivers/memory.ts

@@ -0,0 +1,66 @@
+import type { CacheDriver } from './type'
+import { BentoCache, bentostore } from 'bentocache'
+import { memoryDriver } from 'bentocache/drivers/memory'
+
+const client = new BentoCache({
+  default: 'memory',
+  stores: {
+    memory: bentostore().useL1Layer(
+      memoryDriver({
+        maxSize: 10 * 1024 * 1024,
+        maxItems: 1000,
+      }),
+    ),
+  },
+})
+
+export const memory: CacheDriver = {
+  async set(key: string, value: string, ttl?: number): Promise<void> {
+    await client.set({
+      key,
+      value,
+      gracePeriod: { enabled: true, duration: '5m' },
+    })
+  },
+  async setForever(key: string, value: string, ttl?: number): Promise<void> {
+    await client.setForever({
+      key,
+      value,
+    })
+  },
+  async get(key: string): Promise<string | undefined | null> {
+    const items = await client.get<string>(key)
+
+    return items
+  },
+  async getOrSet(key: string, value: string): Promise<string | undefined | null> {
+    const items = await client.getOrSet(key, () => value)
+
+    return items
+  },
+  async del(key: string): Promise<void> {
+    await client.delete({ key })
+  },
+  async deleteMany(keys: string[]): Promise<void> {
+    await client.deleteMany({ keys })
+  },
+  async remove(key: string): Promise<void> {
+    await client.delete({ key })
+  },
+  async has(key: string): Promise<boolean> {
+    return await client.has({ key })
+  },
+  async missing(key: string): Promise<boolean> {
+    return await client.missing({ key })
+  },
+  async deleteAll(): Promise<void> {
+    await client.clear()
+  },
+  async clear(): Promise<void> {
+    await client.clear()
+  },
+  async disconnect(): Promise<void> {
+    await client.disconnect()
+  },
+  client,
+}

package/src/drivers/redis.ts

@@ -0,0 +1,65 @@
+import type { CacheDriver } from './type'
+import { BentoCache, bentostore } from 'bentocache'
+import { redisDriver } from 'bentocache/drivers/redis'
+
+const client = new BentoCache({
+  default: 'redis',
+  stores: {
+    redis: bentostore().useL2Layer(
+      redisDriver({
+        connection: { host: '127.0.0.1', port: 6379 },
+      }),
+    ),
+  },
+})
+
+export const redis: CacheDriver = {
+  async set(key: string, value: string, ttl?: number): Promise<void> {
+    await client.set({
+      key,
+      value,
+      gracePeriod: { enabled: true, duration: '5m' },
+    })
+  },
+  async setForever(key: string, value: string, ttl?: number): Promise<void> {
+    await client.setForever({
+      key,
+      value,
+    })
+  },
+  async get(key: string): Promise<string | undefined | null> {
+    const items = await client.get<string>(key)
+
+    return items
+  },
+  async getOrSet(key: string, value: string): Promise<string | undefined | null> {
+    const items = await client.getOrSet(key, () => value)
+
+    return items
+  },
+  async del(key: string): Promise<void> {
+    await client.delete({ key })
+  },
+  async deleteMany(keys: string[]): Promise<void> {
+    await client.deleteMany({ keys })
+  },
+  async remove(key: string): Promise<void> {
+    await client.delete({ key })
+  },
+  async has(key: string): Promise<boolean> {
+    return await client.has({ key })
+  },
+  async missing(key: string): Promise<boolean> {
+    return await client.missing({ key })
+  },
+  async deleteAll(): Promise<void> {
+    await client.clear()
+  },
+  async clear(): Promise<void> {
+    await client.clear()
+  },
+  async disconnect(): Promise<void> {
+    await client.disconnect()
+  },
+  client,
+}

package/src/drivers/type.ts

@@ -1,10 +1,17 @@
-import type { DynamoDB } from '@aws-sdk/client-dynamodb'
+import type { BentoCache } from 'bentocache'
 
-export type CacheDriver = {
-  createTable: () => Promise<void>
-  set: (key: string, value: string | number) => Promise<void>
+export interface CacheDriver {
+  set: (key: string, value: string, ttl?: number) => Promise<void>
+  setForever: (key: string, value: string, ttl?: number) => Promise<void>
   get: (key: string) => Promise<string | undefined | null>
+  getOrSet: (key: string, value: string) => Promise<string | undefined | null>
   remove: (key: string) => Promise<void>
+  has: (key: string) => Promise<boolean>
+  missing: (key: string) => Promise<boolean>
   del: (key: string) => Promise<void>
-  client: DynamoDB
+  deleteMany: (keys: string[]) => Promise<void>
+  clear: () => Promise<void>
+  deleteAll: () => Promise<void>
+  disconnect: () => Promise<void>
+  client: BentoCache<Record<string, any>>
 }

package/src/index.ts

@@ -1 +1,2 @@
 export * from './drivers'
+export * as dynamoDbTool from 'dynamodb-tooling'