Skip to content

Open-source manufacturing ERP, MES and QMS. Quoting, MRP, inventory, shop floor, quality and lot/serial traceability on one Postgres schema, with a REST API and MCP server. Self-host or use Carbon Cloud.

22.1 KB
Raw Blame
// SPDX-License-Identifier: LicenseRef-Carbon-Commercial
// Carbon Enterprise file, licensed only under the Carbon Commercial License
// (packages/ee/LICENSE). Not AGPL. Running, modifying, or copying it beyond those terms requires a commercial license.

import { getCarbonServiceRole } from "@carbon/auth/client.server";
import type { Database } from "@carbon/database";
import { redis } from "@carbon/kv";
import { trigger } from "@carbon/lib/trigger";
import { getLogger } from "@carbon/logger";
import { isUrl } from "@carbon/utils";
import type { SupabaseClient } from "@supabase/supabase-js";
import type { IntegrationConnection } from "../../integrations/connections";
import {
  readConnectionAccessToken,
  readConnections,
  readConnectionsByTeamId,
  usableConnections
} from "../../integrations/connections";
import { createSlackWebClient } from "./client";

const logger = getLogger("ee", "slack");

export type DocumentType = "nonConformance";

export interface SlackAuth {
  slackToken: string;
  slackUserId?: string;
  channelId: string;
}

export interface SlackDocumentThread {
  id: string;
  companyId: string;
  documentType: DocumentType;
  documentId: string;
  channelId: string;
  threadTs: string;
  createdAt: string;
  createdBy: string;
  updatedAt?: string;
  updatedBy?: string;
}

export async function createIssueSlackThread(
  client: SupabaseClient<Database>,
  data: {
    carbonUrl: string;
    companyId: string;
    description?: string;
    id: string;
    nonConformanceId: string;
    severity: string;
    title: string;
    userId: string;
  },
  slackAuth?: SlackAuth
) {
  try {
    const auth =
      slackAuth ?? (await getSlackAuth(client, data.companyId, data.userId));
    if (!auth) {
      throw new Error("Slack auth not found");
    }

    const slackClient = createSlackWebClient({ token: auth?.slackToken });

    const blocks = [
      {
        type: "header",
        text: {
          type: "plain_text",
          text: `Issue ${data.nonConformanceId}`
        }
      },
      {
        type: "section",
        text: {
          type: "mrkdwn",
          text: `*${data.title}*\n${
            data.description || "_No description provided_"
          }`
        },
        fields: [
          {
            type: "mrkdwn",
            text: `*Status:*\nRegistered`
          },
          {
            type: "mrkdwn",
            text: `*Severity:*\n${data.severity}`
          }
        ]
      },
      {
        type: "context",
        elements: [
          {
            type: "mrkdwn",
            text: `Created by <@${auth.slackUserId}>`
          }
        ]
      },
      ...(data.carbonUrl && isUrl(data.carbonUrl)
        ? [
            {
              type: "actions",
              elements: [
                {
                  type: "button",
                  text: {
                    type: "plain_text",
                    text: "View in Carbon"
                  },
                  url: data.carbonUrl,
                  action_id: "view_in_carbon"
                }
              ]
            }
          ]
        : [])
    ];

    const threadMessage = await slackClient.chat.postMessage({
      channel: auth.channelId,
      unfurl_links: false,
      unfurl_media: false,
      blocks
    });

    if (threadMessage.ts) {
      const threadRecord = await client
        .from("slackDocumentThread")
        .insert({
          documentType: "nonConformance",
          documentId: data.id,
          companyId: data.companyId,
          channelId: auth.channelId,
          threadTs: threadMessage.ts,
          createdBy: data.userId
        })
        .select("*")
        .single();

      if (threadRecord.error) {
        logger.error("Error creating thread record", {
          error: threadRecord.error
        });
      }

      return threadRecord;
    }

    return {
      data: null,
      error: { message: "Failed to post message to Slack" }
    };
  } catch (error) {
    logger.error("Error creating Issue Slack thread", { error });
    return {
      data: null,
      error: {
        message: error instanceof Error ? error.message : "Unknown error"
      }
    };
  }
}

