@axiom-lattice/pg-stores 1.0.82 → 1.0.84

package/src/stores/PostgreSQLA2AApiKeyStore.ts

@@ -12,7 +12,8 @@ import { encrypt, decrypt } from "@axiom-lattice/core";
 import { randomUUID } from "crypto";
 
 export interface PostgreSQLA2AApiKeyStoreOptions {
-  poolConfig: string | PoolConfig;
+  pool?: Pool;
+  poolConfig?: string | PoolConfig;
   autoMigrate?: boolean;
 }
 
@@ -48,15 +49,26 @@ function mapRowToRecord(row: KeyRow): A2AApiKeyRecord {
 
 export class PostgreSQLA2AApiKeyStore implements A2AApiKeyStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized = false;
+  private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLA2AApiKeyStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     this.pool =
       typeof options.poolConfig === "string"
         ? new Pool({ connectionString: options.poolConfig })
-        : new Pool(options.poolConfig);
+        : options.poolConfig
+          ? new Pool(options.poolConfig as PoolConfig)
+          : (() => { throw new Error("Either pool or poolConfig must be provided"); })();
 
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createA2AApiKeysTable);
@@ -83,6 +95,12 @@ export class PostgreSQLA2AApiKeyStore implements A2AApiKeyStore {
     return this.initPromise;
   }
 
