Typesafety while building an object

I need some help with TypeScript to achieve type safety for an object while building it. I have a function foo that receives an object with properties. Let's say it has two properties, foo and baz. Each property will have the same config object. The config object has the following shape:

type ConfigObject = {
  action: (...args: any[]) => Promise<any>;
  dependencies: string[];
}

The types are quite broad, but this is just for demonstration purposes. I want the type system to infer the arguments of my action function when a config object specifies a dependency. Instead of any, it should infer an object with properties equal to my dependency array (which will have type safety for only introducing properties of my initial root object), and with the values equal to the return type of each of those dependencies, respectively.

For example:

const obj = {
  foo: {
    action: () => {
      return [1, 2, 3];
    },
  },
  baz: {
    action: ({ foo }) => {
      const fooResult = foo; // should be inferred as [1, 2, 3]
      fooResult.forEach((value) => console.log(value)); // 1, 2, and 3
    },
  },
};

Please note that the dependencies array could be optional, and we want to maintain type safety for it as well. How can I achieve this level of type safety and inference for my object?
Any help would be greatly appreciated!

This is my hardest honest unsuccessful attempt to achieve it, but I end up with my arguments as any

type DependencyMap<T extends Record<string, ConfigObject<any, any>>> = {
  [K in keyof T]: ReturnType<T[K]['action']> extends Promise<infer R> ? R : never;
};

type ResolveDependencies<
  T extends Record<string, ConfigObject<any, any>>,
  D extends readonly (keyof T)[]
> = {
  [K in D[number]]: DependencyMap<T>[K];
};

type ConfigObject<T extends Record<string, ConfigObject<any, any>>, D extends readonly (keyof T)[] = [], R = any> = {
  action: (deps: ResolveDependencies<T, D>) => Promise<R>;
  dependencies?: D;
};

type ConfiguredObject<T extends Record<string, ConfigObject<any, any>>> = T;

function createObject<const T extends ConfiguredObject<any>>(arg: T): T {
  return arg;
}

const obj = createObject({
  foo: {
    action: () => {
      return Promise.resolve([1, 2, 3]);
    },
  },
  baz: {
    action: ({ foo }) => {
      const fooResult = foo; // should be infered as [1,2,3] or at least number[]
      fooResult.forEach((value) => console.log(value)); // 1, 2, 3
      return Promise.resolve();
    },
    dependencies: ['foo'],
  },
});

In order for your approach to work, the compiler would need to take a single object with a bunch of interrelated properties, and from that object infer a generic type argument T at the same time as it infers a bunch of callback parameter types contextually from other properties. While this sort of thing might be possible in specific, limited cases, it's intractable for the general case like yours, at least with TypeScript's current approach to type inference.

Perhaps a full unification algorithm would be able to handle it, as described in microsoft/TypeScript#30134, but TypeScript doesn't use such an algorithm. According to the chief language architect in microsoft/TypeScript#17520, the current algorithm "has the distinct advantage of being able to make partial inferences in incomplete code which is hugely beneficial to statement completion in IDEs." Without full unification, TypeScript will inevitably fail to infer types in some cases, and your case is complex enough that it might always be beyond reach. See microsoft/TypeScript#47599 for a related issue.

So what can we do instead of trying to get TypeScript to infer from a single complicate object? One approach is to refactor to use a fluent builder pattern, where you build up your object in stages via chained method calls. Each method call asks the compiler to infer just one property, and it depends only on the previously inferred types. (Note that this only works if your config dependencies form a tree; if they are circular, like foo depends on bar and bar depends on foo, then it's not possible to do it this way directly... but presumably this doesn't happen.) This is much more amenable to TypeScript's inference algorithm. And at the end you call the final "build" method that produces the single object value you wanted.

It could look like this:

interface ConfigBuilder<T extends object, TK extends Record<keyof T, keyof T>> {
add<P extends PropertyKey, U, K extends keyof T = never>(
propName: P,
action: (...args: { [Q in K]: Awaited<T[Q]> }[]) => U,
dependencies?: K[]
): ConfigBuilder<T & { [Q in P]: U }, TK & { [Q in P]: K }>;
build(): { [K in keyof T]: {
action: (...args: { [P in TK[K]]: Awaited<T[P]> }[]) => T[K],
dependencies: K[]
} }
}
const configBuilder = {
config: {},
add(p, a, d = []) {
return {
...this,
config: {
...(this as any).config,
: { action: a, depenencies: d }
}
} as any;
},
build() {
return (this as any).config;
}
} as ConfigBuilder<{}, {}>;

