@intentius/chant-lexicon-github 0.0.18

package/src/generated/index.d.ts

@@ -0,0 +1,358 @@
+// Code generated by chant github generate. DO NOT EDIT.
+
+// --- GitHub Actions Entity classes ---
+
+export declare class Concurrency {
+  constructor(props: {
+    /** When a concurrent job or workflow is queued, if another job or workflow using the same concurrency group in the repository is in progress, the queued job or workflow will be pending. Any previously pending job or workflow in the concurrency group will be canceled. */
+    group: string;
+    /** To cancel any currently running job or workflow in the same concurrency group, specify cancel-in-progress: true. */
+    "cancel-in-progress"?: boolean | string;
+  });
+}
+
+export declare class Container {
+  constructor(props: {
+    /** The Docker image to use as the container to run the action. The value can be the Docker Hub image name or a registry name. */
+    image: string;
+    /** If the image's container registry requires authentication to pull the image, you can use credentials to set a map of the username and password. The credentials are the same values that you would provide to the `docker login` command. */
+    credentials?: Record<string, unknown>;
+    /** Sets an array of environment variables in the container. */
+    env?: any;
+    /** Additional Docker container resource options. For a list of options, see https://docs.docker.com/engine/reference/commandline/create/#options. */
+    options?: string;
+    /** Sets an array of ports to expose on the container. */
+    ports?: (number | string)[];
+    /** Sets an array of volumes for the container to use. You can use volumes to share data between services or other steps in a job. You can specify named Docker volumes, anonymous Docker volumes, or bind mounts on the host.
+To specify a volume, you specify the source and destination path: <source>:<destinationPath>
+The <source> is a volume name or an absolute path on the host machine, and <destinationPath> is an absolute path in the container. */
+    volumes?: string[];
+  });
+}
+
+export declare class Defaults {
+  constructor(props: {
+    run?: Record<string, unknown>;
+  });
+}
+
+export declare class Environment {
+  constructor(props: {
+    /** The name of the environment configured in the repo. */
+    name: string;
+    /** A deployment URL */
+    url?: string;
+  });
+}
+
+export declare class Job {
+  constructor(props: {
+    /** The type of machine to run the job on. The machine can be either a GitHub-hosted runner, or a self-hosted runner. */
+    "runs-on": string | string[];
+    /** Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time. A concurrency group can be any string or expression. The expression can use any context except for the secrets context. 
+You can also specify concurrency at the workflow level. 
+When a concurrent job or workflow is queued, if another job or workflow using the same concurrency group in the repository is in progress, the queued job or workflow will be pending. Any previously pending job or workflow in the concurrency group will be canceled. To also cancel any currently running job or workflow in the same concurrency group, specify cancel-in-progress: true. */
+    concurrency?: Concurrency | string;
+    /** A container to run any steps in a job that don't already specify a container. If you have steps that use both script and container actions, the container actions will run as sibling containers on the same network with the same volume mounts.
+If you do not set a container, all steps will run directly on the host specified by runs-on unless a step refers to an action configured to run in a container. */
+    container?: Container | string;
+    /** Prevents a workflow run from failing when a job fails. Set to true to allow a workflow run to pass when this job fails. */
+    "continue-on-error"?: boolean;
+    /** A map of default settings that will apply to all steps in the job. */
+    defaults?: Defaults;
+    /** A map of environment variables that are available to all steps in the job. */
+    env?: Record<string, string>;
+    /** The environment that the job references. */
+    environment?: Environment | string;
+    /** You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
+Expressions in an if conditional do not require the ${{ }} syntax. For more information, see https://help.github.com/en/articles/contexts-and-expression-syntax-for-github-actions. */
+    if?: string;
+    /** The name of the job displayed on GitHub. */
+    name?: string;
+    needs?: string[];
+    /** A map of outputs for a job. Job outputs are available to all downstream jobs that depend on this job. */
+    outputs?: Record<string, string>;
+    permissions?: Permissions | string;
+    /** Additional containers to host services for a job in a workflow. These are useful for creating databases or cache services like redis. The runner on the virtual machine will automatically create a network and manage the life cycle of the service containers.
+When you use a service container for a job or your step uses container actions, you don't need to set port information to access the service. Docker automatically exposes all ports between containers on the same network.
+When both the job and the action run in a container, you can directly reference the container by its hostname. The hostname is automatically mapped to the service name.
+When a step does not use a container action, you must access the service using localhost and bind the ports. */
+    services?: Record<string, Service>;
+    snapshot?: any;
+    /** A job contains a sequence of tasks called steps. Steps can run commands, run setup tasks, or run an action in your repository, a public repository, or an action published in a Docker registry. Not all steps run actions, but all actions run as a step. Each step runs in its own process in the virtual environment and has access to the workspace and filesystem. Because steps run in their own process, changes to environment variables are not preserved between steps. GitHub provides built-in steps to set up and complete a job.
+Must contain either `uses` or `run`
+ */
+    steps?: Step[];
+    /** A strategy creates a build matrix for your jobs. You can define different variations of an environment to run each job in. */
+    strategy?: Strategy;
+    /** The maximum number of minutes to let a workflow run before GitHub automatically cancels it. Default: 360 */
+    "timeout-minutes"?: number;
+  });
+}
+
+export declare class Permissions {
+  constructor(props: {
+    actions?: "read" | "write" | "none";
+    "artifact-metadata"?: "read" | "write" | "none";
+    attestations?: "read" | "write" | "none";
+    checks?: "read" | "write" | "none";
+    contents?: "read" | "write" | "none";
+    deployments?: "read" | "write" | "none";
+    discussions?: "read" | "write" | "none";
+    "id-token"?: "read" | "write" | "none";
+    issues?: "read" | "write" | "none";
+    models?: "read" | "none";
+    packages?: "read" | "write" | "none";
+    pages?: "read" | "write" | "none";
+    "pull-requests"?: "read" | "write" | "none";
+    "repository-projects"?: "read" | "write" | "none";
+    "security-events"?: "read" | "write" | "none";
+    statuses?: "read" | "write" | "none";
+  });
+}
+
+export declare class PullRequestTargetTrigger {
+  constructor(props: {
+    branches?: string[];
+    "branches-ignore"?: string[];
+    paths?: string[];
+    "paths-ignore"?: string[];
+    types?: string[];
+  });
+}
+
+export declare class PullRequestTrigger {
+  constructor(props: {
+    branches?: string[];
+    "branches-ignore"?: string[];
+    paths?: string[];
+    "paths-ignore"?: string[];
+    types?: string[];
+  });
+}
+
+export declare class PushTrigger {
+  constructor(props: {
+    branches?: string[];
+    "branches-ignore"?: string[];
+    paths?: string[];
+    "paths-ignore"?: string[];
+    tags?: string[];
+    "tags-ignore"?: string[];
+  });
+}
+
+export declare class RepositoryDispatchTrigger {
+  constructor(props: {
+    types?: string[];
+  });
+}
+
+export declare class ReusableWorkflowCallJob {
+  constructor(props: {
+    /** The location and version of a reusable workflow file to run as a job, of the form './{path/to}/{localfile}.yml' or '{owner}/{repo}/{path}/{filename}@{ref}'. {ref} can be a SHA, a release tag, or a branch name. Using the commit SHA is the safest for stability and security. */
+    uses: string;
+    /** Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time. A concurrency group can be any string or expression. The expression can use any context except for the secrets context. 
+You can also specify concurrency at the workflow level. 
+When a concurrent job or workflow is queued, if another job or workflow using the same concurrency group in the repository is in progress, the queued job or workflow will be pending. Any previously pending job or workflow in the concurrency group will be canceled. To also cancel any currently running job or workflow in the same concurrency group, specify cancel-in-progress: true. */
+    concurrency?: string | Record<string, any>;
+    /** You can use the if conditional to prevent a job from running unless a condition is met. You can use any supported context and expression to create a conditional.
+Expressions in an if conditional do not require the ${{ }} syntax. For more information, see https://help.github.com/en/articles/contexts-and-expression-syntax-for-github-actions. */
+    if?: boolean;
+    /** The name of the job displayed on GitHub. */
+    name?: string;
+    needs?: any;
+    permissions?: any;
+    /** When a job is used to call a reusable workflow, you can use 'secrets' to provide a map of secrets that are passed to the called workflow. Any secrets that you pass must match the names defined in the called workflow. */
+    secrets?: "inherit";
+    /** A strategy creates a build matrix for your jobs. You can define different variations of an environment to run each job in. */
+    strategy?: Record<string, unknown>;
+    /** A map of inputs that are passed to the called workflow. Any inputs that you pass must match the input specifications defined in the called workflow. Unlike 'jobs.<job_id>.steps[*].with', the inputs you pass with 'jobs.<job_id>.with' are not be available as environment variables in the called workflow. Instead, you can reference the inputs by using the inputs context. */
+    with?: any;
+  });
+}
+
+export declare class ScheduleTrigger {
+  constructor(props: {
+    /** POSIX cron expression */
+    cron: string;
+  });
+}
+
+export declare class Service {
+  constructor(props: {
+    /** The Docker image to use as the container to run the action. The value can be the Docker Hub image name or a registry name. */
+    image: string;
+    /** If the image's container registry requires authentication to pull the image, you can use credentials to set a map of the username and password. The credentials are the same values that you would provide to the `docker login` command. */
+    credentials?: Record<string, unknown>;
+    /** Sets an array of environment variables in the container. */
+    env?: any;
+    /** Additional Docker container resource options. For a list of options, see https://docs.docker.com/engine/reference/commandline/create/#options. */
+    options?: string;
+    /** Sets an array of ports to expose on the container. */
+    ports?: (number | string)[];
+    /** Sets an array of volumes for the container to use. You can use volumes to share data between services or other steps in a job. You can specify named Docker volumes, anonymous Docker volumes, or bind mounts on the host.
+To specify a volume, you specify the source and destination path: <source>:<destinationPath>
+The <source> is a volume name or an absolute path on the host machine, and <destinationPath> is an absolute path in the container. */
+    volumes?: string[];
+  });
+}
+
+export declare class Step {
+  constructor(props: {
+    /** Continue on error */
+    "continue-on-error"?: boolean;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Step ID for output references */
+    id?: string;
+    /** Conditional expression */
+    if?: string;
+    /** Step display name */
+    name?: string;
+    /** Shell command */
+    run?: string;
+    /** Shell to use */
+    shell?: string;
+    /** Timeout in minutes */
+    "timeout-minutes"?: number;
+    /** Action reference */
+    uses?: string;
+    /** Action inputs */
+    with?: Record<string, string>;
+    /** Working directory */
+    "working-directory"?: string;
+  });
+}
+
+export declare class Strategy {
+  constructor(props: {
+    matrix: Record<string, unknown>;
+    /** When set to true, GitHub cancels all in-progress jobs if any matrix job fails. Default: true */
+    "fail-fast"?: boolean;
+    /** The maximum number of jobs that can run simultaneously when using a matrix job strategy. By default, GitHub will maximize the number of jobs run in parallel depending on the available runners on GitHub-hosted virtual machines. */
+    "max-parallel"?: number;
+  });
+}
+
+export declare class Workflow {
+  constructor(props: {
+    /** A workflow run is made up of one or more jobs. Jobs run in parallel by default. To run jobs sequentially, you can define dependencies on other jobs using the jobs.<job_id>.needs keyword.
+Each job runs in a fresh instance of the virtual environment specified by runs-on.
+You can run an unlimited number of jobs as long as you are within the workflow usage limits. For more information, see https://help.github.com/en/github/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#usage-limits. */
+    jobs: Record<string, unknown>;
+    /** The name of the GitHub event that triggers the workflow. You can provide a single event string, array of events, array of event types, or an event configuration map that schedules a workflow or restricts the execution of a workflow to specific files, tags, or branch changes. For a list of available events, see https://help.github.com/en/github/automating-your-workflow-with-github-actions/events-that-trigger-workflows. */
+    on: Record<string, unknown>;
+    /** Concurrency ensures that only a single job or workflow using the same concurrency group will run at a time. A concurrency group can be any string or expression. The expression can use any context except for the secrets context. 
+You can also specify concurrency at the workflow level. 
+When a concurrent job or workflow is queued, if another job or workflow using the same concurrency group in the repository is in progress, the queued job or workflow will be pending. Any previously pending job or workflow in the concurrency group will be canceled. To also cancel any currently running job or workflow in the same concurrency group, specify cancel-in-progress: true. */
+    concurrency?: Concurrency | string;
+    /** A map of default settings that will apply to all jobs in the workflow. */
+    defaults?: Defaults;
+    /** A map of environment variables that are available to all jobs and steps in the workflow. */
+    env?: Record<string, string>;
+    /** The name of your workflow. GitHub displays the names of your workflows on your repository's actions page. If you omit this field, GitHub sets the name to the workflow's filename. */
+    name?: string;
+    permissions?: Permissions | string;
+    /** The name for workflow runs generated from the workflow. GitHub displays the workflow run name in the list of workflow runs on your repository's 'Actions' tab. */
+    "run-name"?: string;
+  });
+}
+
+export declare class WorkflowCallTrigger {
+  constructor(props: {
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    secrets?: Record<string, unknown>;
+  });
+}
+
+export declare class WorkflowDispatchTrigger {
+  constructor(props: {
+    inputs?: Record<string, unknown>;
+  });
+}
+
+export declare class WorkflowInput {
+  constructor(props: {
+    default?: string;
+    description?: string;
+    options?: string[];
+    required?: boolean;
+    type?: "string" | "boolean" | "number" | "choice" | "environment";
+  });
+}
+
+export declare class WorkflowOutput {
+  constructor(props: {
+    value: string;
+    description?: string;
+  });
+}
+
+export declare class WorkflowRunTrigger {
+  constructor(props: {
+    branches?: string[];
+    "branches-ignore"?: string[];
+    types?: string[];
+    workflows?: string[];
+  });
+}
+
+export declare class WorkflowSecret {
+  constructor(props: {
+    description?: string;
+    required?: boolean;
+  });
+}
+
+// --- Expression type (inlined for portability) ---
+
+export declare class Expression {
+  constructor(raw: string);
+  toString(): string;
+  valueOf(): string;
+  eq(value: string | Expression): Expression;
+  ne(value: string | Expression): Expression;
+  and(other: Expression): Expression;
+  or(other: Expression): Expression;
+  not(): Expression;
+}
+
+// --- GitHub Context Variables ---
+
+export declare const GitHub: {
+  readonly Ref: Expression;
+  readonly RefName: Expression;
+  readonly RefType: Expression;
+  readonly Sha: Expression;
+  readonly Actor: Expression;
+  readonly TriggeringActor: Expression;
+  readonly Repository: Expression;
+  readonly RepositoryOwner: Expression;
+  readonly EventName: Expression;
+  readonly Event: Expression;
+  readonly RunId: Expression;
+  readonly RunNumber: Expression;
+  readonly RunAttempt: Expression;
+  readonly Workflow: Expression;
+  readonly WorkflowRef: Expression;
+  readonly Workspace: Expression;
+  readonly Token: Expression;
+  readonly Job: Expression;
+  readonly HeadRef: Expression;
+  readonly BaseRef: Expression;
+  readonly ServerUrl: Expression;
+  readonly ApiUrl: Expression;
+  readonly GraphqlUrl: Expression;
+  readonly Action: Expression;
+  readonly ActionPath: Expression;
+};
+
+export declare const Runner: {
+  readonly Os: Expression;
+  readonly Arch: Expression;
+  readonly Name: Expression;
+  readonly Temp: Expression;
+  readonly ToolCache: Expression;
+};

