@rebasepro/app 0.17.3 → 0.18.0

package/src/auth/useRebaseAuthController.ts

@@ -1,345 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import type { User, AuthChangeEvent, RebaseSession } from "@rebasepro/types";
-import type { AuthConfigResponse } from "./api";
-import { RebaseAuthController, RebaseAuthControllerProps } from "./types";
-import { clearFetchCache } from "../hooks/data/useFetch";
-
-/**
- * Auth controller hook for JWT-based authentication.
- *
- * This is a thin React binding over the headless SDK `client.auth`.
- * It synchronizes React state with the SDK's internal state and delegates
- * all operations to the SDK to ensure a single source of truth for
- * authentication sessions across the entire application.
- *
- * @param props Configuration options
- * @returns RebaseAuthController instance
- */
-export function useRebaseAuthController(
-    props: RebaseAuthControllerProps = {}
-): RebaseAuthController {
-    const { client, onSignOut, defineRolesFor } = props;
-    const auth = client?.auth;
-
-    const [user, setUser] = useState<User | null>(null);
-    const [authLoading, setAuthLoading] = useState(false);
-    const [initialLoading, setInitialLoading] = useState(true);
-    const [authError, setAuthError] = useState<Error | null>(null);
-    const [authProviderError, setAuthProviderError] = useState<Error | null>(null);
-    const [loginSkipped, setLoginSkipped] = useState(false);
-    const [extra, setExtra] = useState<unknown>(null);
-    const [authConfig, setAuthConfig] = useState<AuthConfigResponse | null>(null);
-
-    const isMountedRef = useRef(true);
-    // Keep a stable ref to onSignOut so the listener never goes stale.
-    const onSignOutRef = useRef(onSignOut);
-    onSignOutRef.current = onSignOut;
-    // Keep a stable ref to defineRolesFor too, so an inline (non-memoized)
-    // function from the consumer does not re-run the sync effect on every
-    // render — which would re-subscribe to auth events and re-fetch the
-    // (uncached) auth config each time.
-    const defineRolesForRef = useRef(defineRolesFor);
-    defineRolesForRef.current = defineRolesFor;
-
-    const clearError = useCallback(() => {
-        setAuthProviderError(null);
-    }, []);
-
-    // Sync state with client.auth
-    useEffect(() => {
-        if (!auth) {
-            setInitialLoading(false);
-            return;
-        }
-
-        isMountedRef.current = true;
-
-        const updateState = async (session: RebaseSession | null) => {
-            if (!isMountedRef.current) return;
-
-            let userToSet = session?.user ?? null;
-            const defineRolesFor = defineRolesForRef.current;
-            if (userToSet && defineRolesFor) {
-                try {
-                    const roles = await defineRolesFor(userToSet);
-                    if (roles && isMountedRef.current) {
-                        userToSet = { ...userToSet, roles };
-                    }
-                } catch (e) {
-                    console.error("Error defining roles:", e);
-                }
-            }
-
-            if (isMountedRef.current) {
-                setUser(userToSet);
-            }
-        };
-
-        const syncState = async (event: AuthChangeEvent, session: RebaseSession | null) => {
-            await updateState(session);
-            if (event === "SIGNED_OUT") {
-                // Entities fetched by the session that just ended. The cache is
-                // module-level and keyed by path only, so without this the next
-                // user in the same tab is shown rows they may not be allowed to
-                // read — previews render straight out of it.
-                clearFetchCache();
-                if (isMountedRef.current) {
-                    setLoginSkipped(false);
-                }
-                onSignOutRef.current?.();
-            }
-        };
-
-        // Initial sync with whatever is currently in the SDK
-        updateState(auth.getSession());
-
-        // Wait for SDK initialization (restoring session from storage or silent refresh)
-        auth.isInitialized().then(() => {
-            if (isMountedRef.current) {
-                updateState(auth.getSession());
-                setInitialLoading(false);
-            }
-        }).catch(() => {
-            if (isMountedRef.current) setInitialLoading(false);
-        });
-
-        // Fetch backend auth configuration
-        auth.getAuthConfig().then((config: AuthConfigResponse) => {
-            if (isMountedRef.current) setAuthConfig(config);
-        }).catch((e: unknown) => {
-            // Swallowed entirely before. This is what tells the login view which
-            // providers exist, so losing it renders a login form that is wrong
-            // rather than one that is broken — the hardest kind to report. Not
-            // promoted to `authError`, which blanks the whole app: a signed-in
-            // user is unaffected by this failing.
-            console.warn("[Rebase] Could not load the backend auth configuration; " +
-                "the login view will fall back to defaults.", e);
-        });
-
-        const unsubscribe = auth.onAuthStateChange(syncState);
-
-        return () => {
-            isMountedRef.current = false;
-            unsubscribe();
-        };
-    }, [auth]);
-
-    const getAuthToken = useCallback(async (): Promise<string> => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        const session = auth.getSession();
-
-        // If we have a valid token, return it
-        if (session?.accessToken && session.expiresAt > Date.now() + 10000) {
-            return session.accessToken;
-        }
-
-        // Otherwise, refresh
-        const newSession = await auth.refreshSession();
-        return newSession.accessToken;
-    }, [auth]);
-
-    const signOut = useCallback(async () => {
-        if (!auth) return;
-        setAuthLoading(true);
-        try {
-            await auth.signOut();
-            // signOut emits SIGNED_OUT → syncState calls onSignOutRef.current
-        } catch (error: unknown) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            setAuthProviderError(err);
-        } finally {
-            setAuthLoading(false);
-        }
-    }, [auth]);
-
-    const emailPasswordLogin = useCallback(async (email: string, password: string) => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        setAuthLoading(true);
-        setAuthProviderError(null);
-        try {
-            await auth.signInWithEmail(email, password);
-        } catch (error: unknown) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            setAuthProviderError(err);
-            throw error;
-        } finally {
-            setAuthLoading(false);
-        }
-    }, [auth]);
-
-    const register = useCallback(async (email: string, password: string, displayName?: string) => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        setAuthLoading(true);
-        setAuthProviderError(null);
-        try {
-            await auth.signUp(email, password, displayName);
-        } catch (error: unknown) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            setAuthProviderError(err);
-            throw error;
-        } finally {
-            setAuthLoading(false);
-        }
-    }, [auth]);
-
-    const googleLogin = useCallback(async (
-        payload: { idToken: string } | { accessToken: string } | { code: string; redirectUri: string }
-    ) => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        setAuthLoading(true);
-        setAuthProviderError(null);
-        try {
-            await auth.signInWithGoogle(payload);
-        } catch (error: unknown) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            setAuthProviderError(err);
-            throw error;
-        } finally {
-            setAuthLoading(false);
-        }
-    }, [auth]);
-
-    const oauthLogin = useCallback(async (providerId: string, payload: Record<string, unknown>) => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        setAuthLoading(true);
-        setAuthProviderError(null);
-        try {
-            await auth.signInWithOAuth(providerId, payload);
-        } catch (error: unknown) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            setAuthProviderError(err);
-            throw error;
-        } finally {
-            setAuthLoading(false);
-        }
-    }, [auth]);
-
-    const skipLogin = useCallback(() => {
-        setLoginSkipped(true);
-        setUser(null);
-    }, []);
-
-    const forgotPassword = useCallback(async (email: string) => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        setAuthLoading(true);
-        setAuthProviderError(null);
-        try {
-            await auth.resetPasswordForEmail(email);
-        } catch (error: unknown) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            setAuthProviderError(err);
-            throw error;
-        } finally {
-            setAuthLoading(false);
-        }
-    }, [auth]);
-
-    const resetPassword = useCallback(async (token: string, password: string) => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        setAuthLoading(true);
-        setAuthProviderError(null);
-        try {
-            await auth.resetPassword(token, password);
-        } catch (error: unknown) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            setAuthProviderError(err);
-            throw error;
-        } finally {
-            setAuthLoading(false);
-        }
-    }, [auth]);
-
-    const changePassword = useCallback(async (oldPassword: string, newPassword: string) => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        setAuthLoading(true);
-        setAuthProviderError(null);
-        try {
-            await auth.changePassword(oldPassword, newPassword);
-            // Sign out after password change as sessions are usually invalidated
-            await auth.signOut();
-        } catch (error: unknown) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            setAuthProviderError(err);
-            throw error;
-        } finally {
-            setAuthLoading(false);
-        }
-    }, [auth]);
-
-    const updateProfile = useCallback(async (displayName?: string, photoURL?: string) => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        setAuthLoading(true);
-        setAuthProviderError(null);
-        try {
-            const updatedUser = await auth.updateUser({ displayName, photoURL });
-            return updatedUser;
-        } catch (error: unknown) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            setAuthProviderError(err);
-            throw error;
-        } finally {
-            setAuthLoading(false);
-        }
-    }, [auth]);
-
-    const fetchSessions = useCallback(async () => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        return await auth.getSessions();
-    }, [auth]);
-
-    const revokeSession = useCallback(async (sessionId: string) => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        await auth.revokeSession(sessionId);
-    }, [auth]);
-
-    const revokeAllSessions = useCallback(async () => {
-        if (!auth) throw new Error("Rebase client with auth is required");
-        await auth.revokeAllSessions();
-    }, [auth]);
-
-    return {
-        user,
-        authLoading,
-        initialLoading,
-        authError,
-        authProviderError,
-        loginSkipped,
-        needsSetup: authConfig?.needsSetup ?? false,
-        registrationEnabled: authConfig?.registrationEnabled ?? false,
-        getAuthToken,
-        getApiUrl: () => client?.baseUrl,
-        signOut,
-        emailPasswordLogin,
-        register,
-        googleLogin,
-        oauthLogin,
-        skipLogin,
-        forgotPassword,
-        resetPassword,
-        changePassword,
-        updateProfile,
-        fetchSessions,
-        revokeSession,
-        revokeAllSessions,
-        clearError,
-        setAuthProviderError,
-        extra,
-        setExtra,
-        // `authConfig` is null until `GET /auth/config` lands, so each fallback
-        // is what to assume *while it is still in flight* — not a stand-in for a
-        // backend that might omit the field. The backend always sends all of them.
-        capabilities: {
-            emailPasswordLogin: true,
-            googleLogin: !!(props.googleClientId),
-            registrationEnabled: authConfig?.registrationEnabled ?? false,
-            passwordReset: authConfig?.passwordReset ?? false,
-            // True while loading: the admin UI's "Reset Password" action is worth
-            // showing optimistically and hiding once a backend says it cannot.
-            adminPasswordReset: authConfig?.adminPasswordReset ?? true,
-            sessionManagement: true,
-            profileUpdate: true,
-            emailVerification: authConfig?.emailVerification ?? false,
-            enabledProviders: authConfig?.enabledProviders ?? []
-        }
-    };
-}

