@dexto/core 1.1.4 → 1.1.6

package/dist/storage/backend/postgres-backend.d.ts

@@ -0,0 +1,37 @@
+import { PoolClient } from 'pg';
+import { DatabaseBackend } from './database-backend.js';
+import { PostgresBackendConfig } from '../schemas.js';
+import 'zod';
+
+/**
+ * PostgreSQL storage backend for production database operations.
+ * Implements the DatabaseBackend interface with connection pooling and JSONB support.
+ * EXPERIMENTAL - NOT FULLY TESTED YET
+ */
+declare class PostgresBackend implements DatabaseBackend {
+    private config;
+    private pool;
+    private connected;
+    constructor(config: PostgresBackendConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getBackendType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    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 createTables;
+    private checkConnection;
+    transaction<T>(callback: (client: PoolClient) => Promise<T>): Promise<T>;
+    getStats(): Promise<{
+        kvCount: number;
+        listCount: number;
+        totalSize: string;
+    }>;
+    vacuum(): Promise<void>;
+}
+
+export { PostgresBackend };

package/dist/{postgres-backend-WMWS7RAT.js → storage/backend/postgres-backend.js}

@@ -1,15 +1,6 @@
-import {
-  StorageError
-} from "./chunk-F2QFAECT.js";
-import "./chunk-TPERKLLN.js";
-import {
-  init_esm_shims
-} from "./chunk-MVKLS3LM.js";
-
-// src/storage/backend/postgres-backend.ts
-init_esm_shims();
 import { Pool } from "pg";
-var PostgresBackend = class {
+import { StorageError } from "../errors.js";
+class PostgresBackend {
   constructor(config) {
     this.config = config;
   }
@@ -210,7 +201,7 @@ var PostgresBackend = class {
       client.release();
     }
   }
-};
+}
 export {
   PostgresBackend
 };

package/dist/storage/backend/redis-backend.cjs

