@dexto/core 1.1.10 → 1.2.0

package/dist/storage/blob/types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Core types for Blob Storage
+ *
+ * Blob storage handles large, unstructured data using various backends.
+ * This module is part of the storage system.
+ */
+/**
+ * Input data for blob storage - supports various formats
+ */
+export type BlobInput = string | Uint8Array | Buffer | ArrayBuffer;
+/**
+ * Metadata associated with a stored blob
+ */
+export interface BlobMetadata {
+    mimeType?: string | undefined;
+    originalName?: string | undefined;
+    createdAt?: Date | undefined;
+    source?: 'tool' | 'user' | 'system' | undefined;
+    size?: number | undefined;
+}
+/**
+ * Complete blob information including stored metadata
+ */
+export interface StoredBlobMetadata {
+    id: string;
+    mimeType: string;
+    originalName?: string | undefined;
+    createdAt: Date;
+    size: number;
+    hash: string;
+    source?: 'tool' | 'user' | 'system' | undefined;
+}
+/**
+ * Reference to a stored blob
+ */
+export interface BlobReference {
+    id: string;
+    uri: string;
+    metadata: StoredBlobMetadata;
+}
+/**
+ * Retrieved blob data in requested format
+ */
+export type BlobData = {
+    format: 'base64';
+    data: string;
+    metadata: StoredBlobMetadata;
+} | {
+    format: 'buffer';
+    data: Buffer;
+    metadata: StoredBlobMetadata;
+} | {
+    format: 'path';
+    data: string;
+    metadata: StoredBlobMetadata;
+} | {
+    format: 'stream';
+    data: NodeJS.ReadableStream;
+    metadata: StoredBlobMetadata;
+} | {
+    format: 'url';
+    data: string;
+    metadata: StoredBlobMetadata;
+};
+/**
+ * Storage statistics for monitoring and management
+ */
+export interface BlobStats {
+    count: number;
+    totalSize: number;
+    backendType: string;
+    storePath: string;
+}
+/**
+ * BlobStore interface for storing and retrieving large, unstructured data.
+ * All implementations must provide these methods for blob operations.
+ *
+ * This interface follows the storage module conventions where:
+ * - Interface name: BlobStore
+ * - Implementation names: MemoryBlobStore, LocalBlobStore, etc.
+ * - Lifecycle methods: connect(), disconnect(), isConnected()
+ * - Type identifier: getStoreType()
+ */
+export interface BlobStore {
+    /**
+     * Store blob data and return a reference.
+     * @param input - The blob data to store (string, Uint8Array, Buffer, ArrayBuffer)
+     * @param metadata - Optional metadata to associate with the blob
+     * @returns Promise resolving to a BlobReference with id, uri, and metadata
+     */
+    store(input: BlobInput, metadata?: BlobMetadata): Promise<BlobReference>;
+    /**
+     * Retrieve blob data in the specified format.
+     * @param reference - The blob reference (id or uri)
+     * @param format - The desired output format (base64, buffer, path, stream, url)
+     * @returns Promise resolving to BlobData with the requested format
+     */
+    retrieve(reference: string, format?: 'base64' | 'buffer' | 'path' | 'stream' | 'url'): Promise<BlobData>;
+    /**
+     * Check if a blob exists.
+     * @param reference - The blob reference (id or uri)
+     * @returns Promise resolving to true if the blob exists, false otherwise
+     */
+    exists(reference: string): Promise<boolean>;
+    /**
+     * Delete a blob.
+     * @param reference - The blob reference (id or uri)
+     * @returns Promise resolving when the blob is deleted
+     */
+    delete(reference: string): Promise<void>;
+    /**
+     * Cleanup old blobs based on age.
+     * @param olderThan - Optional date to delete blobs created before
+     * @returns Promise resolving to the number of blobs deleted
+     */
+    cleanup(olderThan?: Date): Promise<number>;
+    /**
+     * Get storage statistics.
+     * @returns Promise resolving to BlobStats with count, size, type, and path info
+     */
+    getStats(): Promise<BlobStats>;
+    /**
+     * List all blob references (for resource enumeration).
+     * @returns Promise resolving to an array of BlobReferences
+     */
+    listBlobs(): Promise<BlobReference[]>;
+    /**
+     * Get the local filesystem storage path for this store, if applicable.
+     * Used to prevent conflicts with filesystem resource scanning.
+     * @returns The storage path string, or undefined for remote stores (S3, Azure, etc.)
+     */
+    getStoragePath(): string | undefined;
+    /**
+     * Connect to the blob store and initialize resources.
+     * @returns Promise resolving when the store is ready for operations
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the blob store and cleanup resources.
+     * @returns Promise resolving when the store is fully disconnected
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if the blob store is currently connected.
+     * @returns true if connected, false otherwise
+     */
+    isConnected(): boolean;
+    /**
+     * Get the type identifier for this blob store implementation.
+     * @returns A string identifying the store type (e.g., 'memory', 'local', 's3')
+     */
+    getStoreType(): string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/storage/blob/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/types.ts"],"names":[],"mappings":"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"}

package/dist/storage/cache/factory.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var factory_exports = {};
+__export(factory_exports, {
+  createCache: () => createCache
+});
+module.exports = __toCommonJS(factory_exports);
+var import_memory_cache_store = require("./memory-cache-store.js");
+var import_logger = require("../../logger/index.js");
+let RedisStore = null;
+async function createCache(config) {
+  switch (config.type) {
+    case "redis":
+      return createRedisStore(config);
+    case "in-memory":
+    default:
+      import_logger.logger.info("Using in-memory cache store");
+      return new import_memory_cache_store.MemoryCacheStore();
+  }
+}
+async function createRedisStore(config) {
+  try {
+    if (!RedisStore) {
+      const module2 = await import("./redis-store.js");
+      RedisStore = module2.RedisStore;
+    }
+    import_logger.logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
+    return new RedisStore(config);
+  } catch (error) {
+    import_logger.logger.warn(`Redis not available, falling back to in-memory cache: ${error}`);
+    return new import_memory_cache_store.MemoryCacheStore();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCache
+});

package/dist/storage/cache/factory.d.ts

@@ -0,0 +1,8 @@
+import type { Cache } from './types.js';
+import type { CacheConfig } from '../schemas.js';
+/**
+ * Create a cache store based on configuration.
+ * Handles lazy loading of optional dependencies with automatic fallback.
+ */
+export declare function createCache(config: CacheConfig): Promise<Cache>;
+//# sourceMappingURL=factory.d.ts.map

package/dist/storage/cache/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,eAAe,CAAC;AAYnE;;;GAGG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,CAUrE"}

package/dist/storage/cache/factory.js

@@ -0,0 +1,30 @@
+import "../../chunk-C6A6W6XS.js";
+import { MemoryCacheStore } from "./memory-cache-store.js";
+import { logger } from "../../logger/index.js";
+let RedisStore = null;
+async function createCache(config) {
+  switch (config.type) {
+    case "redis":
+      return createRedisStore(config);
+    case "in-memory":
+    default:
+      logger.info("Using in-memory cache store");
+      return new MemoryCacheStore();
+  }
+}
+async function createRedisStore(config) {
+  try {
+    if (!RedisStore) {
+      const module = await import("./redis-store.js");
+      RedisStore = module.RedisStore;
+    }
+    logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
+    return new RedisStore(config);
+  } catch (error) {
+    logger.warn(`Redis not available, falling back to in-memory cache: ${error}`);
+    return new MemoryCacheStore();
+  }
+}
+export {
+  createCache
+};

package/dist/storage/cache/memory-cache-store.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var memory_cache_store_exports = {};
+__export(memory_cache_store_exports, {
+  MemoryCacheStore: () => MemoryCacheStore
+});
+module.exports = __toCommonJS(memory_cache_store_exports);
+var import_errors = require("../errors.js");
+class MemoryCacheStore {
+  data = /* @__PURE__ */ new Map();
+  ttls = /* @__PURE__ */ new Map();
+  connected = false;
+  constructor() {
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.data.clear();
+    this.ttls.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "memory";
+  }
+  async get(key) {
+    this.checkConnection();
+    try {
+      this.checkTTL(key);
+      return this.data.get(key);
+    } catch (error) {
+      throw import_errors.StorageError.readFailed(
+        "get",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    this.checkConnection();
+    try {
+      this.data.set(key, value);
+      if (ttlSeconds) {
+        this.ttls.set(key, Date.now() + ttlSeconds * 1e3);
+      } else {
+        this.ttls.delete(key);
+      }
+    } catch (error) {
+      throw import_errors.StorageError.writeFailed(
+        "set",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async delete(key) {
+    this.checkConnection();
+    this.data.delete(key);
+    this.ttls.delete(key);
+  }
+  // Helper methods
+  checkConnection() {
+    if (!this.connected) {
+      throw import_errors.StorageError.notConnected("MemoryCacheStore");
+    }
+  }
+  checkTTL(key) {
+    const expiry = this.ttls.get(key);
+    if (expiry && Date.now() > expiry) {
+      this.data.delete(key);
+      this.ttls.delete(key);
+    }
+  }
+  // Development helpers
+  async clear() {
+    this.data.clear();
+    this.ttls.clear();
+  }
+  async dump() {
+    return {
+      data: Object.fromEntries(this.data.entries())
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryCacheStore
+});

package/dist/storage/cache/memory-cache-store.d.ts

@@ -0,0 +1,26 @@
+import type { Cache } from './types.js';
+/**
+ * In-memory cache store for development and testing.
+ * Supports TTL for automatic cleanup of temporary data.
+ * Data is lost when the process restarts.
+ */
+export declare class MemoryCacheStore implements Cache {
+    private data;
+    private ttls;
+    private connected;
+    constructor();
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStoreType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    private checkConnection;
+    private checkTTL;
+    clear(): Promise<void>;
+    dump(): Promise<{
+        data: Record<string, any>;
+    }>;
+}
+//# sourceMappingURL=memory-cache-store.d.ts.map

package/dist/storage/cache/memory-cache-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-cache-store.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/memory-cache-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,KAAK;IAC1C,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,SAAS,CAAS;;IAIpB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAMjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAIhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAc3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOxC,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,QAAQ;IASV,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,IAAI,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,CAAC;CAKvD"}

package/dist/storage/cache/memory-cache-store.js

@@ -0,0 +1,84 @@
+import "../../chunk-C6A6W6XS.js";
+import { StorageError } from "../errors.js";
+class MemoryCacheStore {
+  data = /* @__PURE__ */ new Map();
+  ttls = /* @__PURE__ */ new Map();
+  connected = false;
+  constructor() {
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.data.clear();
+    this.ttls.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "memory";
+  }
+  async get(key) {
+    this.checkConnection();
+    try {
+      this.checkTTL(key);
+      return this.data.get(key);
+    } catch (error) {
+      throw StorageError.readFailed(
+        "get",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    this.checkConnection();
+    try {
+      this.data.set(key, value);
+      if (ttlSeconds) {
+        this.ttls.set(key, Date.now() + ttlSeconds * 1e3);
+      } else {
+        this.ttls.delete(key);
+      }
+    } catch (error) {
+      throw StorageError.writeFailed(
+        "set",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async delete(key) {
+    this.checkConnection();
+    this.data.delete(key);
+    this.ttls.delete(key);
+  }
+  // Helper methods
+  checkConnection() {
+    if (!this.connected) {
+      throw StorageError.notConnected("MemoryCacheStore");
+    }
+  }
+  checkTTL(key) {
+    const expiry = this.ttls.get(key);
+    if (expiry && Date.now() > expiry) {
+      this.data.delete(key);
+      this.ttls.delete(key);
+    }
+  }
+  // Development helpers
+  async clear() {
+    this.data.clear();
+    this.ttls.clear();
+  }
+  async dump() {
+    return {
+      data: Object.fromEntries(this.data.entries())
+    };
+  }
+}
+export {
+  MemoryCacheStore
+};

package/dist/storage/{backend/redis-backend.cjs → cache/redis-store.cjs}

@@ -16,14 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var redis_backend_exports = {};
-__export(redis_backend_exports, {
-  RedisBackend: () => RedisBackend
+var redis_store_exports = {};
+__export(redis_store_exports, {
+  RedisStore: () => RedisStore
 });
-module.exports = __toCommonJS(redis_backend_exports);
+module.exports = __toCommonJS(redis_store_exports);
 var import_ioredis = require("ioredis");
 var import_errors = require("../errors.js");
-class RedisBackend {
+class RedisStore {
   constructor(config) {
     this.config = config;
   }
@@ -69,7 +69,7 @@ class RedisBackend {
   isConnected() {
     return this.connected && this.redis?.status === "ready";
   }
-  getBackendType() {
+  getStoreType() {
     return "redis";
   }
   // Core operations
@@ -149,23 +149,9 @@ class RedisBackend {
     this.checkConnection();
     return await this.redis.decrby(key, by);
   }
-  // List operations (for compatibility with DatabaseBackend patterns)
-  async append(key, item) {
-    this.checkConnection();
-    await this.redis.rpush(key, JSON.stringify(item));
-  }
-  async getRange(key, start, count) {
-    this.checkConnection();
-    const items = await this.redis.lrange(key, start, start + count - 1);
-    return items.map((item) => JSON.parse(item));
-  }
-  async list(prefix) {
-    this.checkConnection();
-    return await this.redis.keys(`${prefix}*`);
-  }
   checkConnection() {
     if (!this.connected || !this.redis || this.redis.status !== "ready") {
-      throw import_errors.StorageError.notConnected("RedisBackend");
+      throw import_errors.StorageError.notConnected("RedisStore");
     }
   }
   // Maintenance operations
@@ -180,5 +166,5 @@ class RedisBackend {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RedisBackend
+  RedisStore
 });

package/dist/storage/{backend/redis-backend.d.ts → cache/redis-store.d.ts}

@@ -1,21 +1,19 @@
-import { CacheBackend } from './cache-backend.js';
-import { RedisBackendConfig } from '../schemas.js';
-import 'zod';
-
+import type { Cache } from './types.js';
+import type { RedisCacheConfig } from './schemas.js';
 /**
- * Redis storage backend for production cache operations.
- * Implements the CacheBackend interface with connection pooling and optimizations.
+ * Redis cache store for production cache operations.
+ * Implements the Cache interface with connection pooling and optimizations.
  * EXPERIMENTAL - NOT FULLY TESTED YET
  */
-declare class RedisBackend implements CacheBackend {
+export declare class RedisStore implements Cache {
     private config;
     private redis;
     private connected;
-    constructor(config: RedisBackendConfig);
+    constructor(config: RedisCacheConfig);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
-    getBackendType(): string;
+    getStoreType(): string;
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
     delete(key: string): Promise<void>;
@@ -25,12 +23,8 @@ declare class RedisBackend implements CacheBackend {
     expire(key: string, ttlSeconds: number): Promise<void>;
     increment(key: string, by?: number): Promise<number>;
     decrement(key: string, by?: number): Promise<number>;
-    append<T>(key: string, item: T): Promise<void>;
-    getRange<T>(key: string, start: number, count: number): Promise<T[]>;
-    list(prefix: string): Promise<string[]>;
     private checkConnection;
     flushdb(): Promise<void>;
     info(): Promise<string>;
 }
-
-export { RedisBackend };
+//# sourceMappingURL=redis-store.d.ts.map

package/dist/storage/cache/redis-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-store.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/redis-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD;;;;GAIG;AACH,qBAAa,UAAW,YAAW,KAAK;IAIxB,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,SAAS,CAAS;gBAEN,MAAM,EAAE,gBAAgB;IAEtC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoCxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAKhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAc3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAclC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;IAQnD,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAW9C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7D,OAAO,CAAC,eAAe;IAOjB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAKxB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CAIhC"}

package/dist/storage/{backend/redis-backend.js → cache/redis-store.js}

@@ -1,6 +1,7 @@
+import "../../chunk-C6A6W6XS.js";
 import { Redis } from "ioredis";
 import { StorageError } from "../errors.js";
-class RedisBackend {
+class RedisStore {
   constructor(config) {
     this.config = config;
   }
@@ -46,7 +47,7 @@ class RedisBackend {
   isConnected() {
     return this.connected && this.redis?.status === "ready";
   }
-  getBackendType() {
+  getStoreType() {
     return "redis";
   }
   // Core operations
@@ -126,23 +127,9 @@ class RedisBackend {
     this.checkConnection();
     return await this.redis.decrby(key, by);
   }
-  // List operations (for compatibility with DatabaseBackend patterns)
-  async append(key, item) {
-    this.checkConnection();
-    await this.redis.rpush(key, JSON.stringify(item));
-  }
-  async getRange(key, start, count) {
-    this.checkConnection();
-    const items = await this.redis.lrange(key, start, start + count - 1);
-    return items.map((item) => JSON.parse(item));
-  }
-  async list(prefix) {
-    this.checkConnection();
-    return await this.redis.keys(`${prefix}*`);
-  }
   checkConnection() {
     if (!this.connected || !this.redis || this.redis.status !== "ready") {
-      throw StorageError.notConnected("RedisBackend");
+      throw StorageError.notConnected("RedisStore");
     }
   }
   // Maintenance operations
@@ -156,5 +143,5 @@ class RedisBackend {
   }
 }
 export {
-  RedisBackend
+  RedisStore
 };