package/src/generated/index.ts

@@ -0,0 +1,29 @@
+// Code generated by chant generate. DO NOT EDIT.
+import { createResource, createProperty } from "./runtime";
+
+export const Job = createResource("GitHub::Actions::Job", "github", {});
+export const ReusableWorkflowCallJob = createResource("GitHub::Actions::ReusableWorkflowCallJob", "github", {});
+export const Workflow = createResource("GitHub::Actions::Workflow", "github", {});
+
+export const Concurrency = createProperty("GitHub::Actions::Concurrency", "github");
+export const Container = createProperty("GitHub::Actions::Container", "github");
+export const Defaults = createProperty("GitHub::Actions::Defaults", "github");
+export const Environment = createProperty("GitHub::Actions::Environment", "github");
+export const Permissions = createProperty("GitHub::Actions::Permissions", "github");
+export const PullRequestTargetTrigger = createProperty("GitHub::Actions::PullRequestTargetTrigger", "github");
+export const PullRequestTrigger = createProperty("GitHub::Actions::PullRequestTrigger", "github");
+export const PushTrigger = createProperty("GitHub::Actions::PushTrigger", "github");
+export const RepositoryDispatchTrigger = createProperty("GitHub::Actions::RepositoryDispatchTrigger", "github");
+export const ScheduleTrigger = createProperty("GitHub::Actions::ScheduleTrigger", "github");
+export const Service = createProperty("GitHub::Actions::Service", "github");
+export const Step = createProperty("GitHub::Actions::Step", "github");
+export const Strategy = createProperty("GitHub::Actions::Strategy", "github");
+export const WorkflowCallTrigger = createProperty("GitHub::Actions::WorkflowCallTrigger", "github");
+export const WorkflowDispatchTrigger = createProperty("GitHub::Actions::WorkflowDispatchTrigger", "github");
+export const WorkflowInput = createProperty("GitHub::Actions::WorkflowInput", "github");
+export const WorkflowOutput = createProperty("GitHub::Actions::WorkflowOutput", "github");
+export const WorkflowRunTrigger = createProperty("GitHub::Actions::WorkflowRunTrigger", "github");
+export const WorkflowSecret = createProperty("GitHub::Actions::WorkflowSecret", "github");
+
+// Re-exports for convenience
+export { GitHub, Runner } from "../variables";

