Refactor SDK wrapper to use Classes.Workflow directly instead of deserialize

Signed-off-by: Lorna-Kelly <lornakelly88@gmail.com>

Author: lornakelly

packages/serverless-workflow-diagram-editor/src/core/workflowSdk.ts

@@ -14,29 +14,42 @@
  * limitations under the License.
  */
 
+import yaml from "js-yaml";
 import { Classes, Specification, validate } from "@serverlessworkflow/sdk";
 
-export type WorkflowParseResult =
-  | { success: true; workflow: Specification.Workflow }
-  | { success: false; error: Error };
+export type WorkflowParseResult = {
+  model: Specification.Workflow | null;
+  errors: Error[];
+};
 
-export function deserializeWorkflow(text: string): Specification.Workflow {
-  return Classes.Workflow.deserialize(text);
-}
-
-export function validateWorkflow(workflow: Specification.Workflow): void {
-  validate("Workflow", workflow);
+export function validateWorkflow(model: Specification.Workflow): Error[] {
+  try {
+    validate("Workflow", model);
+    return [];
+  } catch (err) {
+    // TODO: Parse individual validation errors from the SDK into separate Error objects when we are ready to render them.
+    return [err instanceof Error ? err : new Error(String(err))];
+  }
 }
 
 export function parseWorkflow(text: string): WorkflowParseResult {
+  let raw: Partial<Specification.Workflow>;
+
   try {
-    const workflow = deserializeWorkflow(text);
-    validateWorkflow(workflow);
-    return { success: true, workflow };
+    raw = yaml.load(text, { schema: yaml.DEFAULT_SCHEMA }) as Partial<Specification.Workflow>;
   } catch (err) {
     return {
-      success: false,
-      error: err instanceof Error ? err : new Error(String(err)),
+      model: null,
+      errors: [err instanceof Error ? err : new Error(String(err))],
     };
   }
+
+  if (raw == null || typeof raw !== "object") {
+    return { model: null, errors: [new Error("Not a valid workflow object")] };
+  }
+
+  const model = new Classes.Workflow(raw) as Specification.Workflow;
+  const errors = validateWorkflow(model);
+
+  return { model, errors };
 }

packages/serverless-workflow-diagram-editor/tests/core/__snapshots__/workflowSdk.integration.test.ts.snap

@@ -0,0 +1,91 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`parseWorkflow > parses valid 'JSON' and returns model with no errors 1`] = `
+{
+  "errors": [],
+  "model": t {
+    "do": t [
+      t {
+        "step1": t {
+          "set": t {
+            "variable": "my first workflow",
+          },
+        },
+      },
+    ],
+    "document": t {
+      "dsl": "1.0.0",
+      "name": "valid-workflow-json",
+      "namespace": "default",
+      "version": "1.0.0",
+    },
+  },
+}
+`;
+
+exports[`parseWorkflow > parses valid 'YAML' and returns model with no errors 1`] = `
+{
+  "errors": [],
+  "model": t {
+    "do": t [
+      t {
+        "step1": t {
+          "set": t {
+            "variable": "my first workflow",
+          },
+        },
+      },
+    ],
+    "document": t {
+      "dsl": "1.0.0",
+      "name": "valid-workflow-yaml",
+      "namespace": "default",
+      "version": "1.0.0",
+    },
+  },
+}
+`;
+
+exports[`parseWorkflow > returns model and errors for invalid but parseable 'JSON' 1`] = `
+{
+  "errors": [
+    [Error: 'Workflow' is invalid - The DSL version of the workflow 'undefined' doesn't match the supported version of the SDK '1.0.0'.],
+  ],
+  "model": t {
+    "do": t [
+      t {
+        "step1": t {
+          "set": t {
+            "variable": "my first invalid json workflow",
+          },
+        },
+      },
+    ],
+  },
+}
+`;
+
+exports[`parseWorkflow > returns model and errors for invalid but parseable 'YAML' 1`] = `
+{
+  "errors": [
+    [Error: 'Workflow' is invalid - The DSL version of the workflow 'undefined' doesn't match the supported version of the SDK '1.0.0'.],
+  ],
+  "model": t {
+    "do": t [
+      t {
+        "step1": t {
+          "set": t {
+            "variable": "my first invalid yaml workflow",
+          },
+        },
+      },
+    ],
+  },
+}
+`;
+
+exports[`validateWorkflow > returns errors for an invalid workflow 1`] = `
+[
+  [Error: 'Workflow' is invalid - The DSL version of the workflow 'undefined' doesn't match the supported version of the SDK '1.0.0'.],
+]
+`;

packages/serverless-workflow-diagram-editor/tests/core/workflowSdk.integration.test.ts

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2021-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, it, expect } from "vitest";
+import { parseWorkflow, validateWorkflow } from "../../src/core";
+import {
+  BASIC_VALID_WORKFLOW_YAML,
+  BASIC_VALID_WORKFLOW_JSON,
+  BASIC_INVALID_WORKFLOW_YAML,
+  BASIC_INVALID_WORKFLOW_JSON,
+} from "../fixtures/workflows";
+import { Classes, Specification } from "@serverlessworkflow/sdk";
+
+describe("parseWorkflow", () => {
+  it.each([
+    { format: "YAML", input: BASIC_VALID_WORKFLOW_YAML, expectedName: "valid-workflow-yaml" },
+    { format: "JSON", input: BASIC_VALID_WORKFLOW_JSON, expectedName: "valid-workflow-json" },
+  ])("parses valid $format and returns model with no errors", ({ input, expectedName }) => {
+    const result = parseWorkflow(input);
+    expect(result.errors).toHaveLength(0);
+    expect(result.model?.document?.name).toBe(expectedName);
+    expect(result).toMatchSnapshot();
+  });
+
+  it.each([
+    { format: "YAML", input: BASIC_INVALID_WORKFLOW_YAML },
+    { format: "JSON", input: BASIC_INVALID_WORKFLOW_JSON },
+  ])("returns model and errors for invalid but parseable $format", ({ input }) => {
+    const result = parseWorkflow(input);
+    expect(result.model).not.toBeNull();
+    expect(result.errors).toHaveLength(1);
+    expect(result).toMatchSnapshot();
+  });
+
+  it.each([
+    { description: "empty string", input: "" },
+    { description: "non-object YAML", input: "just a string" },
+    { description: "numeric YAML", input: "42" },
+  ])("returns null model with error for $description", ({ input }) => {
+    const result = parseWorkflow(input);
+    expect(result.model).toBeNull();
+    expect(result.errors[0].message).toBe("Not a valid workflow object");
+  });
+
+  it("returns null model with errors for unparseable text", () => {
+    const result = parseWorkflow("}{not yaml or json}{");
+    expect(result.model).toBeNull();
+    expect(result.errors).toHaveLength(1);
+  });
+});
+
+describe("validateWorkflow", () => {
+  it("returns empty array for a valid workflow", () => {
+    const valid = new Classes.Workflow({
+      document: { dsl: "1.0.0", name: "valid-workflow", version: "1.0.0", namespace: "default" },
+      do: [{ step1: { set: { variable: "value" } } }],
+    }) as Specification.Workflow;
+    const errors = validateWorkflow(valid);
+    expect(errors).toHaveLength(0);
+  });
+
+  it("returns errors for an invalid workflow", () => {
+    const invalid = new Classes.Workflow({
+      do: [{ step1: { set: { variable: "value" } } }],
+    }) as Specification.Workflow;
+    const errors = validateWorkflow(invalid);
+    expect(errors).toHaveLength(1);
+    expect(errors).toMatchSnapshot();
+  });
+});