@dexto/core 1.1.4 → 1.1.6

package/dist/storage/schemas.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { StorageErrorCode } from "./error-codes.js";
+import { ErrorScope, ErrorType } from "../errors/types.js";
+const BaseBackendSchema = 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 InMemoryBackendSchema = BaseBackendSchema.extend({
+  type: z.literal("in-memory")
+  // In-memory backend doesn't need connection options, but inherits pool options for consistency
+}).strict();
+const RedisBackendSchema = BaseBackendSchema.extend({
+  type: z.literal("redis"),
+  url: z.string().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 SqliteBackendSchema = BaseBackendSchema.extend({
+  type: z.literal("sqlite"),
+  path: z.string().optional().describe(
+    "SQLite database file path (optional, will auto-detect using path resolver if not provided)"
+  ),
+  database: z.string().optional().describe("Database filename (default: dexto.db)")
+}).strict();
+const PostgresBackendSchema = BaseBackendSchema.extend({
+  type: z.literal("postgres"),
+  url: z.string().optional().describe("PostgreSQL connection URL (postgresql://...)"),
+  connectionString: z.string().optional().describe("PostgreSQL connection string"),
+  host: z.string().optional().describe("PostgreSQL host"),
+  port: z.number().int().positive().optional().describe("PostgreSQL port"),
+  database: z.string().optional().describe("PostgreSQL database name"),
+  password: z.string().optional().describe("PostgreSQL password")
+}).strict();
+const BackendConfigSchema = z.discriminatedUnion(
+  "type",
+  [InMemoryBackendSchema, RedisBackendSchema, SqliteBackendSchema, PostgresBackendSchema],
+  {
+    errorMap: (issue, ctx) => {
+      if (issue.code === z.ZodIssueCode.invalid_union_discriminator) {
+        return {
+          message: `Invalid backend type. Expected 'in-memory', 'redis', 'sqlite', or 'postgres'.`
+        };
+      }
+      return { message: ctx.defaultError };
+    }
+  }
+).describe("Backend configuration for storage system").superRefine((data, ctx) => {
+  if (data.type === "redis") {
+    if (!data.url && !data.host) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Redis backend requires either 'url' or 'host' to be specified",
+        path: ["url"],
+        params: {
+          code: StorageErrorCode.CONNECTION_CONFIG_MISSING,
+          scope: ErrorScope.STORAGE,
+          type: ErrorType.USER
+        }
+      });
+    }
+  }
+  if (data.type === "postgres") {
+    if (!data.url && !data.connectionString && !data.host) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "PostgreSQL backend requires one of 'url', 'connectionString', or 'host' to be specified",
+        path: ["url"],
+        params: {
+          code: StorageErrorCode.CONNECTION_CONFIG_MISSING,
+          scope: ErrorScope.STORAGE,
+          type: ErrorType.USER
+        }
+      });
+    }
+  }
+});
+const StorageSchema = z.object({
+  cache: BackendConfigSchema.describe("Cache backend configuration (fast, ephemeral)"),
+  database: BackendConfigSchema.describe(
+    "Database backend configuration (persistent, reliable)"
+  )
+}).strict().describe("Storage configuration with cache and database backends").brand();
+export {
+  StorageSchema
+};

package/dist/storage/storage-manager.cjs