export async function deleteSlackDocumentThread(
  client: SupabaseClient<Database>,
  documentType: DocumentType,
  documentId: string,
  companyId: string
) {
  return client
    .from("slackDocumentThread")
    .delete()
    .eq("documentType", documentType)
    .eq("documentId", documentId)
    .eq("companyId", companyId);
}

export async function getCompanySlackThreads(
  client: SupabaseClient<Database>,
  companyId: string,
  documentType?: DocumentType
) {
  let query = client
    .from("slackDocumentThread")
    .select("*")
    .eq("companyId", companyId);

  if (documentType) {
    query = query.eq("documentType", documentType);
  }

  return query.order("createdAt", { ascending: false });
}

export async function getIssueSlackThread(
  client: SupabaseClient<Database>,
  nonConformanceId: string,
  companyId: string
) {
  return getSlackDocumentThread(
    client,
    "nonConformance",
    nonConformanceId,
    companyId
  );
}

export interface SlackWorkspace {
  connectionId: string;
  companyId: string;
  token: string;
  teamId?: string;
  channelId?: string;
  botUserId?: string;
}

function workspaceFacts(connection: IntegrationConnection) {
  const m = connection.metadata;
  const str = (v: unknown) =>
    typeof v === "string" && v.length > 0 ? v : undefined;
  return {
    teamId: str(m.team_id),
    channelId: str(m.channel_id),
    botUserId: str(m.bot_user_id)
  };
}

/**
 * The Slack workspace the Assistant acts as for a company: the OLDEST Active
 * connection for piece `slack` that carries a webhook channel, falling back to the
 * oldest Active one (`readConnections` orders by createdAt). The channel preference
 * lives HERE so every Assistant surface picks the same workspace — without it, an
 * oldest connection made without the webhook picker hid a later, complete one.
 * Credentials and workspace facts live on the connection alone —
 * `companyIntegration.slack` is only the installed flag. Service-role client
 * required (vault).
 */
export async function getSlackWorkspace(
  serviceRole: SupabaseClient<Database>,
  companyId: string
): Promise<SlackWorkspace | null> {
  const active = usableConnections(
    await readConnections(serviceRole, companyId, "slack")
  );
  const connection =
    active.find((c) => workspaceFacts(c).channelId !== undefined) ?? active[0];
  if (connection === undefined) return null;
  const token = await readConnectionAccessToken(serviceRole, connection);
  return {
    connectionId: connection.id,
    companyId,
    token,
    ...workspaceFacts(connection)
  };
}

/** One Slack app serves every tenant, so two Carbon companies can connect the same
 * workspace. An inbound event cannot be routed then — refusing beats acting in the
 * wrong company. */
export class AmbiguousSlackWorkspaceError extends Error {
  constructor(public readonly teamId: string) {
    super(`Slack workspace ${teamId} is connected to more than one company.`);
    this.name = "AmbiguousSlackWorkspaceError";
  }
}

/** Inbound: a slash command or interaction names its workspace, so match on team_id. */
export async function getSlackWorkspaceByTeamId(
  serviceRole: SupabaseClient<Database>,
  teamId: string
): Promise<SlackWorkspace | null> {
  const rows = usableConnections(
    await readConnectionsByTeamId(serviceRole, "slack", teamId)
  );
  const connection = rows[0];
  if (connection === undefined) return null;
  if (rows.some((row) => row.companyId !== connection.companyId)) {
    throw new AmbiguousSlackWorkspaceError(teamId);
  }
  const token = await readConnectionAccessToken(serviceRole, connection);
  return {
    connectionId: connection.id,
    companyId: connection.companyId,
    token,
    ...workspaceFacts(connection)
  };
}

export async function getSlackAuth(
  client: SupabaseClient<Database>,
  companyId: string,
  userId: string
): Promise<SlackAuth | null> {
  const workspace = await getSlackWorkspace(getCarbonServiceRole(), companyId);
  // A workspace connected without the webhook picker has no channel; the Assistant
  // treats that as not connected, as it did when `channel_id` was missing.
  if (workspace === null || workspace.channelId === undefined) return null;

  const slackUserId = await getSlackUserIdByCarbonId(
    client,
    workspace.token,
    userId
  );

  return {
    slackToken: workspace.token,
    channelId: workspace.channelId,
    slackUserId: slackUserId || undefined
  };
}

