@axiom-lattice/pg-stores 1.0.37 → 1.0.39

package/dist/index.js

@@ -31,11 +31,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AddMessageParams: () => import_core4.AddMessageParams,
+  ChannelIdentityMappingStore: () => ChannelIdentityMappingStore,
   MigrationManager: () => MigrationManager,
   PendingMessage: () => import_core4.PendingMessage,
-  Pool: () => import_pg13.Pool,
-  PoolConfig: () => import_pg13.PoolConfig,
+  Pool: () => import_pg15.Pool,
+  PoolConfig: () => import_pg15.PoolConfig,
   PostgreSQLAssistantStore: () => PostgreSQLAssistantStore,
+  PostgreSQLChannelInstallationStore: () => PostgreSQLChannelInstallationStore,
   PostgreSQLDatabaseConfigStore: () => PostgreSQLDatabaseConfigStore,
   PostgreSQLMcpServerConfigStore: () => PostgreSQLMcpServerConfigStore,
   PostgreSQLMetricsServerConfigStore: () => PostgreSQLMetricsServerConfigStore,
@@ -57,6 +59,8 @@ __export(index_exports, {
   changeSkillPrimaryKey: () => changeSkillPrimaryKey,
   changeThreadPrimaryKey: () => changeThreadPrimaryKey,
   createAssistantsTable: () => createAssistantsTable,
+  createChannelIdentityMappingTables: () => createChannelIdentityMappingTables,
+  createChannelInstallationsTable: () => createChannelInstallationsTable,
   createDatabaseConfigsTable: () => createDatabaseConfigsTable,
   createMcpServerConfigsTable: () => createMcpServerConfigsTable,
   createMetricsConfigsTable: () => createMetricsConfigsTable,
@@ -71,7 +75,7 @@ __export(index_exports, {
   getThreadMessageQueueStore: () => getThreadMessageQueueStore
 });
 module.exports = __toCommonJS(index_exports);
-var import_pg13 = require("pg");
+var import_pg15 = require("pg");
 
 // src/stores/PostgreSQLThreadStore.ts
 var import_pg = require("pg");
@@ -4084,6 +4088,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
 var import_crypto = __toESM(require("crypto"));
 var import_core4 = require("@axiom-lattice/core");
@@ -4373,14 +4461,423 @@ var ThreadMessageQueueStore = class _ThreadMessageQueueStore {
   }
 };
 var getThreadMessageQueueStore = () => ThreadMessageQueueStore.getInstance();
+
+// src/stores/ChannelIdentityMappingStore.ts
+var import_pg13 = require("pg");
+var ChannelIdentityMappingStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.initPromise = null;
+    this.pool = typeof options.poolConfig === "string" ? new import_pg13.Pool({ connectionString: options.poolConfig }) : new import_pg13.Pool(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
+var import_pg14 = require("pg");
+var import_core5 = require("@axiom-lattice/core");
+var PostgreSQLChannelInstallationStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.initPromise = null;
+    this.pool = typeof options.poolConfig === "string" ? new import_pg14.Pool({ connectionString: options.poolConfig }) : new import_pg14.Pool(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" ? (0, import_core5.encrypt)(config.appSecret) : config.appSecret,
+      verificationToken: typeof config.verificationToken === "string" ? (0, import_core5.encrypt)(config.verificationToken) : config.verificationToken,
+      encryptKey: typeof config.encryptKey === "string" ? (0, import_core5.encrypt)(config.encryptKey) : config.encryptKey
+    };
+  }
+  decryptSecrets(config) {
+    return {
+      appId: String(config.appId || ""),
+      appSecret: typeof config.appSecret === "string" ? (0, import_core5.decrypt)(config.appSecret) : "",
+      verificationToken: typeof config.verificationToken === "string" ? (0, import_core5.decrypt)(config.verificationToken) : void 0,
+      encryptKey: typeof config.encryptKey === "string" ? (0, import_core5.decrypt)(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
+    };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AddMessageParams,
+  ChannelIdentityMappingStore,
   MigrationManager,
   PendingMessage,
   Pool,
   PoolConfig,
   PostgreSQLAssistantStore,
+  PostgreSQLChannelInstallationStore,
   PostgreSQLDatabaseConfigStore,
   PostgreSQLMcpServerConfigStore,
   PostgreSQLMetricsServerConfigStore,
@@ -4402,6 +4899,8 @@ var getThreadMessageQueueStore = () => ThreadMessageQueueStore.getInstance();
   changeSkillPrimaryKey,
   changeThreadPrimaryKey,
   createAssistantsTable,
+  createChannelIdentityMappingTables,
+  createChannelInstallationsTable,
   createDatabaseConfigsTable,
   createMcpServerConfigsTable,
   createMetricsConfigsTable,