@@ -0,0 +1,208 @@
+"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 storage_manager_exports = {};
+__export(storage_manager_exports, {
+  StorageManager: () => StorageManager,
+  createStorageBackends: () => createStorageBackends
+});
+module.exports = __toCommonJS(storage_manager_exports);
+var import_memory_backend = require("./backend/memory-backend.js");
+var import_logger = require("../logger/index.js");
+let SQLiteBackend;
+let RedisBackend;
+let PostgresBackend;
+const HEALTH_CHECK_KEY = "storage_manager_health_check";
+class StorageManager {
+  config;
+  cache;
+  database;
+  connected = false;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected) {
+      return {
+        cache: this.cache,
+        database: this.database
+      };
+    }
+    this.cache = await this.createCacheBackend();
+    await this.cache.connect();
+    this.database = await this.createDatabaseBackend();
+    await this.database.connect();
+    this.connected = true;
+    return {
+      cache: this.cache,
+      database: this.database
+    };
+  }
+  async disconnect() {
+    if (this.cache) {
+      await this.cache.disconnect();
+      delete this.cache;
+    }
+    if (this.database) {
+      await this.database.disconnect();
+      delete this.database;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.cache?.isConnected() === true && this.database?.isConnected() === true;
+  }
+  getBackends() {
+    if (!this.connected) return null;
+    return {
+      cache: this.cache,
+      database: this.database
+    };
+  }
+  async createCacheBackend() {
+    const cacheConfig = this.config.cache;
+    switch (cacheConfig.type) {
+      case "redis":
+        return this.createRedisBackend(cacheConfig);
+      case "in-memory":
+      default:
+        import_logger.logger.info("Using in-memory cache backend");
+        return new import_memory_backend.MemoryBackend();
+    }
+  }
+  async createDatabaseBackend() {
+    const dbConfig = this.config.database;
+    switch (dbConfig.type) {
+      case "postgres":
+        return this.createPostgresBackend(dbConfig);
+      case "sqlite":
+        return this.createSQLiteBackend(dbConfig);
+      case "in-memory":
+      default:
+        import_logger.logger.info("Using in-memory database backend");
+        return new import_memory_backend.MemoryBackend();
+    }
+  }
+  async createRedisBackend(config) {
+    try {
+      if (!RedisBackend) {
+        const module2 = await import("./backend/redis-backend.js");
+        RedisBackend = module2.RedisBackend;
+      }
+      import_logger.logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
+      return new RedisBackend(config);
+    } catch (error) {
+      import_logger.logger.warn(`Redis not available, falling back to in-memory cache: ${error}`);
+      return new import_memory_backend.MemoryBackend();
+    }
+  }
+  async createPostgresBackend(config) {
+    try {
+      if (!PostgresBackend) {
+        const module2 = await import("./backend/postgres-backend.js");
+        PostgresBackend = module2.PostgresBackend;
+      }
+      import_logger.logger.info("Connecting to PostgreSQL database");
+      return new PostgresBackend(config);
+    } catch (error) {
+      import_logger.logger.warn(`PostgreSQL not available, falling back to in-memory database: ${error}`);
+      return new import_memory_backend.MemoryBackend();
+    }
+  }
+  async createSQLiteBackend(config) {
+    try {
+      if (!SQLiteBackend) {
+        const module2 = await import("./backend/sqlite-backend.js");
+        SQLiteBackend = module2.SQLiteBackend;
+      }
+      import_logger.logger.info(`Using SQLite database at ${config.path}`);
+      return new SQLiteBackend(config);
+    } catch (error) {
+      import_logger.logger.error(
+        `SQLite backend failed to load: ${error instanceof Error ? error.message : String(error)}`
+      );
+      import_logger.logger.error(`Full error details: ${JSON.stringify(error)}`);
+      import_logger.logger.warn("Falling back to in-memory database backend");
+      return new import_memory_backend.MemoryBackend();
+    }
+  }
+  // Utility methods
+  async getInfo() {
+    return {
+      cache: {
+        type: this.cache?.getBackendType() || "none",
+        connected: this.cache?.isConnected() || false
+      },
+      database: {
+        type: this.database?.getBackendType() || "none",
+        connected: this.database?.isConnected() || false
+      },
+      connected: this.connected
+    };
+  }
+  // Health check
+  async healthCheck() {
+    let cacheHealthy = false;
+    let databaseHealthy = false;
+    try {
+      if (this.cache?.isConnected()) {
+        await this.cache.set(HEALTH_CHECK_KEY, "ok", 10);
+        const result = await this.cache.get(HEALTH_CHECK_KEY);
+        cacheHealthy = result === "ok";
+        await this.cache.delete(HEALTH_CHECK_KEY);
+      }
+    } catch (error) {
+      import_logger.logger.warn(`Cache health check failed: ${error}`);
+    }
+    try {
+      if (this.database?.isConnected()) {
+        await this.database.set(HEALTH_CHECK_KEY, "ok");
+        const result = await this.database.get(HEALTH_CHECK_KEY);
+        databaseHealthy = result === "ok";
+        await this.database.delete(HEALTH_CHECK_KEY);
+      }
+    } catch (error) {
+      import_logger.logger.warn(`Database health check failed: ${error}`);
+    }
+    return {
+      cache: cacheHealthy,
+      database: databaseHealthy,
+      overall: cacheHealthy && databaseHealthy
+    };
+  }
+}
+async function createStorageBackends(config) {
+  const manager = new StorageManager(config);
+  const backends = await manager.connect();
+  return { manager, backends };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StorageManager,
+  createStorageBackends
+});

