VIA-629 SB Add isActive() method to Campaigns.

Also, make Campaigns a class, and use Zod for our deserialisation.

Author: acerathereinspirative-nhs-nvir

src/services/content-api/types.ts

@@ -220,10 +220,3 @@ export type ContentApiVaccinationsResponse = {
   ];
   webpage: string;
 };
-
-export interface Campaign {
-  start: Date;
-  end: Date;
-}
-
-export type Campaigns = Record<string, Campaign[]>;

src/utils/campaigns/types.test.ts

@@ -0,0 +1,50 @@
+import { VaccineType } from "@src/models/vaccine";
+import { Campaigns } from "@src/utils/campaigns/types";
+
+jest.mock("sanitize-data", () => ({ sanitize: jest.fn() }));
+
+describe("Campaigns", () => {
+  it("should convert json to a Campaigns ", async () => {
+    const jsonString = JSON.stringify({
+      COVID_19: [
+        { start: "20251112", end: "20260301" },
+        { start: "20260901", end: "20270301" },
+      ],
+      FLU_FOR_ADULTS: [
+        { start: "20251112", end: "20260301" },
+        { start: "20260901", end: "20270301" },
+      ],
+    });
+
+    const actual = Campaigns.fromJson(jsonString);
+
+    expect(actual!.get(VaccineType.COVID_19)).toStrictEqual([
+      { start: new Date("2025-11-12"), end: new Date("2026-03-01") },
+      { start: new Date("2026-09-01"), end: new Date("2027-03-01") },
+    ]);
+
+    expect(actual!.get(VaccineType.FLU_FOR_ADULTS)).toStrictEqual([
+      { start: new Date("2025-11-12"), end: new Date("2026-03-01") },
+      { start: new Date("2026-09-01"), end: new Date("2027-03-01") },
+    ]);
+  });
+
+  describe("isActive", () => {
+    const jsonString = JSON.stringify({ COVID_19: [{ start: "20251112", end: "20260301" }] });
+    const campaigns = Campaigns.fromJson(jsonString)!;
+
+    it.each([
+      ["is inactive before start date", "2025-11-11", false],
+      ["is active on start date", "2025-11-12", true],
+      ["is active during campaign", "2025-12-25", true],
+      ["is active on end date", "2026-03-01", true],
+      ["is inactive after end date", "2026-03-02", false],
+      ["is inactive in different year", "2024-01-01", false],
+    ])("%s (%s) -> %s", (_, dateStr, expected) => {
+      const dateToCheck = new Date(dateStr);
+      const actual = campaigns.isActive(VaccineType.COVID_19, dateToCheck);
+
+      expect(actual).toBe(expected);
+    });
+  });
+});

src/utils/campaigns/types.ts

@@ -0,0 +1,73 @@
+import { VaccineType } from "@src/models/vaccine";
+import { UtcDateFromStringSchema } from "@src/utils/date";
+import { logger } from "@src/utils/logger";
+import { Logger } from "pino";
+import { z } from "zod";
+
+const log: Logger = logger.child({ module: "campaigns" });
+
+const CampaignSchema = z
+  .object({
+    start: UtcDateFromStringSchema,
+    end: UtcDateFromStringSchema,
+  })
+  .refine((data) => data.end >= data.start, {
+    message: "End date must be after start date",
+    path: ["end"],
+  });
+
+export type Campaign = z.infer<typeof CampaignSchema>;
+
+export class Campaigns {
+  private schedule: Partial<Record<VaccineType, Campaign[]>>;
+
+  constructor(schedule: Partial<Record<VaccineType, Campaign[]>>) {
+    this.schedule = schedule;
+  }
+
+  /**
+   * Static Deserializer
+   * Parses JSON string -> Validates with Zod -> Returns Class Instance
+   */
+  static fromJson(jsonString: string): Campaigns | undefined {
+    try {
+      const GenericSchema = z.record(z.string(), z.array(CampaignSchema));
+
+      const rawObj = JSON.parse(jsonString);
+      const parsedGeneric = GenericSchema.parse(rawObj);
+
+      const validSchedule: Partial<Record<VaccineType, Campaign[]>> = {};
+
+      const validVaccines = new Set(Object.values(VaccineType) as string[]);
+
+      for (const [key, campaigns] of Object.entries(parsedGeneric)) {
+        if (validVaccines.has(key)) {
+          validSchedule[key as VaccineType] = campaigns;
+        } else {
+          log.warn({ context: { key } }, "Ignored unknown vaccine key");
+        }
+      }
+
+      return new Campaigns(validSchedule);
+    } catch (error) {
+      log.warn({ context: { jsonString }, error }, "Failed to parse campaigns");
+      return undefined;
+    }
+  }
+
+  /** Get all campaigns for a specific vaccine */
+  get(vaccine: VaccineType): Campaign[] {
+    return this.schedule[vaccine] ?? [];
+  }
+
+  /** Check if a vaccine is currently active */
+  isActive(vaccine: VaccineType, date: Date = new Date()): boolean {
+    const campaigns = this.get(vaccine);
+    return campaigns.some((c) => date >= c.start && date <= c.end);
+  }
+
+  /** Get a list of all vaccine names in the schedule */
+  listVaccines(): VaccineType[] {
+    return Object.keys(this.schedule) as VaccineType[];
+  }
+}

