feat: notification v3

app/(gcforms)/[locale]/(app administration)/admin/(with nav)/accounts/[id]/manage-forms/actions.ts

@@ -6,7 +6,7 @@ import { TemplateHasUnprocessedSubmissions } from "@lib/templates/internal/error
 import { revalidatePath } from "next/cache";
 import { AuthenticatedAction } from "@lib/actions";
 import { getTemplateWithAssignedUsers } from "@lib/templates/queries/getTemplateWithAssignedUsers";
-import { sendArchivedFormNotifications } from "@lib/notifications";
+import { sendArchivedFormNotifications } from "@lib/formEmailOrchestration";
 
 // Public facing functions - they can be used by anyone who finds the associated server action identifer
 
@@ -18,13 +18,14 @@ export const deleteForm = AuthenticatedAction(async (session, id: string) => {
     }
 
     await deleteTemplate(id);
-    await sendArchivedFormNotifications(
-      session,
-      id,
-      template.formRecord.form.titleEn,
-      template.formRecord.form.titleFr,
-      template.users
-    );
+
+    sendArchivedFormNotifications(session.user.email, {
+      title: {
+        en: template.formRecord.form.titleEn,
+        fr: template.formRecord.form.titleFr,
+      },
+      ownersEmailAddresses: template.users.map((u) => u.email),
+    });
 
     revalidatePath("app/[locale]/(app administration)/admin/(with nav)/accounts/[id]/manage-forms");
   } catch (error) {

app/(gcforms)/[locale]/(form administration)/form-builder/[id]/settings/manage/page.tsx

@@ -6,10 +6,7 @@ import { authorization } from "@lib/privileges";
 import { AuthenticatedPage } from "@lib/pages/auth";
 import { SetClosingDate } from "./components/close/SetClosingDate";
 import { Notifications } from "./components/notifications/Notifications";
-import {
-  getNotificationsUsersForForm,
-  getUserNotificationSettingsForForm,
-} from "@lib/notifications";
+import { getNotificationsUsersForForm } from "@lib/formEmailOrchestration";
 
 export async function generateMetadata(props: {
   params: Promise<{ locale: string }>;
@@ -47,15 +44,12 @@ export default AuthenticatedPage(
       closedDetails = closedData?.closedDetails;
     }
 
-    // Get logged in user's notification setting for this form
-    const loggedInUserNotificationsSetting = await getUserNotificationSettingsForForm(
-      id,
-      props.session.user.id
-    );
-
     // Get list of users and their notification settings for this form
     const userNotificationsForForm = await getNotificationsUsersForForm(id);
 
+    const loggedInUserNotificationsSetting =
+      userNotificationsForForm?.find((u) => u.id === props.session.user.id)?.enabled ?? false;
+
     // Is the currently logged in user assigned to this form
     const userIsNotifiable = userNotificationsForForm
       ? userNotificationsForForm.some((user) => user.id === props.session.user.id)

app/(gcforms)/[locale]/(form administration)/form-builder/actions.ts

@@ -22,7 +22,7 @@ import { getFullTemplateByID } from "@lib/templates/queries/getFullTemplateByID"
 import { getFormJSONConfig } from "@lib/templates/queries/getFormJSONConfig";
 import { isValidEmail } from "@gcforms/core";
 import { slugify } from "@lib/client/clientHelpers";
-import { sendEmail } from "@lib/integration/notifyConnector";
+import { sendDefaultEmail } from "@lib/integration/notifyConnector";
 import { getOrigin } from "@lib/origin";
 import { NotificationsInterval } from "@gcforms/types";
 import { redirect } from "next/navigation";
@@ -506,19 +506,10 @@ export const shareForm = AuthenticatedAction(
 
       const HOST = await getOrigin();
 
-      // Here is the documentation for the `sendEmail` function: https://docs.notifications.service.gov.uk/node.html#send-an-email
-      await Promise.all(
-        emails.map((email: string) => {
-          return sendEmail(
-            email,
-            {
-              application_file: {
-                file: base64data,
-                filename: `${cleanedFilename}.json`,
-                sending_method: "attach",
-              },
-              subject: "Form shared | Formulaire partagé",
-              formResponse: `
+      await sendDefaultEmail({
+        to: emails,
+        subject: "Form shared | Formulaire partagé",
+        body: `
 **${session.user.name} (${session.user.email}) has shared a form with you.**
 
 To preview this form:
@@ -540,11 +531,13 @@ Pour prévisualiser ce formulaire :
   Aller sur [Formulaires GC](${HOST}). Aucun compte n'est nécessaire.
 - **Étape 3 :**
   Sélectionner "Ouvrir un formulaire".`,
-            },
-            "shareForm"
-          );
-        })
-      );
+        attachments: [
+          {
+            fileName: `${cleanedFilename}.json`,
+            base64EncodedFile: base64data,
+          },
+        ],
+      });
 
       return { success: true };
     } catch (error) {

app/(gcforms)/[locale]/(form administration)/forms/actions.ts

@@ -9,7 +9,7 @@ import { restoreTemplate } from "@lib/templates/mutations/restoreTemplate";
 import { revalidatePath } from "next/cache";
 import { FormRecord } from "@lib/types";
 import { AuthenticatedAction } from "@lib/actions";
-import { sendArchivedFormNotifications } from "@lib/notifications";
+import { sendArchivedFormNotifications } from "@lib/formEmailOrchestration";
 import { getTemplateWithAssignedUsers } from "@lib/templates/queries/getTemplateWithAssignedUsers";
 import { createDraftVersionForTemplate } from "@lib/templates/versioning/mutations/createDraftForTemplate";
 
@@ -52,13 +52,13 @@ export const deleteForm = AuthenticatedAction(
         }
       });
 
-      await sendArchivedFormNotifications(
-        session,
-        id,
-        template.formRecord.form.titleEn,
-        template.formRecord.form.titleFr,
-        template.users
-      );
+      sendArchivedFormNotifications(session.user.email, {
+        title: {
+          en: template.formRecord.form.titleEn,
+          fr: template.formRecord.form.titleFr,
+        },
+        ownersEmailAddresses: template.users.map((u) => u.email),
+      });
 
       revalidatePath("(gcforms)/[locale]/(form administration)/forms", "page");
     } catch (e) {

app/(gcforms)/[locale]/(form filler)/id/[...props]/actions.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach, Mock } from "vitest";
+import { NotificationsInterval } from "@gcforms/types";
 import { submitForm } from "./actions";
 import { PublicFormRecord, FormElementTypes } from "@lib/types";
 
@@ -32,8 +33,14 @@ vi.mock("@root/i18n", () => ({
   serverTranslation: vi.fn(),
 }));
 
-vi.mock("@lib/notifications", () => ({
-  sendNotifications: vi.fn(),
+vi.mock("@lib/formEmailOrchestration", () => ({
+  getFormNotificationInterval: vi.fn(),
+  updateNotificationMarker: vi.fn(),
+  prepareFormSubmissionEmail: vi.fn(),
+}));
+
+vi.mock("@lib/integration/notifyConnector", () => ({
+  sendDefaultEmail: vi.fn(),
 }));
 
 vi.mock("./lib/server/normalizeFormResponses", () => ({
@@ -50,7 +57,12 @@ import { checkOne } from "@lib/cache/flags";
 import { dateHasPast } from "@lib/utils";
 import { validateVisibleElements, valuesMatchErrorContainsElementType } from "@gcforms/core";
 import { serverTranslation } from "@root/i18n";
-import { sendNotifications } from "@lib/notifications";
+import {
+  getFormNotificationInterval,
+  prepareFormSubmissionEmail,
+  updateNotificationMarker,
+} from "@lib/formEmailOrchestration";
+import { sendDefaultEmail } from "@lib/integration/notifyConnector";
 import { normalizeFormResponses } from "./lib/server/normalizeFormResponses";
 import { processFormData } from "./lib/server/processFormData";
 import { ResponseValidationValues } from "@gcforms/core";
@@ -98,7 +110,10 @@ describe("submitForm", () => {
       submissionId: "test-submission-id",
       fileURLMap: {},
     });
-    (sendNotifications as Mock).mockResolvedValue(undefined);
+    (getFormNotificationInterval as Mock).mockResolvedValue(false);
+    (updateNotificationMarker as Mock).mockResolvedValue(null);
+    (prepareFormSubmissionEmail as Mock).mockResolvedValue(null);
+    (sendDefaultEmail as Mock).mockResolvedValue(undefined);
   });
 
   it("should return MissingFormDataError when file input validation fails", async () => {
@@ -151,11 +166,105 @@ describe("submitForm", () => {
       version: 2,
       language: mockLanguage,
       fileChecksums: undefined,
+      notificationId: undefined,
+    });
+    expect(getFormNotificationInterval).toHaveBeenCalledWith(mockFormId);
+    expect(prepareFormSubmissionEmail).not.toHaveBeenCalled();
+    expect(sendDefaultEmail).not.toHaveBeenCalled();
+  });
+
+  it("should send a first submission notification when form is eligible and no prior marker exists", async () => {
+    const mockEmailData = {
+      emails: ["user@example.com"],
+      subject: "You have a new submission",
+      formResponse: "Email body",
+    };
+    (checkOne as Mock).mockResolvedValue(true);
+    (getFormNotificationInterval as Mock).mockResolvedValue(NotificationsInterval.DAY);
+    (updateNotificationMarker as Mock).mockResolvedValue("FIRST_EMAIL");
+    (prepareFormSubmissionEmail as Mock).mockResolvedValue(mockEmailData);
+
+    const result = await submitForm(mockValues, mockLanguage, mockFormId);
+
+    expect(result).toEqual({
+      id: mockFormId,
+      submissionId: "test-submission-id",
+      fileURLMap: {},
+    });
+
+    expect(updateNotificationMarker).toHaveBeenCalledWith(mockFormId, NotificationsInterval.DAY);
+
+    expect(prepareFormSubmissionEmail).toHaveBeenCalledWith(
+      mockFormId,
+      mockTemplate.form.titleEn,
+      mockTemplate.form.titleFr,
+      "FIRST_EMAIL"
+    );
+
+    const notificationId = (processFormData as Mock).mock.calls[0][0].notificationId;
+    expect(notificationId).toBeTypeOf("string");
+
+    expect(sendDefaultEmail).toHaveBeenCalledWith({
+      to: mockEmailData.emails,
+      subject: mockEmailData.subject,
+      body: mockEmailData.formResponse,
+      options: { mode: "deferred", notificationId },
+    });
+    expect(processFormData).toHaveBeenCalledWith(expect.objectContaining({ notificationId }));
+  });
+
+  it("should send a second submission notification when form is eligible and first marker already set", async () => {
+    const mockEmailData = {
+      emails: ["user@example.com"],
+      subject: "You have multiple new submissions",
+      formResponse: "Email body",
+    };
+    (checkOne as Mock).mockResolvedValue(true);
+    (getFormNotificationInterval as Mock).mockResolvedValue(NotificationsInterval.DAY);
+    (updateNotificationMarker as Mock).mockResolvedValue("SECOND_EMAIL");
+    (prepareFormSubmissionEmail as Mock).mockResolvedValue(mockEmailData);
+
+    const result = await submitForm(mockValues, mockLanguage, mockFormId);
+
+    expect(result).toEqual({
+      id: mockFormId,
+      submissionId: "test-submission-id",
+      fileURLMap: {},
     });
-    expect(sendNotifications).toHaveBeenCalledWith(
+
+    expect(updateNotificationMarker).toHaveBeenCalledWith(mockFormId, NotificationsInterval.DAY);
+
+    expect(prepareFormSubmissionEmail).toHaveBeenCalledWith(
       mockFormId,
       mockTemplate.form.titleEn,
-      mockTemplate.form.titleFr
+      mockTemplate.form.titleFr,
+      "SECOND_EMAIL"
+    );
+
+    const notificationId = (processFormData as Mock).mock.calls[0][0].notificationId;
+    expect(notificationId).toBeTypeOf("string");
+
+    expect(sendDefaultEmail).toHaveBeenCalledWith({
+      to: mockEmailData.emails,
+      subject: mockEmailData.subject,
+      body: mockEmailData.formResponse,
+      options: { mode: "deferred", notificationId },
+    });
+    expect(processFormData).toHaveBeenCalledWith(expect.objectContaining({ notificationId }));
+  });
+
+  it("should not send a notification when form is eligible but marker limit is reached", async () => {
+    (checkOne as Mock).mockResolvedValue(true);
+    (getFormNotificationInterval as Mock).mockResolvedValue(NotificationsInterval.DAY);
+    (updateNotificationMarker as Mock).mockResolvedValue(null);
+
+    await submitForm(mockValues, mockLanguage, mockFormId);
+
+    expect(updateNotificationMarker).toHaveBeenCalledWith(mockFormId, NotificationsInterval.DAY);
+    expect(prepareFormSubmissionEmail).not.toHaveBeenCalled();
+    expect(sendDefaultEmail).not.toHaveBeenCalled();
+    expect(processFormData).toHaveBeenCalledWith(
+      expect.objectContaining({ notificationId: undefined })
     );
   });
 
@@ -236,4 +345,37 @@ describe("submitForm", () => {
       t: expect.any(Function),
     });
   });
+
+  it("should fall back to GC Notify (sendEmail without deferred mode) and return undefined notificationId when the notification flag is off", async () => {
+    const mockEmailData = {
+      emails: ["user@example.com"],
+      subject: "You have a new submission",
+      formResponse: "Email body",
+    };
+    // Flag OFF
+    (checkOne as Mock).mockResolvedValue(false);
+    (getFormNotificationInterval as Mock).mockResolvedValue(NotificationsInterval.DAY);
+    (updateNotificationMarker as Mock).mockResolvedValue("FIRST_EMAIL");
+    (prepareFormSubmissionEmail as Mock).mockResolvedValue(mockEmailData);
+
+    const result = await submitForm(mockValues, mockLanguage, mockFormId);
+
+    expect(result).toEqual({
+      id: mockFormId,
+      submissionId: "test-submission-id",
+      fileURLMap: {},
+    });
+
+    // sendEmail is called without deferred mode — falls back to GC Notify
+    expect(sendDefaultEmail).toHaveBeenCalledWith({
+      to: mockEmailData.emails,
+      subject: mockEmailData.subject,
+      body: mockEmailData.formResponse,
+    });
+
+    // No notificationId is generated or forwarded to processFormData when the flag is off
+    expect(processFormData).toHaveBeenCalledWith(
+      expect.objectContaining({ notificationId: undefined })
+    );
+  });
 });