@manta-eu/react 0.8.1 → 0.9.0

package/src/routes/datastores/components/StatusBadge.tsx

@@ -1,3 +1,4 @@
+import { enableDatastoreRemoval } from "@manta-eu/client/shared/constants";
 import { isPresent } from "@manta-eu/lib/present";
 import { LoaderCircle } from "lucide-react";
 import { Badge, type BadgeVariant } from "#components/badge/index";
@@ -7,13 +8,13 @@ import {
   type DatastoreStatusCategory,
 } from "#components/datastore-management/tree";
 
-export type DatastoreStatusFilterValue = "noDatastore" | "checking" | DatastoreStatusCategory;
+export type DatastoreStatusFilterValue = "noDatastore" | "checking" | "notBuilt" | DatastoreStatusCategory;
 
-export function datastoreStatusFilterValue(
-  node: { datastoreId?: string; removed: boolean; isUnlinked?: boolean },
-  status?: DatastoreStatus,
-): DatastoreStatusFilterValue {
+type StatusNode = { datastoreId?: string; removed: boolean; isUnlinked?: boolean; unbuilt?: boolean };
+
+export function datastoreStatusFilterValue(node: StatusNode, status?: DatastoreStatus): DatastoreStatusFilterValue {
   if (!isPresent(node.datastoreId)) return "noDatastore";
+  if (node.unbuilt === true && status?.exists !== true) return "notBuilt";
   return datastoreStatusCategory(node, status) ?? "checking";
 }
 
@@ -33,10 +34,23 @@ const badgeConfigByFilterValue: Record<DatastoreStatusFilterValue, BadgeConfig>
     variant: "destructive",
     title: "This id never reached the datastore registry, so nothing will build it. Provision it again.",
   },
+  notBuilt: {
+    label: "Not built",
+    variant: "warning",
+    title: "Registered in Infisical, but no datastore exists for it. Link it to build it, or delete it.",
+  },
   offline: { label: "Offline", variant: "destructive" },
   unavailable: { label: "Status unavailable", variant: "copy" },
   checking: { label: "Checking…", variant: "copy", spinning: true },
-  removed: { label: "Removed", variant: "copy" },
+  removed: enableDatastoreRemoval
+    ? { label: "Removed", variant: "copy" }
+    : {
+        label: "Removed",
+        variant: "warning",
+        title:
+          "Out of use: a permanent delete stopped partway, or it was removed before removal was turned off. " +
+          "Delete it permanently only if it should go for good.",
+      },
   noDatastore: { label: "No datastore", variant: "copy" },
 };
 
