@dexto/core 1.4.0 → 1.5.1

package/dist/storage/database/postgres-store.js

@@ -12,20 +12,89 @@ class PostgresStore {
   logger;
   async connect() {
     if (this.connected) return;
+    const connectionString = this.config.connectionString || this.config.url;
+    if (connectionString?.startsWith("$")) {
+      throw StorageError.connectionFailed(
+        `PostgreSQL: Connection string contains unexpanded environment variable: ${connectionString}. Ensure the environment variable is set in your .env file.`
+      );
+    }
+    if (!connectionString) {
+      throw StorageError.connectionFailed(
+        "PostgreSQL: No connection string provided. Set url or connectionString in database config."
+      );
+    }
+    const { schema, ...pgOptions } = this.config.options || {};
+    this.logger.info("Connecting to PostgreSQL database...");
     this.pool = new Pool({
-      connectionString: this.config.connectionString || this.config.url,
+      connectionString,
       max: this.config.maxConnections || 20,
-      idleTimeoutMillis: this.config.idleTimeoutMillis || 3e4,
-      connectionTimeoutMillis: this.config.connectionTimeoutMillis || 2e3,
-      ...this.config.options
+      // Shorter idle timeout for serverless DBs (Neon) - connections go stale quickly
+      idleTimeoutMillis: this.config.idleTimeoutMillis || 1e4,
+      connectionTimeoutMillis: this.config.connectionTimeoutMillis || 1e4,
+      // Enable TCP keepalive to detect dead connections
+      keepAlive: true,
+      keepAliveInitialDelayMillis: 1e4,
+      ...pgOptions
     });
-    const client = await this.pool.connect();
+    this.pool.on("error", (err) => {
+      this.logger.warn(`PostgreSQL pool error (will retry on next query): ${err.message}`);
+    });
+    if (schema) {
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schema)) {
+        throw StorageError.connectionFailed(
+          `PostgreSQL: Invalid schema name "${schema}". Schema names must start with a letter or underscore and contain only alphanumeric characters and underscores.`
+        );
+      }
+      this.pool.on("connect", async (client2) => {
+        try {
+          await client2.query(`SET search_path TO "${schema}", public`);
+        } catch (err) {
+          this.logger.error(`Failed to set search_path to "${schema}": ${err}`);
+        }
+      });
+      this.logger.info(`Using custom schema: "${schema}"`);
+    }
+    let client;
     try {
+      client = await this.pool.connect();
       await client.query("SELECT NOW()");
+      if (schema) {
+        await this.createSchema(client, schema);
+      }
       await this.createTables(client);
       this.connected = true;
+      this.logger.info("PostgreSQL database connected successfully");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`PostgreSQL connection failed: ${errorMessage}`);
+      if (this.pool) {
+        await this.pool.end().catch(() => {
+        });
+        this.pool = null;
+      }
+      throw StorageError.connectionFailed(`PostgreSQL: ${errorMessage}`);
     } finally {
-      client.release();
+      if (client) {
+        client.release();
+      }
+    }
+  }
+  /**
+   * Creates a PostgreSQL schema if it doesn't exist.
+   */
+  async createSchema(client, schemaName) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schemaName)) {
+      throw StorageError.connectionFailed(
+        `PostgreSQL: Invalid schema name "${schemaName}". Schema names must start with a letter or underscore and contain only alphanumeric characters and underscores.`
+      );
+    }
+    try {
+      await client.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
+      this.logger.debug(`Schema "${schemaName}" ready`);
+    } catch (error) {
+      this.logger.warn(
+        `Could not create schema "${schemaName}": ${error}. Assuming it exists.`
+      );
     }
   }
   async disconnect() {
@@ -41,61 +110,54 @@ class PostgresStore {
   getStoreType() {
     return "postgres";
   }
-  // Core operations
+  // Core operations - all use withRetry for serverless DB resilience
   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;
+      return await this.withRetry("get", async (client) => {
+        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 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, value, /* @__PURE__ */ new Date()]
-      );
+      await this.withRetry("set", async (client) => {
+        const jsonValue = JSON.stringify(value);
+        await client.query(
+          "INSERT INTO kv (key, value, updated_at) VALUES ($1, $2::jsonb, $3) ON CONFLICT (key) DO UPDATE SET value = $2::jsonb, updated_at = $3",
+          [key, jsonValue, /* @__PURE__ */ new Date()]
+        );
+      });
     } catch (error) {
       throw StorageError.writeFailed(
         "set",
         error instanceof Error ? error.message : String(error),
         { key }
       );
-    } finally {
-      client.release();
     }
   }
   async delete(key) {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    await this.withRetry("delete", async (client) => {
       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();
-    }
+      try {
+        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;
+      }
+    });
   }
   // List operations
   async list(prefix) {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    return await this.withRetry("list", async (client) => {
       const kvResult = await client.query("SELECT key FROM kv WHERE key LIKE $1", [
         `${prefix}%`
       ]);
@@ -108,41 +170,33 @@ class PostgresStore {
         ...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,
-        item,
-        /* @__PURE__ */ new Date()
-      ]);
+      await this.withRetry("append", async (client) => {
+        const jsonItem = JSON.stringify(item);
+        await client.query(
+          "INSERT INTO lists (key, item, created_at) VALUES ($1, $2::jsonb, $3)",
+          [key, jsonItem, /* @__PURE__ */ new Date()]
+        );
+      });
     } catch (error) {
       throw StorageError.writeFailed(
         "append",
         error instanceof Error ? error.message : String(error),
         { key }
       );
-    } finally {
-      client.release();
     }
   }
   async getRange(key, start, count) {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    return await this.withRetry("getRange", async (client) => {
       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) => row.item);
-    } finally {
-      client.release();
-    }
+    });
   }
   // Schema management
   async createTables(client) {
@@ -172,26 +226,74 @@ class PostgresStore {
       throw StorageError.notConnected("PostgresStore");
     }
   }
