@venok/core 1.0.0

package/test/interceptors/consumer.spec.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_hooks_1 = require("async_hooks");
+const chai_1 = require("chai");
+const rxjs_1 = require("rxjs");
+const sinon_1 = __importDefault(require("sinon"));
+const interceptors_1 = require("@venok/core/interceptors");
+describe("InterceptorsConsumer", () => {
+    let consumer;
+    let interceptors;
+    beforeEach(() => {
+        consumer = new interceptors_1.InterceptorsConsumer();
+        interceptors = [
+            {
+                intercept: sinon_1.default.stub().callsFake((ctx, handler) => handler.handle()),
+            },
+            {
+                intercept: sinon_1.default.stub().callsFake(async (ctx, handler) => handler.handle()),
+            },
+        ];
+    });
+    describe("intercept", () => {
+        describe("when interceptors array is empty", () => {
+            let next;
+            beforeEach(() => {
+                next = sinon_1.default.spy();
+            });
+            it("should call next()", async () => {
+                await consumer.intercept([], null, { constructor: null }, null, next);
+                (0, chai_1.expect)(next.calledOnce).to.be.true;
+            });
+        });
+        describe("when interceptors array is not empty", () => {
+            let next;
+            beforeEach(() => {
+                next = sinon_1.default.stub().returns(Promise.resolve(""));
+            });
+            it("does not call `intercept` (lazy evaluation)", async () => {
+                await consumer.intercept(interceptors, null, { constructor: null }, null, next);
+                (0, chai_1.expect)(interceptors[0].intercept.called).to.be.false;
+                (0, chai_1.expect)(interceptors[1].intercept.called).to.be.false;
+            });
+            it("should call every `intercept` method when subscribe", async () => {
+                const intercepted = await consumer.intercept(interceptors, null, { constructor: null }, null, next);
+                await transformToResult(intercepted);
+                (0, chai_1.expect)(interceptors[0].intercept.calledOnce).to.be.true;
+                (0, chai_1.expect)(interceptors[1].intercept.calledOnce).to.be.true;
+            });
+            it("should not call `next` (lazy evaluation)", async () => {
+                await consumer.intercept(interceptors, null, { constructor: null }, null, next);
+                (0, chai_1.expect)(next.called).to.be.false;
+            });
+            it("should call `next` when subscribe", async () => {
+                const intercepted = await consumer.intercept(interceptors, null, { constructor: null }, null, next);
+                await transformToResult(intercepted);
+                (0, chai_1.expect)(next.called).to.be.true;
+            });
+        });
+        describe("when AsyncLocalStorage is used", () => {
+            it("should allow an interceptor to set values in AsyncLocalStorage that are accesible from the controller", async () => {
+                const storage = new async_hooks_1.AsyncLocalStorage();
+                class StorageInterceptor {
+                    intercept(_context, next) {
+                        return storage.run({ value: "hello" }, () => next.handle());
+                    }
+                }
+                const next = () => {
+                    return Promise.resolve(storage.getStore().value);
+                };
+                const intercepted = await consumer.intercept([new StorageInterceptor()], null, { constructor: null }, null, next);
+                const result = await transformToResult(intercepted);
+                (0, chai_1.expect)(result).to.equal("hello");
+            });
+        });
+        describe("when retrying is enabled", () => {
+            it("should retry a specified amount of times", async () => {
+                let count = 0;
+                const next = () => {
+                    count++;
+                    if (count < 3) {
+                        return Promise.reject(new Error("count not reached"));
+                    }
+                    return Promise.resolve(count);
+                };
+                class RetryInterceptor {
+                    intercept(_context, next) {
+                        return next.handle().pipe((0, rxjs_1.retry)(4));
+                    }
+                }
+                const intercepted = await consumer.intercept([new RetryInterceptor()], null, { constructor: null }, null, next);
+                (0, chai_1.expect)(await transformToResult(intercepted)).to.equal(3);
+            });
+        });
+    });
+    describe("createContext", () => {
+        it("should return execution context object", () => {
+            const instance = { constructor: {} };
+            const callback = () => null;
+            const context = consumer.createContext([], instance, callback);
+            (0, chai_1.expect)(context.getClass()).to.be.eql(instance.constructor);
+            (0, chai_1.expect)(context.getHandler()).to.be.eql(callback);
+        });
+    });
+    describe("transformDeferred", () => {
+        describe("when next() result is plain value", () => {
+            it("should return Observable", async () => {
+                const val = 3;
+                const next = async () => val;
+                (0, chai_1.expect)(await (0, rxjs_1.lastValueFrom)(consumer.transformDeferred(next))).to.be.eql(val);
+            });
+        });
+        describe("when next() result is Promise", () => {
+            it("should return Observable", async () => {
+                const val = 3;
+                const next = async () => val;
+                (0, chai_1.expect)(await (0, rxjs_1.lastValueFrom)(consumer.transformDeferred(next))).to.be.eql(val);
+            });
+        });
+        describe("when next() result is Observable", () => {
+            it("should return Observable", async () => {
+                const val = 3;
+                const next = async () => (0, rxjs_1.of)(val);
+                (0, chai_1.expect)(await (0, rxjs_1.lastValueFrom)(consumer.transformDeferred(next))).to.be.eql(val);
+            });
+        });
+    });
+});
+async function transformToResult(resultOrDeferred) {
+    if (resultOrDeferred && typeof resultOrDeferred.subscribe === "function") {
+        return (0, rxjs_1.lastValueFrom)(resultOrDeferred);
+    }
+    return resultOrDeferred;
+}

