@elizaos/plugin-sql 1.0.0-alpha.7 → 1.0.0-beta.0

package/README.md

@@ -9,31 +9,19 @@ A PostgreSQL database adapter built with Drizzle ORM for the ElizaOS ecosystem.
 bun add @elizaos/plugin-sql
 ```
 
-## Database Schema
-
-The adapter includes the following tables:
-- accounts
-- cache
-- embeddings
-- goals
-- logs
-- memories
-- participants
-- relationships
-- rooms
-
 ## Vector Dimensions
 
 The adapter supports the following vector dimensions:
+
 ```typescript
 VECTOR_DIMS = {
-    SMALL: 384,
-    MEDIUM: 512,
-    LARGE: 768,
-    XL: 1024,
-    XXL: 1536,
-    XXXL: 3072
-}
+  SMALL: 384,
+  MEDIUM: 512,
+  LARGE: 768,
+  XL: 1024,
+  XXL: 1536,
+  XXXL: 3072,
+};
 ```
 
 Important Note: Once an agent is initialized with a specific embedding dimension, it cannot be changed. Attempting to change the dimension will result in an error: "Cannot change embedding dimension for agent"
@@ -49,33 +37,57 @@ Important Note: Once an agent is initialized with a specific embedding dimension
 - Room and participant management
 - Goal tracking system
 
+## Database Schema
+
+The plugin uses a structured schema with the following main tables:
+
+### Core Tables
+
+- **Agent**: Stores agent information and configurations
+- **Room**: Manages conversation rooms and their settings
+- **Participant**: Tracks participants in rooms
+- **Memory**: Stores agent memories with vector embeddings for semantic search
+- **Embedding**: Manages vector embeddings for various entities
+- **Entity**: Represents entities that agents can interact with
+- **Relationship**: Tracks relationships between entities
+- **Component**: Stores agent components and their configurations
+- **Tasks**: Manages tasks and goals for agents
+- **Log**: Stores system logs
+- **Cache**: Provides a caching mechanism for frequently accessed data
+- **World**: Manages world settings and configurations
+
+Each table is defined using Drizzle ORM schema definitions in the `src/schema` directory. The schema is designed to support the ElizaOS ecosystem's requirements for agent-based systems.
+
 ## Usage
 
 The adapter is typically used as part of the ElizaOS runtime:
 
 ```typescript
 async function findDatabaseAdapter(runtime: IAgentRuntime) {
-    let adapter = runtime.getDatabaseAdapter();
-    
+  let adapter = runtime;
+
+  if (!adapter) {
+    const drizzleAdapterPlugin = await import('@elizaos/plugin-sql');
+    const drizzleAdapterPluginDefault = drizzleAdapterPlugin.default;
+    adapter = drizzleAdapterPluginDefault.adapter;
     if (!adapter) {
-        const drizzleAdapterPlugin = await import('@elizaos/plugin-sql');
-        const drizzleAdapterPluginDefault = drizzleAdapterPlugin.default;
-        adapter = drizzleAdapterPluginDefault.adapter;
-        if (!adapter) {
-            throw new Error("Internal error: No database adapter found for default plugin-sql");
-        }
-    } else if (!adapter) {
-        throw new Error("Multiple database adapters found. You must have no more than one. Adjust your plugins configuration.");
+      throw new Error('Internal error: No database adapter found for default plugin-sql');
     }
-    
-    const adapterInterface = await adapter?.init(runtime);
-    return adapterInterface;
+  } else if (!adapter) {
+    throw new Error(
+      'Multiple database adapters found. You must have no more than one. Adjust your plugins configuration.'
+    );
+  }
+
+  const adapterInterface = await adapter?.init(runtime);
+  return adapterInterface;
 }
 ```
 
 ## Error Handling Configuration
 
 The adapter implements the following error handling configurations:
+
 ```typescript
 {
     failureThreshold: 5,
@@ -94,9 +106,20 @@ The adapter implements the following error handling configurations:
 - PostgreSQL with vector extension installed
 - Node.js or Bun (≥1.2.2)
 
+## Environment Variables
+
+The plugin uses the following environment variables:
+
+- `POSTGRES_URL`: Connection string for PostgreSQL database (e.g., `postgresql://user:password@localhost:5432/dbname`)
+  - If not provided, the plugin will use PGlite as a fallback
+- `PGLITE_DATA_DIR`: (Optional) Directory for PGlite data storage (default: `../../pglite`)
+
+These variables should be defined in a `.env` file at the root of your project.
+
 ## Database Pool Configuration
 
 Default pool configuration:
+
 ```typescript
 {
     max: 20,
@@ -110,38 +133,45 @@ Default pool configuration:
 The adapter supports two approaches to managing database schema:
 
 ### 1. Initial Setup
+
 Migrations are automatically run during initialization if:
+
 - Database tables don't exist
 - Vector extension is not found
 
 This is handled internally by:
+
 ```typescript
 await runMigrations(pgPool);
 ```
 
 ### 2. Schema Updates
+
 To update the schema:
 
 1. Install drizzle-kit (if not already installed):
+
 ```bash
-pnpm add -D drizzle-kit
+bun add -D drizzle-kit
 ```
 
 2. Create or update your schema files (e.g., `schema/account.ts`):
+
 ```typescript
-import { pgTable, text, uuid } from "drizzle-orm/pg-core";
-import { sql } from "drizzle-orm";
-
-export const accountTable = pgTable("accounts", {
-    id: uuid("id").primaryKey().notNull(),
-    name: text("name"),
-    email: text("email").notNull(),
-    // Add new fields here
-    newField: text("newField"),
+import { pgTable, text, uuid } from 'drizzle-orm/pg-core';
+import { sql } from 'drizzle-orm';
+
+export const accountTable = pgTable('accounts', {
+  id: uuid('id').primaryKey().notNull(),
+  name: text('name'),
+  email: text('email').notNull(),
+  // Add new fields here
+  newField: text('newField'),
 });
 ```
 
 3. Generate migrations:
+
 ```bash
 npx drizzle-kit generate:pg
 ```
@@ -151,25 +181,108 @@ This will create SQL migration files in your migrations directory.
 4. Apply migrations using one of these methods:
 
 a. Using drizzle-kit:
+
 ```bash
 npx drizzle-kit push:pg
 ```
 
 b. Through your application code:
+
 ```typescript
-import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { migrate } from 'drizzle-orm/node-postgres/migrator';
+
+await migrate(db, { migrationsFolder: './drizzle' });
+```
+
+c. Using the provided migration script:
+
+```bash
+npm run migrate
+# or
+bun migrate
+```
+
+d. Using drizzle-kit migrate command:
+
+```bash
+npx drizzle-kit migrate
+```
+
+This command will read the configuration from `drizzle.config.ts` and pull the PostgreSQL URI from the `.env` file. Make sure your `.env` file contains the `POSTGRES_URL` variable with the correct connection string.
+
+### Migration Configuration
+
+The plugin uses a `drizzle.config.ts` file to configure migrations:
 
-await migrate(db, { migrationsFolder: "./drizzle" });
+```typescript
+import { config } from 'dotenv';
+import { defineConfig } from 'drizzle-kit';
+
+config({ path: '../../.env' });
+
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/schema/index.ts',
+  out: './drizzle/migrations',
+  dbCredentials: {
+    url: process.env.POSTGRES_URL || 'file://../../pglite',
+  },
+  breakpoints: true,
+});
 ```
 
+### Database Support
+
+The plugin supports two database backends:
+
+1. **PostgreSQL**: Used when `POSTGRES_URL` environment variable is provided
+2. **PGlite**: Used as a fallback when no PostgreSQL URL is provided
+
+Both backends use the same migration files, ensuring consistent schema across environments.
+
 ### Note on Vector Support
+
 Make sure the PostgreSQL vector extension is installed before running migrations. The adapter will validate vector setup during initialization.
 
 ## Clean Shutdown
 
 The adapter implements cleanup handlers for:
+
 - SIGINT
 - SIGTERM
 - beforeExit
 
 These ensure proper closing of database connections when the application shuts down.
+
+## Implementation Details
+
+### Connection Management
+
+The plugin uses a global singleton pattern to manage database connections. This approach ensures that:
+
+1. **Single Connection Per Process**: Only one connection manager instance exists per Node.js process, regardless of how many times the package is imported or initialized.
+
+2. **Resource Efficiency**: Prevents multiple connection pools to the same database, which could lead to resource exhaustion.
+
+3. **Consistent State**: Ensures all parts of the application share the same database connection state.
+
+4. **Proper Cleanup**: Facilitates proper cleanup of database connections during application shutdown, preventing connection leaks.
+
+This pattern is particularly important in monorepo setups or when the package is used by multiple modules within the same process. The implementation uses JavaScript Symbols to create a global registry that persists across module boundaries.
+
+```typescript
+// Example of the singleton pattern implementation
+const GLOBAL_SINGLETONS = Symbol.for('@elizaos/plugin-sql/global-singletons');
+
+// Store managers in a global symbol registry
+if (!globalSymbols[GLOBAL_SINGLETONS]) {
+  globalSymbols[GLOBAL_SINGLETONS] = {};
+}
+
+// Reuse existing managers or create new ones when needed
+if (!globalSingletons.postgresConnectionManager) {
+  globalSingletons.postgresConnectionManager = new PostgresConnectionManager(config.postgresUrl);
+}
+```
+
+This approach is especially critical for PGlite connections, which require careful management to ensure proper shutdown and prevent resource leaks.

package/dist/chunk-I3JSTNED.js

@@ -0,0 +1,40 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+export {
+  __name,
+  __require,
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=chunk-I3JSTNED.js.map

package/dist/chunk-I3JSTNED.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourceRoot":"./","sourcesContent":[],"mappings":"","names":[]}

package/dist/{chunk-LLEN3JTK.js → chunk-PSEXCDLP.js}

@@ -1,8 +1,9 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import {
+  __name
+} from "./chunk-I3JSTNED.js";
 
-// src/pg-lite/manager.ts
-import path from "node:path";
+// src/pglite/manager.ts
+import { dirname as pathDirname, resolve as pathResolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { PGlite } from "@electric-sql/pglite";
 import { fuzzystrmatch } from "@electric-sql/pglite/contrib/fuzzystrmatch";
@@ -10,8 +11,6 @@ import { vector } from "@electric-sql/pglite/vector";
 import { logger } from "@elizaos/core";
 import { drizzle } from "drizzle-orm/pglite";
 import { migrate } from "drizzle-orm/pglite/migrator";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
 var PGliteClientManager = class {
   static {
     __name(this, "PGliteClientManager");
@@ -61,9 +60,7 @@ var PGliteClientManager = class {
     this.shuttingDown = true;
     logger.info("Starting graceful shutdown of PGlite client...");
     const timeout = setTimeout(() => {
-      logger.warn(
-        "Shutdown timeout reached, forcing database connection closure..."
-      );
+      logger.warn("Shutdown timeout reached, forcing database connection closure...");
       this.client.close().finally(() => {
         process.exit(1);
       });
@@ -129,31 +126,33 @@ var PGliteClientManager = class {
   /**
    * Asynchronously runs database migrations using Drizzle.
    *
+   * Drizzle will first check if the migrations are already applied.
+   * If there is a diff between database schema and migrations, it will apply the migrations.
+   * If they are already applied, it will skip them.
+   *
    * @returns {Promise<void>} A Promise that resolves once the migrations are completed successfully.
    */
   async runMigrations() {
     try {
       const db = drizzle(this.client);
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = pathDirname(__filename);
       await migrate(db, {
-        migrationsFolder: path.resolve(__dirname, "../drizzle/migrations")
+        migrationsFolder: pathResolve(__dirname, "../drizzle/migrations")
       });
-      logger.info("Migrations completed successfully!");
     } catch (error) {
-      logger.error("Failed to run database migrations:", error);
+      logger.error("Failed to run database migrations (pglite):", error);
     }
   }
 };
 
 // src/pg/manager.ts
-import path2 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { logger as logger2 } from "@elizaos/core";
 import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
-import { migrate as migrate2 } from "drizzle-orm/node-postgres/migrator";
+import { dirname as pathDirname2, resolve as pathResolve2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import pkg from "pg";
 var { Pool } = pkg;
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
 var PostgresConnectionManager = class {
   static {
     __name(this, "PostgresConnectionManager");
@@ -165,7 +164,7 @@ var PostgresConnectionManager = class {
    * Constructor for creating a connection pool.
    * @param {string} connectionString - The connection string used to connect to the database.
    */
-  constructor(connectionString) {
+  constructor(db, connectionString) {
     const defaultConfig = {
       max: 20,
       idleTimeoutMillis: 3e4,
@@ -180,7 +179,6 @@ var PostgresConnectionManager = class {
       this.handlePoolError(err);
     });
     this.setupPoolErrorHandling();
-    this.testConnection();
   }
   /**
    * Handles a pool error by attempting to reconnect the pool.
@@ -221,9 +219,7 @@ var PostgresConnectionManager = class {
       return true;
     } catch (error) {
       logger2.error("Database connection test failed:", error);
-      throw new Error(
-        `Failed to connect to database: ${error.message}`
-      );
+      throw new Error(`Failed to connect to database: ${error.message}`);
     } finally {
       if (client) client.release();
     }
@@ -282,8 +278,6 @@ var PostgresConnectionManager = class {
    */
   async initialize() {
     try {
-      await this.testConnection();
-      logger2.info("PostgreSQL connection manager initialized successfully");
     } catch (error) {
       logger2.error("Failed to initialize connection manager:", error);
       throw error;
@@ -309,26 +303,37 @@ var PostgresConnectionManager = class {
     }
   }
   /**
-   * Asynchronously runs database migrations using the Drizzle library.
+   * Asynchronously runs database migrations using the Drizzle library and ensures
+   * the database schema is always up to date with the current schema definition.
    *
-   * @returns {Promise<void>} A Promise that resolves once the migrations are completed successfully.
+   * First applies existing migrations, then uses drizzle-kit push to ensure
+   * the database schema matches the current schema definition.
+   *
+   * @returns {Promise<void>} A Promise that resolves once the schema updates are completed successfully.
    */
   async runMigrations() {
-    try {
-      const db = drizzle2(this.pool);
-      await migrate2(db, {
-        migrationsFolder: path2.resolve(__dirname2, "../drizzle/migrations")
-      });
-      logger2.info("Migrations completed successfully!");
-    } catch (error) {
-      logger2.error("Failed to run database migrations:", error);
-    }
+    const { existsSync } = await import("fs");
+    const db = drizzle2(this.pool);
+    const packagePath = (await import.meta.resolve("@elizaos/plugin-sql")).replace("file://", "");
+    const packageMigrationsPath = pathResolve2(pathDirname2(packagePath), "../drizzle/migrations");
+    console.log("packageMigrationsPath", packageMigrationsPath);
+    const __filename = fileURLToPath2(import.meta.url);
+    const __dirname = pathDirname2(__filename);
+    const appMigrationPath = pathResolve2(__dirname, "../drizzle/migrations");
+    console.log("appMigrationPath", appMigrationPath);
+    const migrationsFolder = existsSync(packageMigrationsPath) ? packageMigrationsPath : appMigrationPath;
+    console.log("migrationsFolder", migrationsFolder);
+    const { execa } = await import("./execa-I2XBH3EI.js");
+    await execa("npx", ["drizzle-kit", "push"], {
+      cwd: migrationsFolder
+    });
+    console.log("migrated");
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
   }
 };
 
 export {
-  __name,
   PGliteClientManager,
   PostgresConnectionManager
 };
-//# sourceMappingURL=chunk-LLEN3JTK.js.map
+//# sourceMappingURL=chunk-PSEXCDLP.js.map

package/dist/chunk-PSEXCDLP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pglite/manager.ts","../src/pg/manager.ts"],"sourceRoot":"./","sourcesContent":["import { dirname as pathDirname, resolve as pathResolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { PGlite, type PGliteOptions } from '@electric-sql/pglite';\nimport { fuzzystrmatch } from '@electric-sql/pglite/contrib/fuzzystrmatch';\nimport { vector } from '@electric-sql/pglite/vector';\nimport { logger } from '@elizaos/core';\nimport { drizzle } from 'drizzle-orm/pglite';\nimport { migrate } from 'drizzle-orm/pglite/migrator';\nimport type { IDatabaseClientManager } from '../types';\n\n/**\n * Class representing a database client manager for PGlite.\n * @implements { IDatabaseClientManager }\n */\nexport class PGliteClientManager implements IDatabaseClientManager<PGlite> {\n  private client: PGlite;\n  private shuttingDown = false;\n  private readonly shutdownTimeout = 500;\n\n  /**\n   * Constructor for creating a new instance of PGlite with the provided options.\n   * Initializes the PGlite client with additional extensions.\n   * @param {PGliteOptions} options - The options to configure the PGlite client.\n   */\n  constructor(options: PGliteOptions) {\n    this.client = new PGlite({\n      ...options,\n      extensions: {\n        vector,\n        fuzzystrmatch,\n      },\n    });\n    this.setupShutdownHandlers();\n  }\n\n  /**\n   * Retrieves the PostgreSQL lite connection.\n   *\n   * @returns {PGlite} The PostgreSQL lite connection.\n   * @throws {Error} If the client manager is currently shutting down.\n   */\n  public getConnection(): PGlite {\n    if (this.shuttingDown) {\n      throw new Error('Client manager is shutting down');\n    }\n    return this.client;\n  }\n\n  /**\n   * Initiates a graceful shutdown of the PGlite client.\n   * Checks if the client is already in the process of shutting down.\n   * Logs the start of shutdown process and sets shuttingDown flag to true.\n   * Sets a timeout for the shutdown process and forces closure of database connection if timeout is reached.\n   * Handles the shutdown process, closes the client connection, clears the timeout, and logs the completion of shutdown.\n   * Logs any errors that occur during the shutdown process.\n   */\n  private async gracefulShutdown() {\n    if (this.shuttingDown) {\n      return;\n    }\n\n    this.shuttingDown = true;\n    logger.info('Starting graceful shutdown of PGlite client...');\n\n    const timeout = setTimeout(() => {\n      logger.warn('Shutdown timeout reached, forcing database connection closure...');\n      this.client.close().finally(() => {\n        process.exit(1);\n      });\n    }, this.shutdownTimeout);\n\n    try {\n      await this.client.close();\n      clearTimeout(timeout);\n      logger.info('PGlite client shutdown completed successfully');\n      process.exit(0);\n    } catch (error) {\n      logger.error('Error during graceful shutdown:', error);\n      process.exit(1);\n    }\n  }\n\n  /**\n   * Sets up shutdown handlers for SIGINT, SIGTERM, and beforeExit events to gracefully shutdown the application.\n   * @private\n   */\n  private setupShutdownHandlers() {\n    process.on('SIGINT', async () => {\n      await this.gracefulShutdown();\n    });\n\n    process.on('SIGTERM', async () => {\n      await this.gracefulShutdown();\n    });\n\n    process.on('beforeExit', async () => {\n      await this.gracefulShutdown();\n    });\n  }\n\n  /**\n   * Initializes the client for PGlite.\n   *\n   * @returns {Promise<void>} A Promise that resolves when the client is initialized successfully\n   */\n  public async initialize(): Promise<void> {\n    try {\n      await this.client.waitReady;\n      logger.info('PGlite client initialized successfully');\n    } catch (error) {\n      logger.error('Failed to initialize PGlite client:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Asynchronously closes the resource. If the resource is not already shutting down,\n   * it performs a graceful shutdown before closing.\n   *\n   * @returns A promise that resolves once the resource has been closed.\n   */\n  public async close(): Promise<void> {\n    if (!this.shuttingDown) {\n      await this.gracefulShutdown();\n    }\n  }\n\n  /**\n   * Check if the system is currently shutting down.\n   *\n   * @returns {boolean} True if the system is shutting down, false otherwise.\n   */\n  public isShuttingDown(): boolean {\n    return this.shuttingDown;\n  }\n\n  /**\n   * Asynchronously runs database migrations using Drizzle.\n   *\n   * Drizzle will first check if the migrations are already applied.\n   * If there is a diff between database schema and migrations, it will apply the migrations.\n   * If they are already applied, it will skip them.\n   *\n   * @returns {Promise<void>} A Promise that resolves once the migrations are completed successfully.\n   */\n  async runMigrations(): Promise<void> {\n    try {\n      const db = drizzle(this.client);\n\n      const __filename = fileURLToPath(import.meta.url);\n      const __dirname = pathDirname(__filename);\n\n      await migrate(db, {\n        migrationsFolder: pathResolve(__dirname, '../drizzle/migrations'),\n      });\n    } catch (error) {\n      logger.error('Failed to run database migrations (pglite):', error);\n    }\n  }\n}\n","import { logger } from '@elizaos/core';\nimport { migrate } from 'drizzle-orm/node-postgres/migrator';\nimport { drizzle } from 'drizzle-orm/node-postgres';\nimport { dirname as pathDirname, resolve as pathResolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport pkg, { type Pool as PgPool } from 'pg';\nimport type { IDatabaseClientManager } from '../types';\n\nconst { Pool } = pkg;\n\n/**\n * Manages connections to a PostgreSQL database using a connection pool.\n * Implements IDatabaseClientManager interface.\n */\n\nexport class PostgresConnectionManager implements IDatabaseClientManager<PgPool> {\n  private pool: PgPool;\n  private isShuttingDown = false;\n  private readonly connectionTimeout: number = 5000;\n\n  /**\n   * Constructor for creating a connection pool.\n   * @param {string} connectionString - The connection string used to connect to the database.\n   */\n  constructor(db: PgPool, connectionString: string) {\n    const defaultConfig = {\n      max: 20,\n      idleTimeoutMillis: 30000,\n      connectionTimeoutMillis: this.connectionTimeout,\n    };\n\n    this.pool = new Pool({\n      ...defaultConfig,\n      connectionString,\n    });\n\n    this.pool.on('error', (err) => {\n      logger.error('Unexpected pool error', err);\n      this.handlePoolError(err);\n    });\n\n    this.setupPoolErrorHandling();\n    // this.testConnection();\n  }\n\n  /**\n   * Handles a pool error by attempting to reconnect the pool.\n   *\n   * @param {Error} error The error that occurred in the pool.\n   * @throws {Error} If failed to reconnect the pool.\n   */\n  private async handlePoolError(error: Error) {\n    logger.error('Pool error occurred, attempting to reconnect', {\n      error: error.message,\n    });\n\n    try {\n      await this.pool.end();\n\n      this.pool = new Pool({\n        ...this.pool.options,\n        connectionTimeoutMillis: this.connectionTimeout,\n      });\n\n      await this.testConnection();\n      logger.success('Pool reconnection successful');\n    } catch (reconnectError) {\n      logger.error('Failed to reconnect pool', {\n        error: reconnectError instanceof Error ? reconnectError.message : String(reconnectError),\n      });\n      throw reconnectError;\n    }\n  }\n\n  /**\n   * Asynchronously tests the database connection by executing a query to get the current timestamp.\n   *\n   * @returns {Promise<boolean>} - A Promise that resolves to true if the database connection test is successful.\n   */\n  async testConnection(): Promise<boolean> {\n    let client: pkg.PoolClient | null = null;\n    try {\n      client = await this.pool.connect();\n      const result = await client.query('SELECT NOW()');\n      logger.success('Database connection test successful:', result.rows[0]);\n      return true;\n    } catch (error) {\n      logger.error('Database connection test failed:', error);\n      throw new Error(`Failed to connect to database: ${(error as Error).message}`);\n    } finally {\n      if (client) client.release();\n    }\n  }\n\n  /**\n   * Sets up event listeners to handle pool cleanup on SIGINT, SIGTERM, and beforeExit events.\n   */\n  private setupPoolErrorHandling() {\n    process.on('SIGINT', async () => {\n      await this.cleanup();\n      process.exit(0);\n    });\n\n    process.on('SIGTERM', async () => {\n      await this.cleanup();\n      process.exit(0);\n    });\n\n    process.on('beforeExit', async () => {\n      await this.cleanup();\n    });\n  }\n\n  /**\n   * Get the connection pool.\n   * @returns {PgPool} The connection pool\n   * @throws {Error} If the connection manager is shutting down or an error occurs when trying to get the connection from the pool\n   */\n  public getConnection(): PgPool {\n    if (this.isShuttingDown) {\n      throw new Error('Connection manager is shutting down');\n    }\n\n    try {\n      return this.pool;\n    } catch (error) {\n      logger.error('Failed to get connection from pool:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Asynchronously acquires a database client from the connection pool.\n   *\n   * @returns {Promise<pkg.PoolClient>} A Promise that resolves with the acquired database client.\n   * @throws {Error} If an error occurs while acquiring the database client.\n   */\n  public async getClient(): Promise<pkg.PoolClient> {\n    try {\n      return await this.pool.connect();\n    } catch (error) {\n      logger.error('Failed to acquire a database client:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Initializes the PostgreSQL connection manager by testing the connection and logging the result.\n   *\n   * @returns {Promise<void>} A Promise that resolves once the manager is successfully initialized\n   * @throws {Error} If there is an error initializing the connection manager\n   */\n  public async initialize(): Promise<void> {\n    try {\n      // await this.testConnection();\n      // logger.debug('PostgreSQL connection manager initialized successfully');\n    } catch (error) {\n      logger.error('Failed to initialize connection manager:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Asynchronously close the current process by executing a cleanup function.\n   * @returns A promise that resolves once the cleanup is complete.\n   */\n  public async close(): Promise<void> {\n    await this.cleanup();\n  }\n\n  /**\n   * Cleans up and closes the database pool.\n   * @returns {Promise<void>} A Promise that resolves when the database pool is closed.\n   */\n  async cleanup(): Promise<void> {\n    try {\n      await this.pool.end();\n      logger.info('Database pool closed');\n    } catch (error) {\n      logger.error('Error closing database pool:', error);\n    }\n  }\n\n  /**\n   * Asynchronously runs database migrations using the Drizzle library and ensures\n   * the database schema is always up to date with the current schema definition.\n   *\n   * First applies existing migrations, then uses drizzle-kit push to ensure\n   * the database schema matches the current schema definition.\n   *\n   * @returns {Promise<void>} A Promise that resolves once the schema updates are completed successfully.\n   */\n  async runMigrations(): Promise<void> {\n    // try {\n    const { existsSync } = await import('fs');\n    const db = drizzle(this.pool);\n\n    const packagePath = (await import.meta.resolve('@elizaos/plugin-sql')).replace('file://', '');\n\n    const packageMigrationsPath = pathResolve(pathDirname(packagePath), '../drizzle/migrations');\n    console.log('packageMigrationsPath', packageMigrationsPath);\n\n    const __filename = fileURLToPath(import.meta.url);\n    const __dirname = pathDirname(__filename);\n    const appMigrationPath = pathResolve(__dirname, '../drizzle/migrations');\n\n    console.log('appMigrationPath', appMigrationPath);\n\n    // if packageMigrationsPath exists, use it, otherwise use appMigrationPath\n    const migrationsFolder = existsSync(packageMigrationsPath)\n      ? packageMigrationsPath\n      : appMigrationPath;\n\n    console.log('migrationsFolder', migrationsFolder);\n    // await migrate(db, {\n    //   migrationsFolder,\n    // });\n    // run npx drizzle-kit push on migrationsFolder cwd\n    const { execa } = await import('execa');\n    await execa('npx', ['drizzle-kit', 'push'], {\n      cwd: migrationsFolder,\n    });\n    console.log('migrated');\n    // wait 2 seconds\n    await new Promise((resolve) => setTimeout(resolve, 2000));\n    // } catch (error) {\n    // logger.error('Failed to run database migrations or schema push (pg):', error);\n    // throw error;\n    // }\n  }\n}\n"],"mappings":"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","names":["logger","drizzle","pathDirname","pathResolve","fileURLToPath","logger","drizzle","pathResolve","pathDirname","fileURLToPath"]}