package/dist/storage/storage-manager.d.cts

@@ -0,0 +1,52 @@
+import { StorageBackends } from './backend/types.cjs';
+import { ValidatedStorageConfig } from './schemas.cjs';
+import './backend/cache-backend.cjs';
+import './backend/database-backend.cjs';
+import 'zod';
+
+/**
+ * Storage manager that initializes and manages storage backends.
+ * Handles both cache and database backends with automatic fallbacks.
+ */
+declare class StorageManager {
+    private config;
+    private cache?;
+    private database?;
+    private connected;
+    constructor(config: ValidatedStorageConfig);
+    connect(): Promise<StorageBackends>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getBackends(): StorageBackends | null;
+    private createCacheBackend;
+    private createDatabaseBackend;
+    private createRedisBackend;
+    private createPostgresBackend;
+    private createSQLiteBackend;
+    getInfo(): Promise<{
+        cache: {
+            type: string;
+            connected: boolean;
+        };
+        database: {
+            type: string;
+            connected: boolean;
+        };
+        connected: boolean;
+    }>;
+    healthCheck(): Promise<{
+        cache: boolean;
+        database: boolean;
+        overall: boolean;
+    }>;
+}
+/**
+ * Create storage backends without using singleton pattern
+ * This allows multiple agent instances to have independent storage
+ */
+declare function createStorageBackends(config: ValidatedStorageConfig): Promise<{
+    manager: StorageManager;
+    backends: StorageBackends;
+}>;
+
+export { StorageManager, createStorageBackends };

package/dist/storage/storage-manager.d.ts

@@ -0,0 +1,52 @@
+import { StorageBackends } from './backend/types.js';
+import { ValidatedStorageConfig } from './schemas.js';
+import './backend/cache-backend.js';
+import './backend/database-backend.js';
+import 'zod';
+
+/**
+ * Storage manager that initializes and manages storage backends.
+ * Handles both cache and database backends with automatic fallbacks.
+ */
+declare class StorageManager {
+    private config;
+    private cache?;
+    private database?;
+    private connected;
+    constructor(config: ValidatedStorageConfig);
+    connect(): Promise<StorageBackends>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getBackends(): StorageBackends | null;
+    private createCacheBackend;
+    private createDatabaseBackend;
+    private createRedisBackend;
+    private createPostgresBackend;
+    private createSQLiteBackend;
+    getInfo(): Promise<{
+        cache: {
+            type: string;
+            connected: boolean;
+        };
+        database: {
+            type: string;
+            connected: boolean;
+        };
+        connected: boolean;
+    }>;
+    healthCheck(): Promise<{
+        cache: boolean;
+        database: boolean;
+        overall: boolean;
+    }>;
+}
+/**
+ * Create storage backends without using singleton pattern
+ * This allows multiple agent instances to have independent storage
+ */
+declare function createStorageBackends(config: ValidatedStorageConfig): Promise<{
+    manager: StorageManager;
+    backends: StorageBackends;
+}>;
+
+export { StorageManager, createStorageBackends };

package/dist/storage/storage-manager.js