package/src/collections/collection_view_config.ts

@@ -1,76 +0,0 @@
-/**
- * Collection helpers that only the admin panel needs.
- *
- * These lived in `@rebasepro/common`, which is on the backend's dependency path,
- * and they read presentation fields — `defaultSelectedView`, `localChangesBackup`
- * — that now live under a collection's `admin` block. A server has no use for
- * either, and `resolveDefaultSelectedView` was the *only* thing making
- * `@rebasepro/common` name an admin view-model type
- * (`DefaultSelectedViewBuilder`), which was the last UI symbol any core package
- * imported.
- */
-import type { ChildViewSource, CollectionConfig } from "@rebasepro/types";
-import { type AdminCollection, type DefaultSelectedViewBuilder, type DefaultSelectedViewParams, resolveAdminCollection } from "@rebasepro/cms-types";
-import { getEntityChildViews } from "@rebasepro/common";
-
-export function resolveDefaultSelectedView(
-    defaultSelectedView: string | DefaultSelectedViewBuilder | undefined,
-    params: DefaultSelectedViewParams
-) {
-    if (!defaultSelectedView) {
-        return undefined;
-    } else if (typeof defaultSelectedView === "string") {
-        return defaultSelectedView;
-    } else {
-        return defaultSelectedView(params);
-    }
-}
-
-export function getLocalChangesBackup(collection: AdminCollection) {
-    if (!collection.localChangesBackup) {
-        return "manual_apply";
-    }
-
-    return collection.localChangesBackup;
-}
-
-/**
- * Returns the primary keys for a entity collection by inspecting the properties
- * and finding any properties with `isId`.
- * Fallbacks to `["id"]` if no properties are marked as `isId: true`.
- * @param collection
- */
-/**
- * A collection's child collections, as the panel's view model.
- *
- * `getSubcollections` in `@rebasepro/common` returns the contract type, so the
- * children of a resolved collection arrived un-flattened and reading
- * `child.icon` or `child.hideFromNavigation` failed. Resolving is not recursive
- * on purpose — children are fetched lazily through a thunk
- * (`childCollections`/`subcollections`), so walking the whole tree eagerly to
- * flatten it would defeat that.
- */
-export function getAdminSubcollections(
-    collection: AdminCollection | CollectionConfig
-): AdminCollection[] {
-    return getAdminEntityChildViews(collection).map(view => view.collection);
-}
-
-/**
- * A collection's child views as the panel's view model, keeping the `source`
- * that says what kind of list each one is.
- *
- * The tabs need it: on a junction-backed relation the parent owns the *link*,
- * so the destructive action is a removal from this record, not a delete. Every
- * caller that renders a tab should prefer this over
- * {@link getAdminSubcollections}, which flattens that distinction away.
- */
-export function getAdminEntityChildViews(
-    collection: AdminCollection | CollectionConfig
-): { key: string; collection: AdminCollection; source: ChildViewSource }[] {
-    return (getEntityChildViews(collection as CollectionConfig) ?? []).map(view => ({
-        key: view.key,
-        collection: resolveAdminCollection(view.collection),
-        source: view.source
-    }));
-}