+  /**
+   * Check if an error is a connection error that should trigger a retry.
+   * Common with serverless databases (Neon) where connections go stale.
+   */
+  isConnectionError(error) {
+    if (!(error instanceof Error)) return false;
+    const code = error.code;
+    return code === "ETIMEDOUT" || code === "ECONNRESET" || code === "ECONNREFUSED" || code === "EPIPE" || code === "57P01" || // admin_shutdown
+    code === "57P02" || // crash_shutdown
+    code === "57P03" || // cannot_connect_now
+    error.message.includes("Connection terminated") || error.message.includes("connection lost");
+  }
+  /**
+   * Execute a database operation with automatic retry on connection errors.
+   * Handles serverless DB connection issues (Neon cold starts, stale connections).
+   */
+  async withRetry(operation, fn, maxRetries = 2) {
+    this.checkConnection();
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      let client;
+      try {
+        client = await this.pool.connect();
+        const result = await fn(client);
+        return result;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (client) {
+          client.release(true);
+          client = void 0;
+        }
+        if (this.isConnectionError(error) && attempt < maxRetries) {
+          this.logger.warn(
+            `PostgreSQL ${operation} failed with connection error (attempt ${attempt + 1}/${maxRetries + 1}): ${lastError.message}. Retrying...`
+          );
+          await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
+          continue;
+        }
+        throw error;
+      } finally {
+        if (client) {
+          client.release();
+        }
+      }
+    }
+    throw lastError;
+  }
   // Advanced operations