package/src/generated/lexicon-github.json

@@ -0,0 +1,135 @@
+{
+  "Concurrency": {
+    "resourceType": "GitHub::Actions::Concurrency",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "Container": {
+    "resourceType": "GitHub::Actions::Container",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "Defaults": {
+    "resourceType": "GitHub::Actions::Defaults",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "Environment": {
+    "resourceType": "GitHub::Actions::Environment",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "Job": {
+    "resourceType": "GitHub::Actions::Job",
+    "kind": "resource",
+    "lexicon": "github",
+    "constraints": {
+      "timeout-minutes": {
+        "default": 360
+      }
+    }
+  },
+  "Permissions": {
+    "resourceType": "GitHub::Actions::Permissions",
+    "kind": "property",
+    "lexicon": "github",
+    "constraints": {
+      "models": {
+        "enum": [
+          "read",
+          "none"
+        ]
+      }
+    }
+  },
+  "PullRequestTargetTrigger": {
+    "resourceType": "GitHub::Actions::PullRequestTargetTrigger",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "PullRequestTrigger": {
+    "resourceType": "GitHub::Actions::PullRequestTrigger",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "PushTrigger": {
+    "resourceType": "GitHub::Actions::PushTrigger",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "RepositoryDispatchTrigger": {
+    "resourceType": "GitHub::Actions::RepositoryDispatchTrigger",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "ReusableWorkflowCallJob": {
+    "resourceType": "GitHub::Actions::ReusableWorkflowCallJob",
+    "kind": "resource",
+    "lexicon": "github",
+    "constraints": {
+      "uses": {
+        "pattern": "^(.+\\/)+(.+)\\.(ya?ml)(@.+)?$"
+      }
+    }
+  },
+  "ScheduleTrigger": {
+    "resourceType": "GitHub::Actions::ScheduleTrigger",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "Service": {
+    "resourceType": "GitHub::Actions::Service",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "Step": {
+    "resourceType": "GitHub::Actions::Step",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "Strategy": {
+    "resourceType": "GitHub::Actions::Strategy",
+    "kind": "property",
+    "lexicon": "github",
+    "constraints": {
+      "fail-fast": {
+        "default": true
+      }
+    }
+  },
+  "Workflow": {
+    "resourceType": "GitHub::Actions::Workflow",
+    "kind": "resource",
+    "lexicon": "github"
+  },
+  "WorkflowCallTrigger": {
+    "resourceType": "GitHub::Actions::WorkflowCallTrigger",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "WorkflowDispatchTrigger": {
+    "resourceType": "GitHub::Actions::WorkflowDispatchTrigger",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "WorkflowInput": {
+    "resourceType": "GitHub::Actions::WorkflowInput",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "WorkflowOutput": {
+    "resourceType": "GitHub::Actions::WorkflowOutput",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "WorkflowRunTrigger": {
+    "resourceType": "GitHub::Actions::WorkflowRunTrigger",
+    "kind": "property",
+    "lexicon": "github"
+  },
+  "WorkflowSecret": {
+    "resourceType": "GitHub::Actions::WorkflowSecret",
+    "kind": "property",
+    "lexicon": "github"
+  }
+}

package/src/generated/runtime.ts

@@ -0,0 +1,4 @@
+/**
+ * Runtime factory constructors — re-exported from core.
+ */
+export { createResource, createProperty } from "@intentius/chant/runtime";

package/src/import/generator.test.ts

@@ -0,0 +1,110 @@
+import { describe, test, expect } from "bun:test";
+import { GitHubActionsGenerator } from "./generator";
+import type { TemplateIR } from "@intentius/chant/import/parser";
+
+const generator = new GitHubActionsGenerator();
+
+describe("GitHubActionsGenerator", () => {
+  test("generates import statement", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "workflow",
+          type: "GitHub::Actions::Workflow",
+          properties: { name: "CI" },
+        },
+      ],
+      parameters: [],
+    };
+    const files = generator.generate(ir);
+    expect(files).toHaveLength(1);
+    expect(files[0].content).toContain('import { Workflow } from "@intentius/chant-lexicon-github"');
+  });
+
+  test("generates workflow export", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "workflow",
+          type: "GitHub::Actions::Workflow",
+          properties: { name: "CI" },
+        },
+      ],
+      parameters: [],
+    };
+    const files = generator.generate(ir);
+    expect(files[0].content).toContain("export const workflow = new Workflow(");
+    expect(files[0].content).toContain('"name": "CI"');
+  });
+
+  test("generates job exports", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "build",
+          type: "GitHub::Actions::Job",
+          properties: { "runs-on": "ubuntu-latest" },
+        },
+      ],
+      parameters: [],
+    };
+    const files = generator.generate(ir);
+    expect(files[0].content).toContain("export const build = new Job(");
+    expect(files[0].content).toContain('"runs-on": "ubuntu-latest"');
+  });
+
+  test("imports multiple used constructors", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "workflow",
+          type: "GitHub::Actions::Workflow",
+          properties: { name: "CI" },
+        },
+        {
+          logicalId: "build",
+          type: "GitHub::Actions::Job",
+          properties: { "runs-on": "ubuntu-latest" },
+        },
+      ],
+      parameters: [],
+    };
+    const files = generator.generate(ir);
+    expect(files[0].content).toContain("Job");
+    expect(files[0].content).toContain("Workflow");
+  });
+
+  test("wraps nested property constructors", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "build",
+          type: "GitHub::Actions::Job",
+          properties: {
+            "runs-on": "ubuntu-latest",
+            strategy: { matrix: { "node-version": ["18", "20"] } },
+          },
+        },
+      ],
+      parameters: [],
+    };
+    const files = generator.generate(ir);
+    expect(files[0].content).toContain("new Strategy(");
+    expect(files[0].content).toContain("Strategy");
+  });
+
+  test("output file is named main.ts", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "workflow",
+          type: "GitHub::Actions::Workflow",
+          properties: { name: "CI" },
+        },
+      ],
+      parameters: [],
+    };
+    const files = generator.generate(ir);
+    expect(files[0].path).toBe("main.ts");
+  });
+});