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.

7.3 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-only
// Carbon (github.com/crbnos/carbon). Modified or adapted versions of this file,
// including ports, remain AGPLv3; serving them over a network requires releasing their source.

import "./zod.client";
import { CONTROLLED_ENVIRONMENT, getBrowserEnv, getCarbon } from "@carbon/auth";
import { flashClientMiddleware } from "@carbon/auth/middleware/flash.client";
import {
  flashHeadersContext,
  flashMiddleware,
  flashResultContext
} from "@carbon/auth/middleware/flash.server";
import { formBodyMiddleware } from "@carbon/auth/middleware/form-body.server";
import { maintenanceMiddleware } from "@carbon/auth/middleware/maintenance.server";
import { securityMiddleware } from "@carbon/auth/middleware/security.server";
import { getOrRefreshAuthSession } from "@carbon/auth/session.server";
import { LocaleProvider } from "@carbon/locale";
import { requestIdMiddleware } from "@carbon/logger/middleware.server";
import {
  OperatingSystemContextProvider,
  Toaster,
  TooltipProvider
} from "@carbon/react";
import { getPreferenceHeaders } from "@carbon/utils";
import { faviconLinks } from "@carbon/utils/favicon";
import type { Messages } from "@lingui/core";
import { I18nProvider } from "@react-aria/i18n";
import { Analytics } from "@vercel/analytics/react";
import type React from "react";
import { useContext } from "react";
import type {
  LinksFunction,
  LoaderFunctionArgs,
  MetaFunction
} from "react-router";
import {
  data,
  isRouteErrorResponse,
  Links,
  Meta,
  Outlet,
  Scripts,
  ScrollRestoration,
  UNSAFE_FrameworkContext,
  useLoaderData
} from "react-router";
import NProgress from "~/styles/nprogress.css?url";
import Tailwind from "~/styles/tailwind.css?url";
import { CourseSidebarNav } from "./components/CourseSidebar";
import { SiteHeader } from "./components/SiteHeader";
import { path } from "./utils/path";

// Academy is English-only, but the `@carbon/react` parts it renders translate
// their own labels with Lingui (a phone Popover becomes a BottomSheet that
// calls `useLingui`), and a production build strips the source text from each
// message, so they need a catalog. The MES catalog holds every
// `@carbon/react` string at a fraction of the ERP catalog's size.
const { messages: catalog } = Object.values(
  import.meta.glob<{ messages: Messages }>(
    "../../../packages/locale/locales/en/mes.po",
    { eager: true }
  )
)[0];

export const middleware = [
  requestIdMiddleware,
  securityMiddleware,
  maintenanceMiddleware,
  formBodyMiddleware,
  flashMiddleware
];
export const clientMiddleware = [flashClientMiddleware];

export const links: LinksFunction = () => [
  { rel: "stylesheet", href: Tailwind },
  { rel: "stylesheet", href: NProgress },
  ...faviconLinks
];

export const meta: MetaFunction = () => {
  return [
    {
      title: "Carbon Academy"
    }
  ];
};

export async function loader({ request, context }: LoaderFunctionArgs) {
  const {
    CARBON_EDITION,
    CARBON_API_URL,
    LOG_LEVEL,
    NODE_ENV,
    POSTHOG_API_HOST,
    POSTHOG_PROJECT_PUBLIC_KEY,
    SUPABASE_URL,
    SUPABASE_ANON_KEY
  } = getBrowserEnv();

  let session = await getOrRefreshAuthSession(request);

  let user = null;
  let lessonCompletions: {
    lessonId: string;
    courseId: string;
  }[] = [];
  let challengeAttempts: {
    topicId: string;
    courseId: string;
    passed: boolean;
  }[] = [];

  if (session) {
    const client = getCarbon(session.accessToken);

    const [authUser, completions, attempts] = await Promise.all([
      client.from("user").select("*").eq("id", session.userId).single(),
      client
        .from("lessonCompletion")
        .select("lessonId, courseId")
        .eq("userId", session.userId),
      client
        .from("challengeAttempt")
        .select("topicId, courseId, passed")
        .eq("userId", session.userId)
    ]);

    if (authUser.data) {
      user = authUser.data;
    }

    lessonCompletions = completions.data ?? [];
    challengeAttempts = attempts.data ?? [];
  }

  return data(
    {
      challengeAttempts,
      env: {
        CARBON_EDITION,
        CARBON_API_URL,
        LOG_LEVEL,
        NODE_ENV,
        POSTHOG_API_HOST,
        POSTHOG_PROJECT_PUBLIC_KEY,
        SUPABASE_URL,
        SUPABASE_ANON_KEY
      },
      lessonCompletions,
      preferences: getPreferenceHeaders(request),
      result: context.get(flashResultContext),
      user,
      session
    },
    {
      headers: context.get(flashHeadersContext) ?? undefined
    }
  );
}

function Document({
  children,
  title = "Carbon"
}: {
  children: React.ReactNode;
  title?: string;
}) {
  return (
    <html lang="en" className="overflow-x-hidden">
      <head>
        <meta charSet="utf-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1" />
        <Meta />
        <title>{title}</title>
        <Links />
      </head>
      <body className="bg-background antialiased selection:bg-primary/10 selection:text-primary">
        <TooltipProvider>{children}</TooltipProvider>
        <Toaster position="bottom-right" visibleToasts={5} />
        <ScrollRestoration />
        <Scripts />
        {!CONTROLLED_ENVIRONMENT && import.meta.env.PROD && <Analytics />}
      </body>
    </html>
  );
}

export default function App() {
  const nonce = useContext(UNSAFE_FrameworkContext)?.nonce;
  const loaderData = useLoaderData<typeof loader>();
  const env = loaderData?.env ?? {};
  const prefs = loaderData?.preferences;

  return (
    <OperatingSystemContextProvider platform={prefs.platform}>
      <LocaleProvider locale="en" catalog={catalog}>
        <I18nProvider locale={prefs.locale}>
          <Document>
            <SiteHeader mobileNav={<CourseSidebarNav />} />
            <div className="pt-16 min-h-screen bg-background">
              <Outlet />
            </div>
            <script
              // Server render only: on the client the nonce is undefined (and browsers hide it).
              nonce={nonce}
              suppressHydrationWarning
              dangerouslySetInnerHTML={{
                __html: `window.env = ${JSON.stringify(env)}`
              }}
            />
          </Document>
        </I18nProvider>
      </LocaleProvider>
    </OperatingSystemContextProvider>
  );
}

export function ErrorBoundary({ error }: { error: unknown }) {
  const message = isRouteErrorResponse(error)
    ? (error.data.message ?? error.data)
    : error instanceof Error
      ? error.message
      : String(error);

  return (
    <Document title="Error!">
      <div className="flex flex-col w-full h-screen items-center justify-center gap-5 bg-ed-paper px-6 text-center">
        <img
          src="/carbon-mark-light.svg"
          alt="Carbon"
          className="block max-w-[56px]"
        />
        <h1 className="text-ed-24 font-semi text-ed-ink">
          Something went wrong
        </h1>
        <p className="max-w-xl text-ed-15 text-ed-ink-66">{message}</p>
        <a
          href={path.to.root}
          className="group relative inline-flex h-10 items-center justify-center rounded-lg px-5 no-underline"
        >
          <span
            aria-hidden="true"
            className="pointer-events-none absolute inset-0 rounded-lg cta-btn-dark"
          />
          <span className="text-on-dark relative z-10 text-ed-14 font-book tracking-[0.15px]">
            Back home
          </span>
        </a>
      </div>
    </Document>
  );
}