@@ -44,6 +58,7 @@ const filterOptionOrder: DatastoreStatusFilterValue[] = [
   "ready",
   "materializing",
   "notRegistered",
+  "notBuilt",
   "offline",
   "unavailable",
   "removed",
@@ -55,7 +70,7 @@ export const datastoreStatusFilterOptions: { id: "ALL" | DatastoreStatusFilterVa
 ];
 
 export type DatastoreStatusBadgeProps = {
-  node: { datastoreId?: string; removed: boolean; isUnlinked?: boolean };
+  node: StatusNode;
   status?: DatastoreStatus;
 };
 

package/src/routes/datastores/flatten.ts

@@ -25,6 +25,7 @@ export type DatastoreRow = {
   // Real in the datastore, but no Keycloak node behind it, so it can only be selected.
   isRealmDefault?: boolean;
   isUnlinked?: boolean;
+  unbuilt?: boolean;
 };
 
 export function realmDefaultRow(datastoreId: Realm): DatastoreRow {
@@ -105,6 +106,15 @@ export function hiddenRowCount(
   return visibleDatastoreRows(rows, { ...visibility, [key]: true }).length - shownCount;
 }
 
+export function hiddenRemovedRowCount(rows: DatastoreRow[], visibility: DatastoreRowVisibility): number {
+  if (visibility.showArchived) return 0;
+
+  const shown = new Set(visibleDatastoreRows(rows, visibility));
+  return rows.filter(
+    (row) => row.removed && !shown.has(row) && matchesVisibility(row, { ...visibility, showArchived: true }),
+  ).length;
+}
+
 // Matches Keycloak's own org lookup (ensureOrganization), which is case-insensitive and trims too.
 export function organizationNameKey(name: string): string {
   return name.trim().toLowerCase();
@@ -118,6 +128,33 @@ export function organizationNames(rows: DatastoreRow[]): string[] {
   return [...new Set(rows.filter((row) => row.isOrganization).map((row) => row.organizationName))].sort();
 }
 
+export function removedSubtreeRowIds(rows: DatastoreRow[]): Set<string> {
+  const ids = new Set<string>();
+  let removedDepth: number | undefined;
+  for (const row of rows) {
+    if (removedDepth === undefined || row.depth <= removedDepth) removedDepth = row.removed ? row.depth : undefined;
+    if (removedDepth !== undefined) ids.add(row.id);
+  }
+  return ids;
+}
+
+export function outsideRemovedSubtrees(rows: DatastoreRow[]): DatastoreRow[] {
+  const removed = removedSubtreeRowIds(rows);
+  return rows.filter((row) => !removed.has(row.id));
+}
+
+export function organizationGroupPaths(rows: DatastoreRow[]): Map<string, string[]> {
+  const paths = new Map<string, string[]>();
+  for (const row of outsideRemovedSubtrees(rows)) {
+    if (row.isOrganization || row.isRealmDefault === true || row.isUnlinked === true) continue;
+
+    const organizationPaths = paths.get(row.organizationName);
+    if (organizationPaths) organizationPaths.push(row.path);
+    else paths.set(row.organizationName, [row.path]);
+  }
+  return paths;
+}
+
 export function visibilityForStatusFilter(
   visibility: DatastoreRowVisibility,
   status: DatastoreStatusFilterValue | "ALL",
@@ -125,11 +162,21 @@ export function visibilityForStatusFilter(
   return match(status)
     .with("removed", () => ({ ...visibility, showArchived: true }))
     .with("noDatastore", () => ({ ...visibility, showUnprovisioned: true }))
-    .with("ALL", "ready", "materializing", "notRegistered", "offline", "unavailable", "checking", () => visibility)
+    .with(
+      "ALL",
+      "ready",
+      "materializing",
+      "notRegistered",
+      "notBuilt",
+      "offline",
+      "unavailable",
+      "checking",
+      () => visibility,
+    )
     .exhaustive();
 }
 
-export function unlinkedDatastoreRow(datastoreId: string): DatastoreRow {
+export function unlinkedDatastoreRow(datastoreId: string, built = true): DatastoreRow {
   return {
     id: `unlinked:${datastoreId}`,
     name: datastoreId,
@@ -142,6 +189,7 @@ export function unlinkedDatastoreRow(datastoreId: string): DatastoreRow {
     removed: false,
     isOrganization: false,
     isUnlinked: true,
+    unbuilt: !built,
   };
 }
 

package/src/routes/datastores/hooks/useDatastoreColumns.tsx

@@ -6,6 +6,7 @@ import {
   Blocks,
   Check,
   DatabaseZap,
+  Hammer,
   Link2,
   MoreHorizontal,
   Pencil,
@@ -113,6 +114,8 @@ type UseDatastoreColumnsArgs = {
   onDelete: (row: DatastoreRow) => void;
   onRename: (row: DatastoreRow) => void;
   onRegister: (row: DatastoreRow) => void;
+  registeringDatastoreIds: ReadonlySet<string>;
+  removedSubtreeRowIds: ReadonlySet<string>;
   onManageUsers: (row: DatastoreRow) => void;
   onManageCustomApps: (row: DatastoreRow) => void;
   onBringOnline: (row: DatastoreRow) => void;
@@ -141,6 +144,8 @@ export function useDatastoreColumns(args: UseDatastoreColumnsArgs): ColumnDef<Da
     onDelete,
     onRename,
     onRegister,
+    registeringDatastoreIds,
+    removedSubtreeRowIds,
     onManageUsers,
     onManageCustomApps,
     onBringOnline,
@@ -311,6 +316,8 @@ export function useDatastoreColumns(args: UseDatastoreColumnsArgs): ColumnDef<Da
           const status = hasDatastore ? statusByDatastoreId[datastoreId] : undefined;
           const category = datastoreStatusCategory(datastoreRow, status);
           const notRegistered = category === "notRegistered";
+          const buildable = category === "materializing";
+          const registering = hasDatastore && registeringDatastoreIds.has(datastoreId);
           const reason = match({ notRegistered, materializing: isMaterializing(status) && !isRealmDefault })
             .with({ notRegistered: true }, () => "Not registered - use Register to fix, then try selecting again.")
             .with({ materializing: true }, () => "Still materializing - this can take a few minutes.")
@@ -359,12 +366,13 @@ export function useDatastoreColumns(args: UseDatastoreColumnsArgs): ColumnDef<Da
                   Bring online
                 </Button>
               )}
-              {!isUnlinked && hasDatastore && !removed && notRegistered && (
+              {!isUnlinked && hasDatastore && !removedSubtreeRowIds.has(datastoreRow.id) && notRegistered && (
                 <Button
                   data-testid={`datastore-register-${datastoreRow.id}`}
                   size="sm"
                   variant="secondary"
                   icon={RefreshCw}
+                  disabled={registering}
                   onClick={() => onRegister(datastoreRow)}
                 >
                   Register
@@ -439,6 +447,16 @@ export function useDatastoreColumns(args: UseDatastoreColumnsArgs): ColumnDef<Da
                               Provision datastore
                             </DropdownItem>
                           ))}
+                        {hasDatastore && !removedSubtreeRowIds.has(datastoreRow.id) && buildable && (
+                          <DropdownItem
+                            icon={<Hammer className="size-4" />}
+                            disabled={registering}
+                            title="Starts a build, or joins the one already running"
+                            onSelect={() => onRegister(datastoreRow)}
+                          >
+                            Build datastore now
+                          </DropdownItem>
+                        )}
                         <DropdownItem icon={<Plus className="size-4" />} onSelect={() => onAddChild(datastoreRow)}>
                           Add datastore
                         </DropdownItem>
@@ -505,6 +523,8 @@ export function useDatastoreColumns(args: UseDatastoreColumnsArgs): ColumnDef<Da
       onRestore,
       onDelete,
       onRegister,
+      registeringDatastoreIds,
+      removedSubtreeRowIds,
       onRename,
       onManageUsers,
       onManageCustomApps,

package/src/routes/datastores/index.tsx

@@ -11,6 +11,7 @@ import {
   useRenameDatastoreGroupMutation,
   useRestoreDatastoreMutation,
   useUnlinkedDatastoresQuery,
+  type GQLRegisterDatastoreMutationVariables,
 } from "@manta-eu/client";
 import { enableDatastoreRemoval } from "@manta-eu/client/shared/constants";
 import { deriveDatastoreId } from "@manta-eu/client/shared/datastore-id";
@@ -18,7 +19,7 @@ import { parseError } from "@manta-eu/client/shared/error-utils";
 import { namesAGroup, pathSegments } from "@manta-eu/client/shared/team";
 import { activeRealm } from "@manta-eu/ldo/realm";
 import { isPresent } from "@manta-eu/lib/present";
-import { useQueryClient } from "@tanstack/react-query";
+import { useMutationState, useQueryClient } from "@tanstack/react-query";
 import type { SortingState } from "@tanstack/react-table";
 import { Archive, Database, EyeOff, type LucideIcon, Plus, RefreshCcw, TriangleAlert } from "lucide-react";
 import { useCallback, useEffect, useMemo, useState } from "react";
@@ -34,12 +35,16 @@ import { RenameDatastoreGroupDialog } from "./components/RenameDatastoreGroupDia
 import { UnlinkedDatastoresPanel } from "./components/UnlinkedDatastoresPanel";
 import {
   existingOrganizationNameKeys,
+  hiddenRemovedRowCount,
   hiddenRowCount,
   matchesProviderFilter,
   nestedDatastoreNamesByRowId,
+  organizationGroupPaths,
   organizationNameKey,
   organizationNames,
+  outsideRemovedSubtrees,
   realmDefaultRow,
+  removedSubtreeRowIds,
   toDatastoreRows,
   unlinkedDatastoreRow,
   visibilityForStatusFilter,
@@ -75,6 +80,8 @@ import { useMantaClient } from "#providers/index";
 
 const realmDatastoreId = activeRealm();
 
+const registerDatastoreMutationKey = ["RegisterDatastore"];
+
 type ActiveTab = "organizations" | "unlinked";
 
 const tabLabels: Record<ActiveTab, string> = {
@@ -233,17 +240,37 @@ export function DatastoresRoute() {
   });
 
   const registerMutation = useRegisterDatastoreMutation(mantaClient, {
-    onSuccess: (result) => {
+    mutationKey: registerDatastoreMutationKey,
+    onSuccess: async (result, variables) => {
       // "Not registered" is treated as settled, so status polling stopped - force a re-check.
-      void queryClient.invalidateQueries({ queryKey: ["DatastoreProvisioningStatuses"] });
-      if (result.registerDatastore.success) toast.success("Datastore registered");
-      else toast.error("Couldn't register the datastore", { description: result.registerDatastore.error ?? undefined });
+      await refreshDatastores();
+      const { success, error, pending } = result.registerDatastore;
+      if (!success) {
+        toast.error("Couldn't build the datastore", { description: error ?? undefined });
+        return;
+      }
+
+      if (pending) {
+        toast.success(`Datastore "${variables.datastoreId}" is being built`, {
+          description: "It is taking longer than usual, and becomes available once its knowledge graph is built.",
+        });
+      } else {
+        toast.success(`Datastore "${variables.datastoreId}" is registered and built`);
+      }
     },
     onError: (error) => {
-      const info = parseError(error, "Couldn't register the datastore");
+      const info = parseError(error, "Couldn't build the datastore");
       toast.error(info.message, { description: info.description });
     },
   });
+  const registeringIds = useMutationState({
+    filters: { mutationKey: registerDatastoreMutationKey, status: "pending" },
+    select: (mutation) => (mutation.state.variables as GQLRegisterDatastoreMutationVariables | undefined)?.datastoreId,
+  });
+  const registeringDatastoreIds = useMemo(
+    () => new Set(registeringIds.filter((id): id is string => id !== undefined)),
+    [registeringIds],
+  );
 
   const renameMutation = useRenameDatastoreGroupMutation(mantaClient, {
     onSuccess: (result) => {
@@ -313,7 +340,7 @@ export function DatastoresRoute() {
     [data],
   );
   const unlinkedRows = useMemo(
-    () => (unlinkedData?.unlinkedDatastores ?? []).map((entry) => unlinkedDatastoreRow(entry.id)),
+    () => (unlinkedData?.unlinkedDatastores ?? []).map((entry) => unlinkedDatastoreRow(entry.id, entry.built)),
     [unlinkedData],
   );
   const allRows = useMemo(() => [...treeRows, ...unlinkedRows], [treeRows, unlinkedRows]);
@@ -323,6 +350,9 @@ export function DatastoresRoute() {
     () => hiddenRowCount(treeRows, visibility, "showUnprovisioned", rows.length),
     [treeRows, visibility, rows.length],
   );
+  const archivedCount = useMemo(() => hiddenRemovedRowCount(treeRows, visibility), [treeRows, visibility]);
+  const groupPathsByOrganization = useMemo(() => organizationGroupPaths(treeRows), [treeRows]);
+  const removedSubtreeIds = useMemo(() => removedSubtreeRowIds(treeRows), [treeRows]);
   const providerLinkEnabled = linkingQuery.data?.organizationLinking?.linkEnabled;
   const linkingUnreadable = linkingQuery.isError || linkingQuery.data?.organizationLinking === null;
   const tableRows = useMemo(
@@ -331,7 +361,7 @@ export function DatastoresRoute() {
   );
   const unlinkedCount = unlinkedRows.length;
   const existingOrganizationNames = useMemo(() => existingOrganizationNameKeys(allRows), [allRows]);
-  const organizationNameOptions = useMemo(() => organizationNames(allRows), [allRows]);
+  const organizationNameOptions = useMemo(() => organizationNames(outsideRemovedSubtrees(allRows)), [allRows]);
   // Mirrors provisionDatastore's assertDatastoreIdAvailable (Infisical folder-per-id is global,
   // not scoped to siblings), so a slug collision is caught before the server round-trip.
   const existingDatastoreIds = useMemo(
@@ -354,7 +384,7 @@ export function DatastoresRoute() {
   );
   const suggestedMatchByDatastoreId = useMemo(() => {
     const matches: Record<string, DatastoreRow> = {};
-    for (const row of treeRows) {
+    for (const row of outsideRemovedSubtrees(treeRows)) {
       if (isPresent(row.datastoreId)) continue;
       const derived = derivedIdForRow(row);
       if (unlinkedIdSet.has(derived)) matches[derived] ??= row;
@@ -383,7 +413,7 @@ export function DatastoresRoute() {
 
   const matchableRowIds = useMemo(() => {
     const ids = new Set<string>();
-    for (const row of allRows) {
+    for (const row of outsideRemovedSubtrees(allRows)) {
       if (!isPresent(row.datastoreId) && unlinkedIdSet.has(derivedIdForRow(row))) ids.add(row.id);
     }
     return ids;
@@ -410,7 +440,11 @@ export function DatastoresRoute() {
       void queryClient.invalidateQueries({ queryKey: useUnlinkedDatastoresQuery.getKey() });
       void queryClient.invalidateQueries({ queryKey: ["DatastoreProvisioningStatuses"] });
       if (result.linkUnlinkedDatastore.success) {
-        toast.success(`Linked to the existing datastore "${result.linkUnlinkedDatastore.datastoreId}"`);
+        toast.success(
+          result.linkUnlinkedDatastore.pending
+            ? `Linked to "${result.linkUnlinkedDatastore.datastoreId}", which is still being built`
+            : `Linked to the existing datastore "${result.linkUnlinkedDatastore.datastoreId}"`,
+        );
         toastProviderWarning(result.linkUnlinkedDatastore.providerWarning);
       } else {
         toast.error("Couldn't link the existing datastore", {
@@ -471,7 +505,9 @@ export function DatastoresRoute() {
 
   const onRegister = useCallback(
     (row: DatastoreRow) => {
-      if (isPresent(row.datastoreId)) registerMutation.mutate({ datastoreId: row.datastoreId });
+      if (isPresent(row.datastoreId)) {
+        registerMutation.mutate({ datastoreId: row.datastoreId, launchProvisioning: true });
+      }
     },
     [registerMutation.mutate],
   );
@@ -524,6 +560,8 @@ export function DatastoresRoute() {
     onRestore,
     onRename: setRenameTarget,
     onRegister,
+    registeringDatastoreIds,
+    removedSubtreeRowIds: removedSubtreeIds,
     onManageUsers,
     onManageCustomApps,
     onBringOnline,
@@ -545,7 +583,19 @@ export function DatastoresRoute() {
             onToggle: () => toggleVisibility("showArchived"),
           },
         ]
-      : []),
+      : showArchived || archivedCount > 0
+        ? [
+            {
+              key: "archived",
+              label: showArchived ? "Hide removed" : `Show removed (${archivedCount})`,
+              description:
+                "Out of use: a permanent delete stopped partway, or they were removed before removal was turned off.",
+              icon: showArchived ? EyeOff : Archive,
+              active: showArchived,
+              onToggle: () => toggleVisibility("showArchived"),
+            },
+          ]
+        : []),
     ...(showUnprovisioned || unprovisionedCount > 0
       ? [
           {
@@ -813,6 +863,7 @@ export function DatastoresRoute() {
           datastoreId={linkDialogTarget}
           suggestedMatch={suggestedLinkTarget(linkDialogTarget)}
           organizationNames={organizationNameOptions}
+          groupPathsByOrganization={groupPathsByOrganization}
           existingOrganizationNames={existingOrganizationNames}
           onClose={() => setLinkDialogTarget(null)}
         />

package/src/routes/integrations/components/connect-forms/GoogleMerchantCenterConnectForm.tsx

@@ -0,0 +1,61 @@
+import {
+  GQLIntegration,
+  useGoogleMerchantCenterSetupConnectMutation,
+  useGoogleMerchantCenterSetupProgressQuery,
+  type GQLGoogleMerchantCenterAccount,
+} from "@manta-eu/client";
+import { useQueryClient } from "@tanstack/react-query";
+import { googleMerchantCenterTreeItems } from "./google-merchant-center-account-tree";
+import { OAuthSetupConnectForm, type OAuthSetup, type SetupCopy } from "./OAuthSetupConnectForm";
+import type { ConnectFormProps } from "./types";
+import { useMantaClient } from "#providers/index";
+
+const copy: SetupCopy = {
+  providerName: "Merchant Center",
+  identityProviderName: "Google",
+  entitySingular: "account",
+  entityPlural: "accounts",
+  signInDescription:
+    "We'll take you to Google sign-in so you can grant Manta access to your Google Merchant Center accounts.",
+  pickTitle: "Pick the Merchant Center accounts to connect",
+  pickDescription:
+    "Choose the accounts whose products Manta should manage. An advanced account only groups its sub-accounts, so connect the sub-accounts. An account whose latest terms aren't accepted yet can be connected once they are accepted in Merchant Center.",
+  noEntitiesLabel:
+    "We couldn't find any Merchant Center accounts on this Google identity. Sign in with a different account or check your Merchant Center access.",
+  noneConnectableLabel:
+    "No connectable Merchant Center accounts remain on this Google identity — they are already connected or unavailable. Sign in with a different Google account to connect a new one.",
+};
+
+function useGoogleMerchantCenterSetup(): OAuthSetup<GQLGoogleMerchantCenterAccount> {
+  const { mantaClient } = useMantaClient();
+  const queryClient = useQueryClient();
+  const progressQuery = useGoogleMerchantCenterSetupProgressQuery(mantaClient, undefined, { staleTime: 0 });
+  const connectMutation = useGoogleMerchantCenterSetupConnectMutation(mantaClient);
+  const progress = progressQuery.data?.googleMerchantCenterSetupProgress;
+
+  return {
+    progress: progress && { state: progress.state, rows: progress.accounts, lastError: progress.lastError },
+    refetchProgress: progressQuery.refetch,
+    resetProgress: () =>
+      queryClient.setQueryData(useGoogleMerchantCenterSetupProgressQuery.getKey(), {
+        googleMerchantCenterSetupProgress: { state: [], accounts: null, lastError: null },
+      }),
+    connect: async (accountIds) => (await connectMutation.mutateAsync({ accountIds })).googleMerchantCenterSetupConnect,
+    isConnecting: connectMutation.isPending,
+  };
+}
+
+export function GoogleMerchantCenterConnectForm(props: ConnectFormProps) {
+  const setup = useGoogleMerchantCenterSetup();
+
+  return (
+    <OAuthSetupConnectForm
+      {...props}
+      integration={GQLIntegration.GoogleMerchantCenter}
+      oauthStartPath="/oauth/google-merchant-center/start"
+      copy={copy}
+      setup={setup}
+      treeItems={googleMerchantCenterTreeItems}
+    />
+  );
+}

package/src/routes/integrations/components/connect-forms/google-merchant-center-account-tree.ts

@@ -0,0 +1,38 @@
+import type { GQLGoogleMerchantCenterAccount } from "@manta-eu/client";
+import { isPresent } from "@manta-eu/lib/present";
+import { unavailableReasonLabel } from "./setup-account-unavailable-reason";
+import { buildTreeRows, type TreeSelectItem } from "#components/tree-multi-select/index";
+
+function rowHint(
+  row: GQLGoogleMerchantCenterAccount,
+  alreadyConnected: boolean,
+  reconnectable: boolean,
+): string | undefined {
+  if (row.advanced === true) return "Advanced account";
+  if (row.isConnectable !== true) return unavailableReasonLabel(row.unavailableReason);
+  if (reconnectable) return "Reconnect";
+  if (alreadyConnected) return "Already connected";
+  if (row.testAccount === true) return "Test account";
+  return undefined;
+}
+
+export function googleMerchantCenterTreeItems(
+  rows: GQLGoogleMerchantCenterAccount[],
+  alreadyConnectedExternalIds: ReadonlySet<string>,
+  reconnectableExternalIds: ReadonlySet<string> = new Set(),
+): TreeSelectItem[] {
+  return buildTreeRows(rows).map(({ node, depth }) => {
+    const reconnectable = isPresent(node.externalId) && reconnectableExternalIds.has(node.externalId);
+    const alreadyConnected =
+      !reconnectable && isPresent(node.externalId) && alreadyConnectedExternalIds.has(node.externalId);
+    return {
+      id: node.id,
+      label: node.name ?? node.externalId ?? node.id,
+      caption: node.name != null ? (node.externalId ?? undefined) : undefined,
+      hint: rowHint(node, alreadyConnected, reconnectable),
+      selectable: node.isConnectable === true,
+      disabled: alreadyConnected,
+      depth,
+    };
+  });
+}

package/src/routes/integrations/components/connect-forms/setup-account-unavailable-reason.ts

@@ -3,6 +3,7 @@ import { isPresent } from "@manta-eu/lib/present";
 
 const unavailableReasonLabels: Record<GQLSetupAccountUnavailableReason, string> = {
   [GQLSetupAccountUnavailableReason.InsufficientPermissions]: "Insufficient permissions",
+  [GQLSetupAccountUnavailableReason.TermsNotAccepted]: "Accept the latest terms in Merchant Center",
 };
 
 export function unavailableReasonLabel(reason: GQLSetupAccountUnavailableReason | null | undefined): string {

package/src/routes/integrations/connect-forms.ts

@@ -11,6 +11,7 @@ export { FigmaConnectForm } from "./components/connect-forms/FigmaConnectForm";
 export { GmailConnectForm } from "./components/connect-forms/GmailConnectForm";
 export { GoogleAdsConnectForm } from "./components/connect-forms/GoogleAdsConnectForm";
 export { GoogleAnalyticsConnectForm } from "./components/connect-forms/GoogleAnalyticsConnectForm";
+export { GoogleMerchantCenterConnectForm } from "./components/connect-forms/GoogleMerchantCenterConnectForm";
 export { KlaviyoConnectForm } from "./components/connect-forms/KlaviyoConnectForm";
 export { LinkedinConnectForm } from "./components/connect-forms/LinkedinConnectForm";
 export { MetaAdsConnectForm } from "./components/connect-forms/MetaAdsConnectForm";

package/src/routes/integrations/connection-view.ts

@@ -42,6 +42,7 @@ const oauthAccountNoun = {
   [GQLIntegration.Slack]: "Workspace",
   [GQLIntegration.Google]: "Customer",
   [GQLIntegration.GoogleAnalytics]: "Property",
+  [GQLIntegration.GoogleMerchantCenter]: "Account",
   [GQLIntegration.Meta]: "Ad account",
   [GQLIntegration.Linkedin]: "Ad account",
   [GQLIntegration.MicrosoftAds]: "Account",

package/src/shared/graph-derived-queries.ts

@@ -10,6 +10,7 @@ import {
   useCurrentFactValueQuery,
   useExplainFactQuery,
   useGetActionPlansSummaryQuery,
+  useManualActionProgressQuery,
   useMemoriesQuery,
   useMemorySchemasQuery,
   useNodePropertiesQuery,
@@ -36,6 +37,7 @@ export const graphDerivedQueries: QueryWithGetKey[] = [
   useCurrentFactValueQuery,
   useExplainFactQuery,
   useGetActionPlansSummaryQuery,
+  useManualActionProgressQuery,
   useMemoriesQuery,
   useMemorySchemasQuery,
   useNodePropertiesQuery,