@manta-eu/react 0.11.0 → 0.13.0

package/src/routes/memories/schemas/schema-table.ts

@@ -0,0 +1,54 @@
+import type { GQLMemorySchemaFieldsFragment, GQLMemorySchemaRuleCountsQuery } from "@manta-eu/client";
+import { isPresent } from "@manta-eu/lib/present";
+
+export function ruleCountsFrom(
+  response: GQLMemorySchemaRuleCountsQuery["memorySchemaRuleCounts"] | undefined,
+): ReadonlyMap<string, number> | undefined {
+  if (!response || isPresent(response.error)) return undefined;
+  return new Map(response.counts.map(({ iri, ruleCount }) => [iri, ruleCount]));
+}
+
+export type CountFilter = "ANY" | "NONE" | "SOME";
+
+export type SchemaCountKey = "properties" | "rules" | "memories";
+
+export type SchemaCountFilters = Record<SchemaCountKey, CountFilter>;
+
+export const anyCount: SchemaCountFilters = { properties: "ANY", rules: "ANY", memories: "ANY" };
+
+export type SchemaCounts = Record<SchemaCountKey, number | null>;
+
+export function schemaCounts(
+  schema: GQLMemorySchemaFieldsFragment,
+  ruleCounts: ReadonlyMap<string, number> | undefined,
+): SchemaCounts {
+  return {
+    properties: schema.properties.filter((property) => !property.computed).length,
+    rules: ruleCounts ? (ruleCounts.get(schema.iri) ?? 0) : null,
+    memories: schema.memoryCount ?? null,
+  };
+}
+
+export function countMatches(count: number | null, filter: CountFilter): boolean {
+  if (filter === "ANY") return true;
+  if (count === null) return false;
+  return filter === "NONE" ? count === 0 : count > 0;
+}
+
+export function filterSchemas(
+  schemas: readonly GQLMemorySchemaFieldsFragment[],
+  search: string,
+  filters: SchemaCountFilters,
+  ruleCounts: ReadonlyMap<string, number> | undefined,
+): GQLMemorySchemaFieldsFragment[] {
+  const needle = search.trim().toLowerCase();
+  return schemas.filter((schema) => {
+    const matchesSearch =
+      !isPresent(needle) ||
+      schema.label.toLowerCase().includes(needle) ||
+      (schema.description ?? "").toLowerCase().includes(needle);
+    if (!matchesSearch) return false;
+    const counts = schemaCounts(schema, ruleCounts);
+    return (Object.keys(filters) as SchemaCountKey[]).every((key) => countMatches(counts[key], filters[key]));
+  });
+}

package/src/routes/memories/schemas/useMemorySchemaMutations.ts

@@ -0,0 +1,49 @@
+import {
+  useAddMemorySchemaFromTemplateMutation,
+  useArchiveMemorySchemaMutation,
+  useClearMemorySchemaPropertyValuesMutation,
+  useCreateMemorySchemaMutation,
+  useDeleteMemorySchemaMutation,
+  useDismissMemorySchemaTemplateUpdateMutation,
+  useMemoriesQuery,
+  useMemorySchemasQuery,
+  useMemorySchemaTemplatesQuery,
+  useMemorySchemaUsageQuery,
+  useResetMemorySchemaToTemplateMutation,
+  useUnarchiveMemorySchemaMutation,
+  useUpdateMemorySchemaMutation,
+} from "@manta-eu/client";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+import { invalidateQueries } from "#lib/tanstack-query";
+import { useMantaClient } from "#providers/index";
+
+// A schema write can rewrite stored values, so the memories that hold them are refetched with it.
+export function useMemorySchemaMutations() {
+  const { mantaClient } = useMantaClient();
+  const queryClient = useQueryClient();
+
+  const refresh = useCallback(async () => {
+    await invalidateQueries(queryClient, [
+      useMemorySchemasQuery,
+      useMemorySchemaUsageQuery,
+      useMemorySchemaTemplatesQuery,
+      useMemoriesQuery,
+    ]);
+  }, [queryClient]);
+
+  return {
+    refresh,
+    create: useCreateMemorySchemaMutation(mantaClient),
+    update: useUpdateMemorySchemaMutation(mantaClient),
+    archive: useArchiveMemorySchemaMutation(mantaClient),
+    unarchive: useUnarchiveMemorySchemaMutation(mantaClient),
+    remove: useDeleteMemorySchemaMutation(mantaClient),
+    addFromTemplate: useAddMemorySchemaFromTemplateMutation(mantaClient),
+    resetToTemplate: useResetMemorySchemaToTemplateMutation(mantaClient),
+    dismissTemplateUpdate: useDismissMemorySchemaTemplateUpdateMutation(mantaClient),
+    clearValues: useClearMemorySchemaPropertyValuesMutation(mantaClient),
+  };
+}
+
+export type MemorySchemaMutations = ReturnType<typeof useMemorySchemaMutations>;

