@dexto/core 1.1.9 → 1.1.11

package/dist/storage/cache/schemas.cjs

@@ -0,0 +1,77 @@
+"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 schemas_exports = {};
+__export(schemas_exports, {
+  CACHE_TYPES: () => CACHE_TYPES,
+  CacheConfigSchema: () => CacheConfigSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var import_result = require("../../utils/result.cjs");
+var import_error_codes = require("../error-codes.js");
+var import_types = require("../../errors/types.cjs");
+const CACHE_TYPES = ["in-memory", "redis"];
+const BaseCacheSchema = import_zod.z.object({
+  maxConnections: import_zod.z.number().int().positive().optional().describe("Maximum connections"),
+  idleTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
+  connectionTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
+  options: import_zod.z.record(import_zod.z.any()).optional().describe("Backend-specific options")
+});
+const InMemoryCacheSchema = BaseCacheSchema.extend({
+  type: import_zod.z.literal("in-memory")
+  // In-memory cache doesn't need connection options, but inherits pool options for consistency
+}).strict();
+const RedisCacheSchema = BaseCacheSchema.extend({
+  type: import_zod.z.literal("redis"),
+  url: (0, import_result.EnvExpandedString)().optional().describe("Redis connection URL (redis://...)"),
+  host: import_zod.z.string().optional().describe("Redis host"),
+  port: import_zod.z.number().int().positive().optional().describe("Redis port"),
+  password: import_zod.z.string().optional().describe("Redis password"),
+  database: import_zod.z.number().int().nonnegative().optional().describe("Redis database number")
+}).strict();
+const CacheConfigSchema = import_zod.z.discriminatedUnion("type", [InMemoryCacheSchema, RedisCacheSchema], {
+  errorMap: (issue, ctx) => {
+    if (issue.code === import_zod.z.ZodIssueCode.invalid_union_discriminator) {
+      return {
+        message: `Invalid cache type. Expected 'in-memory' or 'redis'.`
+      };
+    }
+    return { message: ctx.defaultError };
+  }
+}).describe("Cache configuration").superRefine((data, ctx) => {
+  if (data.type === "redis") {
+    if (!data.url && !data.host) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Redis cache requires either 'url' or 'host' to be specified",
+        path: ["url"],
+        params: {
+          code: import_error_codes.StorageErrorCode.CONNECTION_CONFIG_MISSING,
+          scope: import_types.ErrorScope.STORAGE,
+          type: import_types.ErrorType.USER
+        }
+      });
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CACHE_TYPES,
+  CacheConfigSchema
+});

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

@@ -0,0 +1,151 @@
+import { z } from 'zod';
+export declare const CACHE_TYPES: readonly ["in-memory", "redis"];
+export type CacheType = (typeof CACHE_TYPES)[number];
+declare const InMemoryCacheSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+}, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+}>;
+export type InMemoryCacheConfig = z.output<typeof InMemoryCacheSchema>;
+declare const RedisCacheSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"redis">;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "redis";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: number | undefined;
+}, {
+    type: "redis";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: number | undefined;
+}>;
+export type RedisCacheConfig = z.output<typeof RedisCacheSchema>;
+export declare const CacheConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+}, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+}>, z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    type: z.ZodLiteral<"redis">;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "redis";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: number | undefined;
+}, {
+    type: "redis";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: number | undefined;
+}>]>, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+} | {
+    type: "redis";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: number | undefined;
+}, {
+    type: "in-memory";
+    options?: Record<string, any> | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+} | {
+    type: "redis";
+    password?: string | undefined;
+    options?: Record<string, any> | undefined;
+    url?: string | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    database?: number | undefined;
+}>;
+export type CacheConfig = z.output<typeof CacheConfigSchema>;
+export {};
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW,iCAAkC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAoBrD,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;EAGd,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGvE,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOX,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGjE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BxB,CAAC;AAEP,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/storage/cache/schemas.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { EnvExpandedString } from "../../utils/result.js";
+import { StorageErrorCode } from "../error-codes.js";
+import { ErrorScope, ErrorType } from "../../errors/types.js";
+const CACHE_TYPES = ["in-memory", "redis"];
+const BaseCacheSchema = z.object({
+  maxConnections: z.number().int().positive().optional().describe("Maximum connections"),
+  idleTimeoutMillis: z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
+  connectionTimeoutMillis: z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
+  options: z.record(z.any()).optional().describe("Backend-specific options")
+});
+const InMemoryCacheSchema = BaseCacheSchema.extend({
+  type: z.literal("in-memory")
+  // In-memory cache doesn't need connection options, but inherits pool options for consistency
+}).strict();
+const RedisCacheSchema = BaseCacheSchema.extend({
+  type: z.literal("redis"),
+  url: EnvExpandedString().optional().describe("Redis connection URL (redis://...)"),
+  host: z.string().optional().describe("Redis host"),
+  port: z.number().int().positive().optional().describe("Redis port"),
+  password: z.string().optional().describe("Redis password"),
+  database: z.number().int().nonnegative().optional().describe("Redis database number")
+}).strict();
+const CacheConfigSchema = z.discriminatedUnion("type", [InMemoryCacheSchema, RedisCacheSchema], {
+  errorMap: (issue, ctx) => {
+    if (issue.code === z.ZodIssueCode.invalid_union_discriminator) {
+      return {
+        message: `Invalid cache type. Expected 'in-memory' or 'redis'.`
+      };
+    }
+    return { message: ctx.defaultError };
+  }
+}).describe("Cache configuration").superRefine((data, ctx) => {
+  if (data.type === "redis") {
+    if (!data.url && !data.host) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Redis cache requires either 'url' or 'host' to be specified",
+        path: ["url"],
+        params: {
+          code: StorageErrorCode.CONNECTION_CONFIG_MISSING,
+          scope: ErrorScope.STORAGE,
+          type: ErrorType.USER
+        }
+      });
+    }
+  }
+});
+export {
+  CACHE_TYPES,
+  CacheConfigSchema
+};

