@axiom-lattice/pg-stores 1.0.37 → 1.0.39

package/src/stores/ChannelIdentityMappingStore.ts

@@ -0,0 +1,334 @@
+import { Pool, PoolConfig } from "pg";
+import { MigrationManager } from "../migrations/migration";
+import { createChannelIdentityMappingTables } from "../migrations/channel_identity_mapping_migration";
+
+export interface ChannelIdentityMappingStoreOptions {
+  poolConfig: string | PoolConfig;
+  autoMigrate?: boolean;
+}
+
+export interface CreateChannelIdentityMappingInput {
+  channel: string;
+  channelAppId: string;
+  tenantId: string;
+  assistantId: string;
+  mappingMode: "user" | "group" | "hybrid";
+  externalSubjectType: "user" | "chat";
+  externalSubjectKey: string;
+  larkOpenId?: string;
+  larkChatId: string;
+  larkMessageId?: string;
+  threadId: string;
+}
+
+interface ChannelIdentityMappingRow {
+  id: string;
+  channel: string;
+  channel_app_id: string;
+  tenant_id: string;
+  assistant_id: string;
+  mapping_mode: "user" | "group" | "hybrid";
+  external_subject_type: "user" | "chat";
+  external_subject_key: string;
+  lark_open_id: string | null;
+  lark_chat_id: string;
+  lark_message_id: string | null;
+  thread_id: string;
+  created_at: Date;
+  updated_at: Date;
+  last_activity_at: Date;
+}
+
+export interface ChannelIdentityMapping {
+  id: string;
+  channel: string;
+  channelAppId: string;
+  tenantId: string;
+  assistantId: string;
+  mappingMode: "user" | "group" | "hybrid";
+  externalSubjectType: "user" | "chat";
+  externalSubjectKey: string;
+  larkOpenId?: string;
+  larkChatId: string;
+  larkMessageId?: string;
+  threadId: string;
+  createdAt: Date;
+  updatedAt: Date;
+  lastActivityAt: Date;
+}
+
+export class ChannelIdentityMappingStore {
+  private pool: Pool;
+  private migrationManager: MigrationManager;
+  private initialized = false;
+  private initPromise: Promise<void> | null = null;
+
+  constructor(options: ChannelIdentityMappingStoreOptions) {
+    this.pool =
+      typeof options.poolConfig === "string"
+        ? new Pool({ connectionString: options.poolConfig })
+        : new 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(): 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;
+  }
+
+  async createMapping(
+    input: CreateChannelIdentityMappingInput,
+  ): Promise<ChannelIdentityMapping> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<ChannelIdentityMappingRow>(
+      `
+      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: {
+    channel: string;
+    channelAppId: string;
+    tenantId: string;
+    assistantId: string;
+    externalSubjectKey: string;
+  }): Promise<ChannelIdentityMapping | null> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<ChannelIdentityMappingRow>(
+      `
+      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: {
+    channel: string;
+    channelAppId: string;
+    externalMessageId: string;
+    tenantId: string;
+  }): Promise<{ accepted: boolean; status: "processing" | "completed" }> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      source: "inserted" | "existing" | "retried";
+      status: "processing" | "completed" | "failed";
+    }>(
+      `
+      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: {
+    channel: string;
+    channelAppId: string;
+    externalMessageId: string;
+    tenantId: string;
+    threadId: string;
+  }): Promise<void> {
+    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: {
+    channel: string;
+    channelAppId: string;
+    externalMessageId: string;
+    tenantId: string;
+  }): Promise<void> {
+    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,
+      ],
+    );
+  }
+
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+}
+
+function mapRowToChannelIdentityMapping(
+  row: ChannelIdentityMappingRow,
+): ChannelIdentityMapping {
+  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 || undefined,
+    larkChatId: row.lark_chat_id,
+    larkMessageId: row.lark_message_id || undefined,
+    threadId: row.thread_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    lastActivityAt: row.last_activity_at,
+  };
+}

package/src/stores/PostgreSQLChannelInstallationStore.ts

@@ -0,0 +1,304 @@
+import { Pool, PoolConfig } from "pg";
+import {
+  ChannelInstallation,
+  ChannelInstallationStore,
+  CreateChannelInstallationRequest,
+  LarkChannelInstallationConfig,
+  UpdateChannelInstallationRequest,
+} from "@axiom-lattice/protocols";
+import { MigrationManager } from "../migrations/migration";
+import { createChannelInstallationsTable } from "../migrations/channel_installation_migrations";
+import { decrypt, encrypt } from "@axiom-lattice/core";
+
+export interface PostgreSQLChannelInstallationStoreOptions {
+  poolConfig: string | PoolConfig;
+  autoMigrate?: boolean;
+}
+
+type ChannelInstallationRow = {
+  id: string;
+  tenant_id: string;
+  channel: "lark";
+  name: string | null;
+  config: Record<string, unknown>;
+  created_at: Date;
+  updated_at: Date;
+};
+
+export class PostgreSQLChannelInstallationStore
+  implements ChannelInstallationStore
+{
+  private pool: Pool;
+  private migrationManager: MigrationManager;
+  private initialized = false;
+  private initPromise: Promise<void> | null = null;
+
+  constructor(options: PostgreSQLChannelInstallationStoreOptions) {
+    this.pool =
+      typeof options.poolConfig === "string"
+        ? new Pool({ connectionString: options.poolConfig })
+        : new 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(): 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;
+  }
+
+  async getInstallationById(
+    installationId: string,
+  ): Promise<ChannelInstallation | null> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<ChannelInstallationRow>(
+      `
+      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: string,
+    channel?: "lark",
+  ): Promise<ChannelInstallation[]> {
+    await this.ensureInitialized();
+
+    const result = channel
+      ? await this.pool.query<ChannelInstallationRow>(
+          `
+          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<ChannelInstallationRow>(
+          `
+          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: string,
+    installationId: string,
+    data: CreateChannelInstallationRequest,
+  ): Promise<ChannelInstallation> {
+    await this.ensureInitialized();
+
+    const now = 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: string,
+    installationId: string,
+    updates: UpdateChannelInstallationRequest,
+  ): Promise<ChannelInstallation | null> {
+    await this.ensureInitialized();
+
+    const existing = await this.getInstallationById(installationId);
+    if (!existing || existing.tenantId !== tenantId) {
+      return null;
+    }
+
+    const mergedConfig = {
+      ...existing.config,
+      ...(updates.config || {}),
+    };
+    const now = 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: string,
+    installationId: string,
+  ): Promise<boolean> {
+    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;
+  }
+
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+
+  private mapRowToInstallation(
+    row: ChannelInstallationRow,
+  ): ChannelInstallation {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      channel: row.channel,
+      name: row.name || undefined,
+      config: this.decryptSecrets(
+        typeof row.config === "string"
+          ? JSON.parse(row.config)
+          : row.config,
+      ),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  private encryptSecrets(
+    config: LarkChannelInstallationConfig,
+  ): Record<string, unknown> {
+    return {
+      ...config,
+      appSecret:
+        typeof config.appSecret === "string"
+          ? encrypt(config.appSecret)
+          : config.appSecret,
+      verificationToken:
+        typeof config.verificationToken === "string"
+          ? encrypt(config.verificationToken)
+          : config.verificationToken,
+      encryptKey:
+        typeof config.encryptKey === "string"
+          ? encrypt(config.encryptKey)
+          : config.encryptKey,
+    };
+  }
+
+  private decryptSecrets(
+    config: Record<string, unknown>,
+  ): LarkChannelInstallationConfig {
+    return {
+      appId: String(config.appId || ""),
+      appSecret:
+        typeof config.appSecret === "string"
+          ? decrypt(config.appSecret)
+          : "",
+      verificationToken:
+        typeof config.verificationToken === "string"
+          ? decrypt(config.verificationToken)
+          : undefined,
+      encryptKey:
+        typeof config.encryptKey === "string"
+          ? decrypt(config.encryptKey)
+          : undefined,
+      mappingMode:
+        config.mappingMode === "user" ||
+        config.mappingMode === "group" ||
+        config.mappingMode === "hybrid"
+          ? config.mappingMode
+          : "hybrid",
+      assistantId: String(config.assistantId || ""),
+      workspaceId:
+        typeof config.workspaceId === "string"
+          ? config.workspaceId
+          : undefined,
+      projectId:
+        typeof config.projectId === "string"
+          ? config.projectId
+          : undefined,
+    };
+  }
+}