@bygghammar/cms-platform 0.80.1 → 0.90.0-m7.10

package/src/backoffice/routes/host.ts

@@ -9,6 +9,7 @@
 import type { ReactNode } from "react";
 
 import type { SiteConfig } from "../../config/site-config";
+import type { SecretsLocation } from "../../server/provider-secrets";
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /** Media field component as the reviews editor consumes it. */
@@ -34,6 +35,8 @@ export type BackofficeHost = {
   company: Record<string, string>;
   /** Locale used to preview form copy in the backoffice. */
   previewLocale?: string;
+  /** Where this installation configures provider and system-mail secrets. */
+  secretsLocation?: SecretsLocation;
   /** Server functions, grouped per module. */
   fns: {
     // admin
@@ -78,6 +81,31 @@ export type BackofficeHost = {
     // locale domains
     saveLocaleDomain: HostServerFn;
     deleteLocaleDomain: HostServerFn;
+    /*
+     * Which hostname actually serves the backoffice, and why.
+     *
+     * `SITE_URL` is server information: it cannot be read from the browser,
+     * and a value baked into this registry would be a guess presented to an
+     * administrator as fact about their own install. So the answer is fetched
+     * from the server instead, and returns the package's `EffectiveAdminHost`.
+     *
+     * Optional: a host that has not registered it simply gets no statement
+     * about the backoffice hostname on the domains screen. The editor works
+     * either way — this only ever adds an explanation, never a permission.
+     */
+    getEffectiveAdminHost?: HostServerFn;
+    /*
+     * Popup opt-in destinations, for the popup editor's picker.
+     *
+     * Optional: a site with no delivery integration simply does not register
+     * it, and the popup editor then shows no picker at all rather than an
+     * empty control. Returns names and ids — never an endpoint or a secret.
+     */
+    listWebhookDestinations?: HostServerFn;
+    saveWebhookDestination?: HostServerFn;
+    deleteWebhookDestination?: HostServerFn;
+    sendTestWebhook?: HostServerFn;
+    listWebhookDeliveries?: HostServerFn;
   };
   /** Site-specific example values shown as input placeholders. */
   placeholders?: {
@@ -105,7 +133,10 @@ export type BackofficeHost = {
   /** Editor components a site wires with its own locales, media and forms. */
   components: {
     /** Recursive shared-content editor. */
-    SectionForm: (props: { value: unknown; onChange: (next: unknown) => void }) => ReactNode;
+    SectionForm: (props: {
+      value: unknown;
+      onChange: (next: unknown) => void;
+    }) => ReactNode;
     /** Single media field used by the reviews editor. */
     MediaField: MediaFieldComponent;
     /** Review portrait uploader. */
@@ -193,6 +224,15 @@ export type BackofficeHost = {
       listPagePublications: HostServerFn;
       cancelPagePublication: HostServerFn;
       renamePage: HostServerFn;
+      /**
+       * The site's pages, listed.
+       *
+       * Optional because the builder screens do not need it — they open one
+       * page by key. What needs it is anything offering a choice of pages,
+       * and the popup page picker is the first: without this the picker has
+       * nothing to show and falls back to typing addresses, silently.
+       */
+      listPages?: HostServerFn;
     };
     /** Human labels for the locale switch, keyed by locale. */
     localeLabels?: Record<string, string>;
@@ -200,7 +240,10 @@ export type BackofficeHost = {
      * React hook returning a resolver for a page's public URL. Implemented as a
      * hook so a site can read its slug overrides and locale domains.
      */
-    usePageUrl: () => (pageKey: string, locale: string) => { path: string; host: string };
+    usePageUrl: () => (
+      pageKey: string,
+      locale: string,
+    ) => { path: string; host: string };
     /** Persists unsaved shared-content drafts; returns the keys it saved. */
     flushSharedDrafts?: () => Promise<string[]>;
     /** Renders the block canvas for the builder. */
@@ -211,7 +254,12 @@ export type BackofficeHost = {
       blocks: any[];
       setBlocks: (next: any[]) => void;
       globals: Record<string, any[]>;
-      globalSections: { key: string; name: string; kind: "block" | "section"; blocks: any[] }[];
+      globalSections: {
+        key: string;
+        name: string;
+        kind: "block" | "section";
+        blocks: any[];
+      }[];
       locale: string;
       setLocale: (next: string) => void;
       setDirty: (next: boolean) => void;
@@ -248,7 +296,6 @@ export type BackofficeHost = {
   /* eslint-enable @typescript-eslint/no-explicit-any */
 };
 
-
 let current: BackofficeHost | null = null;
 
 /** Registers the host adapters. Call once, from a module the routes import. */
@@ -283,6 +330,7 @@ export function backofficePaths(host: BackofficeHost = backofficeHost()) {
     email: `${base}/admin/email`,
     contact: `${base}/admin/contact`,
     tracking: `${base}/admin/tracking`,
+    domains: `${base}/admin/domains`,
     redirects: `${base}/admin/redirects`,
     sitemap: `${base}/admin/sitemap`,
     navigation: `${base}/admin/navigation`,
@@ -295,13 +343,16 @@ export function backofficePaths(host: BackofficeHost = backofficeHost()) {
     formDeliveries: `${base}/forms/deliveries`,
     pagesBuilder: `${base}/pages-builder`,
     resetPassword: `${base}/reset-password`,
+    popups: `${base}/popups`,
+    popupDestinations: `${base}/popups/destinations`,
   };
 }
 
 /** Reads a required optional host group, failing loudly when it is missing. */
-export function requireHostGroup<K extends "media" | "forms" | "pages" | "sections" | "dashboard" | "authAdapters">(
-  key: K,
-): NonNullable<BackofficeHost[K]> {
+export function requireHostGroup<
+  K extends
+    "media" | "forms" | "pages" | "sections" | "dashboard" | "authAdapters",
+>(key: K): NonNullable<BackofficeHost[K]> {
   const group = backofficeHost()[key];
   if (!group) {
     throw new Error(

package/src/backoffice/routes/index.tsx

@@ -18,6 +18,7 @@ import {
   Menu,
   Package,
   ScrollText,
+  Languages,
   Shield,
   Signpost,
   SlidersHorizontal,
@@ -25,8 +26,10 @@ import {
   Users,
 } from "lucide-react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useRef } from "react";
 import { useServerFn } from "@tanstack/react-start";
 
+import { MISSING_CREATED_ID } from "../../tracking/injections";
 import type { SiteSettingOverrides } from "../../config/site-config";
 import { AuditView } from "../AuditView";
 import { BackupView } from "../BackupView";
@@ -42,10 +45,16 @@ import { RedirectsView } from "../RedirectsView";
 import { RolesView } from "../RolesView";
 import { SitemapView, type SitemapCheck } from "../SitemapView";
 import { SiteSettingsView } from "../SiteSettingsView";
-import { TrackingView } from "../TrackingView";
+import { TrackingView, type TrackingDeps } from "../TrackingView";
 import { UsersView } from "../UsersView";
 import { VersionView } from "../VersionView";
-import { useFeatureGate } from "../shell/use-resolved-config";
+import { parseEffectiveAdminHost } from "../../site/locale-domains";
+import {
+  useFeatureEnabled,
+  useFeatureGate,
+  useModuleGate,
+  useMyRoles,
+} from "../shell/use-resolved-config";
 import { backofficeHost, backofficePaths } from "./host";
 
 export * from "./host";
@@ -200,13 +209,54 @@ function TrackingRouteInner() {
   const q = useQuery({ queryKey: ["admin", "injections"], queryFn: () => list() });
   const domainsQ = useQuery({ queryKey: ["admin", "locale-domains"], queryFn: () => domains() });
 
+  /*
+   * A create whose answer carried no id, if one has happened.
+   *
+   * The insert may well have succeeded — what is missing is the identity of
+   * the row it wrote, not evidence that it wrote none. Sending the same draft
+   * again would therefore be as likely to create a second profile as to retry
+   * the first, and the screen has no way to tell which. So no further create
+   * is attempted at all until a reload has reconciled the list with what the
+   * server actually holds. Updates carry their own id and are unaffected.
+   */
+  const createUnresolved = useRef(false);
+
+  const saveInjection = useCallback<TrackingDeps["saveInjection"]>(
+    async (input) => {
+      const isCreate = !input.data.id;
+      if (isCreate && createUnresolved.current) throw new Error(MISSING_CREATED_ID);
+      let result: { id?: unknown } | null | undefined;
+      try {
+        result = (await save(input as never)) as { id?: unknown } | null | undefined;
+      } catch (err) {
+        /*
+         * The server refuses an insert it cannot identify, and that refusal is
+         * indeterminate in exactly the way the check below is: the row may have
+         * landed. Any other failure is a plain no, so only this one closes
+         * creates — a rejected create is otherwise still worth another try.
+         */
+        if (isCreate && err instanceof Error && err.message === MISSING_CREATED_ID) {
+          createUnresolved.current = true;
+        }
+        throw err;
+      }
+      const id = typeof result?.id === "string" ? result.id.trim() : "";
+      if (isCreate && !id) {
+        createUnresolved.current = true;
+        throw new Error(MISSING_CREATED_ID);
+      }
+      return { id };
+    },
+    [save],
+  );
+
   return (
     <TrackingView
       deps={{
         profiles: q.data ?? [],
         domains: domainsQ.data ?? [],
         locales: locales as never,
-        saveInjection: (input) => save(input as never),
+        saveInjection,
         deleteInjection: (input) => remove(input),
         refresh: () => q.refetch(),
       }}
@@ -308,9 +358,20 @@ export function AdminLayoutRoute() {
 export function AdminOverviewRoute() {
   const host = backofficeHost();
   const paths = backofficePaths(host);
-  const fetchRoles = useServerFn(host.fns.getMyRoles);
-  const rolesQ = useQuery({ queryKey: ["admin", "my-roles"], queryFn: () => fetchRoles() });
-  const isSuper = ((rolesQ.data ?? []) as string[]).includes("superadmin");
+  const { roles } = useMyRoles();
+  const isSuper = roles.includes("superadmin");
+  // Both screens write through server functions that ask `has_role(user,
+  // 'admin')`, so a card offered to anyone else is an invitation to a screen
+  // whose every save comes back refused. The role is read from the list the
+  // host returns; holding `superadmin` is not the same grant.
+  const isAdmin = roles.includes("admin");
+  // The live flags, not the compiled ones. Both route gates already read the
+  // live value, so a card driven by the compiled default disagrees with the
+  // screen behind it: an override that switched a module on leaves its card
+  // missing, and one that switched a module off leaves a card that opens
+  // straight into a no-access screen.
+  const domainsEnabled = useFeatureEnabled("domains") === true;
+  const trackingEnabled = useFeatureEnabled("tracking") === true;
 
   const cards = [
     {
@@ -360,7 +421,7 @@ export function AdminOverviewRoute() {
       body: "Company address, org. number, email and phone.",
       icon: Building2,
     },
-    ...(host.siteConfig.features.tracking
+    ...(isAdmin && trackingEnabled
       ? [
           {
             to: paths.tracking,
@@ -370,6 +431,16 @@ export function AdminOverviewRoute() {
           },
         ]
       : []),
+    ...(isAdmin && domainsEnabled
+      ? [
+          {
+            to: paths.domains,
+            title: "Languages & domains",
+            body: "One domain per language, the default fallback and the hostname the backoffice is served from.",
+            icon: Languages,
+          },
+        ]
+      : []),
     {
       to: paths.redirects,
       title: "Redirects",
@@ -532,6 +603,7 @@ function EmailSettingsRouteInner() {
           fromEmail: host.placeholders?.fromEmail ?? "",
           notifyTo: host.placeholders?.notifyTo ?? "",
         },
+        secretsLocation: host.secretsLocation,
       }}
     />
   );
@@ -559,6 +631,15 @@ export function NavigationRoute() {
   );
 }
 
+/**
+ * Stand-in for the optional effective-admin-host function.
+ *
+ * `useServerFn` is a hook and cannot be called conditionally, so an
+ * unregistered function still needs something to hand it. This one is never
+ * invoked: the query that would call it stays disabled.
+ */
+const noEffectiveAdminHost = async () => null;
+
 /** Per-locale domain mapping. */
 function DomainsRouteInner() {
   const host = backofficeHost();
@@ -567,19 +648,40 @@ function DomainsRouteInner() {
   const list = useServerFn(host.fns.getLocaleDomains);
   const save = useServerFn(host.fns.saveLocaleDomain);
   const del = useServerFn(host.fns.deleteLocaleDomain);
-  const q = useQuery({ queryKey: ["locale-domains"], queryFn: () => list() });
+  const q = useQuery({ queryKey: ["admin", "locale-domains"], queryFn: () => list() });
+
+  // Where the backoffice is actually served is server knowledge — `SITE_URL`
+  // and the request that arrived. A host that has not registered the function
+  // gets no statement about it at all, which is the honest answer: the editor
+  // keeps working, it just stops explaining a hostname it cannot know.
+  const getAdminHost = useServerFn(host.fns.getEffectiveAdminHost ?? noEffectiveAdminHost);
+  const adminHostQuery = useQuery({
+    queryKey: ["admin", "effective-admin-host"],
+    queryFn: () => getAdminHost(),
+    enabled: Boolean(host.fns.getEffectiveAdminHost),
+  });
+
+  const domains = q.data ?? [];
 
   return (
     <DomainsView
       deps={{
-        domains: q.data ?? [],
+        domains,
         locales: host.siteConfig.locales,
         defaultLocale: host.siteConfig.defaultLocale,
-        backPath: paths.base,
+        backPath: paths.admin,
         domainPlaceholder: host.placeholders?.domain ?? "",
+        adminHost: parseEffectiveAdminHost(adminHostQuery.data) ?? undefined,
+        backofficePath: paths.base,
         saveDomain: (input) => save(input as never),
         deleteDomain: (input) => del(input as never),
-        refresh: () => qc.invalidateQueries({ queryKey: ["locale-domains"] }),
+        // A saved or deleted mapping can move the backoffice itself, and the
+        // banner above the table states where that is. Refreshing only the
+        // table leaves it stating the hostname from before the change.
+        refresh: async () => {
+          await qc.invalidateQueries({ queryKey: ["admin", "locale-domains"] });
+          await qc.invalidateQueries({ queryKey: ["admin", "effective-admin-host"] });
+        },
       }}
     />
   );
@@ -658,16 +760,16 @@ export function ReviewsRoute() {
   return <ReviewsRouteInner />;
 }
 
-/** DomainsRoute guarded by the "domains" module switch. */
+/** DomainsRoute guarded by the "domains" module switch and its admin role. */
 export function DomainsRoute() {
-  const gate = useFeatureGate("domains", "Domains");
+  const gate = useModuleGate("domains", "Languages & domains");
   if (gate) return <>{gate}</>;
   return <DomainsRouteInner />;
 }
 
-/** TrackingRoute guarded by the "tracking" module switch. */
+/** TrackingRoute guarded by the "tracking" module switch and its admin role. */
 export function TrackingRoute() {
-  const gate = useFeatureGate("tracking", "Code & tracking");
+  const gate = useModuleGate("tracking", "Code & tracking");
   if (gate) return <>{gate}</>;
   return <TrackingRouteInner />;
 }

package/src/backoffice/routes/pages.tsx

@@ -107,8 +107,10 @@ export function PageBuilderRoute() {
         publicHost: (locale) => resolveUrl(key, locale).host,
         versions: versionsQ.data as any,
         publications: pubsQ.data as any,
-        save: async ({ pageId: id, blocks, publish, note }) => {
-          const res = await save({ data: { pageId: id, blocks, publish, note } });
+        save: async ({ pageId: id, blocks, publish, note, editSessionId }) => {
+          const res = await save({
+            data: { pageId: id, blocks, publish, note, editSessionId },
+          });
           return res as { versionId: string };
         },
         flushSharedDrafts: pages.flushSharedDrafts
@@ -120,8 +122,10 @@ export function PageBuilderRoute() {
             }
           : undefined,
         schedule: (input) => schedule({ data: input }),
-        cancelPublication: (publicationId) => cancelPub({ data: { publicationId } }),
-        restoreVersion: (versionId) => restore({ data: { versionId } }),
+        cancelPublication: (publicationId, editSessionId) =>
+          cancelPub({ data: { publicationId, editSessionId } }),
+        restoreVersion: (versionId, editSessionId) =>
+          restore({ data: { versionId, editSessionId } }),
         rename: (input) => rename({ data: input }),
         refetchPage: () => void pageQ.refetch(),
         refetchVersions: () => void versionsQ.refetch(),
@@ -190,8 +194,8 @@ export function SectionEditorRoute() {
         meta,
         value,
         codeDefault,
-        save: async (next) => {
-          await save({ data: { key: sectionKey, data: next } });
+        save: async (next, editSessionId) => {
+          await save({ data: { key: sectionKey, data: next, editSessionId } });
           await queryClient.invalidateQueries({ queryKey: host.content.overridesQueryKey });
         },
         goToList: () => navigate({ to: paths.sections as any }),