@@ -0,0 +1,184 @@
+"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 redis_backend_exports = {};
+__export(redis_backend_exports, {
+  RedisBackend: () => RedisBackend
+});
+module.exports = __toCommonJS(redis_backend_exports);
+var import_ioredis = require("ioredis");
+var import_errors = require("../errors.js");
+class RedisBackend {
+  constructor(config) {
+    this.config = config;
+  }
+  redis = null;
+  connected = false;
+  async connect() {
+    if (this.connected) return;
+    this.redis = new import_ioredis.Redis({
+      ...this.config.host && { host: this.config.host },
+      ...this.config.port && { port: this.config.port },
+      ...this.config.password && { password: this.config.password },
+      db: this.config.database || 0,
+      family: 4,
+      // IPv4 by default
+      ...this.config.connectionTimeoutMillis && {
+        connectTimeout: this.config.connectionTimeoutMillis
+      },
+      ...this.config.connectionTimeoutMillis && {
+        commandTimeout: this.config.connectionTimeoutMillis
+      },
+      maxRetriesPerRequest: 3,
+      lazyConnect: true,
+      ...this.config.options
+    });
+    this.redis.on("error", (error) => {
+      console.error("Redis connection error:", error);
+    });
+    this.redis.on("connect", () => {
+      this.connected = true;
+    });
+    this.redis.on("close", () => {
+      this.connected = false;
+    });
+    await this.redis.connect();
+  }
+  async disconnect() {
+    if (this.redis) {
+      await this.redis.quit();
+      this.redis = null;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.redis?.status === "ready";
+  }
+  getBackendType() {
+    return "redis";
+  }
+  // Core operations
+  async get(key) {
+    this.checkConnection();
+    try {
+      const value = await this.redis.get(key);
+      return value ? JSON.parse(value) : void 0;
+    } catch (error) {
+      throw import_errors.StorageError.readFailed(
+        "get",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    this.checkConnection();
+    try {
+      const serialized = JSON.stringify(value);
+      if (ttlSeconds) {
+        await this.redis.setex(key, ttlSeconds, serialized);
+      } else {
+        await this.redis.set(key, serialized);
+      }
+    } catch (error) {
+      throw import_errors.StorageError.writeFailed(
+        "set",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async delete(key) {
+    this.checkConnection();
+    try {
+      await this.redis.del(key);
+    } catch (error) {
+      throw import_errors.StorageError.deleteFailed(
+        "delete",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  // Redis-specific optimizations
+  async mget(keys) {
+    this.checkConnection();
+    if (keys.length === 0) return [];
+    const values = await this.redis.mget(...keys);
+    return values.map((value) => value ? JSON.parse(value) : void 0);
+  }
+  async mset(entries) {
+    this.checkConnection();
+    if (entries.length === 0) return;
+    const pipeline = this.redis.pipeline();
+    for (const [key, value] of entries) {
+      pipeline.set(key, JSON.stringify(value));
+    }
+    await pipeline.exec();
+  }
+  async exists(key) {
+    this.checkConnection();
+    const result = await this.redis.exists(key);
+    return result === 1;
+  }
+  async expire(key, ttlSeconds) {
+    this.checkConnection();
+    await this.redis.expire(key, ttlSeconds);
+  }
+  // Cache-specific operations
+  async increment(key, by = 1) {
+    this.checkConnection();
+    return await this.redis.incrby(key, by);
+  }
+  async decrement(key, by = 1) {
+    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");
+    }
+  }
+  // Maintenance operations
+  async flushdb() {
+    this.checkConnection();
+    await this.redis.flushdb();
+  }
+  async info() {
+    this.checkConnection();
+    return await this.redis.info();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisBackend
+});

package/dist/storage/backend/redis-backend.d.cts

@@ -0,0 +1,36 @@
+import { CacheBackend } from './cache-backend.cjs';
+import { RedisBackendConfig } from '../schemas.cjs';
+import 'zod';
+
+/**
+ * Redis storage backend for production cache operations.
+ * Implements the CacheBackend interface with connection pooling and optimizations.
+ * EXPERIMENTAL - NOT FULLY TESTED YET
+ */
+declare class RedisBackend implements CacheBackend {
+    private config;
+    private redis;
+    private connected;
+    constructor(config: RedisBackendConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getBackendType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    mget<T>(keys: string[]): Promise<(T | undefined)[]>;
+    mset<T>(entries: [string, T][]): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    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 };

package/dist/storage/backend/redis-backend.d.ts

@@ -0,0 +1,36 @@
+import { CacheBackend } from './cache-backend.js';
+import { RedisBackendConfig } from '../schemas.js';
+import 'zod';
+
+/**
+ * Redis storage backend for production cache operations.
+ * Implements the CacheBackend interface with connection pooling and optimizations.
+ * EXPERIMENTAL - NOT FULLY TESTED YET
+ */
+declare class RedisBackend implements CacheBackend {
+    private config;
+    private redis;
+    private connected;
+    constructor(config: RedisBackendConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getBackendType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    mget<T>(keys: string[]): Promise<(T | undefined)[]>;
+    mset<T>(entries: [string, T][]): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    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 };

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

@@ -1,15 +1,6 @@
-import {
-  StorageError
-} from "./chunk-F2QFAECT.js";
-import "./chunk-TPERKLLN.js";
-import {
-  init_esm_shims
-} from "./chunk-MVKLS3LM.js";
-
-// src/storage/backend/redis-backend.ts
-init_esm_shims();
 import { Redis } from "ioredis";
-var RedisBackend = class {
+import { StorageError } from "../errors.js";
+class RedisBackend {
   constructor(config) {
     this.config = config;
   }
@@ -163,7 +154,7 @@ var RedisBackend = class {
     this.checkConnection();
     return await this.redis.info();
   }
-};
+}
 export {
   RedisBackend
 };

package/dist/storage/backend/sqlite-backend.cjs

@@ -0,0 +1,271 @@
+"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 sqlite_backend_exports = {};
+__export(sqlite_backend_exports, {
+  SQLiteBackend: () => SQLiteBackend
+});
+module.exports = __toCommonJS(sqlite_backend_exports);
+var import_path = require("path");
+var import_fs = require("fs");
+var import_logger = require("../../logger/index.js");
+var import_path2 = require("../../utils/path.js");
+var path = __toESM(require("path"), 1);
+var import_errors = require("../errors.js");
+let Database;
+class SQLiteBackend {
+  db;
+  // Database.Database
+  dbPath;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.dbPath = "";
+  }
+  resolveDefaultPath(dbName) {
+    const storageDir = (0, import_path2.getDextoPath)("database");
+    const finalPath = path.join(storageDir, dbName);
+    import_logger.logger.info(`SQLite storage directory: ${storageDir}`);
+    import_logger.logger.debug(`SQLite database file: ${finalPath}`);
+    return finalPath;
+  }
+  initializeTables() {
+    import_logger.logger.debug("SQLite initializing database schema...");
+    try {
+      this.db.exec(`
+                CREATE TABLE IF NOT EXISTS kv_store (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL,
+                    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+                )
+            `);
+      this.db.exec(`
+                CREATE TABLE IF NOT EXISTS list_store (
+                    key TEXT NOT NULL,
+                    value TEXT NOT NULL,
+                    sequence INTEGER,
+                    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+                    PRIMARY KEY (key, sequence)
+                )
+            `);
+      this.db.exec(`
+                CREATE INDEX IF NOT EXISTS idx_kv_store_key ON kv_store(key);
+                CREATE INDEX IF NOT EXISTS idx_list_store_key ON list_store(key);
+                CREATE INDEX IF NOT EXISTS idx_list_store_sequence ON list_store(key, sequence);
+            `);
+      import_logger.logger.debug(
+        "SQLite database schema initialized: kv_store, list_store tables with indexes"
+      );
+    } catch (error) {
+      throw import_errors.StorageError.migrationFailed(
+        error instanceof Error ? error.message : String(error),
+        {
+          operation: "table_initialization",
+          backend: "sqlite"
+        }
+      );
+    }
+  }
+  async connect() {
+    if (!Database) {
+      try {
+        const module2 = await import("better-sqlite3");
+        Database = module2.default || module2;
+      } catch (error) {
+        throw import_errors.StorageError.connectionFailed(
+          `Failed to import better-sqlite3: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (this.config.path) {
+      this.dbPath = this.config.path;
+      import_logger.logger.info(`SQLite using custom path: ${this.dbPath}`);
+    } else {
+      this.dbPath = this.resolveDefaultPath(this.config.database || "dexto.db");
+    }
+    const dir = (0, import_path.dirname)(this.dbPath);
+    import_logger.logger.debug(`SQLite ensuring directory exists: ${dir}`);
+    try {
+      (0, import_fs.mkdirSync)(dir, { recursive: true });
+    } catch (error) {
+      import_logger.logger.debug(`Directory creation result: ${error ? "exists" : "created"}`);
+    }
+    const sqliteOptions = this.config.options || {};
+    import_logger.logger.debug(`SQLite initializing database with config:`, {
+      readonly: sqliteOptions.readonly || false,
+      fileMustExist: sqliteOptions.fileMustExist || false,
+      timeout: sqliteOptions.timeout || 5e3
+    });
+    this.db = new Database(this.dbPath, {
+      readonly: sqliteOptions.readonly || false,
+      fileMustExist: sqliteOptions.fileMustExist || false,
+      timeout: sqliteOptions.timeout || 5e3,
+      verbose: sqliteOptions.verbose ? (message, ...additionalArgs) => {
+        import_logger.logger.debug(
+          typeof message === "string" || typeof message === "object" && message !== null ? message : String(message),
+          ...additionalArgs
+        );
+      } : void 0
+    });
+    this.db.pragma("journal_mode = WAL");
+    import_logger.logger.debug("SQLite enabled WAL mode for better concurrency");
+    this.initializeTables();
+    import_logger.logger.info(`\u2705 SQLite backend successfully connected to: ${this.dbPath}`);
+  }
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+    }
+  }
+  isConnected() {
+    return this.db !== null;
+  }
+  getBackendType() {
+    return "sqlite";
+  }
+  // Core operations
+  async get(key) {
+    this.checkConnection();
+    try {
+      const row = this.db.prepare("SELECT value FROM kv_store WHERE key = ?").get(key);
+      return row ? JSON.parse(row.value) : void 0;
+    } catch (error) {
+      throw import_errors.StorageError.readFailed(
+        "get",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async set(key, value) {
+    this.checkConnection();
+    try {
+      const serialized = JSON.stringify(value);
+      this.db.prepare(
+        "INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, ?)"
+      ).run(key, serialized, Date.now());
+    } catch (error) {
+      throw import_errors.StorageError.writeFailed(
+        "set",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async delete(key) {
+    this.checkConnection();
+    try {
+      this.db.prepare("DELETE FROM kv_store WHERE key = ?").run(key);
+      this.db.prepare("DELETE FROM list_store WHERE key = ?").run(key);
+    } catch (error) {
+      throw import_errors.StorageError.deleteFailed(
+        "delete",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  // List operations
+  async list(prefix) {
+    this.checkConnection();
+    try {
+      const kvKeys = this.db.prepare("SELECT key FROM kv_store WHERE key LIKE ?").all(`${prefix}%`);
+      const listKeys = this.db.prepare("SELECT DISTINCT key FROM list_store WHERE key LIKE ?").all(`${prefix}%`);
+      const allKeys = /* @__PURE__ */ new Set([
+        ...kvKeys.map((row) => row.key),
+        ...listKeys.map((row) => row.key)
+      ]);
+      return Array.from(allKeys).sort();
+    } catch (error) {
+      throw import_errors.StorageError.readFailed(
+        "list",
+        error instanceof Error ? error.message : String(error),
+        { prefix }
+      );
+    }
+  }
+  async append(key, item) {
+    this.checkConnection();
+    try {
+      const serialized = JSON.stringify(item);
+      this.db.prepare(
+        "INSERT INTO list_store (key, value, sequence) VALUES (?, ?, (SELECT COALESCE(MAX(sequence), 0) + 1 FROM list_store WHERE key = ?))"
+      ).run(key, serialized, key);
+    } catch (error) {
+      throw import_errors.StorageError.writeFailed(
+        "append",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async getRange(key, start, count) {
+    this.checkConnection();
+    try {
+      const rows = this.db.prepare(
+        "SELECT value FROM list_store WHERE key = ? ORDER BY sequence ASC LIMIT ? OFFSET ?"
+      ).all(key, count, start);
+      return rows.map((row) => JSON.parse(row.value));
+    } catch (error) {
+      throw import_errors.StorageError.readFailed(
+        "getRange",
+        error instanceof Error ? error.message : String(error),
+        { key, start, count }
+      );
+    }
+  }
+  // Schema management
+  checkConnection() {
+    if (!this.db) {
+      throw import_errors.StorageError.notConnected("SQLiteBackend");
+    }
+  }
+  // Maintenance operations
+  async vacuum() {
+    this.checkConnection();
+    this.db.exec("VACUUM");
+  }
+  async getStats() {
+    this.checkConnection();
+    const kvCount = this.db.prepare("SELECT COUNT(*) as count FROM kv_store").get();
+    const listCount = this.db.prepare("SELECT COUNT(*) as count FROM list_store").get();
+    const dbSize = this.db.prepare(
+      "SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()"
+    ).get();
+    return {
+      kvCount: kvCount.count,
+      listCount: listCount.count,
+      dbSize: dbSize.size
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SQLiteBackend
+});

package/dist/storage/backend/sqlite-backend.d.cts

@@ -0,0 +1,35 @@
+import { DatabaseBackend } from './database-backend.cjs';
+import { SqliteBackendConfig } from '../schemas.cjs';
+import 'zod';
+
+/**
+ * SQLite storage backend for local development and production.
+ * Implements the DatabaseBackend interface with proper schema and connection handling.
+ */
+declare class SQLiteBackend implements DatabaseBackend {
+    private db;
+    private dbPath;
+    private config;
+    constructor(config: SqliteBackendConfig);
+    private resolveDefaultPath;
+    private initializeTables;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getBackendType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    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;
+    vacuum(): Promise<void>;
+    getStats(): Promise<{
+        kvCount: number;
+        listCount: number;
+        dbSize: number;
+    }>;
+}
+
+export { SQLiteBackend };

package/dist/storage/backend/sqlite-backend.d.ts

@@ -0,0 +1,35 @@
+import { DatabaseBackend } from './database-backend.js';
+import { SqliteBackendConfig } from '../schemas.js';
+import 'zod';
+
+/**
+ * SQLite storage backend for local development and production.
+ * Implements the DatabaseBackend interface with proper schema and connection handling.
+ */
+declare class SQLiteBackend implements DatabaseBackend {
+    private db;
+    private dbPath;
+    private config;
+    constructor(config: SqliteBackendConfig);
+    private resolveDefaultPath;
+    private initializeTables;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getBackendType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    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;
+    vacuum(): Promise<void>;
+    getStats(): Promise<{
+        kvCount: number;
+        listCount: number;
+        dbSize: number;
+    }>;
+}
+
+export { SQLiteBackend };