@flusys/nestjs-notification 7.0.2 → 8.0.0-beta.1

package/cjs/modules/notification.module.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "NotificationModule", {
-    enumerable: true,
-    get: function() {
-        return NotificationModule;
-    }
-});
-const _modules = require("@flusys/nestjs-shared/modules");
-const _interfaces = require("@flusys/nestjs-shared/interfaces");
-const _common = require("@nestjs/common");
-const _jwt = require("@nestjs/jwt");
-const _notificationconstants = require("../config/notification.constants");
-const _controllers = require("../controllers");
-const _adapters = require("../adapters");
-const _services = require("../services");
-const _gateways = require("../gateways");
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-const CONTROLLERS = [
-    _controllers.NotificationController
-];
-const EXPORTED_SERVICES = [
-    _services.NotificationConfigService,
-    _services.NotificationDataSourceProvider,
-    _services.NotificationService,
-    _services.NotificationHelperService
-];
-const ADAPTER_PROVIDER = {
-    provide: _interfaces.NOTIFICATION_ADAPTER,
-    useClass: _adapters.NotificationAdapter
-};
-let NotificationModule = class NotificationModule {
-    static forRoot(options) {
-        return {
-            module: NotificationModule,
-            global: options.global ?? false,
-            imports: [
-                _modules.CacheModule,
-                _modules.UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: [
-                ...this.buildProviders(options),
-                _jwt.JwtService,
-                _gateways.NotificationGateway,
-                _adapters.NotificationAdapter,
-                ADAPTER_PROVIDER
-            ],
-            exports: [
-                ...EXPORTED_SERVICES,
-                _gateways.NotificationGateway,
-                _interfaces.NOTIFICATION_ADAPTER
-            ]
-        };
-    }
-    static forRootAsync(options) {
-        return {
-            module: NotificationModule,
-            global: options.global ?? false,
-            imports: [
-                ...options.imports || [],
-                _modules.CacheModule,
-                _modules.UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: [
-                ...this.createAsyncProviders(options),
-                ...this.buildProviders(),
-                _jwt.JwtService,
-                _gateways.NotificationGateway,
-                _adapters.NotificationAdapter,
-                ADAPTER_PROVIDER
-            ],
-            exports: [
-                ...EXPORTED_SERVICES,
-                _gateways.NotificationGateway,
-                _interfaces.NOTIFICATION_ADAPTER
-            ]
-        };
-    }
-    static buildProviders(options) {
-        const providers = [
-            ...EXPORTED_SERVICES
-        ];
-        if (options) {
-            providers.unshift({
-                provide: _notificationconstants.NOTIFICATION_MODULE_OPTIONS,
-                useValue: options
-            });
-        }
-        providers.push((0, _modules.createModuleEventsProvider)('notification', _notificationconstants.NOTIFICATION_MODULE_OPTIONS));
-        return providers;
-    }
-    static createAsyncProviders(options) {
-        if (options.useFactory) {
-            return [
-                {
-                    provide: _notificationconstants.NOTIFICATION_MODULE_OPTIONS,
-                    useFactory: async (...args)=>({
-                            ...options,
-                            config: await options.useFactory(...args)
-                        }),
-                    inject: options.inject || []
-                }
-            ];
-        }
-        const factoryClass = options.useClass || options.useExisting;
-        if (!factoryClass) return [];
-        const providers = [
-            {
-                provide: _notificationconstants.NOTIFICATION_MODULE_OPTIONS,
-                useFactory: async (factory)=>({
-                        ...options,
-                        config: await factory.createNotificationOptions()
-                    }),
-                inject: [
-                    factoryClass
-                ]
-            }
-        ];
-        if (options.useClass) {
-            providers.push({
-                provide: options.useClass,
-                useClass: options.useClass
-            });
-        }
-        return providers;
-    }
-};
-NotificationModule = _ts_decorate([
-    (0, _common.Module)({})
-], NotificationModule);

package/cjs/modules/notification.module.spec.js

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _interfaces = require("@flusys/nestjs-shared/interfaces");
-const _notificationmodule = require("./notification.module");
-const _notificationconstants = require("../config/notification.constants");
-const _controllers = require("../controllers");
-const _gateways = require("../gateways");
-const _adapters = require("../adapters");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function providerTokens(providers) {
-    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
-}
-describe('NotificationModule', ()=>{
-    describe('forRoot', ()=>{
-        it('should default to a non-global module with the notification controller registered', ()=>{
-            const dynamicModule = _notificationmodule.NotificationModule.forRoot({});
-            expect(dynamicModule.module).toBe(_notificationmodule.NotificationModule);
-            expect(dynamicModule.global).toBe(false);
-            expect(dynamicModule.controllers).toEqual([
-                _controllers.NotificationController
-            ]);
-        });
-        it('should respect global: true', ()=>{
-            expect(_notificationmodule.NotificationModule.forRoot({
-                global: true
-            }).global).toBe(true);
-        });
-        it('should register no controllers when includeController is false', ()=>{
-            expect(_notificationmodule.NotificationModule.forRoot({
-                includeController: false
-            }).controllers).toEqual([]);
-        });
-        it('should register the NOTIFICATION_ADAPTER provider backed by NotificationAdapter', ()=>{
-            const dynamicModule = _notificationmodule.NotificationModule.forRoot({});
-            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === _interfaces.NOTIFICATION_ADAPTER);
-            expect(adapterProvider.useClass).toBe(_adapters.NotificationAdapter);
-            expect(providerTokens(dynamicModule.providers)).toContain(_gateways.NotificationGateway);
-        });
-        it('should export NotificationGateway and NOTIFICATION_ADAPTER alongside the base services', ()=>{
-            const dynamicModule = _notificationmodule.NotificationModule.forRoot({});
-            expect(dynamicModule.exports).toEqual(expect.arrayContaining([
-                _gateways.NotificationGateway,
-                _interfaces.NOTIFICATION_ADAPTER
-            ]));
-        });
-        it('should register a NOTIFICATION_MODULE_OPTIONS provider carrying the given options', ()=>{
-            const options = {
-                bootstrapAppConfig: {
-                    enableCompanyFeature: true
-                }
-            };
-            const dynamicModule = _notificationmodule.NotificationModule.forRoot(options);
-            const provider = dynamicModule.providers.find((p)=>p.provide === _notificationconstants.NOTIFICATION_MODULE_OPTIONS);
-            expect(provider.useValue).toBe(options);
-        });
-    });
-    describe('forRootAsync', ()=>{
-        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
-            let FakeImportedModule = class FakeImportedModule {
-            };
-            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
-                imports: [
-                    FakeImportedModule
-                ]
-            });
-            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
-                FakeImportedModule
-            ]));
-        });
-        it('should still wire the adapter/gateway providers when using async registration', ()=>{
-            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
-                useFactory: jest.fn()
-            });
-            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === _interfaces.NOTIFICATION_ADAPTER);
-            expect(adapterProvider.useClass).toBe(_adapters.NotificationAdapter);
-        });
-        it('useFactory: builds a NOTIFICATION_MODULE_OPTIONS provider merging resolved config', async ()=>{
-            const useFactory = jest.fn().mockResolvedValue({
-                foo: 'bar'
-            });
-            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
-                useFactory,
-                inject: [
-                    'SOME_TOKEN'
-                ]
-            });
-            const provider = dynamicModule.providers.find((p)=>p.provide === _notificationconstants.NOTIFICATION_MODULE_OPTIONS);
-            expect(provider.inject).toEqual([
-                'SOME_TOKEN'
-            ]);
-            const resolved = await provider.useFactory('injected');
-            expect(useFactory).toHaveBeenCalledWith('injected');
-            expect(resolved.config).toEqual({
-                foo: 'bar'
-            });
-        });
-        it('useClass: registers both the class provider and an options provider calling createNotificationOptions()', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createNotificationOptions", jest.fn().mockResolvedValue({
-                        foo: 'from-class'
-                    }));
-                }
-            };
-            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
-                useClass: MyOptionsFactory
-            });
-            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
-            expect(classProvider.useClass).toBe(MyOptionsFactory);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _notificationconstants.NOTIFICATION_MODULE_OPTIONS);
-            const instance = new MyOptionsFactory();
-            const resolved = await optionsProvider.useFactory(instance);
-            expect(instance.createNotificationOptions).toHaveBeenCalled();
-            expect(resolved.config).toEqual({
-                foo: 'from-class'
-            });
-        });
-        it('useExisting: registers a single options provider without a duplicate class registration', ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createNotificationOptions", jest.fn());
-                }
-            };
-            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
-                useExisting: MyOptionsFactory
-            });
-            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _notificationconstants.NOTIFICATION_MODULE_OPTIONS);
-            expect(optionsProvider.inject).toEqual([
-                MyOptionsFactory
-            ]);
-        });
-        it('should register no NOTIFICATION_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
-            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({});
-            expect(providerTokens(dynamicModule.providers)).not.toContain(_notificationconstants.NOTIFICATION_MODULE_OPTIONS);
-        });
-    });
-});

