@manta-eu/react 0.11.0 → 0.13.0

package/src/worker/session.ts

@@ -0,0 +1,111 @@
+import {
+  cookiesOf,
+  expiredChunkCookies,
+  httpOnlyCookie,
+  purposeKey,
+  sealedChunkCookies,
+  sessionMaxAgeSeconds,
+  unsealedChunks,
+  type SealingKey,
+} from "@manta-eu/auth/sealed-cookies";
+import { isPresent } from "@manta-eu/lib/present";
+import { identity, memoizeWith } from "ramda";
+import { match } from "ts-pattern";
+
+export type SessionState = { upstreamCookies: Record<string, string> };
+
+export type SessionCookies = { prefix: string; secret: string };
+
+type SessionSetCookiesArgs = { cookies: SessionCookies; state: SessionState; request: Request };
+
+type CaptureArgs = { state: SessionState; response: Response };
+
+const agentsSessionCookie = "auth";
+
+function setCookieFor(request: Request) {
+  return httpOnlyCookie(new URL(request.url).protocol === "https:");
+}
+
+const keyFor = memoizeWith(identity, (secret: string): Promise<SealingKey> => purposeKey(secret, "agents-session"));
+
+export async function sessionSetCookies(args: SessionSetCookiesArgs): Promise<string[]> {
+  const { cookies, state, request } = args;
+
+  return sealedChunkCookies({
+    cookies: cookiesOf(request),
+    name: cookies.prefix,
+    setCookie: setCookieFor(request),
+    key: await keyFor(cookies.secret),
+    value: state,
+    maxAge: sessionMaxAgeSeconds,
+  });
+}
+
+export function clearSessionSetCookies(cookies: SessionCookies, request: Request): string[] {
+  return expiredChunkCookies({ cookies: cookiesOf(request), name: cookies.prefix, setCookie: setCookieFor(request) });
+}
+
+function asSessionState(value: unknown): SessionState | undefined {
+  if (typeof value !== "object" || value === null || !("upstreamCookies" in value)) return undefined;
+
+  const { upstreamCookies } = value;
+
+  if (typeof upstreamCookies !== "object" || upstreamCookies === null) return undefined;
+
+  const entries = Object.entries(upstreamCookies).filter(
+    (entry): entry is [string, string] => isPresent(entry[0]) && typeof entry[1] === "string",
+  );
+
+  return isPresent(entries) ? { upstreamCookies: Object.fromEntries(entries) } : undefined;
+}
+
+export async function readSession(cookies: SessionCookies, request: Request): Promise<SessionState | undefined> {
+  const key = await keyFor(cookies.secret);
+
+  return asSessionState(await unsealedChunks({ cookies: cookiesOf(request), name: cookies.prefix, key }));
+}
+
+export function isSignedIn(state: SessionState | undefined): state is SessionState {
+  return isPresent(state?.upstreamCookies[agentsSessionCookie]);
+}
+
+export function upstreamCookieHeader(state: SessionState): string {
+  return Object.entries(state.upstreamCookies)
+    .map(([name, value]) => `${name}=${value}`)
+    .join("; ");
+}
+
+function expires(attributes: string[]): boolean {
+  return attributes.some((attribute) => {
+    const [rawName = "", ...rest] = attribute.split("=");
+
+    const value = rest.join("=").trim();
+
+    return match(rawName.trim().toLowerCase())
+      .with("max-age", () => isPresent(value) && Number(value) <= 0)
+      .with("expires", () => Date.parse(value) <= Date.now())
+      .otherwise(() => false);
+  });
+}
+
+export function captureUpstreamCookies(args: CaptureArgs): SessionState {
+  const { state, response } = args;
+
+  const jar = { ...state.upstreamCookies };
+
+  for (const header of response.headers.getSetCookie()) {
+    const [pair = "", ...attributes] = header.split(";");
+
+    const index = pair.indexOf("=");
+    const name = pair.slice(0, Math.max(index, 0)).trim();
+
+    if (!isPresent(name)) continue;
+
+    const value = pair.slice(index + 1).trim();
+
+    if (!isPresent(value) || expires(attributes)) delete jar[name];
+    else jar[name] = value;
+  }
+
+  return { upstreamCookies: jar };
+}