@axiom-lattice/pg-stores 1.0.37 → 1.0.39

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/index.ts
-import { Pool as Pool13, PoolConfig as PoolConfig13 } from "pg";
+import { Pool as Pool15, PoolConfig as PoolConfig15 } from "pg";
 
 // src/stores/PostgreSQLThreadStore.ts
 import { Pool } from "pg";
@@ -4014,6 +4014,90 @@ var createThreadMessageQueueTable = {
   }
 };
 
+// src/migrations/channel_identity_mapping_migration.ts
+var createChannelIdentityMappingTables = {
+  version: 20,
+  name: "create_channel_identity_mapping_tables",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS channel_identity_mappings (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        channel VARCHAR(50) NOT NULL,
+        channel_app_id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        assistant_id VARCHAR(255) NOT NULL,
+        mapping_mode VARCHAR(20) NOT NULL CHECK (mapping_mode IN ('user', 'group', 'hybrid')),
+        external_subject_type VARCHAR(20) NOT NULL CHECK (external_subject_type IN ('user', 'chat')),
+        external_subject_key VARCHAR(512) NOT NULL,
+        lark_open_id VARCHAR(255),
+        lark_chat_id VARCHAR(255) NOT NULL,
+        lark_message_id VARCHAR(255),
+        thread_id VARCHAR(255) NOT NULL,
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        last_activity_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE (channel, channel_app_id, tenant_id, assistant_id, external_subject_key)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_channel_identity_lookup
+      ON channel_identity_mappings(channel, channel_app_id, tenant_id, assistant_id, external_subject_key)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_channel_identity_thread
+      ON channel_identity_mappings(thread_id, tenant_id)
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS channel_inbound_message_receipts (
+        channel VARCHAR(50) NOT NULL,
+        channel_app_id VARCHAR(255) NOT NULL,
+        external_message_id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        status VARCHAR(20) NOT NULL DEFAULT 'processing' CHECK (status IN ('processing', 'completed', 'failed')),
+        thread_id VARCHAR(255),
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (channel, channel_app_id, external_message_id)
+      )
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP TABLE IF EXISTS channel_inbound_message_receipts");
+    await client.query("DROP INDEX IF EXISTS idx_channel_identity_thread");
+    await client.query("DROP INDEX IF EXISTS idx_channel_identity_lookup");
+    await client.query("DROP TABLE IF EXISTS channel_identity_mappings");
+  }
+};
+
+// src/migrations/channel_installation_migrations.ts
+var createChannelInstallationsTable = {
+  version: 21,
+  name: "create_channel_installations_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_channel_installations (
+        id UUID PRIMARY KEY,
+        tenant_id VARCHAR(255) NOT NULL,
+        channel VARCHAR(50) NOT NULL,
+        name VARCHAR(255),
+        config JSONB NOT NULL,
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_channel_installations_tenant_channel
+      ON lattice_channel_installations(tenant_id, channel)
+    `);
+  },
+  down: async (client) => {
+    await client.query(
+      "DROP INDEX IF EXISTS idx_channel_installations_tenant_channel"
+    );
+    await client.query("DROP TABLE IF EXISTS lattice_channel_installations");
+  }
+};
+
 // src/stores/ThreadMessageQueueStore.ts
 import crypto from "crypto";
 import {
@@ -4307,13 +4391,422 @@ var ThreadMessageQueueStore = class _ThreadMessageQueueStore {
   }
 };
 var getThreadMessageQueueStore = () => ThreadMessageQueueStore.getInstance();
+
+// src/stores/ChannelIdentityMappingStore.ts
+import { Pool as Pool13 } from "pg";
+var ChannelIdentityMappingStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.initPromise = null;
+    this.pool = typeof options.poolConfig === "string" ? new Pool13({ connectionString: options.poolConfig }) : new Pool13(options.poolConfig);
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createChannelIdentityMappingTables);
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize ChannelIdentityMappingStore:", error);
+        throw error;
+      });
+    }
+  }
+  async initialize() {
+    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;
+  }
+  async createMapping(input) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      INSERT INTO channel_identity_mappings (
+        channel,
+        channel_app_id,
+        tenant_id,
+        assistant_id,
+        mapping_mode,
+        external_subject_type,
+        external_subject_key,
+        lark_open_id,
+        lark_chat_id,
+        lark_message_id,
+        thread_id
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+      RETURNING *
+      `,
+      [
+        input.channel,
+        input.channelAppId,
+        input.tenantId,
+        input.assistantId,
+        input.mappingMode,
+        input.externalSubjectType,
+        input.externalSubjectKey,
+        input.larkOpenId || null,
+        input.larkChatId,
+        input.larkMessageId || null,
+        input.threadId
+      ]
+    );
+    return mapRowToChannelIdentityMapping(result.rows[0]);
+  }
+  async getMappingBySubject(input) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT *
+      FROM channel_identity_mappings
+      WHERE channel = $1
+        AND channel_app_id = $2
+        AND tenant_id = $3
+        AND assistant_id = $4
+        AND external_subject_key = $5
+      LIMIT 1
+      `,
+      [
+        input.channel,
+        input.channelAppId,
+        input.tenantId,
+        input.assistantId,
+        input.externalSubjectKey
+      ]
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    return mapRowToChannelIdentityMapping(result.rows[0]);
+  }
+  async claimInboundReceipt(input) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      WITH existing AS (
+        SELECT status
+        FROM channel_inbound_message_receipts
+        WHERE channel = $1
+          AND channel_app_id = $2
+          AND external_message_id = $3
+          AND tenant_id = $4
+      ),
+      inserted AS (
+        INSERT INTO channel_inbound_message_receipts (
+          channel,
+          channel_app_id,
+          external_message_id,
+          tenant_id,
+          status
+        )
+        SELECT $1, $2, $3, $4, 'processing'
+        WHERE NOT EXISTS (SELECT 1 FROM existing)
+        RETURNING 'inserted'::text AS source, status
+      ),
+      retried AS (
+        UPDATE channel_inbound_message_receipts
+        SET status = 'processing', updated_at = CURRENT_TIMESTAMP
+        WHERE channel = $1
+          AND channel_app_id = $2
+          AND external_message_id = $3
+          AND tenant_id = $4
+          AND EXISTS (SELECT 1 FROM existing WHERE status = 'failed')
+        RETURNING 'retried'::text AS source, status
+      )
+      SELECT source, status FROM inserted
+      UNION ALL
+      SELECT source, status FROM retried
+      UNION ALL
+      SELECT 'existing'::text AS source, status FROM existing
+      WHERE EXISTS (SELECT 1 FROM existing WHERE status IN ('processing', 'completed'))
+      LIMIT 1
+      `,
+      [
+        input.channel,
+        input.channelAppId,
+        input.externalMessageId,
+        input.tenantId
+      ]
+    );
+    const source = result.rows[0]?.source;
+    const status = result.rows[0]?.status || "processing";
+    if (source === "inserted" || source === "retried") {
+      return { accepted: true, status: "processing" };
+    }
+    if (status === "completed") {
+      return { accepted: false, status: "completed" };
+    }
+    return { accepted: false, status: "processing" };
+  }
+  async markInboundReceiptCompleted(input) {
+    await this.ensureInitialized();
+    await this.pool.query(
+      `
+      UPDATE channel_inbound_message_receipts
+      SET status = 'completed', thread_id = $1, updated_at = CURRENT_TIMESTAMP
+      WHERE channel = $2
+        AND channel_app_id = $3
+        AND external_message_id = $4
+        AND tenant_id = $5
+      `,
+      [
+        input.threadId,
+        input.channel,
+        input.channelAppId,
+        input.externalMessageId,
+        input.tenantId
+      ]
+    );
+  }
+  async markInboundReceiptFailed(input) {
+    await this.ensureInitialized();
+    await this.pool.query(
+      `
+      UPDATE channel_inbound_message_receipts
+      SET status = 'failed', updated_at = CURRENT_TIMESTAMP
+      WHERE channel = $1
+        AND channel_app_id = $2
+        AND external_message_id = $3
+        AND tenant_id = $4
+      `,
+      [
+        input.channel,
+        input.channelAppId,
+        input.externalMessageId,
+        input.tenantId
+      ]
+    );
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+};
+function mapRowToChannelIdentityMapping(row) {
+  return {
+    id: row.id,
+    channel: row.channel,
+    channelAppId: row.channel_app_id,
+    tenantId: row.tenant_id,
+    assistantId: row.assistant_id,
+    mappingMode: row.mapping_mode,
+    externalSubjectType: row.external_subject_type,
+    externalSubjectKey: row.external_subject_key,
+    larkOpenId: row.lark_open_id || void 0,
+    larkChatId: row.lark_chat_id,
+    larkMessageId: row.lark_message_id || void 0,
+    threadId: row.thread_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    lastActivityAt: row.last_activity_at
+  };
+}
+
+// src/stores/PostgreSQLChannelInstallationStore.ts
+import { Pool as Pool14 } from "pg";
+import { decrypt as decrypt4, encrypt as encrypt4 } from "@axiom-lattice/core";
+var PostgreSQLChannelInstallationStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.initPromise = null;
+    this.pool = typeof options.poolConfig === "string" ? new Pool14({ connectionString: options.poolConfig }) : new Pool14(options.poolConfig);
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createChannelInstallationsTable);
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error(
+          "Failed to initialize PostgreSQLChannelInstallationStore:",
+          error
+        );
+        throw error;
+      });
+    }
+  }
+  async initialize() {
+    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;
+  }
+  async getInstallationById(installationId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, channel, name, config, created_at, updated_at
+      FROM lattice_channel_installations
+      WHERE id = $1
+      LIMIT 1
+      `,
+      [installationId]
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    return this.mapRowToInstallation(result.rows[0]);
+  }
+  async getInstallationsByTenant(tenantId, channel) {
+    await this.ensureInitialized();
+    const result = channel ? await this.pool.query(
+      `
+          SELECT id, tenant_id, channel, name, config, created_at, updated_at
+          FROM lattice_channel_installations
+          WHERE tenant_id = $1 AND channel = $2
+          ORDER BY created_at DESC
+          `,
+      [tenantId, channel]
+    ) : await this.pool.query(
+      `
+          SELECT id, tenant_id, channel, name, config, created_at, updated_at
+          FROM lattice_channel_installations
+          WHERE tenant_id = $1
+          ORDER BY created_at DESC
+          `,
+      [tenantId]
+    );
+    return result.rows.map((row) => this.mapRowToInstallation(row));
+  }
+  async createInstallation(tenantId, installationId, data) {
+    await this.ensureInitialized();
+    const now = /* @__PURE__ */ new Date();
+    const encryptedConfig = this.encryptSecrets(data.config);
+    await this.pool.query(
+      `
+      INSERT INTO lattice_channel_installations (
+        id, tenant_id, channel, name, config, created_at, updated_at
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7)
+      `,
+      [
+        installationId,
+        tenantId,
+        data.channel,
+        data.name || null,
+        JSON.stringify(encryptedConfig),
+        now,
+        now
+      ]
+    );
+    return {
+      id: installationId,
+      tenantId,
+      channel: data.channel,
+      name: data.name,
+      config: data.config,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  async updateInstallation(tenantId, installationId, updates) {
+    await this.ensureInitialized();
+    const existing = await this.getInstallationById(installationId);
+    if (!existing || existing.tenantId !== tenantId) {
+      return null;
+    }
+    const mergedConfig = {
+      ...existing.config,
+      ...updates.config || {}
+    };
+    const now = /* @__PURE__ */ new Date();
+    await this.pool.query(
+      `
+      UPDATE lattice_channel_installations
+      SET name = $1,
+          config = $2,
+          updated_at = $3
+      WHERE tenant_id = $4 AND id = $5
+      `,
+      [
+        updates.name ?? existing.name ?? null,
+        JSON.stringify(this.encryptSecrets(mergedConfig)),
+        now,
+        tenantId,
+        installationId
+      ]
+    );
+    return {
+      ...existing,
+      name: updates.name ?? existing.name,
+      config: mergedConfig,
+      updatedAt: now
+    };
+  }
+  async deleteInstallation(tenantId, installationId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_channel_installations
+      WHERE tenant_id = $1 AND id = $2
+      `,
+      [tenantId, installationId]
+    );
+    return (result.rowCount || 0) > 0;
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  mapRowToInstallation(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      channel: row.channel,
+      name: row.name || void 0,
+      config: this.decryptSecrets(
+        typeof row.config === "string" ? JSON.parse(row.config) : row.config
+      ),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  encryptSecrets(config) {
+    return {
+      ...config,
+      appSecret: typeof config.appSecret === "string" ? encrypt4(config.appSecret) : config.appSecret,
+      verificationToken: typeof config.verificationToken === "string" ? encrypt4(config.verificationToken) : config.verificationToken,
+      encryptKey: typeof config.encryptKey === "string" ? encrypt4(config.encryptKey) : config.encryptKey
+    };
+  }
+  decryptSecrets(config) {
+    return {
+      appId: String(config.appId || ""),
+      appSecret: typeof config.appSecret === "string" ? decrypt4(config.appSecret) : "",
+      verificationToken: typeof config.verificationToken === "string" ? decrypt4(config.verificationToken) : void 0,
+      encryptKey: typeof config.encryptKey === "string" ? decrypt4(config.encryptKey) : void 0,
+      mappingMode: config.mappingMode === "user" || config.mappingMode === "group" || config.mappingMode === "hybrid" ? config.mappingMode : "hybrid",
+      assistantId: String(config.assistantId || ""),
+      workspaceId: typeof config.workspaceId === "string" ? config.workspaceId : void 0,
+      projectId: typeof config.projectId === "string" ? config.projectId : void 0
+    };
+  }
+};
 export {
   AddMessageParams,
+  ChannelIdentityMappingStore,
   MigrationManager,
   PendingMessage,
-  Pool13 as Pool,
-  PoolConfig13 as PoolConfig,
+  Pool15 as Pool,
+  PoolConfig15 as PoolConfig,
   PostgreSQLAssistantStore,
+  PostgreSQLChannelInstallationStore,
   PostgreSQLDatabaseConfigStore,
   PostgreSQLMcpServerConfigStore,
   PostgreSQLMetricsServerConfigStore,
@@ -4335,6 +4828,8 @@ export {
   changeSkillPrimaryKey,
   changeThreadPrimaryKey,
   createAssistantsTable,
+  createChannelIdentityMappingTables,
+  createChannelInstallationsTable,
   createDatabaseConfigsTable,
   createMcpServerConfigsTable,
   createMetricsConfigsTable,