@factorialco/gat 3.0.4 → 3.2.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import { Workflow } from "./workflow";
-import { type ConcurrencyGroup, type JobOptions, type Matrix, type Service } from "./job";
+import { type ConcurrencyGroup, type StepsJobOptions, type UsesJobOptions, type Matrix, type Service } from "./job";
 import { type RunStep, type UseStep, type BaseStep } from "./step";
-export { Workflow, RunStep, UseStep, BaseStep, ConcurrencyGroup, JobOptions, Matrix, Service, };
+export { Workflow, RunStep, UseStep, BaseStep, ConcurrencyGroup, StepsJobOptions, UsesJobOptions, Matrix, Service, };

package/dist/job.d.ts

@@ -20,7 +20,7 @@ export interface Service {
     options?: string;
     volumes?: string[];
 }
-export interface JobOptions<Step, RunnerDefinition, Name> {
+export interface BaseJobOptions<RunnerDefinition, Name> {
     prettyName?: string;
     permissions?: object;
     ifExpression?: string;
@@ -31,12 +31,19 @@ export interface JobOptions<Step, RunnerDefinition, Name> {
     env?: Record<string, string>;
     concurrency?: ConcurrencyGroup | null;
     matrix?: Matrix | string;
-    steps: Step[];
     outputs?: Record<string, string>;
     workingDirectory?: string;
 }
+export interface StepsJobOptions<Step, RunnerDefinition, Name> extends BaseJobOptions<RunnerDefinition, Name> {
+    steps: Step[];
+}
+export interface UsesJobOptions<RunnerDefinition, Name> extends BaseJobOptions<RunnerDefinition, Name> {
+    uses: string;
+    with?: Record<string, string | number | boolean | object>;
+    secrets?: Record<string, string | number | boolean | object> | "inherit";
+}
 export type StringWithNoSpaces<T> = T extends `${string} ${string}` ? never : T extends ` ${string}` ? never : T extends `${string} ` ? never : T;
 export interface Job<Step, RunnerDefinition, Name> {
     name: string;
-    options: JobOptions<Step, RunnerDefinition, Name>;
+    options: StepsJobOptions<Step, RunnerDefinition, Name> | UsesJobOptions<RunnerDefinition, Name>;
 }

package/dist/workflow.d.ts

@@ -1,4 +1,4 @@
-import { ConcurrencyGroup, Job, JobOptions, StringWithNoSpaces } from "./job";
+import { ConcurrencyGroup, Job, StepsJobOptions, StringWithNoSpaces, UsesJobOptions } from "./job";
 import type { Event, EventName, EventOptions } from "./event";
 import { type Step } from "./step";
 interface DefaultOptions {
@@ -22,7 +22,7 @@ export declare class Workflow<JobStep extends Step = Step, Runner extends Runner
     constructor(name: string);
     on<T extends EventName>(name: T, options?: EventOptions<T>): this;
     addDefaults(options: DefaultOptions): this;
-    addJob<T extends string>(name: StringWithNoSpaces<T>, options: JobOptions<JobStep, Runner, JobName>): Workflow<JobStep, Runner, JobName | T>;
+    addJob<T extends string>(name: StringWithNoSpaces<T>, options: StepsJobOptions<JobStep, Runner, JobName> | UsesJobOptions<Runner, JobName>): Workflow<JobStep, Runner, JobName | T>;
     setEnv(name: string, value: string): this;
     setConcurrencyGroup(concurrencyGroup: ConcurrencyGroup | null): this;
     defaultRunner(): string;

package/dist/workflow.js

@@ -90,9 +90,9 @@ class Workflow {
             env: this.env.length > 0
                 ? Object.fromEntries(this.env.map(({ name, value }) => [name, value]))
                 : undefined,
-            jobs: Object.fromEntries(await Promise.all(this.jobs.map(async ({ name, options: { prettyName, permissions, ifExpression, runsOn, matrix, env, steps, dependsOn, services, timeout, concurrency, outputs, workingDirectory, }, }) => [
-                name,
-                {
+            jobs: Object.fromEntries(await Promise.all(this.jobs.map(async ({ name, options: jobOptions }) => {
+                const { prettyName, permissions, ifExpression, runsOn, matrix, env, dependsOn, services, timeout, concurrency, outputs, workingDirectory, } = jobOptions;
+                const computedOptions = {
                     name: prettyName,
                     permissions,
                     if: ifExpression,
@@ -128,22 +128,39 @@ class Workflow {
                             },
                         }
                         : undefined,
-                    steps: await Promise.all(steps.map(async (step) => {
-                        const { id, name, ifExpression, workingDirectory, continueOnError, timeout, ...options } = step;
-                        return {
-                            id,
-                            name,
-                            if: ifExpression,
-                            "continue-on-error": continueOnError,
-                            "working-directory": workingDirectory,
-                            "timeout-minutes": timeout,
-                            ...options,
-                            uses: await supplyChainAttack(step),
-                        };
-                    })),
                     outputs,
-                },
-            ]))),
+                };
+                if ("uses" in jobOptions) {
+                    return [
+                        name,
+                        {
+                            ...computedOptions,
+                            uses: jobOptions.uses,
+                            with: jobOptions.with,
+                            secrets: jobOptions.secrets,
+                        },
+                    ];
+                }
+                return [
+                    name,
+                    {
+                        ...computedOptions,
+                        steps: await Promise.all(jobOptions.steps.map(async (step) => {
+                            const { id, name, ifExpression, workingDirectory, continueOnError, timeout, ...options } = step;
+                            return {
+                                id,
+                                name,
+                                if: ifExpression,
+                                "continue-on-error": continueOnError,
+                                "working-directory": workingDirectory,
+                                "timeout-minutes": timeout,
+                                ...options,
+                                uses: await supplyChainAttack(step),
+                            };
+                        })),
+                    },
+                ];
+            }))),
         };
         const compiled = `# Workflow automatically generated by gat\n# DO NOT CHANGE THIS FILE MANUALLY\n\n${(0, js_yaml_1.dump)(result, {
             noRefs: true,

package/dist/workflow.spec.js

@@ -257,4 +257,25 @@ exit 0`,
         });
         (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
     });
+    (0, vitest_1.it)("allows creating jobs with no steps, uses and secrets", async () => {
+        const workflow = new workflow_1.Workflow("Uses job")
+            .on("push")
+            .addJob("job1", {
+            uses: "example/example/.github/workflows/example1.yml@main",
+            with: {
+                foo: "foo",
+            },
+            secrets: "inherit",
+        })
+            .addJob("job2", {
+            uses: "example/example/.github/workflows/example2.yml@main",
+            with: {
+                bar: "bar",
+            },
+            secrets: {
+                secret: "super-secret",
+            },
+        });
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factorialco/gat",
-  "version": "3.0.4",
+  "version": "3.2.0",
   "description": "Write your GitHub Actions workflows using TypeScript",
   "bin": {
     "gat": "dist/cli.js"