+  async dispose(): Promise<void> {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+
   private async ensureInitialized(): Promise<void> {
     if (!this.initialized) await this.initialize();
   }

package/src/stores/PostgreSQLAssistantStore.ts

@@ -19,11 +19,17 @@ import { addAssistantOwnerUserId } from "../migrations/assistant_owner_user_migr
  * PostgreSQL AssistantStore options
  */
 export interface PostgreSQLAssistantStoreOptions {
+  /**
+   * External pool instance. When provided, poolConfig is not required and the
+   * caller is responsible for pool lifecycle and migrations.
+   */
+  pool?: Pool;
+
   /**
    * PostgreSQL connection pool configuration
    * Can be a connection string or PoolConfig object
    */
-  poolConfig: string | PoolConfig;
+  poolConfig?: string | PoolConfig;
 
   /**
    * Whether to run migrations automatically on initialization
@@ -40,17 +46,27 @@ export interface PostgreSQLAssistantStoreOptions {
  */
 export class PostgreSQLAssistantStore implements AssistantStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
   private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLAssistantStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     // Create Pool from config
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
 
     this.migrationManager = new MigrationManager(this.pool);

package/src/stores/PostgreSQLChannelInstallationStore.ts

@@ -14,7 +14,8 @@ import { alterChannelInstallationsTable } from "../migrations/channel_installati
 import { decrypt, encrypt } from "@axiom-lattice/core";
 
 export interface PostgreSQLChannelInstallationStoreOptions {
-  poolConfig: string | PoolConfig;
+  pool?: Pool;
+  poolConfig?: string | PoolConfig;
   autoMigrate?: boolean;
 }
 
@@ -35,15 +36,26 @@ export class PostgreSQLChannelInstallationStore
   implements ChannelInstallationStore
 {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized = false;
+  private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLChannelInstallationStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     this.pool =
       typeof options.poolConfig === "string"
         ? new Pool({ connectionString: options.poolConfig })
-        : new Pool(options.poolConfig);
+        : options.poolConfig
+          ? new Pool(options.poolConfig as PoolConfig)
+          : (() => { throw new Error("Either pool or poolConfig must be provided"); })();
 
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createChannelInstallationsTable);
@@ -81,6 +93,12 @@ export class PostgreSQLChannelInstallationStore
     return this.initPromise;
   }
 
+  async dispose(): Promise<void> {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+
   async getInstallationById(
     installationId: string,
   ): Promise<ChannelInstallation | null> {

package/src/stores/PostgreSQLDatabaseConfigStore.ts

@@ -19,11 +19,17 @@ import { encrypt, decrypt } from '@axiom-lattice/core';
  * PostgreSQL DatabaseConfigStore options
  */
 export interface PostgreSQLDatabaseConfigStoreOptions {
+  /**
+   * External pool instance. When provided, poolConfig is not required and the
+   * caller is responsible for pool lifecycle and migrations.
+   */
+  pool?: Pool;
+
   /**
    * PostgreSQL connection pool configuration
    * Can be a connection string or PoolConfig object
    */
-  poolConfig: string | PoolConfig;
+  poolConfig?: string | PoolConfig;
 
   /**
    * Whether to run migrations automatically on initialization
@@ -42,16 +48,27 @@ export interface PostgreSQLDatabaseConfigStoreOptions {
  */
 export class PostgreSQLDatabaseConfigStore implements DatabaseConfigStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
+  private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLDatabaseConfigStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     // Create Pool from config
     if (typeof options.poolConfig === 'string') {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error('Either pool or poolConfig must be provided');
     }
 
     this.migrationManager = new MigrationManager(this.pool);
@@ -368,7 +385,9 @@ export class PostgreSQLDatabaseConfigStore implements DatabaseConfigStore {
    * Dispose resources and close the connection pool
    */
   async dispose(): Promise<void> {
-    await this.pool.end();
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
 
   /**

package/src/stores/PostgreSQLEvalStore.ts

@@ -23,8 +23,10 @@ import { v4 as uuidv4 } from "uuid";
 
 /** PostgreSQL EvalStore options */
 export interface PostgreSQLEvalStoreOptions {
+  /** External pool instance. When provided, poolConfig is not required. */
+  pool?: Pool;
   /** PostgreSQL connection pool configuration */
-  poolConfig: string | PoolConfig;
+  poolConfig?: string | PoolConfig;
   /** Whether to run migrations automatically on initialization @default true */
   autoMigrate?: boolean;
 }
@@ -39,17 +41,27 @@ export interface PostgreSQLEvalStoreOptions {
  */
 export class PostgreSQLEvalStore implements EvalStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
   private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLEvalStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     // Create Pool from config
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
 
     this.migrationManager = new MigrationManager(this.pool);

package/src/stores/PostgreSQLMcpServerConfigStore.ts

@@ -19,11 +19,17 @@ import { encrypt, decrypt } from '@axiom-lattice/core';
  * PostgreSQL McpServerConfigStore options
  */
 export interface PostgreSQLMcpServerConfigStoreOptions {
+  /**
+   * External pool instance. When provided, poolConfig is not required and the
+   * caller is responsible for pool lifecycle and migrations.
+   */
+  pool?: Pool;
+
   /**
    * PostgreSQL connection pool configuration
    * Can be a connection string or PoolConfig object
    */
-  poolConfig: string | PoolConfig;
+  poolConfig?: string | PoolConfig;
 
   /**
    * Whether to run migrations automatically on initialization
@@ -42,16 +48,27 @@ export interface PostgreSQLMcpServerConfigStoreOptions {
  */
 export class PostgreSQLMcpServerConfigStore implements McpServerConfigStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
+  private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLMcpServerConfigStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     // Create Pool from config
     if (typeof options.poolConfig === 'string') {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error('Either pool or poolConfig must be provided');
     }
 
     this.migrationManager = new MigrationManager(this.pool);
@@ -398,7 +415,9 @@ export class PostgreSQLMcpServerConfigStore implements McpServerConfigStore {
    * Dispose resources and close the connection pool
    */
   async dispose(): Promise<void> {
-    await this.pool.end();
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
 
   /**

package/src/stores/PostgreSQLMetricsServerConfigStore.ts

@@ -19,11 +19,17 @@ import { encrypt, decrypt } from '@axiom-lattice/core';
  * PostgreSQL MetricsServerConfigStore options
  */
 export interface PostgreSQLMetricsServerConfigStoreOptions {
+  /**
+   * External pool instance. When provided, poolConfig is not required and the
+   * caller is responsible for pool lifecycle and migrations.
+   */
+  pool?: Pool;
+
   /**
    * PostgreSQL connection pool configuration
    * Can be a connection string or PoolConfig object
    */
-  poolConfig: string | PoolConfig;
+  poolConfig?: string | PoolConfig;
 
   /**
    * Whether to run migrations automatically on initialization
@@ -42,16 +48,27 @@ export interface PostgreSQLMetricsServerConfigStoreOptions {
  */
 export class PostgreSQLMetricsServerConfigStore implements MetricsServerConfigStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
+  private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLMetricsServerConfigStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     // Create Pool from config
     if (typeof options.poolConfig === 'string') {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error('Either pool or poolConfig must be provided');
     }
 
     this.migrationManager = new MigrationManager(this.pool);
@@ -368,7 +385,9 @@ export class PostgreSQLMetricsServerConfigStore implements MetricsServerConfigSt
    * Dispose resources and close the connection pool
    */
   async dispose(): Promise<void> {
-    await this.pool.end();
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
 
   /**

package/src/stores/PostgreSQLProjectStore.ts

@@ -18,11 +18,17 @@ import { addProjectConfigColumn } from "../migrations/add_project_config_column"
  * PostgreSQL ProjectStore options
  */
 export interface PostgreSQLProjectStoreOptions {
+  /**
+   * External pool instance. When provided, poolConfig is not required and the
+   * caller is responsible for pool lifecycle and migrations.
+   */
+  pool?: Pool;
+
   /**
    * PostgreSQL connection pool configuration
    * Can be a connection string or PoolConfig object
    */
-  poolConfig: string | PoolConfig;
+  poolConfig?: string | PoolConfig;
 
   /**
    * Whether to run migrations automatically on initialization
@@ -36,16 +42,26 @@ export interface PostgreSQLProjectStoreOptions {
  */
 export class PostgreSQLProjectStore implements ProjectStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
   private ownsPool: boolean = true;
 
   constructor(options: PostgreSQLProjectStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     // Create Pool from config
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
 
     this.migrationManager = new MigrationManager(this.pool);

package/src/stores/PostgreSQLScheduleStorage.ts

@@ -21,11 +21,17 @@ import { addScheduleTenantId } from "../migrations/schedule_tenant_migration";
  * PostgreSQL ScheduleStorage options
  */
 export interface PostgreSQLScheduleStorageOptions {
+  /**
+   * External pool instance. When provided, poolConfig is not required and the
+   * caller is responsible for pool lifecycle and migrations.
+   */
+  pool?: Pool;
+
   /**
    * PostgreSQL connection pool configuration
    * Can be a connection string or PoolConfig object
    */
-  poolConfig: string | PoolConfig;
+  poolConfig?: string | PoolConfig;
 
   /**
    * Whether to run migrations automatically on initialization
@@ -68,15 +74,26 @@ interface ScheduledTaskRow {
  */
 export class PostgreSQLScheduleStorage implements ScheduleStorage {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
+  private ownsPool: boolean = true;
 
   constructor(options: PostgreSQLScheduleStorageOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     // Create Pool from config
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
 
     this.migrationManager = new MigrationManager(this.pool);
@@ -96,7 +113,7 @@ export class PostgreSQLScheduleStorage implements ScheduleStorage {
    * Dispose resources and close the connection pool
    */
   async dispose(): Promise<void> {
-    if (this.pool) {
+    if (this.ownsPool && this.pool) {
       await this.pool.end();
     }
   }

package/src/stores/PostgreSQLSkillStore.ts

@@ -15,7 +15,8 @@ import { addSkillTenantId } from "../migrations/skill_tenant_migration";
 import { changeSkillPrimaryKey } from "../migrations/skill_pk_migration";
 
 export interface PostgreSQLSkillStoreOptions {
-  poolConfig: string | PoolConfig;
+  pool?: Pool;
+  poolConfig?: string | PoolConfig;
   autoMigrate?: boolean;
 }
 
@@ -27,16 +28,26 @@ export interface PostgreSQLSkillStoreOptions {
  */
 export class PostgreSQLSkillStore implements SkillStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
   private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLSkillStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
 
     this.migrationManager = new MigrationManager(this.pool);

package/src/stores/PostgreSQLTaskStore.ts

@@ -54,22 +54,33 @@ function mapRowToTask(row: TaskRow): TaskItem {
 }
 
 export interface PostgreSQLTaskStoreOptions {
-  poolConfig: string | PoolConfig;
+  pool?: Pool;
+  poolConfig?: string | PoolConfig;
   autoMigrate?: boolean;
 }
 
 export class PostgreSQLTaskStore implements TaskStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
   private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLTaskStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
 
     this.migrationManager = new MigrationManager(this.pool);

package/src/stores/PostgreSQLTenantStore.ts

@@ -18,11 +18,17 @@ import { createTenantsTable } from "../migrations/tenant_migrations";
  * PostgreSQL TenantStore options
  */
 export interface PostgreSQLTenantStoreOptions {
+  /**
+   * External pool instance. When provided, poolConfig is not required and the
+   * caller is responsible for pool lifecycle and migrations.
+   */
+  pool?: Pool;
+
   /**
    * PostgreSQL connection pool configuration
    * Can be a connection string or PoolConfig object
    */
-  poolConfig: string | PoolConfig;
+  poolConfig?: string | PoolConfig;
 
   /**
    * Whether to run migrations automatically on initialization
@@ -37,16 +43,26 @@ export interface PostgreSQLTenantStoreOptions {
  */
 export class PostgreSQLTenantStore implements TenantStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
   private ownsPool: boolean = true;
 
   constructor(options: PostgreSQLTenantStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     // Create Pool from config
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
 
     this.migrationManager = new MigrationManager(this.pool);

package/src/stores/PostgreSQLThreadStore.ts

@@ -18,11 +18,17 @@ import { changeThreadPrimaryKey } from "../migrations/thread_pk_migration";
  * PostgreSQL ThreadStore options
  */
 export interface PostgreSQLThreadStoreOptions {
+  /**
+   * External pool instance. When provided, poolConfig is not required and the
+   * caller is responsible for pool lifecycle and migrations.
+   */
+  pool?: Pool;
+
   /**
    * PostgreSQL connection pool configuration
    * Can be a connection string or PoolConfig object
    */
-  poolConfig: string | PoolConfig;
+  poolConfig?: string | PoolConfig;
 
   /**
    * Whether to run migrations automatically on initialization
@@ -39,17 +45,27 @@ export interface PostgreSQLThreadStoreOptions {
  */
 export class PostgreSQLThreadStore implements ThreadStore {
   private pool: Pool;
-  private migrationManager: MigrationManager;
+  private migrationManager!: MigrationManager;
   private initialized: boolean = false;
   private ownsPool: boolean = true;
   private initPromise: Promise<void> | null = null;
 
   constructor(options: PostgreSQLThreadStoreOptions) {
+    // Use externally-managed pool if provided
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
     // Create Pool from config
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool(options.poolConfig as PoolConfig);
     } else {
-      this.pool = new Pool(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
 
     this.migrationManager = new MigrationManager(this.pool);