A ConfigBuilder<T, TK> represents a builder that is currently holding onto a partially built config object, where T represents the type of the output of each action method, and where TK represents the keys each property depends on. I've written configBuilder to be a ConfigBuilder<{}, {}>, which is a builder for an empty object... notice that every time you call add() you get a new builder, so you can re-use intermediate objects if you need to.

Let's see it in action:

const config = configBuilder
.add("foo", () => [1, 2, 3] as const)
.add("baz", ({ foo }) => {
const fooResult = foo; 
//    ^? const fooResult: readonly [1, 2, 3]
fooResult.forEach((value) => console.log(value)); 
}, ["foo"])
.build();
/* const config: {
foo: {
action: (...args: {}[]) => readonly [1, 2, 3];
dependencies: "foo"[];
};
baz: {
action: (...args: {
foo: readonly [1, 2, 3];
}[]) => void;
dependencies: "baz"[];
};
} */

Looks good. You can see that the compiler is able to infer the type of the action callback parameter at each step, and that the output type is as expected. And it works:

config.baz.action({ foo: [1, 2, 3] }); // logs 1, 2, 3

Just to be clear, let's look at what happens at each step:

const cb1 = configBuilder.add("foo", () => [1, 2, 3] as const);
// const cb1: ConfigBuilder<
//   { foo: readonly [1, 2, 3]; }, 
//   { foo: never; }
// >
const cb2 = cb1.add("baz", ({ foo }) => {
const fooResult = foo; // should be inferred as [1, 2, 3]
fooResult.forEach((value) => console.log(value)); // 1, 2, and 3
}, ["foo"]);
// const cb2: ConfigBuilder<
//    { foo: readonly [1, 2, 3]; } & { baz: void; }, 
//    { foo: never; } & { baz: "foo"; }
// >;
const cfg = cb2.build();
// const cfg: typeof config // <-- same as before

The first call to add() produces a ConfigBuilder<{ foo: readonly [1, 2, 3]; }, { foo: never; }>, meaning there's an object whose foo action produces a readonly [1, 2, 3], and which has no dependencies. The second call to add() produces the equivalent of ConfigBuilder<{ foo: readonly [1, 2, 3]; baz: void; }, { foo: never; baz: "foo"; }>, which is the same as before except that there's also a baz property whose action doesn't return anything useful, and which is dependent on the foo property. And finally when you call build() you get the final config object.

Playground link to code

What you are trying to do is an extremely difficult task, which may not be even possible to accomplish given your requirements.

Basically, you are reinventing a dependency injection pattern but on the level of a single object aand dependencies between its properties instead of a standard way of registering classes in a DI container, that you could do very easily using libraries like TypeDI, InversifyJS etc.

Example using TypeDI that just works without any need for complex custom types:

import 'reflect-metadata';
import { Container, Service } from 'typedi';

type ConfigObject = {
  action: (...args: any[]) => Promise<any>;
}

@Service() class Foo implements ConfigObject {
  action() {
    return Promise.resolve([1, 2, 3] as const);
  }
}

@Service() class Bar implements ConfigObject {
  constructor(private foo: Foo) {} // this is how you declare dependency
  async action() {
    // YES, fooResult is inferred as [1,2,3]
    // OR as number[] if you remove `as const` from foo's return
    const fooResult = await this.foo.action();
    fooResult.forEach((value) => console.log(value)); // YES, prints 1, 2, 3
    return Promise.resolve();
  }
}

const bar = Container.get(Bar);
bar.action();

I know that you are asking a very specific question of how to make your solution work, but your solution is trying to solve some problem and if that problem is combing multiple objects with action() methods and with mutual dependencies, then the solution of building a custom dependency injection system on the level of abstraction that I have not seen before, may not be the most optimal solution to that.

I would seriously consider using a proper DI system and if anyone can solve the problem that you imposed on yourself by deciding to invent a property-level dependency injection system for a single object, I'd love to see the solution.