* [eas-cli][local-build-plugin] Deprecate Node 20, use Node 22 in CI
Print a deprecation warning from the eas-cli and local-build-plugin
bin scripts when running on Node.js < 22. Develop and test on Node.js
22: bump mise, drop 20.18.3 from the test matrix, and move to
@tsconfig/node22 and @types/node 22. Published engines are unchanged.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
<!-- You can skip the changelog check by labeling the PR with "no changelog". -->
# Why
Follow-up to #4399 to upgrade typescript to latest version.
# How
Tell claude to upgrade to 6.x.
# Test Plan
CI, tests
<!-- You can skip the changelog check by labeling the PR with "no changelog". -->
# Why
This is a bit behind in typescript. 6.x is where most of our repos live.
First step is to get to highest 5.x.
# How
Tell claude to upgrade to highest 5.x.
It required a new version of `https-proxy-agent` to be compatible with new node types.
# Test Plan
`yarn start`, tests.
* [steps] Report a broken composite if: on the call, not an inner step
* [steps] Simplify condition evaluation error handling by building the erro message in the error constructor
* [steps] Composite functions: skip the outputs step when the call never ran
* [steps] test coverage improvement: recursive anyAuthoredChildExecuted when a nested call has no outputs
`fast-glob` and `arg` were imported but not declared in their packages,
resolving only via workspace hoisting. Declare them explicitly so the
packages keep working when installed standalone.
* [eas-cli] Validate local composite functions referenced from workflow hooks
* extract the local composite function loader into @expo/steps
* skip validation when project_root_directory is set
* Validate defaults.hooks and remove project_root_directory skip
* [build-tools] Load composite function catalogs for hook steps
* do lazy loading of composite functions in hooks
* report the hook key on composite function load errors
* validate hook step functions only for reached anchors
* cleanup hook key parsing
* warn on unknown hook key
* share one composite function catalog across hook keys
* report the hook key on all composite step config errors
* report the hook key on composite expansion errors
# Why
Hook steps currently reject `uses: ./...` local composite functions. Users should be able to reuse the same composites in hooks as in the main workflow.
# How
A composite function used in a hook is expanded into its inner steps at parse time, the same way it is in the main workflow, and the whole expansion becomes a single hook entry. The step's `if:` gates the expansion as a whole.
Hook construction now takes a catalog of composite functions. Without it, referencing a composite fails with a missing-function error instead of the previous "not supported in hooks" error.
Wiring reading the composite functions files will be added in follow-up PRs in the stack.
# Test Plan
Added unit tests.
# Why
For a step with no `if:`, whether the step should run was decided in 3 separate places: `BuildStep.shouldExecuteStep`, the composite function scope (same rule), and the hook executor (its own rule). That bypass means composite scopes never see hook defaults, which is a blocker for adding support for composite functions in hooks.
# How
A single gate now decides whether any step runs, taking a single input: a bool telling whether a step with no `if:` should run. Composite functions called from hooks therefore inherit the hook's rule. Steps with an explicit `if:` are unaffected.
Behavior-preserving refactor.
# Test Plan
- Existing steps/hook tests still pass.
- Added unit coverage for the run-by-default value on `shouldExecuteStep` /
`isActive`, and hook sibling skip/continue cases for the before/after defaults.
# Why
This PR stack adds local composite functions for EAS workflows (`uses: ./.eas/functions/...`). Earlier PRs define the schema, expand calls into steps, and wire inputs/outputs. The build runtime still needs to load those `function.yml` files from the project and pass them into `StepsConfigParser`.
This PR is the I/O layer: discover referenced local composite functions on disk, validate them, and hand the catalog to the parser for custom builds and generic jobs.
# How
- Adds catalog helpers in `@expo/steps` (`buildCompositeFunctionCatalogFromStepsAsync`, `resolveLocalCompositeFunctionPath`)
- Adds `packages/build-tools/src/steps/compositeFunctions.ts` to resolve paths relative to the EAS project root, read `function.yml` / `function.yaml`, and validate with `CompositeFunctionConfigZ`
- Wires the catalog into `runCustomBuildAsync` and `runGenericJobAsync`
# Test Plan
Added unit tests for catalog loading and custom-build parse integration.
# Why
This PR stack adds local composite functions for EAS workflows. A `function.yml` declares `outputs:` with templated values, and the caller should read them as `${{ steps.setup.outputs.version }}`, where `setup` is the id of the calling step.
After the previous PRs, data flows into a composite function (inputs, env) but nothing flows back out. This PR closes that loop.
# How
For a composite function that declares `outputs:`, `CompositeFunctionExpander` appends a synthetic function step after the inner steps, reusing the caller's step id.
- The step runs with `if: ${{ always() }}`
- Output values are interpolated against the composite-function-local step namespace
# Test Plan
Added outputs unit tests.
# Why
This PR stack adds support for local composite functions in workflows. After structural expansion, inner steps still could not see `${{ inputs.* }}`, and caller `env` did not yet reach them at runtime.
This PR adds the data layer: input declaration, validation and interpolation, and runtime resolution of the caller context (env, templated working directories).
# How
- `CompositeFunctionExpander` builds declared composite function inputs as real `BuildStepInput` instances
- `BuildStepCompositeFunctionScope` exposes `${{ inputs.* }}` as lazy getters
- Caller `env` and working directory templating resolve through the composite function scope
# Test Plan
Added inputs and scoping unit tests.
# Why
EAS workflows need reusable local composite functions: a step like `uses: ./.eas/functions/setup` should run the steps defined in `function.yml`, not be treated as a built-in function.
This PR adds the structural layer for that: turning a composite function call into concrete workflow steps with correct ids, scoping, and control flow. Input interpolation, outputs, and loading `function.yml` from disk are handled in separate PRs.
# How
When `StepsConfigParser` sees a local `uses:` path (`./` or `../`), `CompositeFunctionExpander` replaces the call with a flat list of inner steps:
- ID namespacing: inner step `read` under caller `setup` becomes `setup__read`
- Each expanded step carries a `BuildStepCompositeFunctionScope` so `${{ steps.* }}` and `${{ inputs.* }}` resolve against composite-function-local names
- Nested local composite functions are expanded recursively with cycle and depth checks
- Local composite functions are rejected in hooks
# Test Plan
Added expansion unit tests covering nesting, cycles, depth limits, and id collisions.
# Why
Local composite functions use `uses: ./...` paths. Custom build configs (`.eas/build/*.yml`) must reject these early with a clear error.
# How
- Adds `isCompositeFunctionPath` in `localCompositeFunctions.ts`
- Rejects local composite function paths in `validateAllFunctionsExist` for custom builds
# Test Plan
Added unit tests.