package/src/routes/memories/schemas/useSchemaChangeReview.ts

@@ -0,0 +1,238 @@
+import {
+  GQLMemorySchemaMutationStatus,
+  type GQLMemorySchemaMutationResultFragment,
+  type GQLMemorySchemaOptionRemapInput,
+} from "@manta-eu/client";
+import { parseError } from "@manta-eu/client/shared/error-utils";
+import { isPresent } from "@manta-eu/lib/present";
+import { useCallback, useRef, useState } from "react";
+import { toast } from "sonner";
+import { match, P } from "ts-pattern";
+import {
+  impactNeedsReview,
+  optionRemapsInput,
+  type MemorySchemaImpact,
+  type OptionRemapChoices,
+} from "./schema-impact";
+
+export type SchemaChangeRequest = {
+  expectedRevision: number;
+  optionRemaps: GQLMemorySchemaOptionRemapInput[];
+  clearUnconvertibleValues: boolean;
+  dryRun: boolean;
+};
+
+export type SchemaChangeResult = GQLMemorySchemaMutationResultFragment;
+
+export type SchemaChangeRun = (request: SchemaChangeRequest) => Promise<SchemaChangeResult>;
+
+export type SchemaClearRun = (path: string, expectedRevision: number) => Promise<SchemaChangeResult>;
+
+export type SchemaChangeCallbacks = {
+  onApplied: (result: SchemaChangeResult) => void | Promise<void>;
+  onInvalid?: (result: SchemaChangeResult) => void;
+  onStale: () => void | Promise<void>;
+  onRevisionChange?: (revision: number) => void;
+};
+
+type ReviewState = {
+  session: number;
+  title: string;
+  run: SchemaChangeRun;
+  callbacks: SchemaChangeCallbacks;
+  revision: number;
+  impact: MemorySchemaImpact | null;
+  proposed: SchemaChangeResult["schema"];
+  choices: OptionRemapChoices;
+  clearUnconvertible: boolean;
+};
+
+type Outcome = "open" | "closed";
+
+export function refusalMessage(result: SchemaChangeResult): string {
+  const validation = result.validationErrors.map((error) => error.message).join("; ");
+  return result.error ?? (isPresent(validation) ? validation : "The schema could not be changed");
+}
+
+function requestFor(state: ReviewState, dryRun: boolean): SchemaChangeRequest {
+  return {
+    expectedRevision: state.revision,
+    optionRemaps: state.impact ? optionRemapsInput(state.impact, state.choices) : [],
+    clearUnconvertibleValues: state.clearUnconvertible,
+    dryRun,
+  };
+}
+
+export function reportFailure(error: unknown, fallback: string) {
+  const parsed = parseError(error, fallback);
+  toast.error(parsed.message, { description: parsed.description });
+}
+
+// Every check is a dry run against the server, so the review shows exactly what applying would do. Each review is a
+// session: closing it ends the session, so a check still in flight cannot open the dialog again. Only the latest check
+// settles, so a slower earlier one cannot bring back choices the person has since changed.
+export function useSchemaChangeReview() {
+  const session = useRef(0);
+  const latestCheck = useRef(0);
+  const [state, setState] = useState<ReviewState | null>(null);
+  const [isChecking, setChecking] = useState(false);
+  const [isApplying, setApplying] = useState(false);
+  const [clearingPath, setClearingPath] = useState<string | null>(null);
+
+  const settle = useCallback(async (result: SchemaChangeResult, next: ReviewState, show = true): Promise<Outcome> => {
+    const { onApplied, onInvalid, onStale } = next.callbacks;
+    const current = next.session === session.current;
+    return match(result.status)
+      .with(GQLMemorySchemaMutationStatus.Ok, async (): Promise<Outcome> => {
+        setState(null);
+        await onApplied(result);
+        return "closed";
+      })
+      .with(
+        P.union(GQLMemorySchemaMutationStatus.Preview, GQLMemorySchemaMutationStatus.Blocked),
+        async (): Promise<Outcome> => {
+          if (show && current) setState({ ...next, impact: result.impact ?? null, proposed: result.schema });
+          return current ? "open" : "closed";
+        },
+      )
+      .with(GQLMemorySchemaMutationStatus.Invalid, async (): Promise<Outcome> => {
+        setState(null);
+        if (onInvalid) onInvalid(result);
+        else toast.error(refusalMessage(result));
+        return "closed";
+      })
+      .with(
+        P.union(GQLMemorySchemaMutationStatus.Conflict, GQLMemorySchemaMutationStatus.NotFound),
+        async (): Promise<Outcome> => {
+          setState(null);
+          toast.error(refusalMessage(result));
+          await onStale();
+          return "closed";
+        },
+      )
+      .with(GQLMemorySchemaMutationStatus.Limit, async (): Promise<Outcome> => {
+        setState(null);
+        toast.error(refusalMessage(result));
+        return "closed";
+      })
+      .exhaustive();
+  }, []);
+
+  const check = useCallback(
+    async (next: ReviewState, show = true) => {
+      const ticket = ++latestCheck.current;
+      const superseded = () => ticket !== latestCheck.current;
+      setChecking(true);
+      try {
+        const result = await next.run(requestFor(next, true));
+        if (superseded()) return null;
+        return { result, outcome: await settle(result, next, show) };
+      } catch (error) {
+        if (superseded()) return null;
+        setState(null);
+        reportFailure(error, "Failed to check the change");
+        return null;
+      } finally {
+        if (!superseded()) setChecking(false);
+      }
+    },
+    [settle],
+  );
+
+  const applyState = useCallback(
+    async (current: ReviewState) => {
+      setApplying(true);
+      try {
+        await settle(await current.run(requestFor(current, false)), current);
+      } catch (error) {
+        reportFailure(error, "Failed to save the schema");
+      } finally {
+        setApplying(false);
+      }
+    },
+    [settle],
+  );
+
+  // `alwaysReview` shows the dialog even when no stored value moves, for a change the person did not author.
+  const start = useCallback(
+    async (options: {
+      title: string;
+      run: SchemaChangeRun;
+      revision: number;
+      callbacks: SchemaChangeCallbacks;
+      alwaysReview?: boolean;
+    }) => {
+      session.current += 1;
+      const initial: ReviewState = {
+        session: session.current,
+        title: options.title,
+        run: options.run,
+        callbacks: options.callbacks,
+        revision: options.revision,
+        impact: null,
+        proposed: null,
+        choices: {},
+        clearUnconvertible: false,
+      };
+      const alwaysReview = options.alwaysReview === true;
+      if (alwaysReview) setState(initial);
+      const checked = await check(initial, alwaysReview);
+      if (checked === null || checked.outcome === "closed" || alwaysReview) return;
+      if (initial.session !== session.current) return;
+      const reviewed = { ...initial, impact: checked.result.impact ?? null, proposed: checked.result.schema };
+      if (reviewed.impact && !impactNeedsReview(reviewed.impact)) await applyState(reviewed);
+      else setState(reviewed);
+    },
+    [check, applyState],
+  );
+
+  const recheck = useCallback(
+    (patch: Partial<Pick<ReviewState, "choices" | "clearUnconvertible">>) => {
+      if (state === null) return;
+      const next = { ...state, ...patch };
+      setState(next);
+      void check(next);
+    },
+    [state, check],
+  );
+
+  const clearValues = useCallback(
+    async (path: string, clear: SchemaClearRun) => {
+      if (state === null) return;
+      setClearingPath(path);
+      try {
+        const result = await clear(path, state.revision);
+        if (result.status !== GQLMemorySchemaMutationStatus.Ok || !result.schema) {
+          toast.error(refusalMessage(result));
+          return;
+        }
+        toast.success("Values cleared");
+        state.callbacks.onRevisionChange?.(result.schema.revision);
+        await check({ ...state, revision: result.schema.revision });
+      } catch (error) {
+        reportFailure(error, "Failed to clear the values");
+      } finally {
+        setClearingPath(null);
+      }
+    },
+    [state, check],
+  );
+
+  return {
+    state,
+    isChecking,
+    isApplying,
+    clearingPath,
+    start,
+    close: () => {
+      session.current += 1;
+      setState(null);
+    },
+    apply: () => (state ? applyState(state) : Promise.resolve()),
+    setRemapChoice: (key: string, choice: string) => recheck({ choices: { ...(state?.choices ?? {}), [key]: choice } }),
+    setClearUnconvertible: (clearUnconvertible: boolean) => recheck({ clearUnconvertible }),
+    clearValues,
+  };
+}
+
+export type SchemaChangeReview = ReturnType<typeof useSchemaChangeReview>;