package/dist/storage/cache/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/storage/{backend/cache-backend.d.cts → cache/types.d.ts}

@@ -2,14 +2,13 @@
  * Fast, ephemeral storage for temporary data and performance optimization.
  * Supports TTL for automatic cleanup of temporary data.
  */
-interface CacheBackend {
+export interface Cache {
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
     delete(key: string): Promise<void>;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
-    getBackendType(): string;
+    getStoreType(): string;
 }
-
-export type { CacheBackend };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,KAAK;IAElB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAC5C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAGnC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,WAAW,IAAI,OAAO,CAAC;IACvB,YAAY,IAAI,MAAM,CAAC;CAC1B"}

package/dist/storage/database/factory.cjs

@@ -0,0 +1,84 @@
+"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, {
+  createDatabase: () => createDatabase
+});
+module.exports = __toCommonJS(factory_exports);
+var import_memory_database_store = require("./memory-database-store.js");
+var import_logger = require("../../logger/index.js");
+let SQLiteStore = null;
+let PostgresStore = null;
+async function createDatabase(config) {
+  switch (config.type) {
+    case "postgres":
+      return createPostgresStore(config);
+    case "sqlite":
+      return createSQLiteStore(config);
+    case "in-memory":
+    default:
+      import_logger.logger.info("Using in-memory database store");
+      return new import_memory_database_store.MemoryDatabaseStore();
+  }
+}
+async function createPostgresStore(config) {
+  try {
+    if (!PostgresStore) {
+      const module2 = await import("./postgres-store.js");
+      PostgresStore = module2.PostgresStore;
+    }
+    import_logger.logger.info("Connecting to PostgreSQL database");
+    return new PostgresStore(config);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    import_logger.logger.warn(
+      `PostgreSQL not available, falling back to in-memory database: ${errorMessage}`
+    );
+    return new import_memory_database_store.MemoryDatabaseStore();
+  }
+}
+async function createSQLiteStore(config) {
+  try {
+    if (!SQLiteStore) {
+      const module2 = await import("./sqlite-store.js");
+      SQLiteStore = module2.SQLiteStore;
+    }
+    import_logger.logger.info(`Using SQLite database at ${config.path}`);
+    return new SQLiteStore(config);
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    import_logger.logger.error(`SQLite store failed to load: ${err.message}`, err);
+    import_logger.logger.warn("Falling back to in-memory database store");
+    return new import_memory_database_store.MemoryDatabaseStore();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDatabase
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/database/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAgD,MAAM,eAAe,CAAC;AAiBlG;;;GAGG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,CAa9E"}

package/dist/storage/database/factory.js

@@ -0,0 +1,50 @@
+import { MemoryDatabaseStore } from "./memory-database-store.js";
+import { logger } from "../../logger/index.js";
+let SQLiteStore = null;
+let PostgresStore = null;
+async function createDatabase(config) {
+  switch (config.type) {
+    case "postgres":
+      return createPostgresStore(config);
+    case "sqlite":
+      return createSQLiteStore(config);
+    case "in-memory":
+    default:
+      logger.info("Using in-memory database store");
+      return new MemoryDatabaseStore();
+  }
+}
+async function createPostgresStore(config) {
+  try {
+    if (!PostgresStore) {
+      const module = await import("./postgres-store.js");
+      PostgresStore = module.PostgresStore;
+    }
+    logger.info("Connecting to PostgreSQL database");
+    return new PostgresStore(config);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.warn(
+      `PostgreSQL not available, falling back to in-memory database: ${errorMessage}`
+    );
+    return new MemoryDatabaseStore();
+  }
+}
+async function createSQLiteStore(config) {
+  try {
+    if (!SQLiteStore) {
+      const module = await import("./sqlite-store.js");
+      SQLiteStore = module.SQLiteStore;
+    }
+    logger.info(`Using SQLite database at ${config.path}`);
+    return new SQLiteStore(config);
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    logger.error(`SQLite store failed to load: ${err.message}`, err);
+    logger.warn("Falling back to in-memory database store");
+    return new MemoryDatabaseStore();
+  }
+}
+export {
+  createDatabase
+};

package/dist/storage/{backend/memory-backend.cjs → database/memory-database-store.cjs}

@@ -16,16 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var memory_backend_exports = {};
-__export(memory_backend_exports, {
-  MemoryBackend: () => MemoryBackend
+var memory_database_store_exports = {};
+__export(memory_database_store_exports, {
+  MemoryDatabaseStore: () => MemoryDatabaseStore
 });
-module.exports = __toCommonJS(memory_backend_exports);
+module.exports = __toCommonJS(memory_database_store_exports);
 var import_errors = require("../errors.js");
-class MemoryBackend {
+class MemoryDatabaseStore {
   data = /* @__PURE__ */ new Map();
   lists = /* @__PURE__ */ new Map();
-  ttls = /* @__PURE__ */ new Map();
   connected = false;
   constructor() {
   }
@@ -36,19 +35,16 @@ class MemoryBackend {
     this.connected = false;
     this.data.clear();
     this.lists.clear();
-    this.ttls.clear();
   }
   isConnected() {
     return this.connected;
   }
-  getBackendType() {
+  getStoreType() {
     return "memory";
   }
-  // Core operations
   async get(key) {
     this.checkConnection();
     try {
-      this.checkTTL(key);
       return this.data.get(key);
     } catch (error) {
       throw import_errors.StorageError.readFailed(
@@ -58,15 +54,10 @@ class MemoryBackend {
       );
     }
   }
-  async set(key, value, ttlSeconds) {
+  async set(key, value) {
     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",
@@ -79,10 +70,9 @@ class MemoryBackend {
     this.checkConnection();
     this.data.delete(key);
     this.lists.delete(key);
-    this.ttls.delete(key);
   }
-  // List operations (DatabaseBackend)
   async list(prefix) {
+    this.checkConnection();
     const keys = [];
     for (const key of Array.from(this.data.keys())) {
       if (key.startsWith(prefix)) {
@@ -111,21 +101,13 @@ class MemoryBackend {
   // Helper methods
   checkConnection() {
     if (!this.connected) {
-      throw import_errors.StorageError.notConnected("MemoryBackend");
-    }
-  }
-  checkTTL(key) {
-    const expiry = this.ttls.get(key);
-    if (expiry && Date.now() > expiry) {
-      this.data.delete(key);
-      this.ttls.delete(key);
+      throw import_errors.StorageError.notConnected("MemoryDatabaseStore");
     }
   }
   // Development helpers
   async clear() {
     this.data.clear();
     this.lists.clear();
-    this.ttls.clear();
   }
   async dump() {
     return {
@@ -136,5 +118,5 @@ class MemoryBackend {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  MemoryBackend
+  MemoryDatabaseStore
 });

package/dist/storage/{backend/memory-backend.d.ts → database/memory-database-store.d.ts}

@@ -1,34 +1,29 @@
-import { CacheBackend } from './cache-backend.js';
-import { DatabaseBackend } from './database-backend.js';
-
+import type { Database } from './types.js';
 /**
- * In-memory storage backend for development and testing.
- * Implements both CacheBackend and DatabaseBackend interfaces.
+ * In-memory database store for development and testing.
+ * Supports list operations for message history and enumeration for settings.
  * Data is lost when the process restarts.
  */
-declare class MemoryBackend implements CacheBackend, DatabaseBackend {
+export declare class MemoryDatabaseStore implements Database {
     private data;
     private lists;
-    private ttls;
     private connected;
     constructor();
     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>;
+    set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
     list(prefix: string): Promise<string[]>;
     append<T>(key: string, item: T): Promise<void>;
     getRange<T>(key: string, start: number, count: number): Promise<T[]>;
     private checkConnection;
-    private checkTTL;
     clear(): Promise<void>;
     dump(): Promise<{
         data: Record<string, any>;
         lists: Record<string, any[]>;
     }>;
 }
-
-export { MemoryBackend };
+//# sourceMappingURL=memory-database-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-database-store.d.ts","sourceRoot":"","sources":["../../../src/storage/database/memory-database-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;GAIG;AACH,qBAAa,mBAAoB,YAAW,QAAQ;IAChD,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,KAAK,CAA4B;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;IAa3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMlC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAsBvC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ9C,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAO1E,OAAO,CAAC,eAAe;IAOjB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,IAAI,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAA;KAAE,CAAC;CAMrF"}