src/utils/config.test.ts

@@ -1,3 +1,4 @@
+import { VaccineType } from "@src/models/vaccine";
 import config, { ConfigError } from "@src/utils/config";
 import getSecret from "@src/utils/get-secret";
 import { randomString } from "@test-data/meta-builder";
@@ -88,29 +89,13 @@ describe("lazyConfig", () => {
 
   it("should convert CAMPAIGNS to a Campaigns ", async () => {
     setupTestEnvVars("test/");
-    process.env.CAMPAIGNS = JSON.stringify({
-      covid: [
-        { start: "20251112", end: "20260301" },
-        { start: "20260901", end: "20270301" },
-      ],
-      flu: [
-        { start: "20251112", end: "20260301" },
-        { start: "20260901", end: "20270301" },
-      ],
-    });
+    process.env.CAMPAIGNS = JSON.stringify({ COVID_19: [{ start: "20251112", end: "20260301" }] });
 
     const actual = await config.CAMPAIGNS;
 
-    expect(actual).toStrictEqual({
-      covid: [
-        { start: new Date("2025-11-12"), end: new Date("2026-03-01") },
-        { start: new Date("2026-09-01"), end: new Date("2027-03-01") },
-      ],
-      flu: [
-        { start: new Date("2025-11-12"), end: new Date("2026-03-01") },
-        { start: new Date("2026-09-01"), end: new Date("2027-03-01") },
-      ],
-    });
+    expect(actual.get(VaccineType.COVID_19)).toStrictEqual([
+      { start: new Date("2025-11-12"), end: new Date("2026-03-01") },
+    ]);
   });
 
   it("should throw for invalid URL", async () => {

src/utils/config.ts

@@ -1,6 +1,5 @@
-import { Campaigns } from "@src/services/content-api/types";
 import { EligibilityApiError } from "@src/services/eligibility-api/gateway/exceptions";
-import { UtcDateFromStringSchema } from "@src/utils/date";
+import { Campaigns } from "@src/utils/campaigns/types";
 import getSecret from "@src/utils/get-secret";
 import { logger } from "@src/utils/logger";
 import { retry } from "es-toolkit";
@@ -89,29 +88,7 @@ class Config {
     if (lower === "false") return false;
     return undefined;
   };
-  private static readonly toCampaigns = (rawValue: string): Campaigns | undefined => {
-    try {
-      interface RawCampaign {
-        start: string;
-        end: string;
-      }
-
-      const rawObj: Record<string, RawCampaign[]> = JSON.parse(rawValue);
 
-      const parsedSchedule: Campaigns = {};
-
-      for (const [vaccineName, campaigns] of Object.entries(rawObj)) {
-        parsedSchedule[vaccineName] = campaigns.map((c) => ({
-          start: UtcDateFromStringSchema.parse(c.start),
-          end: UtcDateFromStringSchema.parse(c.end),
-        }));
-      }
-
-      return parsedSchedule;
-    } catch {
-      return undefined;
-    }
-  };
   static readonly converters: Record<string, (value: string) => ConfigValue> = {
     APIM_AUTH_URL: Config.toUrl,
     CONTENT_API_ENDPOINT: Config.toUrl,
@@ -123,7 +100,7 @@ class Config {
     NHS_APP_REDIRECT_LOGIN_URL: Config.toUrl,
     IS_APIM_AUTH_ENABLED: Config.toBoolean,
     MAX_SESSION_AGE_MINUTES: Config.toNumber,
-    CAMPAIGNS: Config.toCampaigns,
+    CAMPAIGNS: Campaigns.fromJson,
   };
 
   /**

src/utils/date.ts

@@ -10,7 +10,7 @@ export const UtcDateFromStringSchema = z
     const utcTimestamp = Date.UTC(year, month - 1, day);
     const date = new Date(utcTimestamp);
     if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
-      ctx.addIssue("invalid_value");
+      ctx.addIssue({ code: "custom", message: "Invalid date value" });
       return z.NEVER;
     }
     return date;