Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

7.1 KB
Raw Blame
import { prisma, type LlmApiKeys, type Prisma } from "@langfuse/shared/src/db";
import { DECISION_MODEL_ADAPTERS } from "@langfuse/shared/src/server";

export type LlmConnectionOwner =
  | {
      type: "project";
      projectId: string;
      organizationId: string;
    }
  | {
      type: "organization";
      organizationId: string;
    };

type PrismaClient = typeof prisma | Prisma.TransactionClient;

const ownerWhere = (owner: LlmConnectionOwner): Prisma.LlmApiKeysWhereInput =>
  owner.type === "project"
    ? { projectId: owner.projectId }
    : { organizationId: owner.organizationId };

export class LlmConnectionRepository {
  constructor(private readonly db: PrismaClient = prisma) {}

  withDb(db: PrismaClient): LlmConnectionRepository {
    return new LlmConnectionRepository(db);
  }

  findById(params: {
    owner: LlmConnectionOwner;
    id: string;
  }): Promise<LlmApiKeys | null> {
    return this.db.llmApiKeys.findFirst({
      where: {
        id: params.id,
        ...ownerWhere(params.owner),
      },
    });
  }

  findByProvider(params: {
    owner: LlmConnectionOwner;
    provider: string;
  }): Promise<LlmApiKeys | null> {
    return this.db.llmApiKeys.findFirst({
      where: {
        provider: params.provider,
        ...ownerWhere(params.owner),
      },
    });
  }

  findIncompatibleConnection(params: {
    owner: LlmConnectionOwner;
    provider: string;
    adapter: string;
  }): Promise<LlmApiKeys | null> {
    return this.db.llmApiKeys.findFirst({
      where: {
        provider: params.provider,
        adapter: { not: params.adapter },
        ...(params.owner.type === "project"
          ? { organizationId: params.owner.organizationId }
          : {
              project: {
                orgId: params.owner.organizationId,
                deletedAt: null,
              },
            }),
      },
    });
  }

  list(params: {
    owner: LlmConnectionOwner;
    includeDecisionModels: boolean;
    limit?: number;
    offset?: number;
  }): Promise<LlmApiKeys[]> {
    return this.db.llmApiKeys.findMany({
      where: {
        ...ownerWhere(params.owner),
        ...(params.includeDecisionModels
          ? {}
          : { adapter: { notIn: [...DECISION_MODEL_ADAPTERS] } }),
      },
      orderBy: { createdAt: "desc" },
      take: params.limit,
      skip: params.offset,
    });
  }

  count(params: {
    owner: LlmConnectionOwner;
    includeDecisionModels: boolean;
  }): Promise<number> {
    return this.db.llmApiKeys.count({
      where: {
        ...ownerWhere(params.owner),
        ...(params.includeDecisionModels
          ? {}
          : { adapter: { notIn: [...DECISION_MODEL_ADAPTERS] } }),
      },
    });
  }

  async listOrganizationConnectionsForProject(params: {
    projectId: string;
    organizationId: string;
    includeDecisionModels: boolean;
  }): Promise<{
    connections: LlmApiKeys[];
    overriddenProviders: Set<string>;
  }> {
    const [connections, projectConnections] = await Promise.all([
      this.db.llmApiKeys.findMany({
        where: {
          organizationId: params.organizationId,
          ...(params.includeDecisionModels
            ? {}
            : { adapter: { notIn: [...DECISION_MODEL_ADAPTERS] } }),
        },
        orderBy: { createdAt: "desc" },
      }),
      this.db.llmApiKeys.findMany({
        where: { projectId: params.projectId },
        select: { provider: true },
      }),
    ]);

    return {
      connections,
      overriddenProviders: new Set(
        projectConnections.map((connection) => connection.provider),
      ),
    };
  }

  async listEffectiveForProject(params: {
    projectId: string;
    organizationId: string;
    includeDecisionModels: boolean;
  }): Promise<LlmApiKeys[]> {
    const connections = await this.db.llmApiKeys.findMany({
      where: {
        OR: [
          { projectId: params.projectId },
          { organizationId: params.organizationId },
        ],
      },
      orderBy: { createdAt: "desc" },
    });
    const projectProviders = new Set(
      connections
        .filter((connection) => connection.projectId === params.projectId)
        .map((connection) => connection.provider),
    );
    const visibleConnections = params.includeDecisionModels
      ? connections
      : connections.filter(
          (connection) =>
            !DECISION_MODEL_ADAPTERS.some(
              (adapter) => adapter === connection.adapter,
            ),
        );

    return visibleConnections.filter(
      (connection) =>
        connection.projectId === params.projectId ||
        !projectProviders.has(connection.provider),
    );
  }

  create(params: {
    owner: LlmConnectionOwner;
    data: Omit<
      Prisma.LlmApiKeysUncheckedCreateInput,
      "projectId" | "organizationId"
    >;
  }): Promise<LlmApiKeys> {
    return this.db.llmApiKeys.create({
      data: {
        ...params.data,
        ...(params.owner.type === "project"
          ? { projectId: params.owner.projectId }
          : { organizationId: params.owner.organizationId }),
      },
    });
  }

  upsert(params: {
    owner: LlmConnectionOwner;
    provider: string;
    create: Omit<
      Prisma.LlmApiKeysUncheckedCreateInput,
      "projectId" | "organizationId"
    >;
    update: Prisma.LlmApiKeysUpdateInput;
  }): Promise<LlmApiKeys> {
    if (params.owner.type === "project") {
      return this.db.llmApiKeys.upsert({
        where: {
          projectId_provider: {
            projectId: params.owner.projectId,
            provider: params.provider,
          },
        },
        create: {
          ...params.create,
          projectId: params.owner.projectId,
        },
        update: params.update,
      });
    }

    return this.db.llmApiKeys.upsert({
      where: {
        organizationId_provider: {
          organizationId: params.owner.organizationId,
          provider: params.provider,
        },
      },
      create: {
        ...params.create,
        organizationId: params.owner.organizationId,
      },
      update: params.update,
    });
  }

  update(params: {
    owner: LlmConnectionOwner;
    id: string;
    data: Prisma.LlmApiKeysUpdateInput;
  }): Promise<LlmApiKeys> {
    return this.db.llmApiKeys.update({
      where:
        params.owner.type === "project"
          ? { id: params.id, projectId: params.owner.projectId }
          : { id: params.id, organizationId: params.owner.organizationId },
      data: params.data,
    });
  }

  delete(params: {
    owner: LlmConnectionOwner;
    id: string;
  }): Promise<LlmApiKeys> {
    return this.db.llmApiKeys.delete({
      where:
        params.owner.type === "project"
          ? { id: params.id, projectId: params.owner.projectId }
          : { id: params.id, organizationId: params.owner.organizationId },
    });
  }

  async listProjectsUsingOrganizationConnection(params: {
    organizationId: string;
    provider: string;
  }): Promise<string[]> {
    const projects = await this.db.project.findMany({
      where: {
        orgId: params.organizationId,
        deletedAt: null,
        LlmApiKeys: {
          none: {
            provider: params.provider,
          },
        },
      },
      select: { id: true },
    });

    return projects.map((project) => project.id);
  }
}