package/test/interceptors/context-creator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/interceptors/context-creator.spec.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const rxjs_1 = require("rxjs");
+const sinon_1 = __importDefault(require("sinon"));
+const interceptors_1 = require("@venok/core/interceptors");
+const config_1 = require("@venok/core/application/config");
+const wrapper_1 = require("@venok/core/injector/instance/wrapper");
+class Interceptor {
+}
+describe("InterceptorsContextCreator", () => {
+    let interceptorsContextCreator;
+    let interceptors;
+    let applicationConfig;
+    let container;
+    let getSpy;
+    class Interceptor1 {
+    }
+    class Interceptor2 {
+    }
+    beforeEach(() => {
+        interceptors = [
+            {
+                name: Interceptor1.name,
+                token: Interceptor1,
+                metatype: Interceptor1,
+                getInstanceByContextId: () => interceptors[0],
+                instance: {
+                    intercept: () => (0, rxjs_1.of)(true),
+                },
+            },
+            {
+                name: Interceptor2.name,
+                token: Interceptor2,
+                metatype: Interceptor2,
+                getInstanceByContextId: () => interceptors[1],
+                instance: {
+                    intercept: () => (0, rxjs_1.of)(true),
+                },
+            },
+            {},
+            undefined,
+        ];
+        getSpy = sinon_1.default.stub().returns({
+            injectables: new Map([
+                [Interceptor1, interceptors[0]],
+                [Interceptor2, interceptors[1]],
+            ]),
+        });
+        container = {
+            getModules: () => ({
+                get: getSpy,
+            }),
+        };
+        applicationConfig = new config_1.ApplicationConfig();
+        interceptorsContextCreator = new interceptors_1.InterceptorsContextCreator(container, applicationConfig);
+    });
+    describe("createConcreteContext", () => {
+        describe("when `moduleContext` is nil", () => {
+            it("should return empty array", () => {
+                const result = interceptorsContextCreator.createConcreteContext(interceptors);
+                (0, chai_1.expect)(result).to.be.empty;
+            });
+        });
+        describe("when `moduleContext` is defined", () => {
+            beforeEach(() => {
+                interceptorsContextCreator["moduleContext"] = "test";
+            });
+            it("should filter metatypes", () => {
+                const interceptorTypeRefs = [interceptors[0].metatype, interceptors[1].instance];
+                (0, chai_1.expect)(interceptorsContextCreator.createConcreteContext(interceptorTypeRefs)).to.have.length(2);
+            });
+        });
+    });
+    describe("getInterceptorInstance", () => {
+        describe("when param is an object", () => {
+            it("should return instance", () => {
+                const instance = { intercept: () => null };
+                (0, chai_1.expect)(interceptorsContextCreator.getInterceptorInstance(instance)).to.be.eql(instance);
+            });
+        });
+        describe("when param is a constructor", () => {
+            it("should pick instance from container", () => {
+                const wrapper = {
+                    instance: "test",
+                    getInstanceByContextId: () => wrapper,
+                };
+                sinon_1.default.stub(interceptorsContextCreator, "getInstanceByMetatype").callsFake(() => wrapper);
+                (0, chai_1.expect)(interceptorsContextCreator.getInterceptorInstance(Interceptor)).to.be.eql(wrapper.instance);
+            });
+            it("should return null", () => {
+                sinon_1.default.stub(interceptorsContextCreator, "getInstanceByMetatype").callsFake(() => null);
+                (0, chai_1.expect)(interceptorsContextCreator.getInterceptorInstance(Interceptor)).to.be.eql(null);
+            });
+        });
+    });
+    describe("getInstanceByMetatype", () => {
+        describe('when "moduleContext" is nil', () => {
+            it("should return undefined", () => {
+                interceptorsContextCreator.moduleContext = undefined;
+                (0, chai_1.expect)(interceptorsContextCreator.getInstanceByMetatype(null)).to.be.undefined;
+            });
+        });
+        describe('when "moduleContext" is not nil', () => {
+            beforeEach(() => {
+                interceptorsContextCreator.moduleContext = "test";
+            });
+            describe("and when module exists", () => {
+                it("should return undefined", () => {
+                    (0, chai_1.expect)(interceptorsContextCreator.getInstanceByMetatype(class {
+                    })).to.be.undefined;
+                });
+            });
+        });
+    });
+    describe("getGlobalMetadata", () => {
+        describe("when contextId is static and inquirerId is nil", () => {
+            it("should return global interceptors", () => {
+                const expectedResult = applicationConfig.getGlobalInterceptors();
+                (0, chai_1.expect)(interceptorsContextCreator.getGlobalMetadata()).to.be.equal(expectedResult);
+            });
+        });
+        describe("otherwise", () => {
+            it("should merge static global with request/transient scoped interceptors", () => {
+                const globalInterceptors = ["test"];
+                const instanceWrapper = new wrapper_1.InstanceWrapper();
+                const instance = "request-scoped";
+                const scopedInterceptorWrappers = [instanceWrapper];
+                sinon_1.default.stub(applicationConfig, "getGlobalInterceptors").callsFake(() => globalInterceptors);
+                sinon_1.default.stub(applicationConfig, "getGlobalRequestInterceptors").callsFake(() => scopedInterceptorWrappers);
+                sinon_1.default.stub(instanceWrapper, "getInstanceByContextId").callsFake(() => ({ instance }));
+                (0, chai_1.expect)(interceptorsContextCreator.getGlobalMetadata({ id: 3 })).to.contains(instance, ...globalInterceptors);
+            });
+        });
+    });
+});

