É melhor confiar nas dependências transitivas ou declará-las explicitamente?

Eu tenho uma estrutura de projeto como esta:

My Project
  - Other Team's Project
     -Third Party Dependency

My Projectrequer Other Team's Projectpara funcionar, e ambos My Projecte Other Team's Projectexigem Third Party Dependencypara funcionar. Estamos usando um sistema de gerenciamento de dependências para gerenciá-los.

Do ponto de vista do design, é melhor My Projectconfiar temporariamente Third Party Dependency? Ou é melhor para ambos My Projecte Other Team's Projectdeclarar explicitamente que eles usam Third Party Dependency?

Algumas outras coisas:

• Ambos os projetos precisam ter a mesma versão do Third Party Dependency.
• Não é garantido que, se Other Team's Projectfor atualizado My Project, será testado para garantir que nada quebre, porque eles são gerenciados por equipes diferentes.

Imagine o que acontece se a outra equipe refatorar seu projeto para fazer a mesma coisa sem usar a biblioteca de terceiros e remover sua dependência. Ou eles mudam para outra biblioteca de terceiros para fazer a mesma coisa. Seu código ainda funcionará?

Se isso acontecer, seu código depende apenas do outro projeto, caso contrário, seu código também depende da biblioteca de terceiros.

Ambos os projetos precisam ter a mesma versão do Third Party Dependency.

Esse é um forte indicador de que seu projeto também depende diretamente da biblioteca de terceiros.

Acho que isso é principalmente baseado em opiniões, mas eu colocarei meus 2p de qualquer maneira.

A maneira como sempre fiz isso é me perguntando, qual é a quantidade mínima de conhecimento que meu código precisa ter para fazer o que deveria fazer?

Se meu código usa apenas código de Other team's library, incluirei apenas Other team's librarycomo dependência.

Se meu código também usa código de Third-party library, também o incluirei.

Vamos dizer que eu tinha as seguintes classes de My Library, Other Librarye Third-party Library(eu vou usar Java para o código de exemplo)

package mylibrary;

import otherlibrary.Bar;

public class Foo {

    public void doFoo() {
        Bar bar = new Bar();
        bar.doBar();
    }
}

No Other Library

package otherlibrary;

import thirdparty.Baz;

public class Bar {

    public void doBar() {
        Baz baz = new Baz();
        baz.doSomething();
    }
}

No Third-party library

package thirdparty;

public class Baz {

    public void doBaz() {
        System.out.println("baz");
    }
}

Como o meu código Foodepende apenas do código otherlibrary, isso é tudo o que eu incluiria, porque é com isso que eu me importo. Eu não me importo como otherlibrary.Bar#doBarfaz o que faz, só quero que faça.

Se, no entanto, alteramos a opção otherlibrary.Bar#doBarde aceitar um Bazpara fazer algo, como

public void doBar(Baz baz) {
    baz.doBaz();
}

Eu precisaria então mudar mylibrary.Foo#doFoopara algo como

public void doFoo() {
    Bar bar = new Bar();
    Baz baz = new Baz();

    bar.doBar(baz);
}

Como agora estou interessado em como Bar#doBaras coisas funcionam, e meu código precisa saber Bazo que quero fazer, preciso ser explícito sobre as bibliotecas que incluo.

Se o meu código deve saber sobre o material dentro da thirdpartybiblioteca, então eu deve incluí-lo como uma dependência.

Embora talvez o autor de Bardeva esconder mais desses detalhes, não preciso incluir a thirdpartybiblioteca ...