package/src/routes/memories/schemas/useSchemaLifecycle.tsx

@@ -0,0 +1,151 @@
+import { GQLMemorySchemaMutationStatus, type GQLMemorySchemaFieldsFragment } from "@manta-eu/client";
+import { humanCount } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+import { useCallback, useState } from "react";
+import { toast } from "sonner";
+import { match, P } from "ts-pattern";
+import { readableBlockers } from "./schema-impact";
+import { SchemaConfirmDialog } from "./SchemaConfirmDialog";
+import { useMemorySchemaMutations } from "./useMemorySchemaMutations";
+import { refusalMessage, reportFailure, type SchemaChangeResult } from "./useSchemaChangeReview";
+
+export function reportResult(result: SchemaChangeResult, success: string): boolean {
+  return match(result)
+    .with({ status: GQLMemorySchemaMutationStatus.Ok }, () => {
+      toast.success(success);
+      return true;
+    })
+    .with({ status: GQLMemorySchemaMutationStatus.Blocked, impact: { blockers: P.when(isPresent) } }, ({ impact }) => {
+      toast.error("This cannot be done yet", { description: readableBlockers(impact).join(" ") });
+      return false;
+    })
+    .otherwise(() => {
+      toast.error(refusalMessage(result));
+      return false;
+    });
+}
+
+export function archiveBlockedReason(ruleCount: number | null | undefined): string | null {
+  if (!ruleCount) return null;
+  return ruleCount === 1
+    ? "1 rule uses this schema. Change that rule first."
+    : `${humanCount(ruleCount, "rule")} use this schema. Change those rules first.`;
+}
+
+export function deleteBlockedReason(memoryCount: number | null | undefined, ruleCount?: number | null): string | null {
+  const rulesBlock = archiveBlockedReason(ruleCount);
+  if (rulesBlock !== null) return rulesBlock;
+  if (!memoryCount) return null;
+  return `${humanCount(memoryCount, "memory")} ${memoryCount === 1 ? "uses" : "use"} this schema, so it can only be archived`;
+}
+
+type Confirming = { action: "archive" | "delete"; schema: GQLMemorySchemaFieldsFragment };
+
+export function useSchemaLifecycle(options: { onDeleted?: () => void } = {}) {
+  const { onDeleted } = options;
+  const mutations = useMemorySchemaMutations();
+  const [confirming, setConfirming] = useState<Confirming | null>(null);
+  const isPending = mutations.archive.isPending || mutations.unarchive.isPending || mutations.remove.isPending;
+
+  const { refresh } = mutations;
+  const runStatus = useCallback(
+    async (
+      action: () => Promise<SchemaChangeResult>,
+      success: string,
+      after?: (result: SchemaChangeResult) => void,
+    ) => {
+      try {
+        const result = await action();
+        if (reportResult(result, success)) after?.(result);
+        await refresh();
+      } catch (error) {
+        reportFailure(error, "The schema could not be changed");
+      } finally {
+        setConfirming(null);
+      }
+    },
+    [refresh],
+  );
+
+  const unarchive = mutations.unarchive.mutateAsync;
+  const restore = useCallback(
+    (schema: GQLMemorySchemaFieldsFragment) => {
+      void runStatus(
+        async () =>
+          (await unarchive({ input: { iri: schema.iri, expectedRevision: schema.revision } })).unarchiveMemorySchema,
+        `Restored ${schema.label}`,
+      );
+    },
+    [runStatus, unarchive],
+  );
+  const askToArchive = useCallback(
+    (schema: GQLMemorySchemaFieldsFragment) => setConfirming({ action: "archive", schema }),
+    [],
+  );
+  const askToDelete = useCallback(
+    (schema: GQLMemorySchemaFieldsFragment) => setConfirming({ action: "delete", schema }),
+    [],
+  );
+
+  const archiving = confirming?.action === "archive" ? confirming.schema : null;
+  const deleting = confirming?.action === "delete" ? confirming.schema : null;
+
+  const dialogs = (
+    <>
+      <SchemaConfirmDialog
+        open={archiving !== null}
+        title={`Archive ${archiving?.label ?? "this schema"}?`}
+        description="No new memory can use it. Memories that already use it keep their values, and you can restore it later."
+        confirmLabel="Archive"
+        pendingLabel="Archiving…"
+        isPending={mutations.archive.isPending}
+        onCancel={() => setConfirming(null)}
+        onConfirm={() => {
+          if (archiving === null) return;
+          void runStatus(
+            async () =>
+              (
+                await mutations.archive.mutateAsync({
+                  input: { iri: archiving.iri, expectedRevision: archiving.revision },
+                })
+              ).archiveMemorySchema,
+            `Archived ${archiving.label}`,
+          );
+        }}
+      />
+      <SchemaConfirmDialog
+        open={deleting !== null}
+        title={`Delete ${deleting?.label ?? "this schema"}?`}
+        description="This removes the schema for good. No memory uses it."
+        confirmLabel="Delete"
+        pendingLabel="Deleting…"
+        destructive
+        isPending={mutations.remove.isPending}
+        onCancel={() => setConfirming(null)}
+        onConfirm={() => {
+          if (deleting === null) return;
+          void runStatus(
+            async () =>
+              (
+                await mutations.remove.mutateAsync({
+                  input: { iri: deleting.iri, expectedRevision: deleting.revision },
+                })
+              ).deleteMemorySchema,
+            `Deleted ${deleting.label}`,
+            onDeleted,
+          );
+        }}
+      />
+    </>
+  );
+
+  return {
+    mutations,
+    isPending,
+    runStatus,
+    askToArchive,
+    askToDelete,
+    restore,
+    dialogs,
+  };
+}