package/test/metadata-scanner.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/metadata-scanner.spec.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const metadata_scanner_1 = require("@venok/core/metadata-scanner");
+describe("MetadataScanner", () => {
+    let scanner;
+    beforeEach(() => {
+        scanner = new metadata_scanner_1.MetadataScanner();
+    });
+    describe("scanFromPrototype", () => {
+        class Parent {
+            constructor() { }
+            testParent() { }
+            testParent2() { }
+            get propParent() {
+                return "";
+            }
+            set valParent(value) { }
+        }
+        class Test extends Parent {
+            constructor() {
+                super();
+            }
+            get prop() {
+                return "";
+            }
+            set val(value) { }
+            test() { }
+            test2() { }
+        }
+        it("should return only methods", () => {
+            const methods = scanner.getAllMethodNames(Test.prototype);
+            (0, chai_1.expect)(methods).to.eql(["test", "test2", "testParent", "testParent2"]);
+        });
+        it("should return the same instance for the same prototype", () => {
+            const methods1 = scanner.getAllMethodNames(Test.prototype);
+            const methods2 = scanner.getAllMethodNames(Test.prototype);
+            (0, chai_1.expect)(methods1 === methods2).to.eql(true);
+        });
+    });
+});

package/test/module/configurable-module.builder.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/module/configurable-module.builder.spec.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const module_1 = require("@venok/core/module");
+describe("ConfigurableModuleBuilder", () => {
+    describe("setExtras", () => {
+        it("should apply module definition transformer function and return typed builder", () => {
+            const { ConfigurableModuleClass } = new module_1.ConfigurableModuleBuilder()
+                .setExtras({ isGlobal: false }, (definition, extras) => ({
+                ...definition,
+                global: extras.isGlobal,
+            }))
+                .build();
+            (0, chai_1.expect)(ConfigurableModuleClass.register({
+                // No type error
+                isGlobal: true,
+            })).to.deep.include({
+                global: true,
+            });
+        });
+    });
+    describe("setClassMethodName", () => {
+        it("should set static class method name and return typed builder", () => {
+            const { ConfigurableModuleClass } = new module_1.ConfigurableModuleBuilder().setClassMethodName("forRoot").build();
+            (0, chai_1.expect)(ConfigurableModuleClass.forRoot).to.not.be.undefined;
+            (0, chai_1.expect)(ConfigurableModuleClass.forRootAsync).to.not.be.undefined;
+            (0, chai_1.expect)(ConfigurableModuleClass.register).to.be.undefined;
+        });
+    });
+    describe("setFactoryMethodName", () => {
+        it("should set configuration factory class method name and return typed builder", () => {
+            const { ConfigurableModuleClass } = new module_1.ConfigurableModuleBuilder().setFactoryMethodName("createOptions").build();
+            (0, chai_1.expect)(ConfigurableModuleClass.registerAsync({
+                useClass: class {
+                    // No type error
+                    createOptions() { }
+                },
+            })).to.not.be.undefined;
+        });
+    });
+    describe("build", () => {
+        it('should return a fully typed "ConfigurableModuleClass"', () => {
+            const { ConfigurableModuleClass, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE, MODULE_OPTIONS_TOKEN } = new module_1.ConfigurableModuleBuilder({
+                moduleName: "RandomTest",
+                alwaysTransient: true,
+            })
+                .setFactoryMethodName("createOptions")
+                .setClassMethodName("forFeature")
+                .setExtras({ isGlobal: false, extraProviders: [] }, (definition, extras) => ({
+                ...definition,
+                global: extras.isGlobal,
+                providers: definition.providers?.concat(extras.extraProviders),
+            }))
+                .build();
+            const provideInjectionTokensFrom = [
+                {
+                    provide: "a",
+                    useFactory: () => { },
+                    inject: ["b"],
+                },
+                {
+                    provide: "b",
+                    useFactory: () => { },
+                    inject: ["x"],
+                },
+                {
+                    provide: "c",
+                    useFactory: () => { },
+                    inject: ["y"],
+                },
+            ];
+            const definition = ConfigurableModuleClass.forFeatureAsync({
+                useFactory: () => { },
+                inject: ["a"],
+                provideInjectionTokensFrom,
+                isGlobal: true,
+                extraProviders: ["test"],
+            });
+            (0, chai_1.expect)(definition.global).to.equal(true);
+            (0, chai_1.expect)(definition.providers).to.have.length(5);
+            (0, chai_1.expect)(definition.providers).to.deep.contain("test");
+            (0, chai_1.expect)(definition.providers).to.include.members(provideInjectionTokensFrom.slice(0, 2));
+            (0, chai_1.expect)(definition.providers).not.to.include(provideInjectionTokensFrom[2]);
+            (0, chai_1.expect)(MODULE_OPTIONS_TOKEN).to.equal("RANDOM_TEST_MODULE_OPTIONS");
+            (0, chai_1.expect)(definition.providers[0].provide).to.equal("RANDOM_TEST_MODULE_OPTIONS");
+            try {
+                (0, chai_1.expect)(ASYNC_OPTIONS_TYPE.imports).to.equal(undefined);
+            }
+            catch (err) {
+                (0, chai_1.expect)(err).to.be.instanceOf(Error);
+                (0, chai_1.expect)(err.message).to.equal('"ASYNC_OPTIONS_TYPE" is not supposed to be used as a value.');
+            }
+            try {
+                (0, chai_1.expect)(OPTIONS_TYPE.isGlobal).to.equal(undefined);
+            }
+            catch (err) {
+                (0, chai_1.expect)(err).to.be.instanceOf(Error);
+                (0, chai_1.expect)(err.message).to.equal('"OPTIONS_TYPE" is not supposed to be used as a value.');
+            }
+        });
+    });
+});

