Copied schemas from nhd-notify-supplier-config - DO NOT MERGE THIS PR

Author: nhsd-david-wass

internal/datastore/src/SupplierConfigDomain/__tests__/specification-supplier.test.ts

@@ -0,0 +1,71 @@
+import { PackSpecification } from "@nhsdigital/nhs-notify-event-schemas-supplier-config/src/domain/pack-specification";
+import { $SupplierPack, SupplierPack } from "../supplier-pack";
+
+describe("SpecificationSupplier schema validation", () => {
+  const standardLetterSpecification: PackSpecification = {
+    id: "standard-letter" as any,
+    name: "Standard Economy-class Letter",
+    status: "PROD",
+    createdAt: "2023-01-01T00:00:00Z",
+    updatedAt: "2023-01-01T00:00:00Z",
+    version: 1,
+    postage: {
+      id: "economy",
+      size: "STANDARD",
+      deliveryDays: 4,
+    },
+    assembly: {
+      envelopeId: "nhs-economy",
+      printColour: "BLACK",
+    },
+  };
+
+  const testSupplierPack: SupplierPack = {
+    id: "test-specification-supplier" as any,
+    packSpecificationId: standardLetterSpecification.id,
+    supplierId: "supplier-123",
+    approval: "APPROVED",
+    status: "PROD",
+  };
+
+  it("should validate a specification supplier", () => {
+    expect(() => $SupplierPack.parse(testSupplierPack)).not.toThrow();
+  });
+
+  describe("approval status validation", () => {
+    it("should accept DRAFT approval status", () => {
+      const supplierPack = { ...testSupplierPack, approval: "DRAFT" };
+      expect(() => $SupplierPack.parse(supplierPack)).not.toThrow();
+    });
+
+    it("should accept SUBMITTED approval status", () => {
+      const supplierPack = { ...testSupplierPack, approval: "SUBMITTED" };
+      expect(() => $SupplierPack.parse(supplierPack)).not.toThrow();
+    });
+
+    it("should accept PROOF_RECEIVED approval status", () => {
+      const supplierPack = { ...testSupplierPack, approval: "PROOF_RECEIVED" };
+      expect(() => $SupplierPack.parse(supplierPack)).not.toThrow();
+    });
+
+    it("should accept APPROVED approval status", () => {
+      const supplierPack = { ...testSupplierPack, approval: "APPROVED" };
+      expect(() => $SupplierPack.parse(supplierPack)).not.toThrow();
+    });
+
+    it("should accept REJECTED approval status", () => {
+      const supplierPack = { ...testSupplierPack, approval: "REJECTED" };
+      expect(() => $SupplierPack.parse(supplierPack)).not.toThrow();
+    });
+
+    it("should accept DISABLED approval status", () => {
+      const supplierPack = { ...testSupplierPack, approval: "DISABLED" };
+      expect(() => $SupplierPack.parse(supplierPack)).not.toThrow();
+    });
+
+    it("should reject invalid approval status", () => {
+      const supplierPack = { ...testSupplierPack, approval: "INVALID_STATUS" };
+      expect(() => $SupplierPack.parse(supplierPack)).toThrow();
+    });
+  });
+});

internal/datastore/src/SupplierConfigDomain/__tests__/specification.test.ts

