@elizaos/plugin-sql 1.0.0-beta.0 → 1.0.0-beta.12

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Shaw Walters, aka Moon aka @lalalune
+Copyright (c) 2025 Shaw Walters and elizaOS Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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

@@ -1,6 +1,5 @@
-import {
-  __name
-} from "./chunk-I3JSTNED.js";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/pglite/manager.ts
 import { dirname as pathDirname, resolve as pathResolve } from "node:path";
@@ -138,7 +137,8 @@ var PGliteClientManager = class {
       const __filename = fileURLToPath(import.meta.url);
       const __dirname = pathDirname(__filename);
       await migrate(db, {
-        migrationsFolder: pathResolve(__dirname, "../drizzle/migrations")
+        migrationsFolder: pathResolve(__dirname, "../drizzle/migrations"),
+        migrationsSchema: "public"
       });
     } catch (error) {
       logger.error("Failed to run database migrations (pglite):", error);
@@ -147,10 +147,11 @@ var PGliteClientManager = class {
 };
 
 // src/pg/manager.ts
+import path 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 { dirname as pathDirname2, resolve as pathResolve2 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { migrate as migrate2 } from "drizzle-orm/node-postgres/migrator";
 import pkg from "pg";
 var { Pool } = pkg;
 var PostgresConnectionManager = class {
@@ -164,7 +165,7 @@ var PostgresConnectionManager = class {
    * Constructor for creating a connection pool.
    * @param {string} connectionString - The connection string used to connect to the database.
    */
-  constructor(db, connectionString) {
+  constructor(connectionString) {
     const defaultConfig = {
       max: 20,
       idleTimeoutMillis: 3e4,
@@ -179,6 +180,7 @@ var PostgresConnectionManager = class {
       this.handlePoolError(err);
     });
     this.setupPoolErrorHandling();
+    this.testConnection();
   }
   /**
    * Handles a pool error by attempting to reconnect the pool.
@@ -278,6 +280,8 @@ var PostgresConnectionManager = class {
    */
   async initialize() {
     try {
+      await this.testConnection();
+      logger2.debug("PostgreSQL connection manager initialized successfully");
     } catch (error) {
       logger2.error("Failed to initialize connection manager:", error);
       throw error;
@@ -303,37 +307,32 @@ var PostgresConnectionManager = class {
     }
   }
   /**
-   * Asynchronously runs database migrations using the Drizzle library and ensures
-   * the database schema is always up to date with the current schema definition.
+   * Asynchronously runs database migrations using the Drizzle library.
    *
-   * First applies existing migrations, then uses drizzle-kit push to ensure
-   * the database schema matches the current schema definition.
+   * 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 schema updates are completed successfully.
+   * @returns {Promise<void>} A Promise that resolves once the migrations are completed successfully.
    */
   async runMigrations() {
-    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));
+    try {
+      const db = drizzle2(this.pool);
+      const __filename = fileURLToPath2(import.meta.url);
+      const __dirname = path.dirname(__filename);
+      await migrate2(db, {
+        migrationsFolder: path.resolve(__dirname, "../drizzle/migrations"),
+        migrationsSchema: "public"
+      });
+    } catch (error) {
+      logger2.error("Failed to run database migrations (pg):", error);
+    }
   }
 };
 
 export {
+  __name,
   PGliteClientManager,
   PostgresConnectionManager
 };
-//# sourceMappingURL=chunk-PSEXCDLP.js.map
+//# sourceMappingURL=chunk-ROCRMD5N.js.map

package/dist/chunk-ROCRMD5N.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        migrationsSchema: 'public',\n      });\n    } catch (error) {\n      logger.error('Failed to run database migrations (pglite):', error);\n    }\n  }\n}\n","import path from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { logger } from '@elizaos/core';\nimport { drizzle } from 'drizzle-orm/node-postgres';\nimport { migrate } from 'drizzle-orm/node-postgres/migrator';\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(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.\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.pool);\n\n      const __filename = fileURLToPath(import.meta.url);\n      const __dirname = path.dirname(__filename);\n\n      await migrate(db, {\n        migrationsFolder: path.resolve(__dirname, '../drizzle/migrations'),\n        migrationsSchema: 'public',\n      });\n    } catch (error) {\n      logger.error('Failed to run database migrations (pg):', error);\n    }\n  }\n}\n"],"mappings":";;;;AAAA,SAAS,WAAW,aAAa,WAAW,mBAAmB;AAC/D,SAAS,qBAAqB;AAC9B,SAAS,cAAkC;AAC3C,SAAS,qBAAqB;AAC9B,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,eAAe;AACxB,SAAS,eAAe;AAOjB,IAAM,sBAAN,MAAoE;AAAA,EAd3E,OAc2E;AAAA;AAAA;AAAA,EACjE;AAAA,EACA,eAAe;AAAA,EACN,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOnC,YAAY,SAAwB;AAClC,SAAK,SAAS,IAAI,OAAO;AAAA,MACvB,GAAG;AAAA,MACH,YAAY;AAAA,QACV;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AACD,SAAK,sBAAsB;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,gBAAwB;AAC7B,QAAI,KAAK,cAAc;AACrB,YAAM,IAAI,MAAM,iCAAiC;AAAA,IACnD;AACA,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAc,mBAAmB;AAC/B,QAAI,KAAK,cAAc;AACrB;AAAA,IACF;AAEA,SAAK,eAAe;AACpB,WAAO,KAAK,gDAAgD;AAE5D,UAAM,UAAU,WAAW,MAAM;AAC/B,aAAO,KAAK,kEAAkE;AAC9E,WAAK,OAAO,MAAM,EAAE,QAAQ,MAAM;AAChC,gBAAQ,KAAK,CAAC;AAAA,MAChB,CAAC;AAAA,IACH,GAAG,KAAK,eAAe;AAEvB,QAAI;AACF,YAAM,KAAK,OAAO,MAAM;AACxB,mBAAa,OAAO;AACpB,aAAO,KAAK,+CAA+C;AAC3D,cAAQ,KAAK,CAAC;AAAA,IAChB,SAAS,OAAO;AACd,aAAO,MAAM,mCAAmC,KAAK;AACrD,cAAQ,KAAK,CAAC;AAAA,IAChB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,wBAAwB;AAC9B,YAAQ,GAAG,UAAU,YAAY;AAC/B,YAAM,KAAK,iBAAiB;AAAA,IAC9B,CAAC;AAED,YAAQ,GAAG,WAAW,YAAY;AAChC,YAAM,KAAK,iBAAiB;AAAA,IAC9B,CAAC;AAED,YAAQ,GAAG,cAAc,YAAY;AACnC,YAAM,KAAK,iBAAiB;AAAA,IAC9B,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAa,aAA4B;AACvC,QAAI;AACF,YAAM,KAAK,OAAO;AAClB,aAAO,KAAK,wCAAwC;AAAA,IACtD,SAAS,OAAO;AACd,aAAO,MAAM,uCAAuC,KAAK;AACzD,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,QAAuB;AAClC,QAAI,CAAC,KAAK,cAAc;AACtB,YAAM,KAAK,iBAAiB;AAAA,IAC9B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,iBAA0B;AAC/B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAM,gBAA+B;AACnC,QAAI;AACF,YAAM,KAAK,QAAQ,KAAK,MAAM;AAE9B,YAAM,aAAa,cAAc,YAAY,GAAG;AAChD,YAAM,YAAY,YAAY,UAAU;AAExC,YAAM,QAAQ,IAAI;AAAA,QAChB,kBAAkB,YAAY,WAAW,uBAAuB;AAAA,QAChE,kBAAkB;AAAA,MACpB,CAAC;AAAA,IACH,SAAS,OAAO;AACd,aAAO,MAAM,+CAA+C,KAAK;AAAA,IACnE;AAAA,EACF;AACF;;;AChKA,OAAO,UAAU;AACjB,SAAS,iBAAAA,sBAAqB;AAC9B,SAAS,UAAAC,eAAc;AACvB,SAAS,WAAAC,gBAAe;AACxB,SAAS,WAAAC,gBAAe;AACxB,OAAO,SAAkC;AAGzC,IAAM,EAAE,KAAK,IAAI;AAOV,IAAM,4BAAN,MAA0E;AAAA,EAfjF,OAeiF;AAAA;AAAA;AAAA,EACvE;AAAA,EACA,iBAAiB;AAAA,EACR,oBAA4B;AAAA;AAAA;AAAA;AAAA;AAAA,EAM7C,YAAY,kBAA0B;AACpC,UAAM,gBAAgB;AAAA,MACpB,KAAK;AAAA,MACL,mBAAmB;AAAA,MACnB,yBAAyB,KAAK;AAAA,IAChC;AAEA,SAAK,OAAO,IAAI,KAAK;AAAA,MACnB,GAAG;AAAA,MACH;AAAA,IACF,CAAC;AAED,SAAK,KAAK,GAAG,SAAS,CAAC,QAAQ;AAC7B,MAAAC,QAAO,MAAM,yBAAyB,GAAG;AACzC,WAAK,gBAAgB,GAAG;AAAA,IAC1B,CAAC;AAED,SAAK,uBAAuB;AAC5B,SAAK,eAAe;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAc,gBAAgB,OAAc;AAC1C,IAAAA,QAAO,MAAM,gDAAgD;AAAA,MAC3D,OAAO,MAAM;AAAA,IACf,CAAC;AAED,QAAI;AACF,YAAM,KAAK,KAAK,IAAI;AAEpB,WAAK,OAAO,IAAI,KAAK;AAAA,QACnB,GAAG,KAAK,KAAK;AAAA,QACb,yBAAyB,KAAK;AAAA,MAChC,CAAC;AAED,YAAM,KAAK,eAAe;AAC1B,MAAAA,QAAO,QAAQ,8BAA8B;AAAA,IAC/C,SAAS,gBAAgB;AACvB,MAAAA,QAAO,MAAM,4BAA4B;AAAA,QACvC,OAAO,0BAA0B,QAAQ,eAAe,UAAU,OAAO,cAAc;AAAA,MACzF,CAAC;AACD,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,iBAAmC;AACvC,QAAI,SAAgC;AACpC,QAAI;AACF,eAAS,MAAM,KAAK,KAAK,QAAQ;AACjC,YAAM,SAAS,MAAM,OAAO,MAAM,cAAc;AAChD,MAAAA,QAAO,QAAQ,wCAAwC,OAAO,KAAK,CAAC,CAAC;AACrE,aAAO;AAAA,IACT,SAAS,OAAO;AACd,MAAAA,QAAO,MAAM,oCAAoC,KAAK;AACtD,YAAM,IAAI,MAAM,kCAAmC,MAAgB,OAAO,EAAE;AAAA,IAC9E,UAAE;AACA,UAAI,OAAQ,QAAO,QAAQ;AAAA,IAC7B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,yBAAyB;AAC/B,YAAQ,GAAG,UAAU,YAAY;AAC/B,YAAM,KAAK,QAAQ;AACnB,cAAQ,KAAK,CAAC;AAAA,IAChB,CAAC;AAED,YAAQ,GAAG,WAAW,YAAY;AAChC,YAAM,KAAK,QAAQ;AACnB,cAAQ,KAAK,CAAC;AAAA,IAChB,CAAC;AAED,YAAQ,GAAG,cAAc,YAAY;AACnC,YAAM,KAAK,QAAQ;AAAA,IACrB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,gBAAwB;AAC7B,QAAI,KAAK,gBAAgB;AACvB,YAAM,IAAI,MAAM,qCAAqC;AAAA,IACvD;AAEA,QAAI;AACF,aAAO,KAAK;AAAA,IACd,SAAS,OAAO;AACd,MAAAA,QAAO,MAAM,uCAAuC,KAAK;AACzD,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,YAAqC;AAChD,QAAI;AACF,aAAO,MAAM,KAAK,KAAK,QAAQ;AAAA,IACjC,SAAS,OAAO;AACd,MAAAA,QAAO,MAAM,wCAAwC,KAAK;AAC1D,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,aAA4B;AACvC,QAAI;AACF,YAAM,KAAK,eAAe;AAC1B,MAAAA,QAAO,MAAM,wDAAwD;AAAA,IACvE,SAAS,OAAO;AACd,MAAAA,QAAO,MAAM,4CAA4C,KAAK;AAC9D,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAa,QAAuB;AAClC,UAAM,KAAK,QAAQ;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,UAAyB;AAC7B,QAAI;AACF,YAAM,KAAK,KAAK,IAAI;AACpB,MAAAA,QAAO,KAAK,sBAAsB;AAAA,IACpC,SAAS,OAAO;AACd,MAAAA,QAAO,MAAM,gCAAgC,KAAK;AAAA,IACpD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAM,gBAA+B;AACnC,QAAI;AACF,YAAM,KAAKC,SAAQ,KAAK,IAAI;AAE5B,YAAM,aAAaC,eAAc,YAAY,GAAG;AAChD,YAAM,YAAY,KAAK,QAAQ,UAAU;AAEzC,YAAMC,SAAQ,IAAI;AAAA,QAChB,kBAAkB,KAAK,QAAQ,WAAW,uBAAuB;AAAA,QACjE,kBAAkB;AAAA,MACpB,CAAC;AAAA,IACH,SAAS,OAAO;AACd,MAAAH,QAAO,MAAM,2CAA2C,KAAK;AAAA,IAC/D;AAAA,EACF;AACF;","names":["fileURLToPath","logger","drizzle","migrate","logger","drizzle","fileURLToPath","migrate"]}