package/test/module/helpers/get-injection-providers.helper.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/module/helpers/get-injection-providers.helper.spec.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const helpers_1 = require("@venok/core/module/helpers");
+describe("getInjectionProviders", () => {
+    it("should take only required providers", () => {
+        class C {
+        }
+        C.token = "a";
+        const p = [
+            {
+                provide: "a",
+                useValue: "a",
+            },
+            {
+                provide: "b",
+                useValue: "b",
+            },
+            C,
+            {
+                provide: "d",
+                useFactory: (c, b) => [c, b],
+                inject: [
+                    C,
+                    {
+                        token: "b",
+                        optional: true,
+                    },
+                    "x",
+                ],
+            },
+            {
+                provide: "e",
+                useFactory: (d, b) => [d, b],
+                inject: ["d", "b"],
+            },
+            {
+                provide: "f",
+                useValue: "f",
+            },
+        ];
+        // should not include 'a' and 'f'
+        const expected = p.slice(1, -1);
+        const result = (0, helpers_1.getInjectionProviders)(p, ["e"]);
+        (0, chai_1.expect)(result).to.have.length(expected.length);
+        (0, chai_1.expect)(result).to.have.members(expected);
+        (0, chai_1.expect)(result).not.to.have.members([p[0], p[5]]);
+    });
+});

