Turborepo: Inter-package dependencies

[claus]

Let's say I have a Turborepo with two packages, pkg1 and pkg2 (both external), where pkg2 depends on stuff in pkg1. Is that even possible? Do i have to configure something for that to work?

[mehulkar]

Hey @claus, I'm not sure what you're asking. If pkg2 is an external package installed through npm (or other package manager) and it has a dependency on pkg1, things should Just Work. Is there something that isn't working? It doesn't seem like Turborepo will play a role in this.

[MathiasPawshake]

Hi I'm going to assume that @claus means that he wants to use pkg2 (import {component} from "pkg2") in pkg1. Does he need to add pkg2 as a dependency in the packages.json of pkg2?

[mehulkar]

If pkg2 and pkg1 are both external, and pkg1 imports pkg2, then pkg2 should be a part of pkg1's dependencies. This doesn't seem like something related to Turborepo unless I'm missing something

[MrDockal]

I came here to seek a different problem, but it seems related so I'll ask here.

Let's assume these two external packages where pkg2 depends on pkg1. The documentation describes how to make an external package work https://turbo.build/repo/docs/handbook/publishing-packages/bundling but it doesn't say how to handle these dependencies properly.

Let's say I did some changes in both pkg1 and pkg2 and now I want to release both of them at the same time. I believe this isn't possible as I should publish pkg1 first, then edit pkg2 dependencies to target the latest deployed pkg1 version and publish pkg2 afterward.

[kenny-f]

Just come across this (or similar) problem myself. I think it would help if it was described with more detail so here goes:

In our turborepo monorepo we have pkg1 and pkg2. pkg2 depends on pkg1

The package json of pkg2 looks like this

"dependencies": {
  "pkg1": "*"
}

Both of these packages are published as they can be used independently (think of something like eslint-base-preset and eslint-react-preset where eslint-react-preset depends on eslint-base-preset, but if you didn't need react you could just install the base)

Setting the scene:

We have an application (which is NOT in the monorepo) consuming pkg2.
So the package.json looks like this:

"dependencies": {
  "pkg2": "1.0.0"
}

And the yarn lock has the following:

"pkg1": "1.0.0", // because this is a dependency for pkg2
"pkg2": "1.0.0"

Making changes in the monorepo

We are going to make some changes to pkg1 and pkg2 in the monorepo and publish a new version 2.0.0

Updating pkg2 in the application

Now that the new versions are published we go and update pkg2 in the application.
Lets say we bump the version from 1.0.0 to 2.0.0 in the package.json and run yarn install.

Result

What we are left with is

"pkg1": "1.0.0",
"pkg2": "2.0.0"

What is expected:

"pkg1": "2.0.0",
"pkg2": "2.0.0"

Why did this happen?

This happened because pkg2 has a * dependency on pkg1 which means any version and since yarn already has 1.0.0 in it's yarn lock it didn't bother to go update pkg1 to 2.0.0.

Hope others will find this description helpful.
Would appreciate if anyone else has come across this problem also to share any workarounds if any.

[aiampogi]

@kenny-f were you able to solve this?

I'm having the same issue as @kenny-f and @MrDockal . Any documentation out there that talks about this?