@factorialco/gat 3.0.4 → 3.1.0

package/dist/job.d.ts

@@ -35,8 +35,13 @@ export interface JobOptions<Step, RunnerDefinition, Name> {
     outputs?: Record<string, string>;
     workingDirectory?: string;
 }
+export interface UsesJobOptions {
+    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: JobOptions<Step, RunnerDefinition, Name> | UsesJobOptions;
 }

package/dist/workflow.d.ts

@@ -1,4 +1,4 @@
-import { ConcurrencyGroup, Job, JobOptions, StringWithNoSpaces } from "./job";
+import { ConcurrencyGroup, Job, JobOptions, 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: JobOptions<JobStep, Runner, JobName> | UsesJobOptions): Workflow<JobStep, Runner, JobName | T>;
     setEnv(name: string, value: string): this;
     setConcurrencyGroup(concurrencyGroup: ConcurrencyGroup | null): this;
     defaultRunner(): string;

package/dist/workflow.js

@@ -90,60 +90,73 @@ 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,
-                {
-                    name: prettyName,
-                    permissions,
-                    if: ifExpression,
-                    "runs-on": runsOn ?? this.defaultRunner(),
-                    "timeout-minutes": timeout ?? 15,
-                    needs: dependsOn,
-                    services,
-                    concurrency: concurrency
-                        ? {
-                            group: `${(0, kebabCase_1.default)(this.name)}-${name}-${concurrency.groupSuffix}`,
-                            "cancel-in-progress": concurrency.cancelPrevious,
-                        }
-                        : undefined,
-                    strategy: matrix
-                        ? {
-                            "fail-fast": false,
-                            matrix: typeof matrix === "string"
-                                ? matrix
-                                : {
-                                    ...Object.fromEntries(matrix.elements.map(({ id, options }) => [
-                                        id,
-                                        options,
-                                    ])),
-                                    include: matrix.extra,
+            jobs: Object.fromEntries(await Promise.all(this.jobs.map(async ({ name, options: jobOptions }) => {
+                if ("uses" in jobOptions) {
+                    return [
+                        name,
+                        {
+                            uses: jobOptions.uses,
+                            with: jobOptions.with,
+                            secrets: jobOptions.secrets,
+                        },
+                    ];
+                }
+                const { prettyName, permissions, ifExpression, runsOn, matrix, env, steps, dependsOn, services, timeout, concurrency, outputs, workingDirectory, } = jobOptions;
+                return [
+                    name,
+                    {
+                        name: prettyName,
+                        permissions,
+                        if: ifExpression,
+                        "runs-on": runsOn ?? this.defaultRunner(),
+                        "timeout-minutes": timeout ?? 15,
+                        needs: dependsOn,
+                        services,
+                        concurrency: concurrency
+                            ? {
+                                group: `${(0, kebabCase_1.default)(this.name)}-${name}-${concurrency.groupSuffix}`,
+                                "cancel-in-progress": concurrency.cancelPrevious,
+                            }
+                            : undefined,
+                        strategy: matrix
+                            ? {
+                                "fail-fast": false,
+                                matrix: typeof matrix === "string"
+                                    ? matrix
+                                    : {
+                                        ...Object.fromEntries(matrix.elements.map(({ id, options }) => [
+                                            id,
+                                            options,
+                                        ])),
+                                        include: matrix.extra,
+                                    },
+                            }
+                            : undefined,
+                        env,
+                        defaults: workingDirectory
+                            ? {
+                                run: {
+                                    "working-directory": workingDirectory,
                                 },
-                        }
-                        : undefined,
-                    env,
-                    defaults: workingDirectory
-                        ? {
-                            run: {
+                            }
+                            : 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,
-                            },
-                        }
-                        : 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,
-                },
-            ]))),
+                                "timeout-minutes": timeout,
+                                ...options,
+                                uses: await supplyChainAttack(step),
+                            };
+                        })),
+                        outputs,
+                    },
+                ];
+            }))),
         };
         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.1.0",
   "description": "Write your GitHub Actions workflows using TypeScript",
   "bin": {
     "gat": "dist/cli.js"