@dexto/storage 1.6.0

package/dist/database/postgres-store.js

@@ -0,0 +1,318 @@
+import { Pool } from "pg";
+import { DextoLogComponent, StorageError } from "@dexto/core";
+class PostgresStore {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger.createChild(DextoLogComponent.STORAGE);
+  }
+  pool = null;
+  connected = false;
+  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,
+      max: this.config.maxConnections || 20,
+      // 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
+    });
+    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 {
+      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() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.pool !== null;
+  }
+  getStoreType() {
+    return "postgres";
+  }
+  // Core operations - all use withRetry for serverless DB resilience
+  async get(key) {
+    try {
+      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 }
+      );
+    }
+  }
+  async set(key, value) {
+    try {
+      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 }
+      );
+    }
+  }
+  async delete(key) {
+    await this.withRetry("delete", async (client) => {
+      await client.query("BEGIN");
+      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) {
+    return await this.withRetry("list", async (client) => {
+      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();
+    });
+  }
+  async append(key, item) {
+    try {
+      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 }
+      );
+    }
+  }
+  async getRange(key, start, count) {
+    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);
+    });
+  }
+  // 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 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;
+    const codeString = typeof code === "string" ? code : void 0;
+    return codeString === "ETIMEDOUT" || codeString === "ECONNRESET" || codeString === "ECONNREFUSED" || codeString === "EPIPE" || codeString === "57P01" || // admin_shutdown
+    codeString === "57P02" || // crash_shutdown
+    codeString === "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) {
+    return await this.withRetry("transaction", async (client) => {
+      await client.query("BEGIN");
+      try {
+        const result = await callback(client);
+        await client.query("COMMIT");
+        return result;
+      } catch (error) {
+        await client.query("ROLLBACK");
+        throw error;
+      }
+    });
+  }
+  async getStats() {
+    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(
+        "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
+      };
+    });
+  }
+  // Maintenance operations
+  async vacuum() {
+    await this.withRetry("vacuum", async (client) => {
+      await client.query("VACUUM ANALYZE kv, lists");
+    });
+  }
+}
+export {
+  PostgresStore
+};

package/dist/database/schemas.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schemas_exports = {};
+__export(schemas_exports, {
+  DATABASE_TYPES: () => DATABASE_TYPES,
+  DatabaseConfigSchema: () => DatabaseConfigSchema,
+  InMemoryDatabaseSchema: () => InMemoryDatabaseSchema,
+  PostgresDatabaseSchema: () => PostgresDatabaseSchema,
+  SqliteDatabaseSchema: () => SqliteDatabaseSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+const DATABASE_TYPES = ["in-memory", "sqlite", "postgres"];
+const BaseDatabaseSchema = import_zod.z.object({
+  maxConnections: import_zod.z.number().int().positive().optional().describe("Maximum connections"),
+  idleTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
+  connectionTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
+  options: import_zod.z.record(import_zod.z.unknown()).optional().describe("Backend-specific options")
+});
+const InMemoryDatabaseSchema = BaseDatabaseSchema.extend({
+  type: import_zod.z.literal("in-memory")
+  // In-memory database doesn't need connection options, but inherits pool options for consistency
+}).strict();
+const SqliteDatabaseSchema = BaseDatabaseSchema.extend({
+  type: import_zod.z.literal("sqlite"),
+  path: import_zod.z.string().describe(
+    "SQLite database file path (required for SQLite - CLI enrichment provides per-agent path)"
+  )
+}).strict();
+const PostgresDatabaseSchema = BaseDatabaseSchema.extend({
+  type: import_zod.z.literal("postgres"),
+  url: (0, import_core.EnvExpandedString)().optional().describe("PostgreSQL connection URL (postgresql://...)"),
+  connectionString: (0, import_core.EnvExpandedString)().optional().describe("PostgreSQL connection string"),
+  host: import_zod.z.string().optional().describe("PostgreSQL host"),
+  port: import_zod.z.number().int().positive().optional().describe("PostgreSQL port"),
+  database: import_zod.z.string().optional().describe("PostgreSQL database name"),
+  password: import_zod.z.string().optional().describe("PostgreSQL password"),
+  // TODO: keyPrefix is reserved for future use - allows namespacing keys when multiple
+  // agents or environments share the same database (e.g., "dev:agent1:" vs "prod:agent2:")
+  keyPrefix: import_zod.z.string().optional().describe('Optional key prefix for namespacing (e.g., "dev:myagent:")')
+}).strict().superRefine((data, ctx) => {
+  if (!data.url && !data.connectionString && !data.host) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "PostgreSQL database requires one of 'url', 'connectionString', or 'host' to be specified",
+      path: ["url"],
+      params: {
+        code: import_core.StorageErrorCode.CONNECTION_CONFIG_MISSING,
+        scope: import_core.ErrorScope.STORAGE,
+        type: import_core.ErrorType.USER
+      }
+    });
+  }
+});
+const DatabaseConfigSchema = import_zod.z.object({
+  type: import_zod.z.string().describe("Database backend type identifier")
+}).passthrough().describe("Database configuration (validated by image factory)");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  InMemoryDatabaseSchema,
+  PostgresDatabaseSchema,
+  SqliteDatabaseSchema
+});

package/dist/database/schemas.d.cts

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+
+declare const DATABASE_TYPES: readonly ["in-memory", "sqlite", "postgres"];
+type DatabaseType = (typeof DATABASE_TYPES)[number];
+declare const InMemoryDatabaseSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}>;
+type InMemoryDatabaseConfig = z.output<typeof InMemoryDatabaseSchema>;
+declare const SqliteDatabaseSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"sqlite">;
+    path: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    type: "sqlite";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}, {
+    path: string;
+    type: "sqlite";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}>;
+type SqliteDatabaseConfig = z.output<typeof SqliteDatabaseSchema>;
+declare const PostgresDatabaseSchema: z.ZodEffects<z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"postgres">;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    connectionString: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    database: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}>, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}>;
+type PostgresDatabaseConfig = z.output<typeof PostgresDatabaseSchema>;
+declare const DatabaseConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+type DatabaseConfig = z.output<typeof DatabaseConfigSchema>;
+
+export { DATABASE_TYPES, type DatabaseConfig, DatabaseConfigSchema, type DatabaseType, type InMemoryDatabaseConfig, InMemoryDatabaseSchema, type PostgresDatabaseConfig, PostgresDatabaseSchema, type SqliteDatabaseConfig, SqliteDatabaseSchema };

package/dist/database/schemas.d.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+export declare const DATABASE_TYPES: readonly ["in-memory", "sqlite", "postgres"];
+export type DatabaseType = (typeof DATABASE_TYPES)[number];
+export declare const InMemoryDatabaseSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}>;
+export type InMemoryDatabaseConfig = z.output<typeof InMemoryDatabaseSchema>;
+export declare const SqliteDatabaseSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"sqlite">;
+    path: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    type: "sqlite";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}, {
+    path: string;
+    type: "sqlite";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}>;
+export type SqliteDatabaseConfig = z.output<typeof SqliteDatabaseSchema>;
+export declare const PostgresDatabaseSchema: z.ZodEffects<z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"postgres">;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    connectionString: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    database: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}>, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}>;
+export type PostgresDatabaseConfig = z.output<typeof PostgresDatabaseSchema>;
+export declare const DatabaseConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+export type DatabaseConfig = z.output<typeof DatabaseConfigSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/database/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/database/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,cAAc,8CAA+C,CAAC;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAoB3D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;EAGxB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;EAOtB,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGzE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B7B,CAAC;AAEP,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;gCAKmC,CAAC;AAErE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}