package/cjs/services/index.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./notification-config.service"), exports);
-_export_star(require("./notification-datasource.provider"), exports);
-_export_star(require("./notification.service"), exports);
-_export_star(require("./notification-helper.service"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/services/notification-config.service.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "NotificationConfigService", {
-    enumerable: true,
-    get: function() {
-        return NotificationConfigService;
-    }
-});
-const _common = require("@nestjs/common");
-const _interfaces = require("../interfaces");
-const _notificationconstants = require("../config/notification.constants");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let NotificationConfigService = class NotificationConfigService {
-    isCompanyFeatureEnabled() {
-        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
-    }
-    getDatabaseMode() {
-        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
-    }
-    isMultiTenant() {
-        return this.getDatabaseMode() === 'multi-tenant';
-    }
-    getJwtSecret() {
-        return this.options.config?.jwtSecret;
-    }
-    getOptions() {
-        return this.options;
-    }
-    constructor(options){
-        _define_property(this, "options", void 0);
-        this.options = options;
-    }
-};
-NotificationConfigService = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_param(0, (0, _common.Inject)(_notificationconstants.NOTIFICATION_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _interfaces.NotificationModuleOptions === "undefined" ? Object : _interfaces.NotificationModuleOptions
-    ])
-], NotificationConfigService);