package/test/pipes/consumer.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/pipes/consumer.spec.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const pipes_1 = require("@venok/core/pipes");
+const createPipe = (transform) => ({ transform });
+describe("PipesConsumer", () => {
+    let consumer;
+    beforeEach(() => {
+        consumer = new pipes_1.PipesConsumer();
+    });
+    describe("apply", () => {
+        let value, metatype, type, stringifiedType, transforms, data;
+        beforeEach(() => {
+            value = 0;
+            data = null;
+            (metatype = {}), (type = "query");
+            stringifiedType = "query";
+            transforms = [
+                createPipe(sinon_1.default.stub().callsFake((val) => val + 1)),
+                createPipe(sinon_1.default.stub().callsFake((val) => Promise.resolve(val + 1))),
+                createPipe(sinon_1.default.stub().callsFake((val) => val + 1)),
+            ];
+        });
+        it("should call all transform functions", (done) => {
+            consumer.apply(value, { metatype, type, data }, transforms).then(() => {
+                (0, chai_1.expect)(transforms.reduce((prev, next) => prev && next.transform.called, true)).to.be.true;
+                done();
+            });
+        });
+        it("should return expected result", (done) => {
+            const expectedResult = 3;
+            consumer.apply(value, { metatype, type, data }, transforms).then((result) => {
+                (0, chai_1.expect)(result).to.be.eql(expectedResult);
+                done();
+            });
+        });
+    });
+});

