@designcrowd/library.brand-page 6.2.9 → 6.2.10

package/src/brand-page-maker/stores/brandpage-container/brand-page-container-store.save.test.ts

@@ -1,11 +1,17 @@
 import { describe, test, expect, beforeEach, vi } from 'vitest';
 import { createPinia, setActivePinia } from 'pinia';
-import { useBrandPageContainerStore } from '@brand-page-maker/stores';
+import {
+  useBrandPageContainerStore,
+  useBrandPageMakerStore,
+} from '@brand-page-maker/stores';
+import { SENSITIVE_CONTENT_TYPES } from '@brand-page';
 import brandPageClient from '../../../clients/brand-page-client';
 
 vi.mock('../../../clients/brand-page-client', () => ({
   default: {
     saveBrandPageAsync: vi.fn(),
+    updateBrandPageMetaAsync: vi.fn(),
+    updateSensitiveContentAsync: vi.fn(),
   },
 }));
 
@@ -16,6 +22,40 @@ const SAVED = {
   canPublish: true,
 };
 
+// Both settings writes share `saveSiteBeforeFirstSettingsWrite`; run each
+// never-saved-site scenario over both so a guard dropped from one write
+// method still fails.
+const settingsActions: [
+  string,
+  (store: ReturnType<typeof useBrandPageContainerStore>) => Promise<void>,
+  ReturnType<typeof vi.fn>,
+  Record<string, unknown>,
+][] = [
+  [
+    'updateBrandPageSettings',
+    (store) =>
+      store.updateBrandPageSettings({
+        description: 'New description',
+        title: 'New title',
+      }),
+    vi.mocked(brandPageClient.updateBrandPageMetaAsync),
+    {
+      pageTitle: 'New title',
+      pageDescription: 'New description',
+      metaKeywords: [],
+    },
+  ],
+  [
+    'updateSensitiveContent',
+    (store) =>
+      store.updateSensitiveContent({
+        sensitiveContent: SENSITIVE_CONTENT_TYPES.plus18,
+      }),
+    vi.mocked(brandPageClient.updateSensitiveContentAsync),
+    { sensitiveContentType: SENSITIVE_CONTENT_TYPES.plus18 },
+  ],
+];
+
 describe('brand-page-container-store saveBrandPage', () => {
   let store: ReturnType<typeof useBrandPageContainerStore>;
 
@@ -104,3 +144,294 @@ describe('brand-page-container-store saveBrandPage', () => {
     expect(requestBody()).toMatchObject({ shouldPublish: true });
   });
 });