package/cjs/services/notification-config.service.spec.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _notificationconfigservice = require("./notification-config.service");
-function buildOptions(overrides = {}) {
-    return {
-        bootstrapAppConfig: {
-            databaseMode: 'single',
-            enableCompanyFeature: false
-        },
-        config: {},
-        ...overrides
-    };
-}
-describe('NotificationConfigService', ()=>{
-    describe('isCompanyFeatureEnabled', ()=>{
-        it('returns true when bootstrapAppConfig enables the company feature', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'single',
-                    enableCompanyFeature: true
-                }
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(true);
-        });
-        it('returns false when bootstrapAppConfig disables the company feature', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'single',
-                    enableCompanyFeature: false
-                }
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(false);
-        });
-        it('defaults to false when bootstrapAppConfig is missing', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                bootstrapAppConfig: undefined
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(false);
-        });
-    });
-    describe('getDatabaseMode', ()=>{
-        it('returns the configured database mode', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant',
-                    enableCompanyFeature: true
-                }
-            }));
-            expect(service.getDatabaseMode()).toBe('multi-tenant');
-        });
-        it('defaults to "single" when bootstrapAppConfig is missing', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                bootstrapAppConfig: undefined
-            }));
-            expect(service.getDatabaseMode()).toBe('single');
-        });
-    });
-    describe('isMultiTenant', ()=>{
-        it('returns true when database mode is multi-tenant', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant',
-                    enableCompanyFeature: true
-                }
-            }));
-            expect(service.isMultiTenant()).toBe(true);
-        });
-        it('returns false when database mode is single', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'single',
-                    enableCompanyFeature: false
-                }
-            }));
-            expect(service.isMultiTenant()).toBe(false);
-        });
-    });
-    describe('getJwtSecret', ()=>{
-        it('returns the configured jwt secret', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                config: {
-                    jwtSecret: 'top-secret'
-                }
-            }));
-            expect(service.getJwtSecret()).toBe('top-secret');
-        });
-        it('returns undefined when no jwt secret is configured', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                config: {}
-            }));
-            expect(service.getJwtSecret()).toBeUndefined();
-        });
-        it('returns undefined when config is missing entirely', ()=>{
-            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
-                config: undefined
-            }));
-            expect(service.getJwtSecret()).toBeUndefined();
-        });
-    });
-    describe('getOptions', ()=>{
-        it('returns the raw options object passed to the constructor', ()=>{
-            const options = buildOptions({
-                config: {
-                    jwtSecret: 'abc'
-                }
-            });
-            const service = new _notificationconfigservice.NotificationConfigService(options);
-            expect(service.getOptions()).toBe(options);
-        });
-    });
-});

