chore: Fix Run API test type warnings

api.planx.uk/editor/publish.test.ts

@@ -3,8 +3,8 @@ import supertest from "supertest";
 import { queryMock } from "../tests/graphqlQueryMock";
 import { authHeader } from "../tests/mockJWT";
 import app from "../server";
-import { Flow } from "../types";
 import { flowWithInviteToPay } from "../tests/mocks/inviteToPayData";
+import { FlowGraph } from "@opensystemslab/planx-core/types";
 
 beforeEach(() => {
   queryMock.mockQuery({
@@ -168,7 +168,7 @@ describe("sections validation on diff", () => {
   });
 
   it("does not update if there are sections, but there is not a section in the first position", async () => {
-    const flowWithSections: Flow["data"] = {
+    const flowWithSections: FlowGraph = {
       _root: {
         edges: ["questionNode", "sectionNode"],
       },
@@ -205,7 +205,7 @@ describe("sections validation on diff", () => {
 
 describe("invite to pay validation on diff", () => {
   it("does not update if invite to pay is enabled, but there is not a Send component", async () => {
-    const { Send, ...invalidatedFlow } = flowWithInviteToPay;
+    const { Send: _Send, ...invalidatedFlow } = flowWithInviteToPay;
     invalidatedFlow["_root"].edges?.splice(
       invalidatedFlow["_root"].edges?.indexOf("Send"),
     );
@@ -266,7 +266,8 @@ describe("invite to pay validation on diff", () => {
   });
 
   it("does not update if invite to pay is enabled, but there is not a FindProperty (`_address`) component", async () => {
-    const { FindProperty, ...invalidatedFlow } = flowWithInviteToPay;
+    const { FindProperty: _FindProperty, ...invalidatedFlow } =
+      flowWithInviteToPay;
     invalidatedFlow["_root"].edges?.splice(
       invalidatedFlow["_root"].edges?.indexOf("FindProperty"),
     );
@@ -326,9 +327,9 @@ describe("invite to pay validation on diff", () => {
 
   it("does not update if invite to pay is enabled, but there is not a Checklist that sets `proposal.projectType`", async () => {
     const {
-      Checklist,
-      ChecklistOptionOne,
-      ChecklistOptionTwo,
+      Checklist: _Checklist,
+      ChecklistOptionOne: _ChecklistOptionOne,
+      ChecklistOptionTwo: _ChecklistOptionTwo,
       ...invalidatedFlow
     } = flowWithInviteToPay;
     invalidatedFlow["_root"].edges?.splice(
@@ -358,7 +359,7 @@ describe("invite to pay validation on diff", () => {
   });
 });
 
-const mockFlowData: Flow["data"] = {
+const mockFlowData: FlowGraph = {
   _root: {
     edges: [
       "SectionOne",

api.planx.uk/editor/publish.ts

@@ -4,8 +4,13 @@ import { adminGraphQLClient as adminClient } from "../hasura";
 import { dataMerged, getMostRecentPublishedFlow } from "../helpers";
 import { gql } from "graphql-request";
 import intersection from "lodash/intersection";
-import { ComponentType } from "@opensystemslab/planx-core/types";
+import {
+  ComponentType,
+  FlowGraph,
+  Node,
+} from "@opensystemslab/planx-core/types";
 import { userContext } from "../modules/auth/middleware";
+import type { Entry } from "type-fest";
 
 const validateAndDiffFlow = async (
   req: Request,
@@ -139,17 +144,17 @@ type ValidationResponse = {
   description?: string;
 };
 
-const validateSections = (flow: Record<string, any>): ValidationResponse => {
-  if (getSectionNodeIds(flow)?.length > 0) {
-    if (!sectionIsInFirstPosition(flow)) {
+const validateSections = (flowGraph: FlowGraph): ValidationResponse => {
+  if (getSectionNodeIds(flowGraph)?.length > 0) {
+    if (!sectionIsInFirstPosition(flowGraph)) {
       return {
         isValid: false,
         message: "Cannot publish an invalid flow",
         description: "When using Sections, your flow must start with a Section",
       };
     }
 
-    if (!allSectionsOnRoot(flow)) {
+    if (!allSectionsOnRoot(flowGraph)) {
       return {
         isValid: false,
         message: "Cannot publish an invalid flow",
@@ -165,57 +170,58 @@ const validateSections = (flow: Record<string, any>): ValidationResponse => {
   };
 };
 
-const getSectionNodeIds = (flow: Record<string, any>): string[] => {
-  return Object.entries(flow)
-    .filter(([_nodeId, nodeData]) => nodeData?.type === ComponentType.Section)
-    ?.map(([nodeId, _nodeData]) => nodeId);
+const getSectionNodeIds = (flowGraph: FlowGraph): string[] => {
+  const sectionNodes = Object.entries(flowGraph).filter((entry) =>
+    isComponentType(entry, ComponentType.Section),
+  );
+  return sectionNodes.map(([nodeId, _nodeData]) => nodeId);
 };
 
-const sectionIsInFirstPosition = (flow: Record<string, any>): boolean => {
-  const firstNodeId = flow["_root"].edges[0];
-  return flow[firstNodeId].type === ComponentType.Section;
+const sectionIsInFirstPosition = (flowGraph: FlowGraph): boolean => {
+  const firstNodeId = flowGraph["_root"].edges[0];
+  return flowGraph[firstNodeId].type === ComponentType.Section;
 };
 
-const allSectionsOnRoot = (flow: Record<string, any>): boolean => {
-  const sectionTypeNodeIds = getSectionNodeIds(flow);
+const allSectionsOnRoot = (flowData: FlowGraph): boolean => {
+  const sectionTypeNodeIds = getSectionNodeIds(flowData);
   const intersectingNodeIds = intersection(
-    flow["_root"].edges,
+    flowData["_root"].edges,
     sectionTypeNodeIds,
   );
   return intersectingNodeIds.length === sectionTypeNodeIds.length;
 };
 
-const validateInviteToPay = (flow: Record<string, any>): ValidationResponse => {
+const validateInviteToPay = (flowGraph: FlowGraph): ValidationResponse => {
   const invalidResponseTemplate = {
     isValid: false,
     message: "Cannot publish an invalid flow",
   };
 
-  if (inviteToPayEnabled(flow)) {
-    if (numberOfComponentType(flow, ComponentType.Pay) > 1) {
+  if (inviteToPayEnabled(flowGraph)) {
+    if (numberOfComponentType(flowGraph, ComponentType.Pay) > 1) {
       return {
         ...invalidResponseTemplate,
         description:
           "When using Invite to Pay, your flow must have exactly ONE Pay",
       };
     }
 
-    if (!hasComponentType(flow, ComponentType.Send)) {
+    if (!hasComponentType(flowGraph, ComponentType.Send)) {
       return {
         ...invalidResponseTemplate,
         description: "When using Invite to Pay, your flow must have a Send",
       };
     }
 
-    if (numberOfComponentType(flow, ComponentType.Send) > 1) {
+    if (numberOfComponentType(flowGraph, ComponentType.Send) > 1) {
       return {
         ...invalidResponseTemplate,
         description:
           "When using Invite to Pay, your flow must have exactly ONE Send. It can select many destinations",
       };
     }
 
-    if (!hasComponentType(flow, ComponentType.FindProperty)) {
+    if (!hasComponentType(flowGraph, ComponentType.FindProperty)) {
       return {
         ...invalidResponseTemplate,
         description:
@@ -224,7 +230,11 @@ const validateInviteToPay = (flow: Record<string, any>): ValidationResponse => {
     }
 
     if (
-      !hasComponentType(flow, ComponentType.Checklist, "proposal.projectType")
+      !hasComponentType(
+        flowGraph,
+        ComponentType.Checklist,
+        "proposal.projectType",
+      )
     ) {
       return {
         ...invalidResponseTemplate,
@@ -241,27 +251,40 @@ const validateInviteToPay = (flow: Record<string, any>): ValidationResponse => {
   };
 };
 
-const inviteToPayEnabled = (flow: Record<string, any>): boolean => {
-  const payNodeStatuses = Object.entries(flow)
-    .filter(([_nodeId, nodeData]) => nodeData?.type === ComponentType.Pay)
-    ?.map(([_nodeId, nodeData]) => nodeData?.data?.allowInviteToPay);
+const inviteToPayEnabled = (flowGraph: FlowGraph): boolean => {
+  const payNodes = Object.entries(flowGraph).filter(
+    (entry): entry is [string, Node] =>
+      isComponentType(entry, ComponentType.Pay),
+  );
+  const payNodeStatuses = payNodes.map(
+    ([_nodeId, node]) => node?.data?.allowInviteToPay,
+  );
   return (
     payNodeStatuses.length > 0 &&
     payNodeStatuses.every((status) => status === true)
   );
 };
 
+const isComponentType = (
+  entry: Entry<FlowGraph>,
+  type: ComponentType,
+): entry is [string, Node] => {
+  const [nodeId, node] = entry;
+  if (nodeId === "_root") return false;
+  return Boolean(node?.type === type);
+};
+
 const hasComponentType = (
-  flow: Record<string, any>,
+  flowGraph: FlowGraph,
   type: ComponentType,
   fn?: string,
 ): boolean => {
-  const nodeIds = Object.entries(flow).filter(
-    ([_nodeId, nodeData]) => nodeData?.type === type,
+  const nodeIds = Object.entries(flowGraph).filter(
+    (entry): entry is [string, Node] => isComponentType(entry, type),
   );
   if (fn) {
     nodeIds
-      ?.filter(([_nodeId, nodeData]) => nodeData?.data.fn === fn)
+      ?.filter(([_nodeId, nodeData]) => nodeData?.data?.fn === fn)
       ?.map(([nodeId, _nodeData]) => nodeId);
   } else {
     nodeIds?.map(([nodeId, _nodeData]) => nodeId);
@@ -270,16 +293,16 @@ const hasComponentType = (
 };
 
 const numberOfComponentType = (
-  flow: Record<string, any>,
+  flowGraph: FlowGraph,
   type: ComponentType,
   fn?: string,
 ): number => {
-  const nodeIds = Object.entries(flow).filter(
-    ([_nodeId, nodeData]) => nodeData?.type === type,
+  const nodeIds = Object.entries(flowGraph).filter(
+    (entry): entry is [string, Node] => isComponentType(entry, type),
   );
   if (fn) {
     nodeIds
-      ?.filter(([_nodeId, nodeData]) => nodeData?.data.fn === fn)
+      ?.filter(([_nodeId, nodeData]) => nodeData?.data?.fn === fn)
       ?.map(([nodeId, _nodeData]) => nodeId);
   } else {
     nodeIds?.map(([nodeId, _nodeData]) => nodeId);

api.planx.uk/helpers.test.ts

@@ -159,7 +159,9 @@ describe("dataMerged() function", () => {
   });
   it("handles multiple external portal nodes", async () => {
     const result = await dataMerged("parent-id");
-    const nodeTypes = Object.values(result).map((node) => node.type);
+    const nodeTypes = Object.values(result).map((node) =>
+      "type" in node ? node.type : undefined,
+    );
     const areAllPortalsFlattened = !nodeTypes.includes(
       ComponentType.ExternalPortal,
     );

api.planx.uk/helpers.ts

@@ -2,7 +2,7 @@ import { gql } from "graphql-request";
 import { capitalize } from "lodash";
 import { adminGraphQLClient as adminClient } from "./hasura";
 import { Flow, Node } from "./types";
-import { ComponentType } from "@opensystemslab/planx-core/types";
+import { ComponentType, FlowGraph } from "@opensystemslab/planx-core/types";
 
 // Get a flow's data (unflattened, without external portal nodes)
 const getFlowData = async (id: string): Promise<Flow> => {
@@ -135,7 +135,10 @@ const getPublishedFlowByDate = async (id: string, created_at: string) => {
 // Flatten a flow's data to include main content & portals in a single JSON representation
 // XXX: getFlowData & dataMerged are currently repeated in ../editor.planx.uk/src/lib/dataMergedHotfix.ts
 //        in order to load frontend /preview routes for flows that are not published
-const dataMerged = async (id: string, ob: Record<string, any> = {}) => {
+const dataMerged = async (
+  id: string,
+  ob: FlowGraph = { _root: { edges: [] } },
+): Promise<FlowGraph> => {
   // get the primary flow data
   const { slug, data } = await getFlowData(id);
 

api.planx.uk/package.json

@@ -42,6 +42,7 @@
     "string-to-stream": "^3.0.1",
     "swagger-jsdoc": "^6.2.8",
     "swagger-ui-express": "^5.0.0",
+    "type-fest": "^4.6.0",
     "zod": "^3.22.3"
   },
   "scripts": {

api.planx.uk/types.ts

@@ -8,6 +8,9 @@ export interface Node {
   type?: number;
 }
 
+/**
+ * @deprecated Migrating to Flow and FlowGraph from planx-core
+ */
 export interface Flow {
   id: string;
   slug: string;