How to use with other decorators?

function logNew() {
  return <T extends constructor<any>>(constructor: T) => {
    return class extends constructor {
      constructor(...args: any[]) {
        super(...args);
        console.log("CREATED", args)
      }
    }
  };
}

class Foo {
  value = "foo"
}

@logNew()
@injectable()
class Bar {
  constructor(foo: Foo){
    console.log(foo.value)
  }
}

const bar = container.resolve(Bar)

foo is undefined

[cypherix93]

I actually ran into this same issue and found out that I could just pass on the reflection metadata onto the new constructor. Now the new constructor gets called with the injected dependencies. Not sure if this is the correct approach, but it seems to work for now. See below:

const INJECTION_TOKEN_METADATA_KEY = 'injectionTokens';

export function MyDecorator(): ClassDecorator {
    return ((target: { new(...args: any[]): any }) => {
        const original = target;

        const injectionTokensMetadata = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, original) || {};

        const wrapper = function (...args: any[]) {
                // args here have the injected constructor dependencies
        };

        wrapper.prototype = original.prototype;

        Reflect.defineMetadata(INJECTION_TOKEN_METADATA_KEY, injectionTokensMetadata, wrapper);

        return wrapper;
    }) as ClassDecorator;
}

Caveat is that I have to register MyDecorator below the tsyringe one, so that tsyringe registers my overriden constructor reference. For example:

@singleton()
@MyDecorator()
export class MyService implements IMyService {

    constructor(
        @inject('MyOtherService') private _myOtherService: IMyOtherService
    ) {
    }
}

And then I’m doing

// registration
container.register('MyService', MyService);

// resolution somewhere else
container.resolve<IMyService>('MyService');

[lrembacz]

@skiptirengu, @user753 Had the same issue but only when I was using @babel/typescript presets. When I changed it to ts-loader issue dissapeared.

It’s probably because resolving of decorators is other in both cases.

Code from injectable decorator passed with param inject decorator is no more giiving errors and getting resolved.

export function fixedInject(token: InjectionToken<any>): (target: any, propertyKey: string | symbol, parameterIndex: number) => any {
    return (target: any, propertyKey: string | symbol, parameterIndex: number) => {
        inject(token)(target, propertyKey, parameterIndex);
        const params = Reflect.getMetadata("design:paramtypes", target) || [];
        const injectionTokens = Reflect.getOwnMetadata("injectionTokens", target) || {};
        Object.keys(injectionTokens).forEach(function (key) {
            params[+key] = injectionTokens[key];
        });
    }
}

After some tries I’ve managed that generating keys for injectionTokens is working. It’s for sure related to babel-plugin-transform-typescript-metadata and @babel/typescript.