package/dist/index.js

@@ -1,10 +1,8 @@
 import {
   PGliteClientManager,
-  PostgresConnectionManager
-} from "./chunk-PSEXCDLP.js";
-import {
+  PostgresConnectionManager,
   __name
-} from "./chunk-I3JSTNED.js";
+} from "./chunk-ROCRMD5N.js";
 
 // src/index.ts
 import * as os from "node:os";
@@ -29,7 +27,8 @@ import {
   inArray,
   lte,
   or,
-  sql as sql12
+  sql as sql12,
+  not
 } from "drizzle-orm";
 import { v4 } from "uuid";
 
@@ -571,6 +570,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           throw new Error("Agent ID is required for update");
         }
         await this.db.transaction(async (tx) => {
+          if (agent.settings) {
+            agent.settings = await this.mergeAgentSettings(tx, agentId, agent.settings);
+          }
           await tx.update(agentTable).set({
             ...agent,
             updatedAt: Date.now()
@@ -590,6 +592,39 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Merges updated agent settings with existing settings in the database,
+   * with special handling for nested objects like secrets.
+   * @param tx - The database transaction
+   * @param agentId - The ID of the agent
+   * @param updatedSettings - The settings object with updates
+   * @returns The merged settings object
+   * @private
+   */
+  async mergeAgentSettings(tx, agentId, updatedSettings) {
+    const currentAgent = await tx.select({ settings: agentTable.settings }).from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
+    if (currentAgent.length === 0 || !currentAgent[0].settings) {
+      return updatedSettings;
+    }
+    const currentSettings = currentAgent[0].settings;
+    if (updatedSettings.secrets) {
+      const currentSecrets = currentSettings.secrets || {};
+      const updatedSecrets = updatedSettings.secrets;
+      const mergedSecrets = { ...currentSecrets };
+      for (const [key, value] of Object.entries(updatedSecrets)) {
+        if (value === null) {
+          delete mergedSecrets[key];
+        } else {
+          mergedSecrets[key] = value;
+        }
+      }
+      updatedSettings.secrets = mergedSecrets;
+    }
+    return {
+      ...currentSettings,
+      ...updatedSettings
+    };
+  }
   /**
    * Asynchronously deletes an agent with the specified UUID and all related entries.
    *
@@ -599,6 +634,42 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async deleteAgent(agentId) {
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
+        const entities = await this.db.select({ entityId: entityTable.id }).from(entityTable).where(eq(entityTable.agentId, agentId));
+        const entityIds = entities.map((e) => e.entityId);
+        let memoryIds = [];
+        if (entityIds.length > 0) {
+          const entityMemories = await this.db.select({ memoryId: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.entityId, entityIds));
+          memoryIds = entityMemories.map((m) => m.memoryId);
+        }
+        const agentMemories = await this.db.select({ memoryId: memoryTable.id }).from(memoryTable).where(eq(memoryTable.agentId, agentId));
+        memoryIds.push(...agentMemories.map((m) => m.memoryId));
+        if (memoryIds.length > 0) {
+          await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, memoryIds));
+          await tx.delete(memoryTable).where(inArray(memoryTable.id, memoryIds));
+        }
+        const rooms = await this.db.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.agentId, agentId));
+        const roomIds = rooms.map((r) => r.roomId);
+        if (entityIds.length > 0) {
+          await tx.delete(logTable).where(inArray(logTable.entityId, entityIds));
+          await tx.delete(participantTable).where(inArray(participantTable.entityId, entityIds));
+        }
+        if (roomIds.length > 0) {
+          await tx.delete(logTable).where(inArray(logTable.roomId, roomIds));
+          await tx.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
+        }
+        await tx.delete(participantTable).where(eq(participantTable.agentId, agentId));
+        if (roomIds.length > 0) {
+          await tx.delete(roomTable).where(inArray(roomTable.id, roomIds));
+        }
+        await tx.delete(cacheTable).where(eq(cacheTable.agentId, agentId));
+        await tx.delete(relationshipTable).where(eq(relationshipTable.agentId, agentId));
+        await tx.delete(entityTable).where(eq(entityTable.agentId, agentId));
+        const newAgent = await this.db.select({ newAgentId: agentTable.id }).from(agentTable).where(not(eq(agentTable.id, agentId))).limit(1);
+        if (newAgent.length > 0) {
+          await tx.update(worldTable).set({ agentId: newAgent[0].newAgentId }).where(eq(worldTable.agentId, agentId));
+        } else {
+          await tx.delete(worldTable).where(eq(worldTable.agentId, agentId));
+        }
         await tx.delete(agentTable).where(eq(agentTable.id, agentId));
       });
       return true;
@@ -712,6 +783,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     return this.withDatabase(async () => {
       try {
         return await this.db.transaction(async (tx) => {
+          const existingEntity = await this.getEntityById(entity.id);
+          if (existingEntity) {
+            logger.debug("Entity already exists:", {
+              entity
+            });
+            return true;
+          }
           await tx.insert(entityTable).values(entity);
           logger.debug("Entity created successfully:", {
             entity
@@ -1446,7 +1524,16 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @param {Room} room - The room object to create.
    * @returns {Promise<UUID>} A Promise that resolves to the ID of the created room.
    */
-  async createRoom({ id, name, source, type, channelId, serverId, worldId }) {
+  async createRoom({
+    id,
+    name,
+    source,
+    type,
+    channelId,
+    serverId,
+    worldId,
+    metadata
+  }) {
     return this.withDatabase(async () => {
       const newRoomId = id || v4();
       await this.db.insert(roomTable).values({
@@ -1457,7 +1544,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         type,
         channelId,
         serverId,
-        worldId
+        worldId,
+        metadata
       }).onConflictDoNothing({ target: roomTable.id });
       return newRoomId;
     });
@@ -1585,9 +1673,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   async getParticipantsForRoom(roomId) {
     return this.withDatabase(async () => {
-      const result = await this.db.select({ entityId: participantTable.entityId }).from(participantTable).where(
-        and(eq(participantTable.roomId, roomId), eq(participantTable.agentId, this.agentId))
-      );
+      const result = await this.db.select({ entityId: participantTable.entityId }).from(participantTable).where(eq(participantTable.roomId, roomId));
       return result.map((row) => row.entityId);
     });
   }
@@ -2053,6 +2139,66 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       });
     });
   }
+  /**
+   * Asynchronously retrieves group chat memories from all rooms under a given server.
+   * It fetches all room IDs associated with the `serverId`, then retrieves memories
+   * from those rooms in descending order (latest to oldest), with an optional count limit.
+   *
+   * @param {Object} params - Parameters for fetching memories.
+   * @param {UUID} params.serverId - The server ID to fetch memories for.
+   * @param {number} [params.count] - The maximum number of memories to retrieve.
+   * @returns {Promise<Memory[]>} - A promise that resolves to an array of memory objects.
+   */
+  async getMemoriesByServerId(params) {
+    return this.withDatabase(async () => {
+      const roomIdsResult = await this.db.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.serverId, params.serverId));
+      if (roomIdsResult.length === 0) return [];
+      const roomIds = roomIdsResult.map((row) => row.roomId);
+      const query = this.db.select({
+        memory: memoryTable,
+        embedding: embeddingTable[this.embeddingDimension]
+      }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(inArray(memoryTable.roomId, roomIds)).orderBy(desc(memoryTable.createdAt));
+      const rows = params.count ? await query.limit(params.count) : await query;
+      return rows.map((row) => ({
+        id: row.memory.id,
+        type: row.memory.type,
+        createdAt: row.memory.createdAt,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        unique: row.memory.unique,
+        embedding: row.embedding ?? void 0
+      }));
+    });
+  }
+  /**
+   * Asynchronously deletes all rooms associated with a specific serverId.
+   * @param {UUID} serverId - The server ID to delete rooms for.
+   * @returns {Promise<void>} A Promise that resolves when the rooms are deleted.
+   */
+  async deleteRoomsByServerId(serverId) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        const roomIdsResult = await tx.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.serverId, serverId));
+        if (roomIdsResult.length === 0) return;
+        const roomIds = roomIdsResult.map((row) => row.roomId);
+        await tx.delete(embeddingTable).where(
+          inArray(
+            embeddingTable.memoryId,
+            tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds))
+          )
+        );
+        await tx.delete(memoryTable).where(inArray(memoryTable.roomId, roomIds));
+        await tx.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
+        await tx.delete(logTable).where(inArray(logTable.roomId, roomIds));
+        await tx.delete(roomTable).where(inArray(roomTable.id, roomIds));
+      });
+      logger.debug("Rooms and related logs deleted successfully for server:", {
+        serverId
+      });
+    });
+  }
 };
 
 // src/pglite/adapter.ts
@@ -2170,7 +2316,6 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
 };
 
 // src/index.ts
-import { Pool } from "pg";
 var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-sql/global-singletons");
 var globalSymbols = global;
 if (!globalSymbols[GLOBAL_SINGLETONS]) {
@@ -2189,10 +2334,8 @@ function createDatabaseAdapter(config, agentId) {
     config.dataDir = expandTildePath(config.dataDir);
   }
   if (config.postgresUrl) {
-    const pool = new Pool({ connectionString: config.postgresUrl });
     if (!globalSingletons.postgresConnectionManager) {
       globalSingletons.postgresConnectionManager = new PostgresConnectionManager(
-        pool,
         config.postgresUrl
       );
     }