package/cjs/services/notification-datasource.provider.js

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "NotificationDataSourceProvider", {
-    enumerable: true,
-    get: function() {
-        return NotificationDataSourceProvider;
-    }
-});
-const _modules = require("@flusys/nestjs-shared/modules");
-const _common = require("@nestjs/common");
-const _core = require("@nestjs/core");
-const _express = require("express");
-const _notificationconfigservice = require("./notification-config.service");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let NotificationDataSourceProvider = class NotificationDataSourceProvider extends _modules.MultiTenantDataSourceService {
-    static buildParentOptions(options) {
-        return {
-            bootstrapAppConfig: options.bootstrapAppConfig,
-            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
-            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
-            tenants: options.config?.tenants
-        };
-    }
-    getEnableCompanyFeatureForTenant(tenant) {
-        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
-    }
-    async getNotificationEntities(enableCompanyFeature) {
-        const enable = enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
-        const entities = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
-        return enable ? [
-            entities.NotificationWithCompany
-        ] : [
-            entities.Notification
-        ];
-    }
-    async createDataSourceFromConfig(config) {
-        const currentTenant = this.getCurrentTenant();
-        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
-        const entities = await this.getNotificationEntities(enableCompanyFeature);
-        return super.createDataSourceFromConfig(config, entities);
-    }
-    constructor(configService, request){
-        super(NotificationDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), this.configService = configService;
-    }
-};
-_define_property(NotificationDataSourceProvider, "tenantConnections", new Map());
-_define_property(NotificationDataSourceProvider, "singleDataSource", null);
-_define_property(NotificationDataSourceProvider, "tenantsRegistry", new Map());
-_define_property(NotificationDataSourceProvider, "initialized", false);
-_define_property(NotificationDataSourceProvider, "connectionLocks", new Map());
-_define_property(NotificationDataSourceProvider, "singleConnectionLock", null);
-NotificationDataSourceProvider = _ts_decorate([
-    (0, _common.Injectable)({
-        scope: _common.Scope.REQUEST
-    }),
-    _ts_param(0, (0, _common.Inject)(_notificationconfigservice.NotificationConfigService)),
-    _ts_param(1, (0, _common.Optional)()),
-    _ts_param(1, (0, _common.Inject)(_core.REQUEST)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _notificationconfigservice.NotificationConfigService === "undefined" ? Object : _notificationconfigservice.NotificationConfigService,
-        typeof _express.Request === "undefined" ? Object : _express.Request
-    ])
-], NotificationDataSourceProvider);