package/src/routes/memories/schemas/useSchemasTab.ts

@@ -0,0 +1,119 @@
+import {
+  GQLMemorySchemaMutationStatus,
+  GQLMemorySchemaStatus,
+  useMemorySchemasQuery,
+  useMemorySchemaTemplatesQuery,
+  type GQLMemorySchemaFieldsFragment,
+} from "@manta-eu/client";
+import { parseError } from "@manta-eu/client/shared/error-utils";
+import { Archive, EyeOff, LayoutTemplate, Plus } from "lucide-react";
+import { useCallback, useMemo, useState } from "react";
+import { useLocation, useNavigate, useParams } from "react-router";
+import { toast } from "sonner";
+import { memorySchemaView, newMemorySchemaPath } from "./schema-route";
+import type { SchemaTemplatesDialogProps } from "./SchemaTemplatesDialog";
+import { useMemorySchemaMutations } from "./useMemorySchemaMutations";
+import type { PageHeaderAction } from "#components/layouts/page/index";
+import { useMantaClient } from "#providers/index";
+
+const emptySchemas: GQLMemorySchemaFieldsFragment[] = [];
+
+// Everything the memories route needs for its Schemas tab, the schema pages under it, and the defaults dialog.
+export function useSchemasTab(options: { canManage: boolean }) {
+  const { canManage } = options;
+  const { mantaClient } = useMantaClient();
+  const navigate = useNavigate();
+  const { schemaName } = useParams<{ schemaName?: string }>();
+  const { pathname } = useLocation();
+
+  const { data, isLoading, error } = useMemorySchemasQuery(mantaClient, { includeArchived: true });
+  const schemas = data?.memorySchemas.schemas ?? emptySchemas;
+  const errorMessage =
+    data?.memorySchemas.error ?? (error ? parseError(error, "Failed to load schemas").message : null);
+  const mutations = useMemorySchemaMutations();
+
+  const [query, setQuery] = useState("");
+  const [showArchived, setShowArchived] = useState(false);
+  const [showTemplates, setShowTemplates] = useState(false);
+  const [addingTemplateIri, setAddingTemplateIri] = useState<string | null>(null);
+  const {
+    data: templatesData,
+    isLoading: templatesLoading,
+    error: templatesError,
+  } = useMemorySchemaTemplatesQuery(mantaClient, undefined, { enabled: showTemplates && canManage });
+
+  const listedSchemas = useMemo(
+    () => (showArchived ? schemas : schemas.filter((schema) => schema.status === GQLMemorySchemaStatus.Active)),
+    [schemas, showArchived],
+  );
+
+  const addTemplate = useCallback(
+    async (templateIri: string) => {
+      setAddingTemplateIri(templateIri);
+      try {
+        const result = (await mutations.addFromTemplate.mutateAsync({ templateIri })).addMemorySchemaFromTemplate;
+        if (result.status !== GQLMemorySchemaMutationStatus.Ok) {
+          throw new Error(result.error ?? "The default schema could not be restored");
+        }
+        toast.success(`Restored ${result.schema?.label ?? "the default schema"}`);
+        await mutations.refresh();
+      } catch (e) {
+        const err = parseError(e, "Failed to restore the default schema");
+        toast.error(err.message, { description: err.description });
+      } finally {
+        setAddingTemplateIri(null);
+      }
+    },
+    [mutations],
+  );
+
+  const openNew = useCallback(() => void navigate(newMemorySchemaPath), [navigate]);
+
+  const headerActions: PageHeaderAction[] = [
+    {
+      key: "archived-schemas",
+      label: showArchived ? "Hide archived" : "Show archived",
+      icon: showArchived ? EyeOff : Archive,
+      variant: "secondary",
+      active: showArchived,
+      onClick: () => setShowArchived((v) => !v),
+    },
+    ...(canManage
+      ? [
+          {
+            key: "templates",
+            label: "Restore defaults",
+            icon: LayoutTemplate,
+            variant: "secondary",
+            onClick: () => setShowTemplates(true),
+          } satisfies PageHeaderAction,
+          { key: "new-schema", label: "New schema", icon: Plus, onClick: openNew } satisfies PageHeaderAction,
+        ]
+      : []),
+  ];
+
+  const templatesDialog: SchemaTemplatesDialogProps = {
+    open: showTemplates,
+    templates: templatesData?.memorySchemaTemplates.templates ?? [],
+    isLoading: templatesLoading,
+    errorMessage:
+      templatesData?.memorySchemaTemplates.error ??
+      (templatesError ? parseError(templatesError, "Failed to load the default schemas").message : null),
+    addingIri: addingTemplateIri,
+    onAdd: (iri) => void addTemplate(iri),
+    onClose: () => setShowTemplates(false),
+  };
+
+  return {
+    view: memorySchemaView(pathname, schemaName),
+    schemas,
+    listedSchemas,
+    isLoading,
+    errorMessage,
+    query,
+    setQuery,
+    openNew,
+    headerActions,
+    templatesDialog,
+  };
+}

package/src/routes/plans/index.tsx

@@ -30,7 +30,8 @@ function renderActionPlansRouteLayout(props: ActionPlansFrameProps) {
 }
 
 export function PlansRoute() {
-  const { datastore, datastores, user, logout, isOperator, canSwitchDatastore, allowedModels } = useAuthContext();
+  const { datastore, user } = useAuthContext();
+
   const { planName } = useActionPlanRouteState();
 
   const routeContent = useMemo(() => {
@@ -41,19 +42,7 @@ export function PlansRoute() {
     return <StandalonePlanDetailRoute planName={planName} datastoreId={datastore?.id} userId={user.id} />;
   }, [planName, datastore?.id, user.id]);
 
-  return (
-    <RouteLayout
-      user={user}
-      datastore={datastore}
-      datastores={datastores}
-      isOperator={isOperator}
-      canSwitchDatastore={canSwitchDatastore}
-      logout={logout}
-      allowedModels={allowedModels}
-    >
-      {routeContent}
-    </RouteLayout>
-  );
+  return <RouteLayout>{routeContent}</RouteLayout>;
 }
 
 function StandalonePlanDetailRoute(props: { planName: string; datastoreId?: string; userId?: string }) {