+
+describe('settings on a never-saved site', () => {
+  let store: ReturnType<typeof useBrandPageContainerStore>;
+  let brandPageMakerStore: ReturnType<typeof useBrandPageMakerStore>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setActivePinia(createPinia());
+
+    store = useBrandPageContainerStore();
+    brandPageMakerStore = useBrandPageMakerStore();
+
+    // The export is exercised by its own tests; stub it so these cover only the
+    // settings-write sequencing.
+    vi.spyOn(store, 'exportDesignAsync').mockResolvedValue({} as any);
+
+    // Real timers inside showNextNotificationMessage would make every test wait
+    // out the message-visible duration and dequeue the very message these tests
+    // assert on, so only its own invocation is observed here.
+    vi.spyOn(
+      brandPageMakerStore,
+      'showNextNotificationMessage',
+    ).mockResolvedValue(undefined);
+
+    vi.mocked(brandPageClient.updateBrandPageMetaAsync).mockResolvedValue({
+      pageTitle: 'New title',
+      pageDescription: 'New description',
+    } as any);
+
+    vi.mocked(brandPageClient.updateSensitiveContentAsync).mockResolvedValue({
+      sensitiveContentType: SENSITIVE_CONTENT_TYPES.plus18,
+    } as any);
+  });
+
+  describe('a saved site', () => {
+    beforeEach(() => {
+      store.designDraftToken = 'draft-123';
+      store.brandPageStatus = 'Published';
+    });
+
+    // Once a token exists — whether from an earlier save or the host's, mid-
+    // session — a pre-purchase site writes directly, the same as any other
+    // saved site.
+    test('saved site writes only the setting', async () => {
+      store.isPrePurchase = true;
+
+      const dispatchSpy = vi.spyOn(window, 'dispatchEvent');
+
+      await store.updateSensitiveContent({
+        sensitiveContent: SENSITIVE_CONTENT_TYPES.plus18,
+      });
+
+      expect(
+        brandPageClient.updateSensitiveContentAsync,
+      ).toHaveBeenCalledOnce();
+      expect(brandPageClient.updateSensitiveContentAsync).toHaveBeenCalledWith(
+        expect.anything(),
+        'draft-123',
+        expect.objectContaining({
+          sensitiveContentType: SENSITIVE_CONTENT_TYPES.plus18,
+        }),
+      );
+      expect(brandPageClient.saveBrandPageAsync).not.toHaveBeenCalled();
+      expect(dispatchSpy).not.toHaveBeenCalled();
+      expect(brandPageMakerStore.notificationMessageQueue).toHaveLength(1);
+      expect(brandPageMakerStore.notificationMessageQueue[0].type).toBe(
+        'success',
+      );
+    });
+  });
+
+  describe('post-purchase, never saved', () => {
+    beforeEach(() => {
+      store.designDraftToken = undefined;
+      store.isPrePurchase = false;
+    });
+
+    test.each(settingsActions)(
+      'saves the site first (%s)',
+      async (_name, callAction, endpoint, expectedPayload) => {
+        vi.mocked(brandPageClient.saveBrandPageAsync).mockResolvedValue(
+          SAVED as any,
+        );
+
+        await callAction(store);
+
+        expect(brandPageClient.saveBrandPageAsync).toHaveBeenCalledOnce();
+
+        const [, saveRequest, saveToken] = vi.mocked(
+          brandPageClient.saveBrandPageAsync,
+        ).mock.calls[0];
+
+        expect(saveRequest).toMatchObject({ saveOnly: true });
+        expect(saveToken).toBeFalsy();
+
+        expect(endpoint).toHaveBeenCalledOnce();
+        expect(endpoint).toHaveBeenCalledWith(
+          expect.anything(),
+          'draft-123',
+          expect.objectContaining(expectedPayload),
+        );
+
+        const saveOrder = vi.mocked(brandPageClient.saveBrandPageAsync).mock
+          .invocationCallOrder[0];
+        const writeOrder = endpoint.mock.invocationCallOrder[0];
+
+        expect(saveOrder).toBeLessThan(writeOrder);
+
+        expect(brandPageMakerStore.notificationMessageQueue).toHaveLength(1);
+        expect(brandPageMakerStore.notificationMessageQueue[0].type).toBe(
+          'success',
+        );
+
+        // The save's own banner was disarmed — a later close must not raise it.
+        brandPageMakerStore.notificationMessageQueue.length = 0;
+
+        await store.closePublishModal();
+        await store.showSaveSuccessMessage();
+
+        expect(store.triggerSaveSuccessMessage).toBe(false);
+        expect(brandPageMakerStore.notificationMessageQueue).toHaveLength(0);
+      },
+    );
+
+    test.each([
+      [
+        'save throws',
+        (): void => {
+          vi.mocked(brandPageClient.saveBrandPageAsync).mockRejectedValue(
+            new Error('network'),
+          );
+        },
+        false,
+      ],
+      [
+        'save returns nothing',
+        (): void => {
+          vi.mocked(brandPageClient.saveBrandPageAsync).mockResolvedValue(
+            null as any,
+          );
+        },
+        false,
+      ],
+      [
+        'save ok, write returns nothing',
+        (): void => {
+          vi.mocked(brandPageClient.saveBrandPageAsync).mockResolvedValue(
+            SAVED as any,
+          );
+          vi.mocked(
+            brandPageClient.updateSensitiveContentAsync,
+          ).mockResolvedValue(null as any);
+        },
+        true,
+      ],
+    ])(
+      'failed first save (%s)',
+      async (_case: string, setup: () => void, writeReached: boolean) => {
+        setup();
+
+        await store.updateSensitiveContent({
+          sensitiveContent: SENSITIVE_CONTENT_TYPES.plus18,
+        });
+
+        expect(brandPageMakerStore.notificationMessageQueue).toHaveLength(1);
+        expect(brandPageMakerStore.notificationMessageQueue[0].type).toBe(
+          'error',
+        );
+        expect(
+          brandPageMakerStore.showNextNotificationMessage,
+        ).toHaveBeenCalled();
+        expect(store.isPublishing).toBe(false);
+
+        if (!writeReached) {
+          expect(
+            brandPageClient.updateSensitiveContentAsync,
+          ).not.toHaveBeenCalled();
+        }
+      },
+    );
+  });
+
+  describe('pre-purchase, never saved', () => {
+    beforeEach(() => {
+      store.isPrePurchase = true;
+      store.designDraftToken = undefined;
+    });
+
+    // No listener started a save, so isSaving never went true on the dispatch —
+    // the click would otherwise go silent.
+    test.each(settingsActions)(
+      'pre-purchase asks the host to save, no listener (%s)',
+      async (_name, callAction) => {
+        const dispatchSpy = vi.spyOn(window, 'dispatchEvent');
+        const setIsPublishingSpy = vi.spyOn(store, 'setIsPublishing');
+
+        await callAction(store);
+
+        expect(dispatchSpy).toHaveBeenCalledOnce();
+        expect((dispatchSpy.mock.calls[0][0] as Event).type).toBe(
+          'SAVE_PROGRESS_CLICKED',
+        );
+        expect(brandPageClient.saveBrandPageAsync).not.toHaveBeenCalled();
+        expect(
+          brandPageClient.updateSensitiveContentAsync,
+        ).not.toHaveBeenCalled();
+        expect(brandPageClient.updateBrandPageMetaAsync).not.toHaveBeenCalled();
+        expect(brandPageMakerStore.notificationMessageQueue).toHaveLength(1);
+        expect(brandPageMakerStore.notificationMessageQueue[0].type).toBe(
+          'error',
+        );
+        expect(setIsPublishingSpy).not.toHaveBeenCalled();
+      },
+    );
+
+    // The host's saveDesign sets isSaving synchronously on the dispatch
+    // (MakerLeadCaptureModalContainer.vue), before its first await.
+    test.each(settingsActions)(
+      'pre-purchase asks the host to save, a listener starts a save (%s)',
+      async (_name, callAction) => {
+        const dispatchSpy = vi
+          .spyOn(window, 'dispatchEvent')
+          .mockImplementation((event: Event) => {
+            if (event.type === 'SAVE_PROGRESS_CLICKED') {
+              store.setIsSaving({ isSaving: true });
+            }
+
+            return true;
+          });
+
+        await callAction(store);
+
+        expect(dispatchSpy).toHaveBeenCalledOnce();
+        expect(brandPageClient.saveBrandPageAsync).not.toHaveBeenCalled();
+        expect(brandPageMakerStore.notificationMessageQueue).toHaveLength(0);
+      },
+    );
+  });
+
+  describe('admin template editor, never saved', () => {
+    test.each(settingsActions)(
+      'admin never saves (%s)',
+      async (_name, callAction) => {
+        store.isAdminMaker = true;
+        store.designDraftToken = undefined;
+
+        await callAction(store);
+
+        expect(brandPageClient.saveBrandPageAsync).not.toHaveBeenCalled();
+        expect(
+          brandPageClient.updateSensitiveContentAsync,
+        ).not.toHaveBeenCalled();
+        expect(brandPageClient.updateBrandPageMetaAsync).not.toHaveBeenCalled();
+        expect(brandPageMakerStore.notificationMessageQueue).toHaveLength(0);
+      },
+    );
+  });
+
+  test.each([
+    ['a save already running', { isSaving: true }],
+    ['a publish already running', { isPublishing: true }],
+  ])(
+    'another save running (%s)',
+    async (_case: string, flags: Record<string, boolean>) => {
+      store.isPrePurchase = false;
+      store.designDraftToken = undefined;
+      Object.assign(store, flags);
+
+      const isPublishingBefore = store.isPublishing;
+      const setIsPublishingSpy = vi.spyOn(store, 'setIsPublishing');
+
+      await store.updateSensitiveContent({
+        sensitiveContent: SENSITIVE_CONTENT_TYPES.plus18,
+      });
+
+      expect(brandPageClient.saveBrandPageAsync).not.toHaveBeenCalled();
+      expect(
+        brandPageClient.updateSensitiveContentAsync,
+      ).not.toHaveBeenCalled();
+      expect(store.isPublishing).toBe(isPublishingBefore);
+      expect(setIsPublishingSpy).not.toHaveBeenCalled();
+      expect(brandPageMakerStore.notificationMessageQueue).toHaveLength(1);
+      expect(brandPageMakerStore.notificationMessageQueue[0].type).toBe(
+        'error',
+      );
+      expect(
+        brandPageMakerStore.showNextNotificationMessage,
+      ).toHaveBeenCalled();
+    },
+  );
+});