package/test/pipes/context-creator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/pipes/context-creator.spec.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const pipes_1 = require("@venok/core/pipes");
+const container_1 = require("@venok/core/injector/container");
+const config_1 = require("@venok/core/application/config");
+const wrapper_1 = require("@venok/core/injector/instance/wrapper");
+class Pipe {
+}
+describe("PipesContextCreator", () => {
+    let creator;
+    let container;
+    let applicationConfig;
+    beforeEach(() => {
+        container = new container_1.VenokContainer();
+        applicationConfig = new config_1.ApplicationConfig();
+        creator = new pipes_1.PipesContextCreator(container, applicationConfig);
+    });
+    describe("createConcreteContext", () => {
+        describe("when metadata is empty or undefined", () => {
+            it("should return empty array", () => {
+                (0, chai_1.expect)(creator.createConcreteContext(undefined)).to.be.deep.equal([]);
+                (0, chai_1.expect)(creator.createConcreteContext([])).to.be.deep.equal([]);
+            });
+        });
+        describe("when metadata is not empty or undefined", () => {
+            const metadata = [null, {}, { transform: () => ({}) }];
+            it("should return expected array", () => {
+                const transforms = creator.createConcreteContext(metadata);
+                (0, chai_1.expect)(transforms).to.have.length(1);
+            });
+        });
+    });
+    describe("getPipeInstance", () => {
+        describe("when param is an object", () => {
+            it("should return instance", () => {
+                const instance = { transform: () => null };
+                (0, chai_1.expect)(creator.getPipeInstance(instance)).to.be.eql(instance);
+            });
+        });
+        describe("when param is a constructor", () => {
+            it("should pick instance from container", () => {
+                const wrapper = {
+                    instance: "test",
+                    getInstanceByContextId: () => wrapper,
+                };
+                sinon_1.default.stub(creator, "getInstanceByMetatype").callsFake(() => wrapper);
+                (0, chai_1.expect)(creator.getPipeInstance(Pipe)).to.be.eql(wrapper.instance);
+            });
+            it("should return null", () => {
+                sinon_1.default.stub(creator, "getInstanceByMetatype").callsFake(() => null);
+                (0, chai_1.expect)(creator.getPipeInstance(Pipe)).to.be.eql(null);
+            });
+        });
+    });
+    describe("getInstanceByMetatype", () => {
+        describe('when "moduleContext" is nil', () => {
+            it("should return undefined", () => {
+                creator.moduleContext = undefined;
+                (0, chai_1.expect)(creator.getInstanceByMetatype(null)).to.be.undefined;
+            });
+        });
+        describe('when "moduleContext" is not nil', () => {
+            beforeEach(() => {
+                creator.moduleContext = "test";
+            });
+            describe("and when module exists", () => {
+                it("should return undefined", () => {
+                    sinon_1.default.stub(container.getModules(), "get").callsFake(() => undefined);
+                    (0, chai_1.expect)(creator.getInstanceByMetatype(null)).to.be.undefined;
+                });
+            });
+            describe("and when module does not exist", () => {
+                it("should return instance", () => {
+                    const instance = { test: true };
+                    const module = { injectables: { get: () => instance } };
+                    sinon_1.default.stub(container.getModules(), "get").callsFake(() => module);
+                    (0, chai_1.expect)(creator.getInstanceByMetatype(class Test {
+                    })).to.be.eql(instance);
+                });
+            });
+        });
+    });
+    describe("getGlobalMetadata", () => {
+        describe("when contextId is static and inquirerId is nil", () => {
+            it("should return global pipes", () => {
+                const expectedResult = applicationConfig.getGlobalPipes();
+                (0, chai_1.expect)(creator.getGlobalMetadata()).to.be.equal(expectedResult);
+            });
+        });
+        describe("otherwise", () => {
+            it("should merge static global with request/transient scoped pipes", () => {
+                const globalPipes = ["test"];
+                const instanceWrapper = new wrapper_1.InstanceWrapper();
+                const instance = "request-scoped";
+                const scopedPipeWrappers = [instanceWrapper];
+                sinon_1.default.stub(applicationConfig, "getGlobalPipes").callsFake(() => globalPipes);
+                sinon_1.default.stub(applicationConfig, "getGlobalRequestPipes").callsFake(() => scopedPipeWrappers);
+                sinon_1.default.stub(instanceWrapper, "getInstanceByContextId").callsFake(() => ({ instance }));
+                (0, chai_1.expect)(creator.getGlobalMetadata({ id: 3 })).to.contains(instance, ...globalPipes);
+            });
+        });
+    });
+});

package/test/scanner.spec.d.ts

@@ -0,0 +1 @@
+export {};