@stacksjs/cache 0.65.0 → 0.67.0

package/src/drivers/dynamodb.ts

@@ -1,80 +0,0 @@
-import type { CacheDriver } from './type'
-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,
-        },
-        credentials: {
-          accessKeyId: awsAccessKeyId,
-          secretAccessKey: awsSecretAccessKey,
-        },
-      }),
-    ),
-  },
-})
-
-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 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/filesystem.ts

@@ -1,66 +0,0 @@
-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,29 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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,17 +0,0 @@
-import type { BentoCache } from 'bentocache'
-
-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>
-  deleteMany: (keys: string[]) => Promise<void>
-  clear: () => Promise<void>
-  deleteAll: () => Promise<void>
-  disconnect: () => Promise<void>
-  client: BentoCache<Record<string, any>>
-}

package/src/index.ts

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