chore: wip

Author: glennmichael123

storage/framework/core/cache/src/drivers/dynamodb.ts

@@ -1,92 +1,46 @@
-import type { CacheDriver } from '@stacksjs/types'
-import type { GetOptions } from 'bentocache/types'
-import process from 'node:process'
+// dynamodb-cache-driver.ts
 import { BentoCache, bentostore } from 'bentocache'
 import { dynamoDbDriver } from 'bentocache/drivers/dynamodb'
+import { BaseCacheDriver } from './base'
 
-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> {
-    const data: { key: string, value: string, gracePeriod?: { enabled: boolean, duration: string } } = {
-      key,
-      value,
-    }
+export interface DynamoDBOptions {
+  endpoint?: string
+  region?: string
+  tableName?: string
+  accessKeyId?: string
+  secretAccessKey?: string
+}
 
-    if (ttl) {
-      data.gracePeriod = {
-        enabled: true,
-        duration: `${ttl}m`,
-      }
-    }
+export class DynamoDBCacheDriver extends BaseCacheDriver {
+  constructor(options: DynamoDBOptions = {}) {
+    // Use environment variables with fallbacks
+    const awsAccessKeyId = options.accessKeyId ?? process.env.AWS_ACCESS_KEY_ID ?? 'dummy'
+    const awsSecretAccessKey = options.secretAccessKey ?? process.env.AWS_SECRET_ACCESS_KEY ?? 'dummy'
+    const dynamoEndpoint = options.endpoint ?? process.env.AWS_DYNAMODB_ENDPOINT ?? 'http://localhost:8000'
+    const tableName = options.tableName ?? process.env.AWS_DYNAMODB_TABLE ?? 'stacks'
+    const region = options.region ?? process.env.AWS_REGION ?? 'us-east-1'
 
-    await client.set(data)
-  },
-  async setForever(key: string, value: string): Promise<void> {
-    await client.setForever({
-      key,
-      value,
+    const client = new BentoCache({
+      default: 'dynamo',
+      stores: {
+        dynamo: bentostore().useL2Layer(
+          dynamoDbDriver({
+            endpoint: dynamoEndpoint,
+            region,
+            table: {
+              name: tableName,
+            },
+            credentials: {
+              accessKeyId: awsAccessKeyId,
+              secretAccessKey: awsSecretAccessKey,
+            },
+          }),
+        ),
+      },
     })
-  },
-  async get<T>(key: GetOptions<T>): Promise<T> {
-    const items = await client.get<T>(key)
-
-    return items
-  },
-  async getOrSet<T>(key: string, value: T): Promise<T> {
-    const result = await client.getOrSet<T>({
-      key,
-      factory: async () => value,
-    })
-
-    return result
-  },
-  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,
+    
+    super(client)
+  }
 }
+
+export const dynamodb: DynamoDBCacheDriver = new DynamoDBCacheDriver()

storage/framework/core/cache/src/drivers/index.ts

@@ -1,29 +1,56 @@
+// index.ts
 import type { CacheDriver } from '@stacksjs/types'
 import { config } from '@stacksjs/config'
-import { dynamodb } from './dynamodb'
-import { fileSystem } from './filesystem'
-
+import { dynamodb, type DynamoDBOptions } from './dynamodb'
+import { fileSystem, type FileSystemOptions } 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
+import { redis, type RedisOptions } from './redis'
+
+// Map of available drivers
+const drivers: Record<string, CacheDriver> = {
+  redis,
+  fileSystem,
+  memory,
+  dynamodb,
 }
 
-export const cache: CacheDriver = driverInstance
+// Get configured driver name with fallback to memory
+const driverName = config.cache?.driver || 'memory'
+
+// Select the appropriate driver
+const selectedDriver = drivers[driverName] || memory
+
+// Export the selected driver as the default cache implementation
+export const cache: CacheDriver = selectedDriver
+
+// Also export individual drivers and base class for direct usage
+export { BaseCacheDriver } from './base'
+export { dynamodb, DynamoDBCacheDriver, type DynamoDBOptions } from './dynamodb'
+export { fileSystem, FileSystemCacheDriver, type FileSystemOptions } from './filesystem'
+export { memory, MemoryCacheDriver } from './memory'
+export { redis, RedisCacheDriver, type RedisOptions } from './redis'
+
+/**
+ * Create a custom cache driver instance with specific options
+ */
+export function createCache(driver: 'redis', options?: RedisOptions): CacheDriver
+export function createCache(driver: 'fileSystem', options?: FileSystemOptions): CacheDriver
+export function createCache(driver: 'memory', options?: { maxSize?: number; maxItems?: number }): CacheDriver
+export function createCache(driver: 'dynamodb', options?: DynamoDBOptions): CacheDriver
+export function createCache(
+  driver: 'redis' | 'fileSystem' | 'memory' | 'dynamodb',
+  options?: any
+): CacheDriver {
+  switch (driver) {
+    case 'redis':
+      return new RedisCacheDriver(options)
+    case 'fileSystem':
+      return new FileSystemCacheDriver(options)
+    case 'memory':
+      return new MemoryCacheDriver(options)
+    case 'dynamodb':
+      return new DynamoDBCacheDriver(options)
+    default:
+      return memory
+  }
+}