@axiom-lattice/pg-stores 1.0.65 → 1.0.67

package/examples/database-config-store.example.ts

@@ -102,11 +102,9 @@ async function examplePostgreSQL() {
 import { sqlDatabaseManager } from '@axiom-lattice/core';
 
 async function exampleWithSqlManager() {
-  const store = await storeLatticeManager.getStoreLattice('default', 'database').store;
   const tenantId = 'tenant-123';
   
-  // 设置配置存储以便按需加载
-  sqlDatabaseManager.setConfigStore(store);
+  // Store is auto-read from StoreLatticeManager by SqlDatabaseManager — no setConfigStore needed
   
   // 现在可以使用注册的数据库（会自动从 store 加载）
   const db = await sqlDatabaseManager.getDatabase(tenantId, 'main-db');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/pg-stores",
-  "version": "1.0.65",
+  "version": "1.0.67",
   "description": "PG stores implementation for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -22,8 +22,8 @@
   "dependencies": {
     "pg": "^8.16.3",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.75",
-    "@axiom-lattice/protocols": "2.1.38"
+    "@axiom-lattice/core": "2.1.76",
+    "@axiom-lattice/protocols": "2.1.39"
   },
   "devDependencies": {
     "@types/node": "^20.11.24",

package/src/__tests__/ThreadMessageQueueStore.test.ts

@@ -19,21 +19,17 @@ jest.mock('pg', () => ({
 
 describe('ThreadMessageQueueStore', () => {
   let store: ThreadMessageQueueStore;
-  const mockPool = {
-    query: mockQuery,
-    connect: mockConnect,
-  };
 
   const mockThreadId = 'test-thread';
   const mockTenantId = 'test-tenant';
   const mockAssistantId = 'test-assistant';
 
   beforeEach(() => {
-    // Reset singleton
-    (ThreadMessageQueueStore as any)._instance = undefined;
-    store = ThreadMessageQueueStore.getInstance();
-    store.initialize(mockPool as any);
-    
+    store = new ThreadMessageQueueStore({
+      poolConfig: { connectionString: "mock" },
+      autoMigrate: false,
+    });
+
     jest.clearAllMocks();
   });
 
@@ -333,19 +329,6 @@ describe('ThreadMessageQueueStore', () => {
     });
   });
 
-  describe('markCompleted', () => {
-    it('should mark message as completed', async () => {
-      mockQuery.mockResolvedValueOnce({ rowCount: 1 });
-
-      await store.markCompleted('msg-1');
-
-      expect(mockQuery).toHaveBeenCalledWith(
-        expect.stringContaining("UPDATE thread_message_queue"),
-        ['msg-1']
-      );
-    });
-  });
-
   describe('clearMessages', () => {
     it('should clear all messages for thread', async () => {
       mockQuery.mockResolvedValueOnce({ rowCount: 5 });
@@ -359,35 +342,4 @@ describe('ThreadMessageQueueStore', () => {
     });
   });
 
-  describe('clearCompletedMessages', () => {
-    it('should remove completed messages for thread', async () => {
-      mockQuery.mockResolvedValueOnce({ rowCount: 3 });
-
-      await store.clearCompletedMessages(mockThreadId);
-
-      expect(mockQuery).toHaveBeenCalledWith(
-        expect.stringContaining("DELETE FROM thread_message_queue"),
-        [mockThreadId]
-      );
-    });
-  });
-
-  describe('singleton pattern', () => {
-    it('should return same instance', () => {
-      const instance1 = ThreadMessageQueueStore.getInstance();
-      const instance2 = ThreadMessageQueueStore.getInstance();
-      
-      expect(instance1).toBe(instance2);
-    });
-
-    it('should throw error if not initialized', () => {
-      // Reset instance
-      (ThreadMessageQueueStore as any)._instance = undefined;
-      const newStore = ThreadMessageQueueStore.getInstance();
-      
-      expect(() => {
-        newStore.getQueueSize('thread-1');
-      }).toThrow('not initialized');
-    });
-  });
 });

package/src/createPgStoreConfig.ts

@@ -0,0 +1,47 @@
+/**
+ * createPgStoreConfig
+ *
+ * Creates a map of all PG store instances from a single connection string,
+ * ready to pass directly to configureStores().
+ */
+
+import { PostgreSQLThreadStore } from "./stores/PostgreSQLThreadStore";
+import { PostgreSQLAssistantStore } from "./stores/PostgreSQLAssistantStore";
+import { PostgreSQLDatabaseConfigStore } from "./stores/PostgreSQLDatabaseConfigStore";
+import { PostgreSQLMetricsServerConfigStore } from "./stores/PostgreSQLMetricsServerConfigStore";
+import { PostgreSQLMcpServerConfigStore } from "./stores/PostgreSQLMcpServerConfigStore";
+import { PostgreSQLWorkspaceStore } from "./stores/PostgreSQLWorkspaceStore";
+import { PostgreSQLProjectStore } from "./stores/PostgreSQLProjectStore";
+import { PostgreSQLUserStore } from "./stores/PostgreSQLUserStore";
+import { PostgreSQLTenantStore } from "./stores/PostgreSQLTenantStore";
+import { PostgreSQLUserTenantLinkStore } from "./stores/PostgreSQLUserTenantLinkStore";
+import { PostgreSQLWorkflowTrackingStore } from "./stores/PostgreSQLWorkflowTrackingStore";
+import { PostgreSQLEvalStore } from "./stores/PostgreSQLEvalStore";
+import { ThreadMessageQueueStore } from "./stores/ThreadMessageQueueStore";
+import { ChannelBindingStore } from "./stores/ChannelBindingStore";
+import { PostgreSQLChannelInstallationStore } from "./stores/PostgreSQLChannelInstallationStore";
+import { PostgreSQLScheduleStorage } from "./stores/PostgreSQLScheduleStorage";
+
+export function createPgStoreConfig(connectionString: string) {
+  const opts = { poolConfig: connectionString, autoMigrate: false } as const;
+  const optsAuto = { poolConfig: connectionString, autoMigrate: true } as const;
+
+  return {
+    workspace: new PostgreSQLWorkspaceStore(opts),
+    project: new PostgreSQLProjectStore(opts),
+    eval: new PostgreSQLEvalStore(optsAuto),
+    user: new PostgreSQLUserStore(opts),
+    tenant: new PostgreSQLTenantStore(opts),
+    userTenantLink: new PostgreSQLUserTenantLinkStore(opts),
+    channelBinding: new ChannelBindingStore(optsAuto),
+    channelInstallation: new PostgreSQLChannelInstallationStore(optsAuto),
+    thread: new PostgreSQLThreadStore(opts),
+    database: new PostgreSQLDatabaseConfigStore(opts),
+    metrics: new PostgreSQLMetricsServerConfigStore(opts),
+    mcp: new PostgreSQLMcpServerConfigStore(opts),
+    assistant: new PostgreSQLAssistantStore(opts),
+    workflowTracking: new PostgreSQLWorkflowTrackingStore(optsAuto),
+    threadMessageQueue: new ThreadMessageQueueStore(optsAuto),
+    schedule: new PostgreSQLScheduleStorage(opts),
+  };
+}

package/src/index.ts

@@ -8,6 +8,8 @@
 export { Pool } from "pg";
 export type { PoolConfig } from "pg";
 
+export * from "./createPgStoreConfig";
+
 export * from "./stores/PostgreSQLThreadStore";
 export * from "./stores/PostgreSQLAssistantStore";
 export * from "./stores/PostgreSQLScheduleStorage";

package/src/migrations/add_custom_run_config_column.ts

@@ -9,7 +9,7 @@ import { Migration } from "./migration";
  * Migration: Add custom_run_config column
  */
 export const addCustomRunConfigColumn: Migration = {
-  version: 102,
+  version: 114,
   name: "add_custom_run_config_column",
   up: async (client: PoolClient) => {
     await client.query(`

package/src/migrations/assistant_pk_migration.ts

@@ -10,7 +10,7 @@ import { Migration } from "./migration";
  * Migration: Change primary key to support multi-tenancy
  */
 export const changeAssistantPrimaryKey: Migration = {
-  version: 15,
+  version: 112,
   name: "change_assistant_primary_key",
   up: async (client: PoolClient) => {
     // Check if table exists and has the old primary key structure

package/src/migrations/database_config_migrations.ts

@@ -9,7 +9,7 @@ import { Migration } from './migration';
  * Initial migration: Create database configs table
  */
 export const createDatabaseConfigsTable: Migration = {
-  version: 4,
+  version: 111,
   name: 'create_database_configs_table',
   up: async (client: PoolClient) => {
     await client.query(`

package/src/migrations/thread_tenant_migration.ts

@@ -10,7 +10,7 @@ import { Migration } from "./migration";
  * Migration: Add tenant_id column to threads table
  */
 export const addThreadTenantId: Migration = {
-  version: 15,
+  version: 23,
   name: "add_thread_tenant_id",
   up: async (client: PoolClient) => {
     // Add tenant_id column

package/src/migrations/user_status_migration.ts

@@ -18,7 +18,7 @@ export const addUserStatusColumn: Migration = {
     // Create index on status for filtering
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_lattice_users_status 
-      ON lattice_users(tenant_id, status)
+      ON lattice_users(status)
     `);
     
     // Migrate existing users to active status

package/src/stores/PostgreSQLEvalStore.ts

@@ -700,7 +700,7 @@ export class PostgreSQLEvalStore implements EvalStore {
   async deleteRun(tenantId: string, id: string): Promise<boolean> {
     await this.ensureInitialized();
     // Delete results first, then the run
-    await this.pool.query(`DELETE FROM lattice_eval_run_results WHERE run_id = $1 AND tenant_id = $2`, [id, tenantId]);
+    await this.pool.query(`DELETE FROM lattice_eval_run_results WHERE run_id = $1 AND run_id IN (SELECT id FROM lattice_eval_runs WHERE tenant_id = $2)`, [id, tenantId]);
     const { rowCount } = await this.pool.query(
       `DELETE FROM lattice_eval_runs WHERE id = $1 AND tenant_id = $2`, [id, tenantId]
     );

package/src/stores/PostgreSQLSkillStore.ts

@@ -201,7 +201,7 @@ export class PostgreSQLSkillStore implements SkillStore {
       `
       INSERT INTO lattice_skills (id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at)
       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
-      ON CONFLICT (id) DO UPDATE SET
+      ON CONFLICT (tenant_id, id) DO UPDATE SET
         tenant_id = EXCLUDED.tenant_id,
         name = EXCLUDED.name,
         description = EXCLUDED.description,

package/src/stores/ThreadMessageQueueStore.ts

@@ -4,7 +4,7 @@
  * Provides PostgreSQL storage for thread message queues
  */
 
-import { Pool, PoolClient } from "pg";
+import { Pool, type PoolConfig } from "pg";
 import crypto from "crypto";
 import type {
   IMessageQueueStore,
@@ -20,55 +20,69 @@ import { alterMessageQueueIdColumn } from "../migrations/alter_message_queue_id_
 
 export type { PendingMessage, AddMessageParams, ThreadInfo };
 
+export interface PostgreSQLThreadMessageQueueStoreOptions {
+  poolConfig: string | PoolConfig;
+  autoMigrate?: boolean;
+}
+
 export class ThreadMessageQueueStore implements IMessageQueueStore {
-  private static _instance: ThreadMessageQueueStore;
-  private pool: Pool | null = null;
+  private pool: Pool;
+  private ownsPool: boolean = true;
   private initialized: boolean = false;
+  private initPromise: Promise<void> | null = null;
+  private migrationManager: MigrationManager;
+
+  constructor(options: PostgreSQLThreadMessageQueueStoreOptions) {
+    // Create Pool from config
+    if (typeof options.poolConfig === "string") {
+      this.pool = new Pool({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new Pool(options.poolConfig);
+    }
 
-  public static getInstance(): ThreadMessageQueueStore {
-    if (!ThreadMessageQueueStore._instance) {
-      ThreadMessageQueueStore._instance = new ThreadMessageQueueStore();
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createThreadMessageQueueTable);
+    this.migrationManager.register(addPriorityAndCommandColumns);
+    this.migrationManager.register(addCustomRunConfigColumn);
+    this.migrationManager.register(alterMessageQueueIdColumn);
+
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize ThreadMessageQueueStore:", error);
+        throw error;
+      });
     }
-    return ThreadMessageQueueStore._instance;
   }
 
-  private constructor() {}
-
-  /**
-   * Initialize with PostgreSQL pool
-   * @param pool - PostgreSQL connection pool
-   * @param autoMigrate - Whether to run migrations automatically (default: true)
-   */
-  async initialize(pool: Pool, autoMigrate: boolean = true): Promise<void> {
-    this.pool = pool;
-
-    if (autoMigrate && !this.initialized) {
-      const migrationManager = new MigrationManager(pool);
-      migrationManager.register(createThreadMessageQueueTable);
-      migrationManager.register(addPriorityAndCommandColumns);
-      migrationManager.register(addCustomRunConfigColumn);
-      migrationManager.register(alterMessageQueueIdColumn);
-      await migrationManager.migrate();
-      this.initialized = true;
-    }
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
   }
 
-  private getPool(): Pool {
-    if (!this.pool) {
-      throw new Error("ThreadMessageQueueStore not initialized. Call initialize() first.");
+  async dispose(): Promise<void> {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
     }
-    return this.pool;
   }
 
   /**
    * Add message to queue
    */
   async addMessage(params: AddMessageParams): Promise<PendingMessage> {
-    const pool = this.getPool();
     const { threadId, tenantId, assistantId, content, type = "human", priority = 0, command, custom_run_config, id } = params;
 
     // Get current max sequence (no lock needed without unique constraint)
-    const seqResult = await pool.query(
+    const seqResult = await this.pool.query(
       `SELECT COALESCE(MAX(sequence_order), 0) + 1 as next_seq
        FROM lattice_thread_message_queue 
        WHERE thread_id = $1`,
@@ -76,7 +90,7 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
     );
     const nextSeq = seqResult.rows[0].next_seq;
 
-    const result = await pool.query(
+    const result = await this.pool.query(
       `INSERT INTO lattice_thread_message_queue 
        (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config)
        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
@@ -92,16 +106,13 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    * Uses priority=100 to ensure message is processed first
    */
   async addMessageAtHead(params: AddMessageParams): Promise<PendingMessage> {
-    const pool = this.getPool();
     const { threadId, tenantId, assistantId, content, type = "human", command, custom_run_config, id } = params;
 
-    // Use provided tenantId and assistantId directly
-    // These should always be provided by the caller (Agent)
     const resolvedTenantId = tenantId!;
     const resolvedAssistantId = assistantId!;
 
     // Get current max sequence for ordering within same priority
-    const seqResult = await pool.query(
+    const seqResult = await this.pool.query(
       `SELECT COALESCE(MAX(sequence_order), 0) + 1 as next_seq
        FROM lattice_thread_message_queue 
        WHERE thread_id = $1`,
@@ -110,7 +121,7 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
     const nextSeq = seqResult.rows[0].next_seq;
 
     // Insert with high priority (100)
-    const result = await pool.query(
+    const result = await this.pool.query(
       `INSERT INTO lattice_thread_message_queue 
        (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config)
        VALUES ($1, $2, $3, $4, $5, $6, $7, 100, $8, $9)
@@ -125,8 +136,7 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    * Get pending messages for thread
    */
   async getPendingMessages(threadId: string): Promise<PendingMessage[]> {
-    const pool = this.getPool();
-    const result = await pool.query(
+    const result = await this.pool.query(
       `SELECT * FROM lattice_thread_message_queue 
        WHERE thread_id = $1 AND status = 'pending'
        ORDER BY priority DESC, sequence_order ASC`,
@@ -140,8 +150,7 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    * Get processing messages for a thread
    */
   async getProcessingMessages(threadId: string): Promise<PendingMessage[]> {
-    const pool = this.getPool();
-    const result = await pool.query(
+    const result = await this.pool.query(
       `SELECT * FROM lattice_thread_message_queue 
        WHERE thread_id = $1 AND status = 'processing'
        ORDER BY priority DESC, sequence_order ASC`,
@@ -155,8 +164,7 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    * Get queue size
    */
   async getQueueSize(threadId: string): Promise<number> {
-    const pool = this.getPool();
-    const result = await pool.query(
+    const result = await this.pool.query(
       `SELECT COUNT(*) as count FROM lattice_thread_message_queue 
        WHERE thread_id = $1 AND status = 'pending'`,
       [threadId]
@@ -169,8 +177,7 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    * Get all threads with pending or processing messages
    */
   async getThreadsWithPendingMessages(): Promise<ThreadInfo[]> {
-    const pool = this.getPool();
-    const result = await pool.query(
+    const result = await this.pool.query(
       `SELECT DISTINCT tenant_id, assistant_id, thread_id 
        FROM lattice_thread_message_queue 
        WHERE status IN ('pending', 'processing')
@@ -188,8 +195,7 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    * Remove message
    */
   async removeMessage(messageId: string): Promise<boolean> {
-    const pool = this.getPool();
-    const result = await pool.query(
+    const result = await this.pool.query(
       `DELETE FROM lattice_thread_message_queue WHERE id = $1 RETURNING id`,
       [messageId]
     );
@@ -201,8 +207,7 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    * Clear all messages for thread
    */
   async clearMessages(threadId: string): Promise<void> {
-    const pool = this.getPool();
-    await pool.query(
+    await this.pool.query(
       `DELETE FROM lattice_thread_message_queue WHERE thread_id = $1`,
       [threadId]
     );
@@ -212,43 +217,18 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    * Mark message as processing
    */
   async markProcessing(messageId: string): Promise<void> {
-    const pool = this.getPool();
-    await pool.query(
+    await this.pool.query(
       `UPDATE lattice_thread_message_queue SET status = 'processing' WHERE id = $1`,
       [messageId]
     );
   }
 
-  /**
-   * Mark message as completed
-   */
-  async markCompleted(messageId: string): Promise<void> {
-    const pool = this.getPool();
-    await pool.query(
-      `UPDATE lattice_thread_message_queue SET status = 'completed' WHERE id = $1`,
-      [messageId]
-    );
-  }
-
-  /**
-   * Clear completed messages for thread
-   */
-  async clearCompletedMessages(threadId: string): Promise<void> {
-    const pool = this.getPool();
-    await pool.query(
-      `DELETE FROM lattice_thread_message_queue 
-       WHERE thread_id = $1 AND status = 'completed'`,
-      [threadId]
-    );
-  }
-
   /**
    * Reset all processing messages to pending state for a thread
    * Returns the number of messages reset
    */
   async resetProcessingToPending(threadId: string): Promise<number> {
-    const pool = this.getPool();
-    const result = await pool.query(
+    const result = await this.pool.query(
       `UPDATE lattice_thread_message_queue 
        SET status = 'pending'
        WHERE thread_id = $1 AND status = 'processing'
@@ -275,5 +255,3 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
     };
   }
 }
-
-export const getThreadMessageQueueStore = () => ThreadMessageQueueStore.getInstance();