package/src/brand-page-maker/stores/brandpage-container/brand-page-container-store.ts

@@ -23,6 +23,7 @@ import {
   getAbTestResults,
   type AbTest,
   type LogoContent,
+  type SensitiveContent,
 } from '@brand-page';
 import { isLogoContent } from '@brand-page/utils';
 import { useUiEditableLogoStore } from '@shared/logo-settings/store';
@@ -1336,7 +1337,17 @@ export const useBrandPageContainerStore = defineStore('brandPageContainer', {
       }
     },
 
-    async updateBrandPageSettings({ description, title }) {
+    async updateBrandPageSettings(payload: {
+      description: string;
+      title: string;
+    }): Promise<void> {
+      if (
+        !this.designDraftToken &&
+        !(await this.saveSiteBeforeFirstSettingsWrite())
+      ) {
+        return;
+      }
+
       const brandPageMakerStore = useBrandPageMakerStore();
 
       try {
@@ -1346,8 +1357,8 @@ export const useBrandPageContainerStore = defineStore('brandPageContainer', {
           brandPageMakerStore.brandPageType,
           this.designDraftToken,
           {
-            pageDescription: description,
-            pageTitle: title,
+            pageDescription: payload.description,
+            pageTitle: payload.title,
             metaKeywords: [],
           },
         );
@@ -1377,7 +1388,16 @@ export const useBrandPageContainerStore = defineStore('brandPageContainer', {
       }
     },
 
-    async updateSensitiveContent({ sensitiveContent }) {
+    async updateSensitiveContent(payload: {
+      sensitiveContent: SensitiveContent;
+    }): Promise<void> {
+      if (
+        !this.designDraftToken &&
+        !(await this.saveSiteBeforeFirstSettingsWrite())
+      ) {
+        return;
+      }
+
       const brandPageMakerStore = useBrandPageMakerStore();
 
       try {
@@ -1387,7 +1407,7 @@ export const useBrandPageContainerStore = defineStore('brandPageContainer', {
           brandPageMakerStore.brandPageType,
           this.designDraftToken,
           {
-            sensitiveContentType: sensitiveContent,
+            sensitiveContentType: payload.sensitiveContent,
           },
         );
 
@@ -1416,6 +1436,64 @@ export const useBrandPageContainerStore = defineStore('brandPageContainer', {
       }
     },
 
+    // Pre-purchase drafts are saved by the host, never the maker — save-publish.md.
+    async saveSiteBeforeFirstSettingsWrite(): Promise<boolean> {
+      if (this.isAdminMaker) {
+        return false;
+      }
+
+      const brandPageMakerStore = useBrandPageMakerStore();
+
+      if (this.isPrePurchase) {
+        window.dispatchEvent(new Event('SAVE_PROGRESS_CLICKED'));
+
+        // The host's saveDesign sets isSaving synchronously on the dispatch; if it
+        // didn't, no listener is wired and the click would otherwise go silent.
+        if (!this.isSaving) {
+          await brandPageMakerStore.enqueueErrorMessage();
+          await brandPageMakerStore.showNextNotificationMessage();
+        }
+
+        return false;
+      }
+
+      if (this.isSaving || this.isPublishing) {
+        await brandPageMakerStore.enqueueErrorMessage();
+        await brandPageMakerStore.showNextNotificationMessage();
+
+        return false;
+      }
+
+      this.setIsPublishing({ isPublishing: true });
+
+      // saveBrandPage enqueues its own error on a throw but not on an empty response.
+      const messagesBeforeSave = [
+        ...brandPageMakerStore.notificationMessageQueue,
+      ];
+      const result = await this.saveBrandPage({ saveOnly: true });
+
+      if (!result || !result.saved) {
+        const hasErrorQueued =
+          brandPageMakerStore.notificationMessageQueue.some(
+            (message) =>
+              message.type === 'error' && !messagesBeforeSave.includes(message),
+          );
+
+        if (!hasErrorQueued) {
+          await brandPageMakerStore.enqueueErrorMessage();
+        }
+
+        this.setIsPublishing({ isPublishing: false });
+        await brandPageMakerStore.showNextNotificationMessage();
+
+        return false;
+      }
+
+      this.setTriggerSaveSuccessMessage({ triggerSaveSuccessMessage: false });
+
+      return true;
+    },
+
     async createBrandPageCustomDomain({ domainName }) {
       const brandPageMakerStore = useBrandPageMakerStore();