package/src/collections/entity-display-cache.ts

@@ -1,195 +0,0 @@
-/**
- * The store behind a computed display value.
- *
- * A record's title is asked for far more often than it changes, and by many
- * components at once: a list of fifty rows, each row's relation chips, the
- * breadcrumb above them. Resolving per component is what makes an async display
- * value a bad idea — fifty rows becomes fifty reads, then fifty more on the next
- * render.
- *
- * So resolution is keyed by record *and* role, in-flight calls are shared, and
- * results are kept until something says otherwise. Deliberately not a React
- * thing: the same store answers an imperative caller (an export, a breadcrumb
- * built outside the tree), and it is testable without a renderer.
- */
-import type { EntityDisplayRole } from "@rebasepro/cms-types";
-
-type CacheEntry = {
-    /** Set once resolved. `null` means "resolved to nothing", not "unknown". */
-    value: unknown;
-} | {
-    /** Shared by every caller that arrives while the first one is in flight. */
-    promise: Promise<unknown>;
-};
-
-export type EntityDisplayKey = string;
-
-/** The identity of one role of one record, as a cache key. */
-export function entityDisplayKey(
-    path: string,
-    entityId: string | number | undefined,
-    role: EntityDisplayRole
-): EntityDisplayKey {
-    return `${role} ${path} ${entityId ?? ""}`;
-}
-
-export class EntityDisplayCache {
-
-    private readonly entries = new Map<EntityDisplayKey, CacheEntry>();
-    private readonly listeners = new Set<() => void>();
-
-    /**
-     * The resolved value, or `undefined` when this pair has not been resolved
-     * yet. `null` is a resolved absence, and the two must stay distinct: a
-     * caller that reads "not yet" as "nothing" flickers its fallback in on every
-     * mount.
-     */
-    peek(key: EntityDisplayKey): unknown | undefined {
-        const entry = this.entries.get(key);
-        if (!entry || "promise" in entry) return undefined;
-        return entry.value;
-    }
-
-    /** True while a resolution for this pair is in flight. */
-    isLoading(key: EntityDisplayKey): boolean {
-        const entry = this.entries.get(key);
-        return Boolean(entry && "promise" in entry);
-    }
-
-    /**
-     * Resolve once per record and role. Concurrent callers share the first
-     * call's promise; later callers get the cached value with no promise at all.
-     *
-     * A resolver that throws is recorded as "nothing" rather than retried: the
-     * alternative is every render re-running a call that just failed. And it is
-     * reported here, which is a correction.
-     *
-     * It used to say "the caller that saw the rejection is the one that logs
-     * it", and `useEntityDisplay` duly attached a `.catch()` that warned. But
-     * both failure paths below swallow and return a *resolved* promise, so that
-     * catch could never run — the two halves each did the reasonable thing and
-     * between them the log was unreachable. A resolver that blew up produced a
-     * blank chip and total silence, which is the failure mode
-     * `EntityDisplayResolver`'s own contract ("treated as `undefined` and logged
-     * once") exists to rule out.
-     *
-     * Reporting belongs here for the reason the caller could not do it: this is
-     * the one place that runs exactly once per key, so "once" is a property of
-     * the code rather than a hope about how many components mount.
-     */
-    resolve(key: EntityDisplayKey, resolver: () => unknown): Promise<unknown> {
-        const entry = this.entries.get(key);
-        if (entry) {
-            return "promise" in entry ? entry.promise : Promise.resolve(entry.value);
-        }
-
-        let produced: unknown;
-        try {
-            produced = resolver();
-        } catch (error: unknown) {
-            this.fail(key, error);
-            return Promise.resolve(null);
-        }
-
-        // A synchronous resolver never enters the loading state. Putting it
-        // through one would render every caller's fallback for a frame, for
-        // nothing.
-        if (!isPromise(produced)) {
-            const value = normalize(produced);
-            this.set(key, value);
-            return Promise.resolve(value);
-        }
-
-        const promise = produced
-            .then(resolved => {
-                const value = normalize(resolved);
-                this.set(key, value);
-                return value;
-            })
-            .catch((error: unknown) => {
-                this.fail(key, error);
-                return null;
-            });
-
-        this.entries.set(key, { promise });
-        return promise;
-    }
-
-    /**
-     * Drop what is known about a record, so the next ask resolves again. Called
-     * after a write: the row that just saved may be called something else now.
-     */
-    invalidate(path: string, entityId?: string | number): void {
-        const suffix = ` ${path} ${entityId ?? ""}`;
-        let changed = false;
-        for (const key of [...this.entries.keys()]) {
-            // `undefined` id means the whole collection — after an import, or a
-            // locale switch that changes what every title in it reads.
-            const matches = entityId === undefined
-                ? key.includes(` ${path} `) || key.endsWith(` ${path} `)
-                : key.endsWith(suffix);
-            if (matches) {
-                this.entries.delete(key);
-                changed = true;
-            }
-        }
-        if (changed) this.emit();
-    }
-
-    /** Drop everything. The user signed out, or the app swapped datasource. */
-    clear(): void {
-        if (this.entries.size === 0) return;
-        this.entries.clear();
-        this.emit();
-    }
-
-    subscribe(listener: () => void): () => void {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
-
-    private set(key: EntityDisplayKey, value: unknown): void {
-        this.entries.set(key, { value });
-        this.emit();
-    }
-
-    /**
-     * Record a failed resolution as "nothing", and say so once.
-     *
-     * The key is the message: it is `<role> <path> <id>`, which is exactly what a
-     * reader needs to find the resolver that blew up. A warning with no key would
-     * tell them a display resolver failed somewhere in a list of fifty rows.
-     *
-     * `console.warn` rather than a thrown error, because this runs while a row is
-     * rendering: the contract is that a title which cannot be fetched must not
-     * take down the row that shows it.
-     */
-    private fail(key: EntityDisplayKey, error: unknown): void {
-        console.warn(`[rebase] Could not resolve display value for ${key}:`, error);
-        this.set(key, null);
-    }
-
-    private emit(): void {
-        for (const listener of [...this.listeners]) listener();
-    }
-}
-
-/**
- * Empty strings and empty arrays are absences, not values — a title of `"  "`
- * would otherwise beat the derived one and render as a blank heading.
- */
-function normalize(value: unknown): unknown {
-    if (value === undefined || value === null) return null;
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : null;
-    }
-    if (Array.isArray(value)) return value.length > 0 ? value : null;
-    return value;
-}
-
-function isPromise(value: unknown): value is Promise<unknown> {
-    return typeof (value as Promise<unknown> | undefined)?.then === "function";
-}