export async function getSlackUserIdByCarbonId(
  client: SupabaseClient<Database>,
  accessToken: string,
  userId: string
) {
  const cachedUserId = await redis.get(`slack-user:${userId}`);
  if (cachedUserId && typeof cachedUserId === "string") {
    return cachedUserId;
  }

  const user = await client
    .from("user")
    .select("email")
    .eq("id", userId)
    .single();

  if (user.error || !user.data?.email) {
    return null;
  }

  try {
    const slackClient = createSlackWebClient({ token: accessToken });
    const slackUser = await slackClient.users.lookupByEmail({
      email: user.data.email
    });

    if (slackUser.ok && slackUser.user?.id) {
      await redis.set(`slack-user:${userId}`, slackUser.user.id);
      return slackUser.user.id;
    }
  } catch (error) {
    logger.error("Failed to lookup Slack user by email", { error });
  }
}

export async function getSlackDocumentThread(
  client: SupabaseClient<Database>,
  documentType: DocumentType,
  documentId: string,
  companyId: string
) {
  return client
    .from("slackDocumentThread")
    .select("*")
    .eq("documentType", documentType)
    .eq("documentId", documentId)
    .eq("companyId", companyId)
    .single();
}

export async function getCarbonEmployeeFromSlackId(
  client: SupabaseClient<Database>,
  accessToken: string,
  slackUserId: string,
  carbonCompanyId: string
) {
  try {
    const slackClient = createSlackWebClient({ token: accessToken });

    const userInfo = await slackClient.users.info({
      user: slackUserId
    });

    if (!userInfo.ok || !userInfo.user?.profile?.email) {
      return { data: null, error: "Could not retrieve user email from Slack" };
    }

    const email = userInfo.user.profile.email;

    const user = await client
      .from("user")
      .select("id")
      .eq("email", email)
      .single();

    if (user.error || !user.data?.id) {
      const location = await client
        .from("location")
        .select("id")
        .eq("companyId", carbonCompanyId);
      return {
        data: {
          id: "system",
          locationId: location.data?.[0]?.id
        },
        error: null
      };
    }
    const job = await client
      .from("employeeJob")
      .select("*")
      .eq("id", user.data.id)
      .eq("companyId", carbonCompanyId)
      .maybeSingle();

    if (job.error || !job.data?.id) {
      const location = await client
        .from("location")
        .select("id")
        .eq("companyId", carbonCompanyId);
      return {
        data: {
          id: user.data.id,
          locationId: location.data?.[0]?.id
        },
        error: null
      };
    }

    return job;
  } catch (error) {
    logger.error("Error getting Carbon employee from Slack ID", { error });
    return {
      data: null,
      error: error instanceof Error ? error.message : "Unknown error"
    };
  }
}