@@ -0,0 +1,172 @@
+import {
+  $PackSpecification,
+  PackSpecification,
+} from "@nhsdigital/nhs-notify-event-schemas-supplier-config/src/domain/pack-specification";
+
+describe("Specification schema validation", () => {
+  const standardLetterSpecification: PackSpecification = {
+    id: "standard-letter",
+    name: "Standard Economy-class Letter",
+    status: "INT",
+    createdAt: "2023-01-01T00:00:00Z",
+    updatedAt: "2023-01-01T00:00:00Z",
+    version: 1,
+    postage: {
+      id: "economy",
+      size: "STANDARD",
+      deliveryDays: 4,
+    },
+    assembly: {
+      envelopeId: "nhs-economy",
+      printColour: "BLACK",
+    },
+  };
+
+  it("should validate a standard letter specification", () => {
+    expect(() =>
+      $PackSpecification.strict().parse(standardLetterSpecification),
+    ).not.toThrow();
+  });
+
+  it("should accept a letter specification with unrecognised fields", () => {
+    expect(() =>
+      $PackSpecification.parse({
+        ...standardLetterSpecification,
+        additionalField: { some: "data" },
+      }),
+    ).not.toThrow();
+  });
+
+  it("should validate a specification with optional description", () => {
+    const specWithDescription: PackSpecification = {
+      ...standardLetterSpecification,
+      description: "A standard economy-class letter for bulk mailings",
+    };
+
+    expect(() =>
+      $PackSpecification.strict().parse(specWithDescription),
+    ).not.toThrow();
+  });
+
+  it("should validate a specification without description", () => {
+    const specWithoutDescription: PackSpecification = {
+      ...standardLetterSpecification,
+    };
+
+    expect(() =>
+      $PackSpecification.strict().parse(specWithoutDescription),
+    ).not.toThrow();
+  });
+
+  it("should validate a specification with duplex set to true", () => {
+    const specWithDuplex: PackSpecification = {
+      ...standardLetterSpecification,
+      assembly: {
+        ...standardLetterSpecification.assembly,
+        duplex: true,
+      },
+    };
+
+    expect(() =>
+      $PackSpecification.strict().parse(specWithDuplex),
+    ).not.toThrow();
+  });
+
+  it("should validate a specification with duplex set to false", () => {
+    const specWithoutDuplex: PackSpecification = {
+      ...standardLetterSpecification,
+      assembly: {
+        ...standardLetterSpecification.assembly,
+        duplex: false,
+      },
+    };
+
+    expect(() =>
+      $PackSpecification.strict().parse(specWithoutDuplex),
+    ).not.toThrow();
+  });
+
+  it("should validate a specification without duplex field", () => {
+    const specWithoutDuplexField: PackSpecification = {
+      ...standardLetterSpecification,
+    };
+
+    expect(() =>
+      $PackSpecification.strict().parse(specWithoutDuplexField),
+    ).not.toThrow();
+  });
+
+  it("should validate a specification with constraints", () => {
+    const specWithConstraints: PackSpecification = {
+      ...standardLetterSpecification,
+      constraints: {
+        sheets: {
+          value: 10,
+          operator: "LESS_THAN",
+        },
+        deliveryDays: {
+          value: 4,
+          operator: "LESS_THAN",
+        },
+      },
+    };
+
+    expect(() =>
+      $PackSpecification.strict().parse(specWithConstraints),
+    ).not.toThrow();
+  });
+
+  it("should validate a specification with all constraint fields", () => {
+    const specWithConstraints: PackSpecification = {
+      ...standardLetterSpecification,
+      constraints: {
+        deliveryDays: {
+          value: 5,
+          operator: "EQUALS",
+        },
+        sheets: {
+          value: 20,
+          operator: "LESS_THAN",
+        },
+        sides: {
+          value: 4,
+          operator: "LESS_THAN",
+        },
+        blackCoveragePercentage: {
+          value: 80,
+          operator: "LESS_THAN",
+        },
+        colourCoveragePercentage: {
+          value: 50,
+          operator: "LESS_THAN",
+        },
+      },
+    };
+
+    expect(() =>
+      $PackSpecification.strict().parse(specWithConstraints),
+    ).not.toThrow();
+  });
+
+  it("should reject a specification with invalid constraint value", () => {
+    const specWithInvalidConstraints = {
+      ...standardLetterSpecification,
+      constraints: {
+        sheets: {
+          value: "not a number",
+          operator: "LESS_THAN",
+        },
+      },
+    };
+
+    expect(() =>
+      $PackSpecification.strict().parse(specWithInvalidConstraints),
+    ).toThrow();
+  });
+
+  it("should validate a specification without constraints", () => {
+    expect(() =>
+      $PackSpecification.strict().parse(standardLetterSpecification),
+    ).not.toThrow();
+  });
+});

internal/datastore/src/SupplierConfigDomain/channel.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const $ChannelType = z.enum(["NHSAPP", "SMS", "EMAIL", "LETTER"]);
+
+export type ChannelType = z.infer<typeof $ChannelType>;

internal/datastore/src/SupplierConfigDomain/common.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const $EnvironmentStatus = z
+  .enum(["DRAFT", "INT", "PROD", "DISABLED"])
+  .meta({
+    title: "EnvironmentStatus",
+    description:
+      "Indicates whether the configuration is in draft, or enabled in the integration or production environment. " +
+      "`PROD` implies that the configuration is also enabled in the integration environment.",
+  });

internal/datastore/src/SupplierConfigDomain/constraint.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+
+export const $Constraint = z
+  .object({
+    value: z.number(),
+    operator: z
+      .enum(["EQUALS", "NOT_EQUALS", "GREATER_THAN", "LESS_THAN"])
+      .default("LESS_THAN"),
+  })
+  .meta({
+    title: "Constraint",
+  });
+export type Constraint = z.infer<typeof $Constraint>;
+
+export const $Constraints = z.object({
+  deliveryDays: $Constraint.optional().meta({
+    title: "Delivery Days",
+    description:
+      "The expected number of days for delivery under this configuration.",
+  }),
+  sheets: $Constraint.optional().meta({
+    title: "Sheets of paper",
+    description:
+      "The number of sheets that can be accommodated with this configuration.",
+  }),
+  sides: $Constraint.optional().meta({
+    title: "Sides",
+    description:
+      "The number of sides to be printed for this letter. Dependent on duplex printing options.",
+  }),
+  blackCoveragePercentage: $Constraint.optional().meta({
+    title: "Black Coverage Percentage",
+    description:
+      "The percentage of black coverage allowed on the paper under this configuration.",
+  }),
+  colourCoveragePercentage: $Constraint.optional().meta({
+    title: "Colour Coverage Percentage",
+    description:
+      "The percentage of colour coverage allowed on the paper under this configuration.",
+  }),
+});

internal/datastore/src/SupplierConfigDomain/envelope.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+
+export const $EnvelopeFeature = z.enum([
+  "WHITEMAIL",
+  "NHS_BRANDING",
+  "NHS_BARCODE",
+]);
+
+export const $Envelope = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    size: z.enum(["C5", "C4", "DL"]),
+    features: z.array($EnvelopeFeature).optional(),
+    artwork: z.url().optional().meta({
+      title: "Artwork URL",
+      description:
+        "An S3 URL pointing to the artwork for this envelope, if applicable.",
+    }),
+    maxThicknessMm: z
+      .number()
+      .optional()
+      .meta({
+        title: "Max Thickness (mm)",
+        description:
+          "The maximum thickness in millimetres for this envelope. " +
+          "Used to validate that the assembled pack will fit within the envelope.",
+      }),
+    maxSheets: z
+      .number()
+      .optional()
+      .meta({
+        title: "Max Sheets",
+        description:
+          "The maximum number of sheets that can be accommodated within this envelope. " +
+          "Used to validate that the assembled pack will fit within the envelope.",
+      }),
+  })
+  .describe("Envelope");
+export type Envelope = z.infer<typeof $Envelope>;