Parse reusable workflows up to a depth of 1

actions-workflow-parser/src/model/convert.test.ts

@@ -7,7 +7,7 @@ function serializeTemplate(template: unknown): unknown {
 }
 
 describe("convertWorkflowTemplate", () => {
-  it("converts workflow with one job", () => {
+  it("converts workflow with one job", async () => {
     const result = parseWorkflow(
       {
         name: "wf.yaml",
@@ -19,7 +19,7 @@ jobs:
       nullTrace
     );
 
-    const template = convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
+    const template = await convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
 
     expect(serializeTemplate(template)).toEqual({
       events: {
@@ -43,7 +43,7 @@ jobs:
     });
   });
 
-  it("converts workflow if expressions", () => {
+  it("converts workflow if expressions", async () => {
     const result = parseWorkflow(
       {
         name: "wf.yaml",
@@ -59,7 +59,7 @@ jobs:
       nullTrace
     );
 
-    const template = convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
+    const template = await convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
 
     expect(serializeTemplate(template)).toEqual({
       events: {
@@ -92,7 +92,7 @@ jobs:
     });
   });
 
-  it("converts workflow with empty needs", () => {
+  it("converts workflow with empty needs", async () => {
     const result = parseWorkflow(
       {
         name: "wf.yaml",
@@ -105,7 +105,7 @@ jobs:
       nullTrace
     );
 
-    const template = convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
+    const template = await convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
 
     expect(serializeTemplate(template)).toEqual({
       errors: [
@@ -134,7 +134,7 @@ jobs:
     });
   });
 
-  it("converts workflow with needs errors", () => {
+  it("converts workflow with needs errors", async () => {
     const result = parseWorkflow(
       {
         name: "wf.yaml",
@@ -152,7 +152,7 @@ jobs:
       nullTrace
     );
 
-    const template = convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
+    const template = await convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
 
     expect(serializeTemplate(template)).toEqual({
       errors: [
@@ -211,7 +211,7 @@ jobs:
     });
   });
 
-  it("converts workflow with invalid on", () => {
+  it("converts workflow with invalid on", async () => {
     const result = parseWorkflow(
       {
         name: "wf.yaml",
@@ -229,7 +229,7 @@ jobs:
       nullTrace
     );
 
-    const template = convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
+    const template = await convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
 
     expect(template.jobs).not.toBeUndefined();
     expect(template.jobs).toHaveLength(1);
@@ -271,7 +271,7 @@ jobs:
     });
   });
 
-  it("converts workflow with invalid jobs", () => {
+  it("converts workflow with invalid jobs", async () => {
     const result = parseWorkflow(
       {
         name: "wf.yaml",
@@ -282,7 +282,7 @@ jobs:
       nullTrace
     );
 
-    const template = convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
+    const template = await convertWorkflowTemplate(result.context, result.value!, ErrorPolicy.TryConversion);
 
     expect(template.jobs).not.toBeUndefined();
     expect(template.jobs).toHaveLength(0);

actions-workflow-parser/src/model/convert.ts

@@ -1,9 +1,13 @@
 import {TemplateContext} from "../templates/template-context";
 import {TemplateToken, TemplateTokenError} from "../templates/tokens/template-token";
+import {FileProvider} from "../workflows/file-provider";
+import {parseWorkflow} from "../workflows/workflow-parser";
 import {convertConcurrency} from "./converter/concurrency";
 import {convertOn} from "./converter/events";
 import {handleTemplateTokenErrors} from "./converter/handle-errors";
 import {convertJobs} from "./converter/jobs";
+import {convertReferencedWorkflow} from "./converter/referencedWorkflow";
+import {isReusableWorkflowJob} from "./type-guards";
 import {WorkflowTemplate} from "./workflow-template";
 
 export enum ErrorPolicy {
@@ -11,11 +15,35 @@ export enum ErrorPolicy {
   TryConversion
 }
 
-export function convertWorkflowTemplate(
+export type WorkflowTemplateConverterOptions = {
+  /**
+   * The maximum depth of reusable workflows allowed in the workflow.
+   * If this depth is exceeded, an error will be reported.
+   * If {@link fetchReusableWorkflowDepth} is less than this value, the maximum depth
+   * won't be enforced.
+   * Default: 4
+   */
+  maxReusableWorkflowDepth?: number;
+  /**
+   * The depth to fetch reusable workflows, up to {@link maxReusableWorkflowDepth}.
+   * Currently only a fetch depth of 0 or 1 is supported.
+   * Default: 0
+   */
+  fetchReusableWorkflowDepth?: number;
+};
+
+const defaultOptions: Required<WorkflowTemplateConverterOptions> = {
+  maxReusableWorkflowDepth: 4,
+  fetchReusableWorkflowDepth: 0
+};
+
+export async function convertWorkflowTemplate(
   context: TemplateContext,
   root: TemplateToken,
-  errorPolicy: ErrorPolicy = ErrorPolicy.ReturnErrorsOnly
-): WorkflowTemplate {
+  errorPolicy: ErrorPolicy = ErrorPolicy.ReturnErrorsOnly,
+  fileProvider?: FileProvider,
+  options: WorkflowTemplateConverterOptions = defaultOptions
+): Promise<WorkflowTemplate> {
   const result = {} as WorkflowTemplate;
 
   if (context.errors.getErrors().length > 0 && errorPolicy === ErrorPolicy.ReturnErrorsOnly) {
@@ -25,6 +53,12 @@ export function convertWorkflowTemplate(
     return result;
   }
 
+  const opts = getOptionsWithDefaults(options);
+
+  if (fileProvider === undefined && opts.fetchReusableWorkflowDepth > 0) {
+    context.error(root, new Error("A file provider is required to fetch reusable workflows"));
+  }
+
   try {
     const rootMapping = root.assertMapping("root");
 
@@ -49,6 +83,31 @@ export function convertWorkflowTemplate(
           break;
       }
     }
+
+    // Load referenced workflows
+    for (const job of result.jobs || []) {
+      if (isReusableWorkflowJob(job)) {
+        if (opts.maxReusableWorkflowDepth === 0) {
+          context.error(job.ref, new Error("Reusable workflows are not allowed"));
+          continue;
+        }
+
+        if (opts.fetchReusableWorkflowDepth === 0 || fileProvider === undefined) {
+          continue;
+        }
+
+        try {
+          const file = await fileProvider.getFileContent(job.ref.value);
+          const workflow = parseWorkflow(file, context);
+          if (!workflow.value) {
+            continue;
+          }
+          convertReferencedWorkflow(context, workflow.value, job);
+        } catch {
+          context.error(job.ref, new Error("Unable to find reusable workflow"));
+        }
+      }
+    }
   } catch (err) {
     if (err instanceof TemplateTokenError) {
       context.error(err.token, err);
@@ -66,3 +125,16 @@ export function convertWorkflowTemplate(
 
   return result;
 }
+
+function getOptionsWithDefaults(options: WorkflowTemplateConverterOptions): Required<WorkflowTemplateConverterOptions> {
+  return {
+    maxReusableWorkflowDepth:
+      options.maxReusableWorkflowDepth !== undefined
+        ? options.maxReusableWorkflowDepth
+        : defaultOptions.maxReusableWorkflowDepth,
+    fetchReusableWorkflowDepth:
+      options.fetchReusableWorkflowDepth !== undefined
+        ? options.fetchReusableWorkflowDepth
+        : defaultOptions.fetchReusableWorkflowDepth
+  };
+}

actions-workflow-parser/src/model/converter/base-job.ts

@@ -1,66 +0,0 @@
-import {TemplateContext} from "../../templates/template-context";
-import {StringToken, MappingToken, BasicExpressionToken} from "../../templates/tokens";
-import {isSequence, isString} from "../../templates/tokens/type-guards";
-import {BaseJob} from "../workflow-template";
-import {convertConcurrency} from "./concurrency";
-import {handleTemplateTokenErrors} from "./handle-errors";
-import {IdBuilder} from "./id-builder";
-
-export function convertBaseJob(
-  context: TemplateContext,
-  jobKey: StringToken,
-  token: MappingToken
-): Omit<BaseJob, "type"> {
-  const error = new IdBuilder().tryAddKnownId(jobKey.value);
-  if (error) {
-    context.error(jobKey, error);
-  }
-
-  const result: Omit<BaseJob, "type"> = {
-    id: jobKey,
-    name: undefined,
-    needs: undefined,
-    if: new BasicExpressionToken(undefined, undefined, "success()", undefined, undefined, undefined),
-    concurrency: undefined,
-    strategy: undefined
-  };
-
-  for (const item of token) {
-    const propertyName = item.key.assertString("job property name");
-    switch (propertyName.value) {
-      case "concurrency":
-        handleTemplateTokenErrors(item.value, context, undefined, () => convertConcurrency(context, item.value));
-        result.concurrency = item.value;
-        break;
-
-      case "name":
-        result.name = item.value.assertScalar("job name");
-        break;
-
-      case "needs":
-        result.needs = [];
-        if (isString(item.value)) {
-          const jobNeeds = item.value.assertString("job needs id");
-          result.needs.push(jobNeeds);
-        }
-
-        if (isSequence(item.value)) {
-          for (const seqItem of item.value) {
-            const jobNeeds = seqItem.assertString("job needs id");
-            result.needs.push(jobNeeds);
-          }
-        }
-        break;
-
-      case "strategy":
-        result.strategy = item.value;
-        break;
-    }
-  }
-
-  if (!result.name) {
-    result.name = result.id;
-  }
-
-  return result;
-}

actions-workflow-parser/src/model/converter/job.ts

@@ -1,70 +1,137 @@
 import {TemplateContext} from "../../templates/template-context";
-import {StringToken, MappingToken} from "../../templates/tokens";
-import {Job} from "../workflow-template";
-import {convertBaseJob} from "./base-job";
+import {StringToken, MappingToken, BasicExpressionToken, TemplateToken, ScalarToken} from "../../templates/tokens";
+import {isSequence, isString} from "../../templates/tokens/type-guards";
+import {WorkflowJob, Step} from "../workflow-template";
+import {convertConcurrency} from "./concurrency";
 import {convertToJobContainer, convertToJobServices} from "./container";
 import {handleTemplateTokenErrors} from "./handle-errors";
+import {IdBuilder} from "./id-builder";
 import {convertToActionsEnvironmentRef} from "./job/environment";
 import {convertRunsOn} from "./job/runs-on";
 import {convertSteps} from "./steps";
 
-export function convertJob(context: TemplateContext, jobKey: StringToken, token: MappingToken): Job {
-  const base = convertBaseJob(context, jobKey, token);
-  const result: Job = {
-    type: "job",
-    id: base.id,
-    name: base.name,
-    needs: base.needs,
-    if: base.if,
-    env: undefined,
-    concurrency: base.concurrency,
-    environment: undefined,
-    strategy: base.strategy,
-    "runs-on": undefined,
-    container: undefined,
-    services: undefined,
-    outputs: undefined,
-    steps: []
-  };
+export function convertJob(context: TemplateContext, jobKey: StringToken, token: MappingToken): WorkflowJob {
+  const error = new IdBuilder().tryAddKnownId(jobKey.value);
+  if (error) {
+    context.error(jobKey, error);
+  }
+
+  let concurrency, container, env, environment, name, outputs, runsOn, services, strategy: TemplateToken | undefined;
+  let needs: StringToken[] | undefined = undefined;
+  let steps: Step[] = [];
+  let workflowJobRef: StringToken | undefined;
 
   for (const item of token) {
     const propertyName = item.key.assertString("job property name");
     switch (propertyName.value) {
+      case "concurrency":
+        handleTemplateTokenErrors(item.value, context, undefined, () => convertConcurrency(context, item.value));
+        concurrency = item.value;
+        break;
+
       case "container":
         convertToJobContainer(context, item.value);
-        result.container = item.value;
+        container = item.value;
         break;
 
       case "env":
-        result.env = item.value.assertMapping("job env");
+        env = item.value.assertMapping("job env");
         break;
 
       case "environment":
         handleTemplateTokenErrors(item.value, context, undefined, () =>
           convertToActionsEnvironmentRef(context, item.value)
         );
-        result.environment = item.value;
+        environment = item.value;
         break;
 
+      case "name":
+        name = item.value.assertScalar("job name");
+        break;
+
+      case "needs": {
+        needs = [];
+        if (isString(item.value)) {
+          const jobNeeds = item.value.assertString("job needs id");
+          needs.push(jobNeeds);
+        }
+
+        if (isSequence(item.value)) {
+          for (const seqItem of item.value) {
+            const jobNeeds = seqItem.assertString("job needs id");
+            needs.push(jobNeeds);
+          }
+        }
+        break;
+      }
+
       case "outputs":
-        result.outputs = item.value.assertMapping("job outputs");
+        outputs = item.value.assertMapping("job outputs");
         break;
 
       case "runs-on":
         handleTemplateTokenErrors(item.value, context, undefined, () => convertRunsOn(context, item.value));
-        result["runs-on"] = item.value;
+        runsOn = item.value;
         break;
 
       case "services":
         convertToJobServices(context, item.value);
-        result.services = item.value;
+        services = item.value;
         break;
 
       case "steps":
-        result.steps = convertSteps(context, item.value);
+        steps = convertSteps(context, item.value);
+        break;
+
+      case "strategy":
+        strategy = item.value;
+        break;
+
+      case "uses":
+        workflowJobRef = item.value.assertString("job item uses");
         break;
     }
   }
 
-  return result;
+  if (workflowJobRef !== undefined) {
+    return {
+      type: "reusableWorkflowJob",
+      id: jobKey,
+      name: jobName(name, jobKey),
+      needs: needs ?? [],
+      if: new BasicExpressionToken(undefined, undefined, "success()", undefined, undefined, undefined),
+      ref: workflowJobRef,
+      concurrency,
+      strategy
+    };
+  } else {
+    return {
+      type: "job",
+      id: jobKey,
+      name: jobName(name, jobKey),
+      needs,
+      if: new BasicExpressionToken(undefined, undefined, "success()", undefined, undefined, undefined),
+      env,
+      concurrency,
+      environment,
+      strategy,
+      "runs-on": runsOn,
+      container,
+      services,
+      outputs,
+      steps
+    };
+  }
+}
+
+function jobName(name: ScalarToken | undefined, jobKey: StringToken): ScalarToken {
+  if (name === undefined) {
+    return jobKey;
+  }
+
+  if (isString(name) && name.value === "") {
+    return jobKey;
+  }
+
+  return name;
 }

actions-workflow-parser/src/model/converter/jobs.ts

@@ -2,7 +2,7 @@ import {TemplateContext} from "../../templates/template-context";
 import {StringToken} from "../../templates/tokens";
 import {TemplateToken} from "../../templates/tokens/template-token";
 import {isMapping} from "../../templates/tokens/type-guards";
-import {Job} from "../workflow-template";
+import {WorkflowJob} from "../workflow-template";
 import {handleTemplateTokenErrors} from "./handle-errors";
 import {convertJob} from "./job";
 
@@ -11,9 +11,9 @@ type nodeInfo = {
   needs: StringToken[];
 };
 
-export function convertJobs(context: TemplateContext, token: TemplateToken): Job[] {
+export function convertJobs(context: TemplateContext, token: TemplateToken): WorkflowJob[] {
   if (isMapping(token)) {
-    const result: Job[] = [];
+    const result: WorkflowJob[] = [];
     const jobsWithSatisfiedNeeds: nodeInfo[] = [];
     const alljobsWithUnsatisfiedNeeds: nodeInfo[] = [];
 
@@ -49,7 +49,7 @@ export function convertJobs(context: TemplateContext, token: TemplateToken): Job
 function validateNeeds(
   token: TemplateToken,
   context: TemplateContext,
-  result: Job[],
+  result: WorkflowJob[],
   jobsWithSatisfiedNeeds: nodeInfo[],
   alljobsWithUnsatisfiedNeeds: nodeInfo[]
 ) {

actions-workflow-parser/src/model/converter/referencedWorkflow.ts

@@ -0,0 +1,98 @@
+import {TemplateContext} from "../../templates/template-context";
+import {TemplateToken} from "../../templates/tokens";
+import {TokenType} from "../../templates/tokens/types";
+import {ReusableWorkflowJob} from "../workflow-template";
+import {convertOn} from "./events";
+import {handleTemplateTokenErrors} from "./handle-errors";
+import {convertJobs} from "./jobs";
+
+export function convertReferencedWorkflow(
+  context: TemplateContext,
+  referencedWorkflow: TemplateToken,
+  job: ReusableWorkflowJob
+) {
+  const mapping = referencedWorkflow.assertMapping("root");
+
+  let onToken: TemplateToken | undefined;
+  for (const pair of mapping) {
+    const key = pair.key.assertString("root key");
+    switch (key.value) {
+      case "on": {
+        handleTemplateTokenErrors(mapping, context, undefined, () =>
+          convertReferencedWorkflowOn(context, pair.value, job)
+        );
+        break;
+      }
+      case "jobs": {
+        job.jobs = handleTemplateTokenErrors(mapping, context, [], () => convertJobs(context, pair.value));
+        break;
+      }
+    }
+  }
+
+  if (!onToken) {
+    return;
+  }
+
+  const events = convertOn(context, onToken);
+  if (events.workflow_call === undefined) {
+    context.error(onToken, "workflow_call key is not defined in the referenced workflow.");
+  }
+}
+
+function convertReferencedWorkflowOn(context: TemplateContext, on: TemplateToken, job: ReusableWorkflowJob) {
+  switch (on.templateTokenType) {
+    case TokenType.String: {
+      const event = on.assertString("Reference workflow on value").value;
+      if (event === "workflow_call") {
+        // TODO: Validate workflow job trigger
+        return;
+      }
+      break;
+    }
+
+    case TokenType.Sequence: {
+      const events = on.assertSequence("Reference workflow on value");
+      for (const eventToken of events) {
+        const event = eventToken.assertString(`Reference workflow on value ${eventToken}`).value;
+        if (event === "workflow_call") {
+          // TODO: Validate workflow job trigger
+          return;
+        }
+      }
+      break;
+    }
+
+    case TokenType.Mapping: {
+      const eventMapping = on.assertMapping("Reference workflow on value");
+
+      for (const pair of eventMapping) {
+        const event = pair.key.assertString(`Reference workflow on value ${pair.key}`).value;
+        if (event !== "workflow_call") {
+          continue;
+        }
+
+        if (pair.value.templateTokenType === TokenType.Null) {
+          // TODO: Validate workflow job trigger
+          return;
+        }
+
+        const definitions = pair.value.assertMapping(`Reference workflow on value ${pair.key}`);
+        for (const definition of definitions) {
+          const definitionKey = definition.key.assertString(`on-workflow_call-${definition.key}`).value;
+          switch (definitionKey) {
+            case "inputs":
+              job["input-definitions"] = definition.value.assertMapping(`on-workflow_call-${definition.key}`);
+              break;
+          }
+        }
+
+        // TODO: Validate workflow job trigger
+        return;
+      }
+      break;
+    }
+  }
+
+  context.error(on, "workflow_call key is not defined in the referenced workflow.");
+}

actions-workflow-parser/src/model/converter/reusable-job.ts

@@ -1,34 +0,0 @@
-import {TemplateContext} from "../../templates/template-context";
-import {MappingToken, StringToken} from "../../templates/tokens";
-import {ReusableWorkflowJob} from "../workflow-template";
-import {convertBaseJob} from "./base-job";
-
-export function convertResuableWorkflowJob(
-  context: TemplateContext,
-  jobKey: StringToken,
-  token: MappingToken
-): ReusableWorkflowJob {
-  const base = convertBaseJob(context, jobKey, token);
-
-  const result: ReusableWorkflowJob = {
-    type: "reusableWorkflowJob",
-    id: base.id,
-    name: base.name,
-    needs: base.needs,
-    if: base.if,
-    concurrency: base.concurrency,
-    strategy: base.strategy,
-    uses: new StringToken(undefined, undefined, "undefined", undefined, undefined)
-  };
-
-  for (const item of token) {
-    const propertyName = item.key.assertString("job property name");
-    switch (propertyName.value) {
-      case "uses":
-        result.uses = item.value.assertString("job item uses");
-        break;
-    }
-  }
-
-  return result;
-}

actions-workflow-parser/src/model/workflow-template.ts

@@ -57,7 +57,10 @@ export type Job = BaseJob & {
 // `workflow-job` in the schema
 export type ReusableWorkflowJob = BaseJob & {
   type: "reusableWorkflowJob";
-  uses: StringToken;
+  ref: StringToken;
+  "input-definitions"?: MappingToken;
+  "input-values"?: MappingToken;
+  jobs?: WorkflowJob[];
 };
 
 export type Container = {