@manta-eu/horns-client 0.1.0 → 0.1.2

package/dist/lib/manta/session.js

@@ -1,204 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, use, useCallback, useEffect, useMemo, useState } from "react";
-import { isPresent } from "@manta-eu/lib/present";
-import { isRecord, isString } from "@manta-eu/horns";
-import { signedInParam } from "@manta-eu/horns-server/shared";
-export function signInHref(redirect) {
-    const params = new URLSearchParams();
-    if (isPresent(redirect) && redirect !== "/")
-        params.set("redirect", redirect);
-    const query = params.toString();
-    return `/login${query ? `?${query}` : ""}`;
-}
-export async function readJsonError(response, fallback) {
-    const body = await response.json().catch(() => undefined);
-    if (typeof body === "object" && isPresent(body) && "error" in body && typeof body.error === "string") {
-        return body.error;
-    }
-    return fallback;
-}
-export class RequestFailed extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.name = "RequestFailed";
-        this.status = status;
-    }
-}
-export function statusOf(caught) {
-    return caught instanceof RequestFailed ? caught.status : undefined;
-}
-// 204 responses are success, not a parse failure. The body is untrusted until `parse` has checked it.
-export async function requestJson(path, init, fallback, parse) {
-    const response = await fetch(path, { credentials: "same-origin", ...init });
-    if (!response.ok)
-        throw new RequestFailed(response.status, await readJsonError(response, fallback));
-    const text = await response.text();
-    if (!isPresent(text.trim()))
-        return undefined;
-    const body = JSON.parse(text);
-    return parse(body);
-}
-const readJson = (path, fallback, parse) => requestJson(path, { headers: { accept: "application/json" } }, fallback, parse);
-function parseDatastore(value) {
-    if (!isRecord(value) || typeof value.id !== "string" || typeof value.name !== "string")
-        return undefined;
-    return {
-        id: value.id,
-        name: value.name,
-        ...(typeof value.depth === "number" ? { depth: value.depth } : {}),
-        ...(typeof value.selectable === "boolean" ? { selectable: value.selectable } : {}),
-    };
-}
-function parseLoginStatus(body) {
-    if (!isRecord(body) || typeof body.valid !== "boolean")
-        throw new Error("Sign-in status is malformed.");
-    return {
-        valid: body.valid,
-        canSwitchDatastore: body.canSwitchDatastore === true,
-        allowedModels: Array.isArray(body.allowedModels) ? body.allowedModels.filter(isString) : [],
-    };
-}
-function parseUserContext(body) {
-    if (!isRecord(body) || !isRecord(body.user))
-        throw new Error("User context is malformed.");
-    const { user } = body;
-    if (typeof user.id !== "string" || typeof user.email !== "string")
-        throw new Error("User context is malformed.");
-    const datastore = parseDatastore(user.datastore);
-    return {
-        user: {
-            id: user.id,
-            email: user.email,
-            isOperator: user.isOperator === true,
-            ...(typeof user.name === "string" ? { name: user.name } : {}),
-            ...(datastore ? { datastore } : {}),
-        },
-        datastores: Array.isArray(body.datastores) ? body.datastores.flatMap((entry) => parseDatastore(entry) ?? []) : [],
-    };
-}
-export function sessionGate(value) {
-    if (isPresent(value.authError))
-        return "blocked";
-    if (value.status === "loading")
-        return "loading";
-    if (value.status === "error")
-        return "blocked";
-    if (value.status === "signed-out")
-        return value.justSignedIn ? "looped" : "sign-in";
-    return "ready";
-}
-// The realm's own top-level datastore is the one with no depth that cannot be picked.
-export function realmDatastore(value) {
-    return value.datastores.find((datastore) => !isPresent(datastore.depth) && datastore.selectable !== true);
-}
-export function activeDatastore(value) {
-    if (isPresent(value.user?.datastore))
-        return value.user.datastore;
-    if (!value.isOperator)
-        return undefined;
-    return realmDatastore(value);
-}
-const MantaSessionContext = createContext(undefined);
-function readAuthError() {
-    const raw = new URLSearchParams(window.location.search).get("auth_error");
-    return isPresent(raw) ? raw : undefined;
-}
-function readJustSignedIn() {
-    return new URLSearchParams(window.location.search).get(signedInParam) === "1";
-}
-export function MantaSessionProvider({ children }) {
-    const [status, setStatus] = useState("loading");
-    const [context, setContext] = useState();
-    const [canSwitchDatastore, setCanSwitchDatastore] = useState(false);
-    const [error, setError] = useState();
-    const [reloads, setReloads] = useState(0);
-    const [revision, setRevision] = useState(0);
-    const [authError, setAuthError] = useState(readAuthError);
-    const [justSignedIn] = useState(readJustSignedIn);
-    useEffect(() => {
-        if (!isPresent(authError) && !justSignedIn)
-            return;
-        const url = new URL(window.location.href);
-        url.searchParams.delete("auth_error");
-        url.searchParams.delete(signedInParam);
-        window.history.replaceState(window.history.state, "", url.pathname + url.search);
-    }, [authError, justSignedIn]);
-    useEffect(() => {
-        let live = true;
-        void (async () => {
-            if (reloads === 0)
-                setStatus("loading");
-            setError(undefined);
-            try {
-                const login = await readJson("/api/login", "Sign-in status is unavailable.", parseLoginStatus);
-                if (!live)
-                    return;
-                if (!isPresent(login))
-                    throw new Error("Sign-in status is unavailable.");
-                setCanSwitchDatastore(login.canSwitchDatastore);
-                if (!login.valid) {
-                    setContext(undefined);
-                    setStatus("signed-out");
-                    return;
-                }
-                const loaded = await readJson("/api/data/context", "User context is unavailable.", parseUserContext);
-                if (!live)
-                    return;
-                if (!isPresent(loaded))
-                    throw new Error("User context is unavailable.");
-                setContext(loaded);
-                setStatus("ready");
-                setRevision((count) => count + 1);
-            }
-            catch (caught) {
-                if (!live)
-                    return;
-                // The upstream session can expire between the /api/login check and this fetch.
-                if (statusOf(caught) === 401) {
-                    setContext(undefined);
-                    setStatus("signed-out");
-                    return;
-                }
-                setError(caught instanceof Error ? caught.message : "Manta Horns is unavailable.");
-                setStatus("error");
-            }
-        })();
-        return () => {
-            live = false;
-        };
-    }, [reloads]);
-    const reload = useCallback(() => {
-        setAuthError(undefined);
-        setReloads((count) => count + 1);
-    }, []);
-    const value = useMemo(() => {
-        const isOperator = context?.user.isOperator ?? false;
-        const datastore = activeDatastore({
-            isOperator,
-            ...(isPresent(context) ? { user: context.user } : {}),
-            datastores: context?.datastores ?? [],
-        });
-        return {
-            status,
-            isLive: status === "ready",
-            ...(isPresent(context) ? { user: context.user } : {}),
-            ...(isPresent(datastore) ? { datastore } : {}),
-            datastores: context?.datastores ?? [],
-            isOperator,
-            canSwitchDatastore,
-            ...(isPresent(error) ? { error } : {}),
-            ...(isPresent(authError) ? { authError } : {}),
-            justSignedIn,
-            revision,
-            reload,
-        };
-    }, [status, context, canSwitchDatastore, error, authError, justSignedIn, revision, reload]);
-    return _jsx(MantaSessionContext.Provider, { value: value, children: children });
-}
-export function useMantaSession() {
-    const value = use(MantaSessionContext);
-    if (!isPresent(value))
-        throw new Error("useMantaSession must be used inside MantaSessionProvider");
-    return value;
-}