Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
4.8 KB
Raw Blame
import { and, eq, isNull } from "@omnirush-ee/den-db/drizzle"
import {
  AuthAccountTable,
  AuthUserTable,
  MemberTable,
  OrganizationTable,
  SsoConnectionTable,
  SsoProviderTable,
} from "@omnirush-ee/den-db/schema"
import { normalizeDenTypeId } from "@omnirush-ee/utils/typeid"
import { db } from "./db.js"

type EnterpriseAuthRequirementRow = {
  organizationId: string
  organizationSlug: string
  signInPath: string | null
  ssoProviderId: string | null
}

export type EnterpriseAuthRequirement = {
  organizationId: string
  organizationSlug: string
  signInPath: string
  ssoProviderId: string | null
  hasSso: boolean
}

export type ResolvedNonSsoMethod = "google" | "password" | "signup"

function normalizeEmail(email: string) {
  return email.trim().toLowerCase()
}

function getEmailDomain(email: string) {
  const normalizedEmail = normalizeEmail(email)
  const atIndex = normalizedEmail.lastIndexOf("@")
  if (atIndex <= 0 || atIndex === normalizedEmail.length - 1) {
    return null
  }
  const domain = normalizedEmail.slice(atIndex + 1)
  return domain.includes(".") ? domain : null
}

function getOrganizationSsoSignInPath(organizationSlug: string) {
  return `/sso/${encodeURIComponent(organizationSlug)}`
}

function toRequirement(row: EnterpriseAuthRequirementRow): EnterpriseAuthRequirement {
  return {
    organizationId: row.organizationId,
    organizationSlug: row.organizationSlug,
    signInPath: row.signInPath ?? getOrganizationSsoSignInPath(row.organizationSlug),
    ssoProviderId: row.ssoProviderId,
    hasSso: Boolean(row.ssoProviderId),
  }
}

function pickRequirement(rows: EnterpriseAuthRequirementRow[]) {
  const ssoRow = rows.find((row) => row.ssoProviderId)
  return ssoRow ?? rows[0] ?? null
}

async function findEnterpriseAuthRequirement(where: ReturnType<typeof and>) {
  const rows = await db
    .select({
      organizationId: OrganizationTable.id,
      organizationSlug: OrganizationTable.slug,
      signInPath: SsoConnectionTable.signInPath,
      ssoProviderId: SsoProviderTable.providerId,
    })
    .from(AuthUserTable)
    .innerJoin(MemberTable, eq(AuthUserTable.id, MemberTable.userId))
    .innerJoin(OrganizationTable, eq(MemberTable.organizationId, OrganizationTable.id))
    .innerJoin(SsoConnectionTable, and(
      eq(OrganizationTable.id, SsoConnectionTable.organizationId),
      eq(SsoConnectionTable.status, "enabled"),
    ))
    .innerJoin(SsoProviderTable, and(
      eq(SsoConnectionTable.providerId, SsoProviderTable.providerId),
      eq(OrganizationTable.id, SsoProviderTable.organizationId),
      eq(SsoProviderTable.domainVerified, true),
    ))
    .where(and(
      where,
      isNull(MemberTable.removedAt),
    ))

  const requirement = pickRequirement(rows)
  return requirement ? toRequirement(requirement) : null
}

export async function findEnterpriseAuthRequirementForEmail(email: string) {
  const normalizedEmail = normalizeEmail(email)
  if (!normalizedEmail) {
    return null
  }

  return findEnterpriseAuthRequirement(eq(AuthUserTable.email, normalizedEmail))
}

export async function findEnterpriseAuthRequirementForEmailDomain(email: string) {
  const domain = getEmailDomain(email)
  if (!domain) {
    return null
  }

  const rows = await db
    .select({
      organizationId: OrganizationTable.id,
      organizationSlug: OrganizationTable.slug,
      signInPath: SsoConnectionTable.signInPath,
      ssoProviderId: SsoProviderTable.providerId,
    })
    .from(OrganizationTable)
    .innerJoin(SsoConnectionTable, and(
      eq(OrganizationTable.id, SsoConnectionTable.organizationId),
      eq(SsoConnectionTable.status, "enabled"),
      eq(SsoConnectionTable.domain, domain),
    ))
    .innerJoin(SsoProviderTable, and(
      eq(SsoConnectionTable.providerId, SsoProviderTable.providerId),
      eq(OrganizationTable.id, SsoProviderTable.organizationId),
      eq(SsoProviderTable.domain, domain),
      eq(SsoProviderTable.domainVerified, true),
    ))

  const requirement = pickRequirement(rows)
  return requirement ? toRequirement(requirement) : null
}

export async function resolveNonSsoSignInMethodForEmail(email: string): Promise<ResolvedNonSsoMethod> {
  const normalizedEmail = normalizeEmail(email)
  if (!normalizedEmail) {
    return "signup"
  }

  const rows = await db
    .select({
      providerId: AuthAccountTable.providerId,
      password: AuthAccountTable.password,
    })
    .from(AuthUserTable)
    .innerJoin(AuthAccountTable, eq(AuthUserTable.id, AuthAccountTable.userId))
    .where(eq(AuthUserTable.email, normalizedEmail))

  if (rows.length === 0) {
    return "signup"
  }

  if (rows.some((row) => row.providerId.trim().toLowerCase() === "google")) {
    return "google"
  }

  return "password"
}

export async function findEnterpriseAuthRequirementForUserId(userId: string) {
  return findEnterpriseAuthRequirement(eq(AuthUserTable.id, normalizeDenTypeId("user", userId)))
}