export async function syncDocumentToSlack(
  client: SupabaseClient<Database>,
  data: {
    documentType: DocumentType;
    documentId: string;
    companyId: string;
    userId: string;
    type:
      | "created"
      | "status-update"
      | "task-update"
      | "assignment-update"
      | "custom";
    payload: Record<string, any>;
  }
) {
  const serviceRole = getCarbonServiceRole();
  const [thread, slackAuth] = await Promise.all([
    getSlackDocumentThread(
      serviceRole,
      data.documentType,
      data.documentId,
      data.companyId
    ),
    getSlackAuth(serviceRole, data.companyId, data.userId)
  ]);

  if (!slackAuth) {
    logger.error("Slack auth not found for company", {
      companyId: data.companyId
    });
    return {
      data: null,
      error: "Slack auth not found"
    };
  }

  if (thread.data) {
    try {
      let result;
      switch (data.type) {
        case "created":
          result = await trigger("slack-document-created", {
            documentType: data.documentType,
            documentId: data.documentId,
            companyId: data.companyId,
            channelId: thread.data.channelId,
            threadTs: thread.data.threadTs
          });
          break;

        case "status-update":
          result = await trigger("slack-document-status-update", {
            documentType: data.documentType,
            documentId: data.documentId,
            companyId: data.companyId,
            previousStatus: data.payload.previousStatus,
            newStatus: data.payload.newStatus,
            updatedBy: slackAuth.slackUserId || data.payload.updatedBy
          });
          break;

        case "task-update":
          let taskName = "";
          let assignee: string | null | undefined = null;
          const taskId = data.payload.taskId || data.documentId; // fallback for backward compatibility
          if (data.payload.taskType === "investigation") {
            const task: any = await (client as any)
              .from("nonConformanceInvestigationTask")
              .select(
                "assignee, status, ...nonConformanceInvestigationType(name)"
              )
              .eq("id", taskId)
              .single();
            taskName = task.data?.name || "";
            assignee = task.data?.assignee
              ? await getSlackUserIdByCarbonId(
                  client,
                  slackAuth.slackToken,
                  task.data?.assignee || ""
                )
              : null;
          } else if (data.payload.taskType === "action") {
            const task: any = await client
              .from("nonConformanceActionTask")
              .select("assignee,status, ...nonConformanceRequiredAction(name)")
              .eq("id", taskId)
              .single();

            taskName = task.data?.name || "";
            assignee = task.data?.assignee
              ? await getSlackUserIdByCarbonId(
                  client,
                  slackAuth.slackToken,
                  task.data?.assignee || ""
                )
              : null;
          } else if (data.payload.taskType === "approval") {
            const task = await client
              .from("nonConformanceApprovalTask")
              .select("assignee, status, approvalType")
              .eq("id", taskId)
              .single();

            taskName = task.data?.approvalType || "";
            assignee = task.data?.assignee
              ? await getSlackUserIdByCarbonId(
                  client,
                  slackAuth.slackToken,
                  task.data?.assignee || ""
                )
              : "";
          }
          result = await trigger("slack-document-task-update", {
            assignee,
            documentType: data.documentType,
            documentId: data.documentId,
            companyId: data.companyId,
            taskName,
            taskType: data.payload.taskType,
            status: data.payload.status,
            completedAt: data.payload.completedAt
          });
          break;

        case "assignment-update":
          let previousAssignee: string | undefined;
          let newAssignee: string | undefined;
          if (data.payload.previousAssignee) {
            previousAssignee =
              (await getSlackUserIdByCarbonId(
                client,
                slackAuth.slackToken,
                data.payload.previousAssignee || ""
              )) ?? undefined;
          }
          if (data.payload.newAssignee) {
            newAssignee =
              (await getSlackUserIdByCarbonId(
                client,
                slackAuth.slackToken,
                data.payload.newAssignee || ""
              )) ?? undefined;
          }
          result = await trigger("slack-document-assignment-update", {
            documentType: data.documentType,
            documentId: data.documentId,
            companyId: data.companyId,
            previousAssignee,
            newAssignee: newAssignee ?? "",
            updatedBy: slackAuth.slackUserId || data.payload.updatedBy
          });
          break;

        case "custom":
          // For now, just log custom updates
          logger.info("Custom update", {
            documentType: data.documentType,
            payload: data.payload
          });
          return { data: { success: true }, error: null };

        default:
          throw new Error(`Invalid type ${data.type}`);
      }

      return { data: { success: true, taskId: result.ids[0] }, error: null };
    } catch (error) {
      logger.error("slack-document-sync error", { error });
      return {
        data: null,
        error: error instanceof Error ? error.message : "Unknown error"
      };
    }
  }

  return { data: null, error: null };
}

export async function syncDocumentCreatedToSlack(
  client: SupabaseClient<Database>,
  data: {
    channelId: string;
    companyId: string;
    documentId: string;
    documentType: DocumentType;
    metadata?: Record<string, any>;
    threadTs: string;
    userId: string;
  }
) {
  return syncDocumentToSlack(client, {
    documentType: data.documentType,
    documentId: data.documentId,
    companyId: data.companyId,
    userId: data.userId,
    type: "created",
    payload: {
      channelId: data.channelId,
      threadTs: data.threadTs,
      metadata: data.metadata
    }
  });
}

export async function syncDocumentStatusToSlack(
  client: SupabaseClient<Database>,
  data: {
    documentType: DocumentType;
    documentId: string;
    companyId: string;
    userId: string;
    previousStatus: string;
    newStatus: string;
    reason?: string;
    metadata?: Record<string, any>;
  }
) {
  return syncDocumentToSlack(client, {
    documentType: data.documentType,
    documentId: data.documentId,
    companyId: data.companyId,
    userId: data.userId,
    type: "status-update",
    payload: {
      previousStatus: data.previousStatus,
      newStatus: data.newStatus,
      updatedBy: data.userId,
      reason: data.reason,
      metadata: data.metadata
    }
  });
}

