Skip to content

📈 Open source, privacy-first web analytics — a cookie-less Google Analytics alternative with built-in error tracking and performance monitoring. Self-host it or use our cloud. Get started for free!

10.0 KB
Raw Blame
import { useTranslation } from 'react-i18next'
import type {
  ActionFunctionArgs,
  LinksFunction,
  LoaderFunctionArgs,
  MetaFunction,
} from 'react-router'
import { data, useLoaderData } from 'react-router'
import type { SitemapFunction } from 'remix-sitemap'

import { serverFetch } from '~/api/api.server'
import { isSelfhosted } from '~/lib/constants'
import AdminPage from '~/pages/Admin'
import NotFound from '~/pages/NotFound'
// The billboard.js theming (line widths, axis fonts, dark-mode grid colours)
// lives in this stylesheet - without it the admin charts render with
// billboard defaults
import ProjectViewStyle from '~/styles/ProjectViewStyle.css?url'
import { TREND_MONTHS_OPTIONS } from '~/pages/Admin/types'
import type {
  AdminActionData,
  AdminBilling,
  AdminBotBlocks,
  AdminCharts,
  AdminDatabaseInfo,
  AdminFeedbackList,
  AdminLoaderData,
  AdminOrganisationDetails,
  AdminOrganisationsList,
  AdminOverview,
  AdminProjectDetails,
  AdminProjectsList,
  AdminRevenue,
  AdminRevenueTrends,
  AdminTab,
  AdminTopProjects,
  AdminUserDetails,
  AdminUsersList,
} from '~/pages/Admin/types'
import { getDescription, getTitle } from '~/utils/seo'
import { createHeadersWithCookies, hasAuthTokens } from '~/utils/session.server'

export const links: LinksFunction = () => [
  { rel: 'stylesheet', href: ProjectViewStyle },
]

export const meta: MetaFunction<typeof loader> = ({ loaderData: data }) => {
  // eslint-disable-next-line react-hooks/rules-of-hooks
  const { t } = useTranslation('common')

  // Render the exact 404 meta for non-admins so the page is
  // indistinguishable from a non-existent route
  if (!data) {
    return [
      ...getTitle(t('notFoundPage.title')),
      ...getDescription(t('notFoundPage.description')),
    ]
  }

  return [...getTitle('Admin')]
}

export const sitemap: SitemapFunction = () => ({
  exclude: true,
})

const TABS: AdminTab[] = [
  'overview',
  'billing',
  'users',
  'projects',
  'organisations',
  'feedback',
  'bot-blocks',
  'database',
]

const CHART_DAYS = [30, 90, 180, 365]

const notFound = () => new Response('Not Found', { status: 404 })

const parseTab = (tab: string | null): AdminTab =>
  TABS.includes(tab as AdminTab) ? (tab as AdminTab) : 'overview'

