How to create a pipeline when one build produces a "bin" which is used by another build?

[goenning]

I have a monorepo with 2 packages (core and cli) and 1 app.

the app uses the cli, like this:

  "scripts": {
    "build": "bingo build"
  },

Where bingo is the bin produced by the cli package:

{
  "name": "bingo-cli",
  "bin": {
    "bingo": "./dist/index.js"
  },

So what happens is that when I run npm run build, turborepo will build the cli correctly, but it won't be available for the build step on the app. It fails with: example-hello-world:build: sh: 1: bingo: not found

If I run npm install (after the cli was built) and run it again, then it'll work. I believe it's because the bin file was not available during the first npm install, so it was not linked.

Right now, what I'm doing on the github workflow as a workaround is:

      - run: npm ci

      - name: npm run build (cli)
        run: npm run build
        working-directory: ./packages/cli

      - run: npm ci

      - run: npm run lint

      - name: npm run build (all)
        run: npm run build

But I want developers to have a good first experience with the repo, they should be able to just npm install and npm run build.

Any thoughts?

For what's worth, this is my turbo settings:

  "turbo": {
    "pipeline": {
      "build": {
        "dependsOn": [
          "^build"
        ],
        "outputs": [
          "dist/**"
        ]
      },
      "lint": {
        "outputs": []
      },
      "dev": {
        "cache": false
      }
    }
  },

[jaredpalmer]

You can force the cli to always be built first by specifying it as a dependency of all build tasks.

"turbo": {
    "pipeline": {
      "build": {
        "dependsOn": [
         "cli#build",
          "^build",          
        ],
        "outputs": [
          "dist/**"
        ]
      },
      "lint": {
        "outputs": []
      },
      "dev": {
        "cache": false
      }
    }
  },

[steveruizok]

After some research, it looks like this would be solved in lerna by running bootstrap a second time. Curious to see whether pnpm would have the same behavior.

[tundera]

@steveruizok You can add a file to your CLI package in a bin folder that imports the built file it needs to execute to run the CLI program. If the file that runs your CLI is built to dist/cli.js, the file at bin/cli.js would look something like this:

#!/usr/bin/env node
require('../dist/cli.js')

You have to update your package.json though as well, so if the bin field is currently set to the dist/cli.js file it needs to be changed to bin/cli.js. Then add the bin folder to the files array since your package will need the files in both dist and bin to run correctly.

This wasn't something I needed to do when I used yarn v3 but noticed it was needed once I switched to pnpm. I'm not sure, but guessing this is probably what would be needed in yarn v1 too.

[jsbrain]

Is there currently a way to run a task after a special set of tasks?

I have a directory which includes various extensions and I have one build task that needs to run after all extensions have been built.

So I'm searching for a way to express this without listing all extensions explicitly (because it could be many of them).

So something like

    "somepackage#build": {
      "dependsOn": ["packages/**#build"] // <- glob pattern?!
    },

[wujekbogdan]

I'm afraid this isn't a complete solution.

Linking happens right after install, so having one build command depend on another build command doesn't solve a problem because a package can't be link if the compiled output doesn't exist in dist/* yet.

[jlpospisil]

Running into this same issue. Any updates?