+  /**
+   * Execute a callback within a database transaction.
+   * Note: On connection failure, the entire callback will be retried on a new connection.
+   * Ensure callback operations are idempotent or use this only for read operations.
+   */
   async transaction(callback) {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    return await this.withRetry("transaction", async (client) => {
       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();
-    }
+      try {
+        const result = await callback(client);
+        await client.query("COMMIT");
+        return result;
+      } catch (error) {
+        await client.query("ROLLBACK");
+        throw error;
+      }
+    });
   }
   async getStats() {
-    this.checkConnection();
-    const client = await this.pool.connect();
-    try {
+    return await this.withRetry("getStats", async (client) => {
       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(
@@ -203,19 +305,13 @@ class PostgresStore {
         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 this.withRetry("vacuum", async (client) => {
       await client.query("VACUUM ANALYZE kv, lists");
-    } finally {
-      client.release();
-    }
+    });
   }
 }
 export {

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

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

@@ -0,0 +1,56 @@
+import type { z } from 'zod';
+import type { Database } from './types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
+/**
+ * Provider interface for creating database instances.
+ *
+ * This interface uses TypeScript generics to enforce type safety:
+ * - TType: The literal type string (e.g., 'sqlite', 'postgres')
+ * - TConfig: The configuration type with discriminator { type: TType }
+ *
+ * This ensures that the provider type matches the config type discriminator,
+ * providing compile-time safety for provider implementations.
+ */
+export interface DatabaseProvider<TType extends string = string, TConfig extends {
+    type: TType;
+} = any> {
+    /**
+     * Unique identifier for this provider (e.g., 'sqlite', 'postgres', 'in-memory').
+     * Must match the 'type' field in the configuration.
+     */
+    type: TType;
+    /**
+     * Zod schema for validating provider-specific configuration.
+     * The schema must output TConfig type.
+     *
+     * Note: Uses z.ZodType with relaxed generics to allow input/output type variance.
+     * This is necessary because Zod schemas with `.optional().default()` have
+     * input types that include undefined, but output types that don't.
+     */
+    configSchema: z.ZodType<TConfig, any, any>;
+    /**
+     * Factory function to create a Database instance.
+     *
+     * Unlike blob store providers (which are sync), database providers may return
+     * a Promise to support lazy loading of optional dependencies (e.g., better-sqlite3, pg).
+     *
+     * @param config - Validated configuration specific to this provider
+     * @param logger - Logger instance for the database
+     * @returns A Database implementation (or Promise for async providers)
+     */
+    create(config: TConfig, logger: IDextoLogger): Database | Promise<Database>;
+    /**
+     * Optional metadata for documentation, UIs, and discovery.
+     */
+    metadata?: {
+        /** Human-readable name (e.g., "SQLite", "PostgreSQL") */
+        displayName: string;
+        /** Brief description of this storage backend */
+        description: string;
+        /** Whether this provider requires network connectivity */
+        requiresNetwork?: boolean;
+        /** Whether this provider supports list operations (append/getRange) */
+        supportsListOperations?: boolean;
+    };
+}
+//# sourceMappingURL=provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/storage/database/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB,CAC7B,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,OAAO,SAAS;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GAAG,GAAG;IAErC;;;OAGG;IACH,IAAI,EAAE,KAAK,CAAC;IAEZ;;;;;;;OAOG;IACH,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAE3C;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAE5E;;OAEG;IACH,QAAQ,CAAC,EAAE;QACP,yDAAyD;QACzD,WAAW,EAAE,MAAM,CAAC;QACpB,gDAAgD;QAChD,WAAW,EAAE,MAAM,CAAC;QACpB,0DAA0D;QAC1D,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,uEAAuE;QACvE,sBAAsB,CAAC,EAAE,OAAO,CAAC;KACpC,CAAC;CACL"}

package/dist/storage/database/providers/index.cjs

@@ -0,0 +1,34 @@
+"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 providers_exports = {};
+__export(providers_exports, {
+  inMemoryDatabaseProvider: () => import_memory.inMemoryDatabaseProvider,
+  postgresDatabaseProvider: () => import_postgres.postgresDatabaseProvider,
+  sqliteDatabaseProvider: () => import_sqlite.sqliteDatabaseProvider
+});
+module.exports = __toCommonJS(providers_exports);
+var import_memory = require("./memory.js");
+var import_sqlite = require("./sqlite.js");
+var import_postgres = require("./postgres.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inMemoryDatabaseProvider,
+  postgresDatabaseProvider,
+  sqliteDatabaseProvider
+});

package/dist/storage/database/providers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Built-in database providers.
+ *
+ * These providers are automatically registered when importing from @dexto/core.
+ */
+export { inMemoryDatabaseProvider } from './memory.js';
+export { sqliteDatabaseProvider } from './sqlite.js';
+export { postgresDatabaseProvider } from './postgres.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/database/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/storage/database/providers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC"}

package/dist/storage/database/providers/index.js

@@ -0,0 +1,9 @@
+import "../../../chunk-PTJYTZNU.js";
+import { inMemoryDatabaseProvider } from "./memory.js";
+import { sqliteDatabaseProvider } from "./sqlite.js";
+import { postgresDatabaseProvider } from "./postgres.js";
+export {
+  inMemoryDatabaseProvider,
+  postgresDatabaseProvider,
+  sqliteDatabaseProvider
+};

package/dist/storage/database/providers/memory.cjs

@@ -0,0 +1,40 @@
+"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_exports = {};
+__export(memory_exports, {
+  inMemoryDatabaseProvider: () => inMemoryDatabaseProvider
+});
+module.exports = __toCommonJS(memory_exports);
+var import_schemas = require("../schemas.js");
+var import_memory_database_store = require("../memory-database-store.js");
+const inMemoryDatabaseProvider = {
+  type: "in-memory",
+  configSchema: import_schemas.InMemoryDatabaseSchema,
+  create: (_config, _logger) => new import_memory_database_store.MemoryDatabaseStore(),
+  metadata: {
+    displayName: "In-Memory",
+    description: "Store data in RAM (ephemeral, for testing and development)",
+    requiresNetwork: false,
+    supportsListOperations: true
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inMemoryDatabaseProvider
+});

package/dist/storage/database/providers/memory.d.ts

@@ -0,0 +1,16 @@
+import type { DatabaseProvider } from '../provider.js';
+import type { InMemoryDatabaseConfig } from '../schemas.js';
+/**
+ * Provider for in-memory database storage.
+ *
+ * This provider stores data in RAM and is ideal for development,
+ * testing, and ephemeral use cases where persistence is not required.
+ *
+ * Features:
+ * - Zero external dependencies
+ * - Fast in-memory operations
+ * - No network required
+ * - Data is lost on restart
+ */
+export declare const inMemoryDatabaseProvider: DatabaseProvider<'in-memory', InMemoryDatabaseConfig>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/storage/database/providers/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../../src/storage/database/providers/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAI5D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,EAAE,gBAAgB,CAAC,WAAW,EAAE,sBAAsB,CAU1F,CAAC"}

package/dist/storage/database/providers/memory.js

@@ -0,0 +1,17 @@
+import "../../../chunk-PTJYTZNU.js";
+import { InMemoryDatabaseSchema } from "../schemas.js";
+import { MemoryDatabaseStore } from "../memory-database-store.js";
+const inMemoryDatabaseProvider = {
+  type: "in-memory",
+  configSchema: InMemoryDatabaseSchema,
+  create: (_config, _logger) => new MemoryDatabaseStore(),
+  metadata: {
+    displayName: "In-Memory",
+    description: "Store data in RAM (ephemeral, for testing and development)",
+    requiresNetwork: false,
+    supportsListOperations: true
+  }
+};
+export {
+  inMemoryDatabaseProvider
+};

package/dist/storage/database/providers/postgres.cjs

@@ -0,0 +1,62 @@
+"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 postgres_exports = {};
+__export(postgres_exports, {
+  postgresDatabaseProvider: () => postgresDatabaseProvider
+});
+module.exports = __toCommonJS(postgres_exports);
+var import_schemas = require("../schemas.js");
+var import_errors = require("../../errors.js");
+const postgresDatabaseProvider = {
+  type: "postgres",
+  configSchema: import_schemas.PostgresDatabaseSchema,
+  create: async (config, logger) => {
+    try {
+      const module2 = await import("../postgres-store.js");
+      logger.info("Connecting to PostgreSQL database");
+      return new module2.PostgresStore(config, logger);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ERR_MODULE_NOT_FOUND") {
+        throw import_errors.StorageError.dependencyNotInstalled("PostgreSQL", "pg", "npm install pg");
+      }
+      throw error;
+    }
+  },
+  metadata: {
+    displayName: "PostgreSQL",
+    description: "Production PostgreSQL database with connection pooling",
+    requiresNetwork: true,
+    supportsListOperations: true
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  postgresDatabaseProvider
+});

package/dist/storage/database/providers/postgres.d.ts

@@ -0,0 +1,19 @@
+import type { DatabaseProvider } from '../provider.js';
+import type { PostgresDatabaseConfig } from '../schemas.js';
+/**
+ * Provider for PostgreSQL database storage.
+ *
+ * This provider stores data in a PostgreSQL database server using the pg package.
+ * It's ideal for production deployments requiring scalability and multi-machine access.
+ *
+ * Features:
+ * - Connection pooling for efficient resource usage
+ * - JSONB storage for flexible data types
+ * - Transaction support
+ * - Suitable for distributed deployments
+ *
+ * Note: pg is an optional dependency. Install it with:
+ * npm install pg
+ */
+export declare const postgresDatabaseProvider: DatabaseProvider<'postgres', PostgresDatabaseConfig>;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/storage/database/providers/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../../src/storage/database/providers/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAI5D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,EAAE,gBAAgB,CAAC,UAAU,EAAE,sBAAsB,CAsBzF,CAAC"}