export async function loader({ request }: LoaderFunctionArgs) {
  // The admin panel exists on the Cloud edition only, and only for allowlisted
  // admins. Everyone else gets a 404, as if this page does not exist.
  if (isSelfhosted || !hasAuthTokens(request)) {
    return data(null, { status: 404 })
  }

  const url = new URL(request.url)
  const searchParams = url.searchParams
  const tab = parseTab(searchParams.get('tab'))

  const page = searchParams.get('page') || '0'
  const search = searchParams.get('search') || ''
  const filter = searchParams.get('filter') || 'all'
  const sortBy = searchParams.get('sortBy') || 'created'
  const order = searchParams.get('order') || 'DESC'

  const cookies: string[] = []

  const adminFetch = async <T,>(endpoint: string): Promise<T> => {
    const result = await serverFetch<T>(request, endpoint)

    cookies.push(...result.cookies)

    // The backend responds with 404 for non-admins - mirror it here so the
    // page is indistinguishable from a non-existent route
    if (
      result.status === 401 ||
      result.status === 403 ||
      result.status === 404
    ) {
      throw notFound()
    }

    if (result.error || !result.data) {
      throw new Response('Something went wrong', { status: 500 })
    }

    return result.data
  }

  const listParams = new URLSearchParams({
    page,
    search,
    filter,
    sortBy,
    order,
  }).toString()

  const loadTabData = async (): Promise<AdminLoaderData> => {
    if (tab === 'overview') {
      const chartDays = CHART_DAYS.includes(Number(searchParams.get('days')))
        ? Number(searchParams.get('days'))
        : 30

      const [overview, charts, revenue] = await Promise.all([
        adminFetch<AdminOverview>('admin/overview'),
        adminFetch<AdminCharts>(`admin/charts?days=${chartDays}`),
        // Paddle can be slow/unavailable - the page still renders without it
        adminFetch<AdminRevenue>('admin/revenue').catch(() => null),
      ])

      return { tab, overview, charts, chartDays, revenue }
    }

    if (tab === 'billing') {
      const trendMonths = TREND_MONTHS_OPTIONS.includes(
        Number(searchParams.get('months')),
      )
        ? Number(searchParams.get('months'))
        : 12

      const [billing, revenueTrends] = await Promise.all([
        adminFetch<AdminBilling>('admin/billing'),
        // A cold Paddle history fetch is slow - the rest of the tab should not
        // wait on it, nor disappear if Paddle is down
        adminFetch<AdminRevenueTrends>(
          `admin/revenue-trends?months=${trendMonths}`,
        ).catch(() => null),
      ])

      return { tab, billing, revenueTrends, trendMonths }
    }

    if (tab === 'bot-blocks') {
      const days = [7, 30, 90].includes(Number(searchParams.get('days')))
        ? Number(searchParams.get('days'))
        : 7

      const botBlocks = await adminFetch<AdminBotBlocks>(
        `admin/bot-blocks?days=${days}`,
      )

      return { tab, botBlocks }
    }

    if (tab === 'users') {
      const userId = searchParams.get('user')

      const [users, userDetails] = await Promise.all([
        adminFetch<AdminUsersList>(`admin/users?${listParams}`),
        userId
          ? adminFetch<AdminUserDetails>(
              `admin/users/${encodeURIComponent(userId)}`,
            ).catch(() => null)
          : Promise.resolve(null),
      ])

      return { tab, users, userDetails }
    }

    if (tab === 'projects') {
      const projectId = searchParams.get('project')

      if (projectId) {
        const projectDetails = await adminFetch<AdminProjectDetails>(
          `admin/projects/${encodeURIComponent(projectId)}`,
        ).catch(() => null)

        return { tab, projectDetails }
      }

      if (searchParams.get('view') === 'top') {
        const days = [1, 7, 30].includes(Number(searchParams.get('days')))
          ? Number(searchParams.get('days'))
          : 7

        const topProjects = await adminFetch<AdminTopProjects>(
          `admin/projects/top?days=${days}`,
        )

        return { tab, topProjects }
      }

      const projects = await adminFetch<AdminProjectsList>(
        `admin/projects?${listParams}`,
      )

      return { tab, projects }
    }

    if (tab === 'organisations') {
      const organisationId = searchParams.get('org')

      const [organisations, organisationDetails] = await Promise.all([
        adminFetch<AdminOrganisationsList>(`admin/organisations?${listParams}`),
        organisationId
          ? adminFetch<AdminOrganisationDetails>(
              `admin/organisations/${encodeURIComponent(organisationId)}`,
            ).catch(() => null)
          : Promise.resolve(null),
      ])

      return { tab, organisations, organisationDetails }
    }

    if (tab === 'feedback') {
      const type = ['user', 'cancellation', 'deletion'].includes(
        searchParams.get('type') || '',
      )
        ? searchParams.get('type')
        : 'user'

      const feedbackParams = new URLSearchParams({
        type: type as string,
        page,
        search,
        order,
      }).toString()

      const feedback = await adminFetch<AdminFeedbackList>(
        `admin/feedback?${feedbackParams}`,
      )

      return { tab, feedback }
    }

    const database = await adminFetch<AdminDatabaseInfo>('admin/database')

    return { tab, database }
  }

  let loaderData: AdminLoaderData

  try {
    loaderData = await loadTabData()
  } catch (error) {
    // Render the same NotFound page a non-existent route would render
    if (error instanceof Response && error.status === 404) {
      return data(null, {
        status: 404,
        headers: createHeadersWithCookies(cookies),
      })
    }

    throw error
  }

  return data<AdminLoaderData>(loaderData, {
    headers: createHeadersWithCookies(cookies),
  })
}

export async function action({ request }: ActionFunctionArgs) {
  if (isSelfhosted || !hasAuthTokens(request)) {
    throw notFound()
  }

  const formData = await request.formData()
  const intent = formData.get('intent')?.toString()

  if (intent !== 'update-user') {
    return data<AdminActionData>({ error: 'Unknown action' }, { status: 400 })
  }

  const userId = formData.get('userId')?.toString()

  if (!userId) {
    return data<AdminActionData>(
      { error: 'User ID is required' },
      { status: 400 },
    )
  }

  const parseJsonField = (
    field: string,
  ): Record<string, unknown> | null | undefined => {
    const raw = formData.get(field)?.toString().trim()

    if (!raw) {
      return null
    }

    try {
      return JSON.parse(raw)
    } catch {
      return undefined
    }
  }

  const addonOverrides = parseJsonField('addonOverrides')
  const entitlementOverrides = parseJsonField('entitlementOverrides')

  if (addonOverrides === undefined || entitlementOverrides === undefined) {
    return data<AdminActionData>(
      { error: 'Overrides must be valid JSON objects' },
      { status: 400 },
    )
  }

  const planTypeRaw = formData.get('planType')?.toString()

  const result = await serverFetch(
    request,
    `admin/users/${encodeURIComponent(userId)}`,
    {
      method: 'PATCH',
      body: {
        planType: planTypeRaw || null,
        addonOverrides,
        entitlementOverrides,
      },
    },
  )

  if (result.status === 401 || result.status === 403 || result.status === 404) {
    throw notFound()
  }

  if (result.error) {
    return data<AdminActionData>(
      {
        error: Array.isArray(result.error)
          ? result.error.join(', ')
          : result.error,
      },
      { status: 400, headers: createHeadersWithCookies(result.cookies) },
    )
  }

  return data<AdminActionData>(
    { success: true },
    { headers: createHeadersWithCookies(result.cookies) },
  )
}

export default function Admin() {
  const loaderData = useLoaderData<typeof loader>()

  if (!loaderData) {
    return <NotFound />
  }

  return <AdminPage />
}