@@ -0,0 +1,173 @@
+import { MemoryBackend } from "./backend/memory-backend.js";
+import { logger } from "../logger/index.js";
+let SQLiteBackend;
+let RedisBackend;
+let PostgresBackend;
+const HEALTH_CHECK_KEY = "storage_manager_health_check";
+class StorageManager {
+  config;
+  cache;
+  database;
+  connected = false;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected) {
+      return {
+        cache: this.cache,
+        database: this.database
+      };
+    }
+    this.cache = await this.createCacheBackend();
+    await this.cache.connect();
+    this.database = await this.createDatabaseBackend();
+    await this.database.connect();
+    this.connected = true;
+    return {
+      cache: this.cache,
+      database: this.database
+    };
+  }
+  async disconnect() {
+    if (this.cache) {
+      await this.cache.disconnect();
+      delete this.cache;
+    }
+    if (this.database) {
+      await this.database.disconnect();
+      delete this.database;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.cache?.isConnected() === true && this.database?.isConnected() === true;
+  }
+  getBackends() {
+    if (!this.connected) return null;
+    return {
+      cache: this.cache,
+      database: this.database
+    };
+  }
+  async createCacheBackend() {
+    const cacheConfig = this.config.cache;
+    switch (cacheConfig.type) {
+      case "redis":
+        return this.createRedisBackend(cacheConfig);
+      case "in-memory":
+      default:
+        logger.info("Using in-memory cache backend");
+        return new MemoryBackend();
+    }
+  }
+  async createDatabaseBackend() {
+    const dbConfig = this.config.database;
+    switch (dbConfig.type) {
+      case "postgres":
+        return this.createPostgresBackend(dbConfig);
+      case "sqlite":
+        return this.createSQLiteBackend(dbConfig);
+      case "in-memory":
+      default:
+        logger.info("Using in-memory database backend");
+        return new MemoryBackend();
+    }
+  }
+  async createRedisBackend(config) {
+    try {
+      if (!RedisBackend) {
+        const module = await import("./backend/redis-backend.js");
+        RedisBackend = module.RedisBackend;
+      }
+      logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
+      return new RedisBackend(config);
+    } catch (error) {
+      logger.warn(`Redis not available, falling back to in-memory cache: ${error}`);
+      return new MemoryBackend();
+    }
+  }
+  async createPostgresBackend(config) {
+    try {
+      if (!PostgresBackend) {
+        const module = await import("./backend/postgres-backend.js");
+        PostgresBackend = module.PostgresBackend;
+      }
+      logger.info("Connecting to PostgreSQL database");
+      return new PostgresBackend(config);
+    } catch (error) {
+      logger.warn(`PostgreSQL not available, falling back to in-memory database: ${error}`);
+      return new MemoryBackend();
+    }
+  }
+  async createSQLiteBackend(config) {
+    try {
+      if (!SQLiteBackend) {
+        const module = await import("./backend/sqlite-backend.js");
+        SQLiteBackend = module.SQLiteBackend;
+      }
+      logger.info(`Using SQLite database at ${config.path}`);
+      return new SQLiteBackend(config);
+    } catch (error) {
+      logger.error(
+        `SQLite backend failed to load: ${error instanceof Error ? error.message : String(error)}`
+      );
+      logger.error(`Full error details: ${JSON.stringify(error)}`);
+      logger.warn("Falling back to in-memory database backend");
+      return new MemoryBackend();
+    }
+  }
+  // Utility methods
+  async getInfo() {
+    return {
+      cache: {
+        type: this.cache?.getBackendType() || "none",
+        connected: this.cache?.isConnected() || false
+      },
+      database: {
+        type: this.database?.getBackendType() || "none",
+        connected: this.database?.isConnected() || false
+      },
+      connected: this.connected
+    };
+  }
+  // Health check
+  async healthCheck() {
+    let cacheHealthy = false;
+    let databaseHealthy = false;
+    try {
+      if (this.cache?.isConnected()) {
+        await this.cache.set(HEALTH_CHECK_KEY, "ok", 10);
+        const result = await this.cache.get(HEALTH_CHECK_KEY);
+        cacheHealthy = result === "ok";
+        await this.cache.delete(HEALTH_CHECK_KEY);
+      }
+    } catch (error) {
+      logger.warn(`Cache health check failed: ${error}`);
+    }
+    try {
+      if (this.database?.isConnected()) {
+        await this.database.set(HEALTH_CHECK_KEY, "ok");
+        const result = await this.database.get(HEALTH_CHECK_KEY);
+        databaseHealthy = result === "ok";
+        await this.database.delete(HEALTH_CHECK_KEY);
+      }
+    } catch (error) {
+      logger.warn(`Database health check failed: ${error}`);
+    }
+    return {
+      cache: cacheHealthy,
+      database: databaseHealthy,
+      overall: cacheHealthy && databaseHealthy
+    };
+  }
+}
+async function createStorageBackends(config) {
+  const manager = new StorageManager(config);
+  const backends = await manager.connect();
+  return { manager, backends };
+}
+export {
+  StorageManager,
+  createStorageBackends
+};

package/dist/storage/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/types.d.cts

@@ -0,0 +1,5 @@
+export { StorageBackends } from './backend/types.cjs';
+export { CacheBackend } from './backend/cache-backend.cjs';
+export { DatabaseBackend } from './backend/database-backend.cjs';
+export { BackendConfig, StorageConfig } from './schemas.cjs';
+import 'zod';

package/dist/storage/types.d.ts

@@ -0,0 +1,5 @@
+export { StorageBackends } from './backend/types.js';
+export { CacheBackend } from './backend/cache-backend.js';
+export { DatabaseBackend } from './backend/database-backend.js';
+export { BackendConfig, StorageConfig } from './schemas.js';
+import 'zod';