package/src/collections/entity-display.ts

@@ -1,77 +0,0 @@
-/**
- * Reading a collection's `display` block.
- *
- * Two questions, kept apart because they are answered at different times: which
- * *property* fills a role (readable from values already in hand) and which
- * *resolver* fills it (may have to go to the network). A caller that cannot
- * await — a sort comparator, an export column, a server render — uses the key
- * and is documented to ignore resolvers.
- */
-import type {
-    AdminCollection,
-    EntityDisplayResolver,
-    EntityDisplayRole
-} from "@rebasepro/cms-types";
-
-/**
- * What the collection declares for a role, before deciding which form it is.
- *
- * One field states it: `display[role]`. `admin.titleProperty` used to be a
- * second way to say `display.title` and is gone — a role with two spellings is
- * a role with two readers, and this one had grown seven.
- */
-function getDeclaredSource<M extends Record<string, unknown>>(
-    collection: AdminCollection<M>,
-    role: EntityDisplayRole
-): string | EntityDisplayResolver<M, unknown> | undefined {
-    const display = collection.display as Record<string, unknown> | undefined;
-    const declared = display?.[role];
-    return declared === undefined
-        ? undefined
-        : declared as string | EntityDisplayResolver<M, unknown>;
-}
-
-/**
- * The property path a role is declared to read, when it is declared as a path.
- *
- * Returns `undefined` for a role filled by a resolver — a resolver has no key —
- * and for a role the collection says nothing about, which is then derived.
- *
- * @group Collections
- */
-export function getDisplayPropertyKey<M extends Record<string, unknown>>(
-    collection: AdminCollection<M>,
-    role: EntityDisplayRole
-): string | undefined {
-    const declared = getDeclaredSource(collection, role);
-    return typeof declared === "string" ? declared : undefined;
-}
-
-/**
- * The resolver a role is declared to use, when it is declared as one.
- *
- * @group Collections
- */
-export function getDisplayResolver<M extends Record<string, unknown>>(
-    collection: AdminCollection<M>,
-    role: EntityDisplayRole
-): EntityDisplayResolver<M, unknown> | undefined {
-    const declared = getDeclaredSource(collection, role);
-    return typeof declared === "function" ? declared : undefined;
-}
-
-/**
- * True when the collection states this role at all, in either form.
- *
- * The derivation is a guess about what a collection probably means; a statement
- * outranks it, and the heuristics that look for "the first enum" or "the leading
- * relation" have to stand down when one exists.
- *
- * @group Collections
- */
-export function hasDeclaredDisplay<M extends Record<string, unknown>>(
-    collection: AdminCollection<M>,
-    role: EntityDisplayRole
-): boolean {
-    return getDeclaredSource(collection, role) !== undefined;
-}