export async function syncDocumentAssignmentToSlack(
  client: SupabaseClient<Database>,
  data: {
    documentType: DocumentType;
    documentId: string;
    companyId: string;
    userId: string;
    previousAssignee?: string;
    newAssignee: string;
    metadata?: Record<string, any>;
  }
) {
  return syncDocumentToSlack(client, {
    documentType: data.documentType,
    documentId: data.documentId,
    companyId: data.companyId,
    userId: data.userId,
    type: "assignment-update",
    payload: {
      previousAssignee: data.previousAssignee,
      newAssignee: data.newAssignee,
      updatedBy: data.userId,
      metadata: data.metadata
    }
  });
}

export async function syncDocumentCustomToSlack(
  client: SupabaseClient<Database>,
  data: {
    companyId: string;
    customType: string;
    documentId: string;
    documentType: DocumentType;
    payload: Record<string, any>;
    userId: string;
  }
) {
  return syncDocumentToSlack(client, {
    documentType: data.documentType,
    documentId: data.documentId,
    companyId: data.companyId,
    userId: data.userId,
    type: "custom",
    payload: {
      customType: data.customType,
      ...data.payload
    }
  });
}

export async function syncIssueStatusToSlack(
  client: SupabaseClient<Database>,
  data: {
    companyId: string;
    newStatus: string;
    nonConformanceId: string;
    previousStatus: string;
    reason?: string;
    userId: string;
  }
) {
  return syncDocumentStatusToSlack(client, {
    documentType: "nonConformance",
    documentId: data.nonConformanceId,
    companyId: data.companyId,
    userId: data.userId,
    previousStatus: data.previousStatus,
    newStatus: data.newStatus,
    reason: data.reason
  });
}

export async function syncIssueTaskToSlack(
  client: SupabaseClient<Database>,
  data: {
    companyId: string;
    completedAt?: string;
    id: string;
    status: string;
    taskType: "investigation" | "action" | "review";
    userId: string;
  }
) {
  let nonConformanceId = "";
  if (data.taskType === "investigation") {
    const nonConformance: any = await (client as any)
      .from("nonConformanceInvestigationTask")
      .select("nonConformanceId")
      .eq("id", data.id)
      .single();
    nonConformanceId = nonConformance.data?.nonConformanceId || "";
  }
  if (data.taskType === "action") {
    const nonConformance: any = await client
      .from("nonConformanceActionTask")
      .select("nonConformanceId")
      .eq("id", data.id)
      .single();
    nonConformanceId = nonConformance.data?.nonConformanceId || "";
  }
  if (data.taskType === "review") {
    const nonConformance: any = await client
      .from("nonConformanceApprovalTask")
      .select("nonConformanceId")
      .eq("id", data.id)
      .single();
    nonConformanceId = nonConformance.data?.nonConformanceId || "";
  }

  return syncDocumentToSlack(client, {
    documentType: "nonConformance",
    documentId: nonConformanceId,
    companyId: data.companyId,
    userId: data.userId,
    type: "task-update",
    payload: {
      taskId: data.id,
      taskType: data.taskType,
      status: data.status,
      completedAt: data.completedAt
    }
  });
}

export async function syncIssueAssignmentToSlack(
  client: SupabaseClient<Database>,
  data: {
    nonConformanceId: string;
    companyId: string;
    userId: string;
    previousAssignee?: string;
    newAssignee: string;
  }
) {
  return syncDocumentAssignmentToSlack(client, {
    documentType: "nonConformance",
    documentId: data.nonConformanceId,
    companyId: data.companyId,
    userId: data.userId,
    previousAssignee: data.previousAssignee,
    newAssignee: data.newAssignee
  });
}

export async function updateSlackDocumentThread(
  client: SupabaseClient<Database>,
  id: string,
  updates: {
    channelId?: string;
    threadTs?: string;
    updatedBy: string;
  }
) {
  return client
    .from("slackDocumentThread")
    .update({
      ...updates,
      updatedAt: new Date().toISOString()
    })
    .eq("id", id)
    .select("*")
    .single();
}