Our discussion on dependency injection

testA.ts

import { SoilAssertion, assertSoilFertilized, assertSoilPloughed } from 'testB';

interface PlantPotatoes {
  injected: (seeds: string[], soil: string) => Promise<string>;
  dependencies: {
    assertPloughed: SoilAssertion;
    assertFertilized: SoilAssertion;
  };
}

const plantPotatoesInjected = async (
  { assertFertilized, assertPloughed }: PlantPotatoes['dependencies'],
  seeds: string[],
  soil: string,
): Promise<string> => {
  await assertPloughed(soil);
  await assertFertilized(soil);

  return seeds.reduce((acc, seed) => acc + seed, soil);
};

export const plantPotatoes: PlantPotatoes['injected'] = (seeds, soil) => plantPotatoesInjected(
  {
    assertFertilized: assertSoilFertilized,
    assertPloughed: assertSoilPloughed,
  },
  seeds,
  soil,
);

export const plantPotatoesSkippingChecks: PlantPotatoes['injected'] = (seeds, soil) => plantPotatoesInjected(
  {
    assertFertilized: () => Promise.resolve(),
    assertPloughed: () => Promise.resolve(),
  },
  seeds,
  soil,
);

testB.ts

export interface SoilAssertion {
  (soil: string): Promise<void>;
}

export const assertSoilPloughed: SoilAssertion = () => Promise.resolve();
export const assertSoilFertilized: SoilAssertion = () => Promise.resolve();