@dexto/core 1.1.4 → 1.1.6

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

@@ -0,0 +1,15 @@
+/**
+ * Fast, ephemeral storage for temporary data and performance optimization.
+ * Supports TTL for automatic cleanup of temporary data.
+ */
+interface CacheBackend {
+    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;
+}
+
+export type { CacheBackend };

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

@@ -0,0 +1,15 @@
+/**
+ * Fast, ephemeral storage for temporary data and performance optimization.
+ * Supports TTL for automatic cleanup of temporary data.
+ */
+interface CacheBackend {
+    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;
+}
+
+export type { CacheBackend };

package/dist/storage/backend/database-backend.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 database_backend_exports = {};
+module.exports = __toCommonJS(database_backend_exports);

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

@@ -0,0 +1,19 @@
+/**
+ * Persistent, reliable storage for important data with list operations for message history.
+ * Data survives restarts and supports enumeration for settings management.
+ */
+interface DatabaseBackend {
+    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>;
+    /** Get a range of items in chronological order (oldest first, matching insertion order) */
+    getRange<T>(key: string, start: number, count: number): Promise<T[]>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getBackendType(): string;
+}
+
+export type { DatabaseBackend };

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

@@ -0,0 +1,19 @@
+/**
+ * Persistent, reliable storage for important data with list operations for message history.
+ * Data survives restarts and supports enumeration for settings management.
+ */
+interface DatabaseBackend {
+    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>;
+    /** Get a range of items in chronological order (oldest first, matching insertion order) */
+    getRange<T>(key: string, start: number, count: number): Promise<T[]>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getBackendType(): string;
+}
+
+export type { DatabaseBackend };

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

@@ -0,0 +1,140 @@
+"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_backend_exports = {};
+__export(memory_backend_exports, {
+  MemoryBackend: () => MemoryBackend
+});
+module.exports = __toCommonJS(memory_backend_exports);
+var import_errors = require("../errors.js");
+class MemoryBackend {
+  data = /* @__PURE__ */ new Map();
+  lists = /* @__PURE__ */ new Map();
+  ttls = /* @__PURE__ */ new Map();
+  connected = false;
+  constructor() {
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.data.clear();
+    this.lists.clear();
+    this.ttls.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getBackendType() {
+    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(
+        "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.lists.delete(key);
+    this.ttls.delete(key);
+  }
+  // List operations (DatabaseBackend)
+  async list(prefix) {
+    const keys = [];
+    for (const key of Array.from(this.data.keys())) {
+      if (key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+    for (const key of Array.from(this.lists.keys())) {
+      if (key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+    return Array.from(new Set(keys)).sort();
+  }
+  async append(key, item) {
+    this.checkConnection();
+    if (!this.lists.has(key)) {
+      this.lists.set(key, []);
+    }
+    this.lists.get(key).push(item);
+  }
+  async getRange(key, start, count) {
+    this.checkConnection();
+    const list = this.lists.get(key) || [];
+    return list.slice(start, start + count);
+  }
+  // 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);
+    }
+  }
+  // Development helpers
+  async clear() {
+    this.data.clear();
+    this.lists.clear();
+    this.ttls.clear();
+  }
+  async dump() {
+    return {
+      data: Object.fromEntries(this.data.entries()),
+      lists: Object.fromEntries(this.lists.entries())
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryBackend
+});

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

@@ -0,0 +1,34 @@
+import { CacheBackend } from './cache-backend.cjs';
+import { DatabaseBackend } from './database-backend.cjs';
+
+/**
+ * In-memory storage backend for development and testing.
+ * Implements both CacheBackend and DatabaseBackend interfaces.
+ * Data is lost when the process restarts.
+ */
+declare class MemoryBackend implements CacheBackend, DatabaseBackend {
+    private data;
+    private lists;
+    private ttls;
+    private connected;
+    constructor();
+    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>;
+    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 };

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

@@ -0,0 +1,34 @@
+import { CacheBackend } from './cache-backend.js';
+import { DatabaseBackend } from './database-backend.js';
+
+/**
+ * In-memory storage backend for development and testing.
+ * Implements both CacheBackend and DatabaseBackend interfaces.
+ * Data is lost when the process restarts.
+ */
+declare class MemoryBackend implements CacheBackend, DatabaseBackend {
+    private data;
+    private lists;
+    private ttls;
+    private connected;
+    constructor();
+    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>;
+    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 };

package/dist/storage/backend/memory-backend.js

@@ -0,0 +1,116 @@
+import { StorageError } from "../errors.js";
+class MemoryBackend {
+  data = /* @__PURE__ */ new Map();
+  lists = /* @__PURE__ */ new Map();
+  ttls = /* @__PURE__ */ new Map();
+  connected = false;
+  constructor() {
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.data.clear();
+    this.lists.clear();
+    this.ttls.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getBackendType() {
+    return "memory";
+  }
+  // Core operations
+  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.lists.delete(key);
+    this.ttls.delete(key);
+  }
+  // List operations (DatabaseBackend)
+  async list(prefix) {
+    const keys = [];
+    for (const key of Array.from(this.data.keys())) {
+      if (key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+    for (const key of Array.from(this.lists.keys())) {
+      if (key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+    return Array.from(new Set(keys)).sort();
+  }
+  async append(key, item) {
+    this.checkConnection();
+    if (!this.lists.has(key)) {
+      this.lists.set(key, []);
+    }
+    this.lists.get(key).push(item);
+  }
+  async getRange(key, start, count) {
+    this.checkConnection();
+    const list = this.lists.get(key) || [];
+    return list.slice(start, start + count);
+  }
+  // Helper methods
+  checkConnection() {
+    if (!this.connected) {
+      throw StorageError.notConnected("MemoryBackend");
+    }
+  }
+  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.lists.clear();
+    this.ttls.clear();
+  }
+  async dump() {
+    return {
+      data: Object.fromEntries(this.data.entries()),
+      lists: Object.fromEntries(this.lists.entries())
+    };
+  }
+}
+export {
+  MemoryBackend
+};

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

@@ -0,0 +1,231 @@
+"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 postgres_backend_exports = {};
+__export(postgres_backend_exports, {
+  PostgresBackend: () => PostgresBackend
+});
+module.exports = __toCommonJS(postgres_backend_exports);
+var import_pg = require("pg");
+var import_errors = require("../errors.js");
+class PostgresBackend {
+  constructor(config) {
+    this.config = config;
+  }
+  pool = null;
+  connected = false;
+  async connect() {
+    if (this.connected) return;
+    this.pool = new import_pg.Pool({
+      connectionString: this.config.connectionString || this.config.url,
+      max: this.config.maxConnections || 20,
+      idleTimeoutMillis: this.config.idleTimeoutMillis || 3e4,
+      connectionTimeoutMillis: this.config.connectionTimeoutMillis || 2e3,
+      ...this.config.options
+    });
+    const client = await this.pool.connect();
+    try {
+      await client.query("SELECT NOW()");
+      await this.createTables(client);
+      this.connected = true;
+    } finally {
+      client.release();
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.pool !== null;
+  }
+  getBackendType() {
+    return "postgres";
+  }
+  // Core operations
+  async get(key) {
+    this.checkConnection();
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query("SELECT value FROM kv WHERE key = $1", [key]);
+      return result.rows[0] ? result.rows[0].value : void 0;
+    } catch (error) {
+      throw import_errors.StorageError.readFailed(
+        "get",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    } finally {
+      client.release();
+    }
+  }
+  async set(key, value) {
+    this.checkConnection();
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        "INSERT INTO kv (key, value, updated_at) VALUES ($1, $2, $3) ON CONFLICT (key) DO UPDATE SET value = $2, updated_at = $3",
+        [key, JSON.stringify(value), /* @__PURE__ */ new Date()]
+      );
+    } finally {
+      client.release();
+    }
+  }
+  async delete(key) {
+    this.checkConnection();
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query("DELETE FROM kv WHERE key = $1", [key]);
+      await client.query("DELETE FROM lists WHERE key = $1", [key]);
+      await client.query("COMMIT");
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  // List operations
+  async list(prefix) {
+    this.checkConnection();
+    const client = await this.pool.connect();
+    try {
+      const kvResult = await client.query("SELECT key FROM kv WHERE key LIKE $1", [
+        `${prefix}%`
+      ]);
+      const listResult = await client.query(
+        "SELECT DISTINCT key FROM lists WHERE key LIKE $1",
+        [`${prefix}%`]
+      );
+      const allKeys = /* @__PURE__ */ new Set([
+        ...kvResult.rows.map((row) => row.key),
+        ...listResult.rows.map((row) => row.key)
+      ]);
+      return Array.from(allKeys).sort();
+    } finally {
+      client.release();
+    }
+  }
+  async append(key, item) {
+    this.checkConnection();
+    const client = await this.pool.connect();
+    try {
+      await client.query("INSERT INTO lists (key, item, created_at) VALUES ($1, $2, $3)", [
+        key,
+        JSON.stringify(item),
+        /* @__PURE__ */ new Date()
+      ]);
+    } finally {
+      client.release();
+    }
+  }
+  async getRange(key, start, count) {
+    this.checkConnection();
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        "SELECT item FROM lists WHERE key = $1 ORDER BY created_at ASC LIMIT $2 OFFSET $3",
+        [key, count, start]
+      );
+      return result.rows.map((row) => JSON.parse(row.item));
+    } finally {
+      client.release();
+    }
+  }
+  // Schema management
+  async createTables(client) {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS kv (
+        key VARCHAR(255) PRIMARY KEY,
+        value JSONB NOT NULL,
+        updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lists (
+        id BIGSERIAL PRIMARY KEY,
+        key VARCHAR(255) NOT NULL,
+        item JSONB NOT NULL,
+        created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
+      )
+    `);
+    await client.query("CREATE INDEX IF NOT EXISTS idx_kv_key ON kv(key)");
+    await client.query("CREATE INDEX IF NOT EXISTS idx_lists_key ON lists(key)");
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS idx_lists_created_at ON lists(key, created_at DESC)"
+    );
+  }
+  checkConnection() {
+    if (!this.connected || !this.pool) {
+      throw import_errors.StorageError.notConnected("PostgresBackend");
+    }
+  }
+  // Advanced operations
+  async transaction(callback) {
+    this.checkConnection();
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await callback(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async getStats() {
+    this.checkConnection();
+    const client = await this.pool.connect();
+    try {
+      const kvResult = await client.query("SELECT COUNT(*) as count FROM kv");
+      const listResult = await client.query("SELECT COUNT(*) as count FROM lists");
+      const sizeResult = await client.query(
+        "SELECT pg_size_pretty(pg_total_relation_size($1)) as size",
+        ["kv"]
+      );
+      return {
+        kvCount: parseInt(kvResult.rows[0].count),
+        listCount: parseInt(listResult.rows[0].count),
+        totalSize: sizeResult.rows[0].size
+      };
+    } finally {
+      client.release();
+    }
+  }
+  // Maintenance operations
+  async vacuum() {
+    this.checkConnection();
+    const client = await this.pool.connect();
+    try {
+      await client.query("VACUUM ANALYZE kv, lists");
+    } finally {
+      client.release();
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresBackend
+});

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

@@ -0,0 +1,37 @@
+import { PoolClient } from 'pg';
+import { DatabaseBackend } from './database-backend.cjs';
+import { PostgresBackendConfig } from '../schemas.cjs';
+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 };