@opra/nestjs 0.0.5 → 0.0.8

package/cjs/factories/service.factory.js

@@ -16,8 +16,9 @@ const handler_paramtype_enum_js_1 = require("../enums/handler-paramtype.enum.js"
 const nest_explorer_js_1 = require("../services/nest-explorer.js");
 const function_utils_js_1 = require("../utils/function.utils.js");
 const params_factory_js_1 = require("./params.factory.js");
-const entityHandlers = ['search', 'create', 'read', 'update', 'updateMany', 'delete', 'deleteMany'];
 const noOpFunction = () => void 0;
+const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
+const METHOD_PATCHED = 'ServiceFactory.method-patched';
 let ServiceFactory = class ServiceFactory {
     paramsFactory = new params_factory_js_1.OpraParamsFactory();
     injector = new injector_1.Injector();
@@ -44,49 +45,85 @@ let ServiceFactory = class ServiceFactory {
             /* Wrap resolver functions */
             const prototype = Object.getPrototypeOf(instance);
             const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            if (schema_1.OpraSchema.isEntityResource(resourceDef)) {
-                for (const x of entityHandlers) {
-                    const fn = instance[x];
-                    if (typeof fn === 'function') {
-                        const methodName = fn.name || x;
-                        const callback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType);
-                        const newFn = instance[x] = (ctx) => {
-                            switch (ctx.type) {
-                                case 'http':
-                                    const http = ctx.switchToHttp();
-                                    return callback(http.getRequest().getInstance(), http.getResponse().getInstance(), noOpFunction, ctx);
-                                default:
-                                    throw new Error(`"${ctx.type}" context type is not implemented yet`);
-                            }
-                        };
-                        if (methodName && newFn.name !== methodName)
-                            Object.defineProperty(newFn, 'name', {
-                                configurable: false,
-                                writable: false,
-                                enumerable: true,
-                                value: methodName
-                            });
+            const methodsToWrap = schema_1.OpraSchema.isEntityResource(resourceDef) ? entityMethods : [];
+            for (const methodName of methodsToWrap) {
+                const fn = prototype[methodName];
+                if (typeof fn !== 'function')
+                    continue;
+                // We add special non-operational "prepare" method to prototype.
+                // This allows us to call Guards, Interceptors etc, before calling handler method
+                const oldPreFn = prototype['pre_' + methodName] = noOpFunction;
+                // Copy all metadata info
+                Reflect.getMetadataKeys(fn).forEach(k => {
+                    const metadata = Reflect.getMetadata(k, fn);
+                    Reflect.defineMetadata(k, metadata, oldPreFn);
+                });
+                const preCallback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType, true);
+                const newPreFn = instance['pre_' + methodName] = function (ctx) {
+                    switch (ctx.type) {
+                        case 'http':
+                            const http = ctx.switchToHttp();
+                            const req = http.getRequest().getInstance();
+                            const res = http.getResponse().getInstance();
+                            return preCallback(req, res, noOpFunction, ctx);
+                        default:
+                            throw new Error(`"${ctx.type}" context type is not implemented yet`);
                     }
+                };
+                Object.defineProperty(newPreFn, 'name', {
+                    configurable: false,
+                    writable: false,
+                    enumerable: true,
+                    value: 'pre_' + methodName
+                });
+                if (!Reflect.hasMetadata(METHOD_PATCHED, fn)) {
+                    Reflect.defineMetadata(METHOD_PATCHED, true, fn);
+                    const patchedFn = prototype[methodName] = function (req, res, next, ctx) {
+                        return fn.call(this, ctx);
+                    };
+                    Reflect.getMetadataKeys(fn).forEach(k => {
+                        const metadata = Reflect.getMetadata(k, fn);
+                        Reflect.defineMetadata(k, metadata, patchedFn);
+                    });
                 }
+                const callback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType, false);
+                const newFn = instance[methodName] = function (ctx) {
+                    switch (ctx.type) {
+                        case 'http':
+                            const http = ctx.switchToHttp();
+                            const req = http.getRequest().getInstance();
+                            const res = http.getResponse().getInstance();
+                            return callback(req, res, noOpFunction, ctx);
+                        default:
+                            throw new Error(`"${ctx.type}" context type is not implemented yet`);
+                    }
+                };
+                Object.defineProperty(newFn, 'name', {
+                    configurable: false,
+                    writable: false,
+                    enumerable: true,
+                    value: methodName
+                });
             }
         }
         return await core_2.OpraService.create(serviceArgs);
     }
-    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = lodash_1.default.identity, contextType) {
+    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = lodash_1.default.identity, contextType, forPre) {
         const paramsFactory = this.paramsFactory;
+        const options = !forPre ?
+            { guards: false, interceptors: false, filters: false } : undefined;
+        const fnName = forPre ? 'pre_' + methodName : methodName;
         if (isRequestScoped) {
             return async (...args) => {
                 const opraContext = paramsFactory.exchangeKeyForValue(handler_paramtype_enum_js_1.HandlerParamType.CONTEXT, undefined, args);
                 const contextId = this.getContextId(opraContext);
                 this.registerContextProvider(opraContext, contextId);
                 const contextInstance = await this.injector.loadPerContext(instance, moduleRef, moduleRef.providers, contextId);
-                const callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[methodName]), methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, undefined, // contextOptions
-                opraContext.type);
+                const callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[fnName]), methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.type);
                 return callback(...args);
             };
         }
-        return this.externalContextCreator.create(instance, prototype[methodName], methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, undefined, // contextOptions
-        contextType);
+        return this.externalContextCreator.create(instance, prototype[fnName], methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
     }
     // noinspection JSMethodCanBeStatic
     getContextId(gqlContext) {

package/cjs/opra-core.module.js

@@ -7,7 +7,6 @@ const crypto = tslib_1.__importStar(require("crypto"));
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const metadata_scanner_1 = require("@nestjs/core/metadata-scanner");
-const i18n_1 = require("@opra/i18n");
 const constants_js_1 = require("./constants.js");
 const service_factory_js_1 = require("./factories/service.factory.js");
 const nest_explorer_js_1 = require("./services/nest-explorer.js");
@@ -36,8 +35,7 @@ let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
                 {
                     provide: constants_js_1.OPRA_INITIALIZER,
                     useClass: service_loader_js_1.OpraServiceLoader
-                },
-                this.createI18nProvider()
+                }
             ],
             exports: [...(options.exports || [])]
         };
@@ -56,30 +54,10 @@ let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
                     provide: constants_js_1.OPRA_INITIALIZER,
                     useClass: service_loader_js_1.OpraServiceLoader
                 },
-                ...this.createAsyncProviders(asyncOptions),
-                this.createI18nProvider(),
+                ...this.createAsyncProviders(asyncOptions)
             ]
         };
     }
-    static createI18nProvider() {
-        return {
-            provide: i18n_1.I18n,
-            inject: [constants_js_1.OPRA_MODULE_OPTIONS],
-            useFactory: async (options) => {
-                const opts = options.i18n;
-                const initOptions = {
-                    lng: opts?.lng,
-                    fallbackLng: opts?.fallbackLng,
-                    defaultNS: opts?.defaultNS,
-                    resources: opts?.resources,
-                    resourceDirs: opts?.resourceDirs
-                };
-                const instance = i18n_1.I18n.createInstance();
-                await instance.init(initOptions);
-                return instance;
-            }
-        };
-    }
     static createAsyncProviders(asyncOptions) {
         if (asyncOptions.useExisting || asyncOptions.useFactory)
             return [this.createAsyncOptionsProvider(asyncOptions)];

package/cjs/services/service-loader.js

@@ -1,12 +1,10 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraServiceLoader = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const core_2 = require("@opra/core");
-const i18n_1 = require("@opra/i18n");
 const url_1 = require("@opra/url");
 const constants_js_1 = require("../constants.js");
 const service_factory_js_1 = require("../factories/service.factory.js");
@@ -17,7 +15,6 @@ class OpraServiceLoader {
     applicationConfig;
     opraFactory;
     opraModuleOptions;
-    i18n;
     async initialize(rootModule) {
         const httpAdapter = this.httpAdapterHost?.httpAdapter;
         const globalPrefix = this.applicationConfig.getGlobalPrefix();
@@ -35,7 +32,6 @@ class OpraServiceLoader {
                 this.logger.warn(`No resources found (${name})`);
                 return;
             }
-            // serviceConfiguration.i18n = this.i18n;
             if (platformName === 'express') {
                 this.adapter = await this.registerExpress(serviceHost, options);
                 // else if (platformName === 'fastify')
@@ -59,10 +55,7 @@ class OpraServiceLoader {
         if (!httpAdapter)
             return;
         const app = httpAdapter.getInstance();
-        return core_2.OpraExpressAdapter.init(app, service, {
-            i18n: this.i18n,
-            prefix: moduleOptions.prefix
-        });
+        return core_2.OpraExpressAdapter.init(app, service, moduleOptions);
     }
 }
 tslib_1.__decorate([
@@ -81,8 +74,4 @@ tslib_1.__decorate([
     (0, common_1.Inject)(constants_js_1.OPRA_MODULE_OPTIONS),
     tslib_1.__metadata("design:type", Object)
 ], OpraServiceLoader.prototype, "opraModuleOptions", void 0);
-tslib_1.__decorate([
-    (0, common_1.Inject)(),
-    tslib_1.__metadata("design:type", typeof (_a = typeof i18n_1.I18n !== "undefined" && i18n_1.I18n) === "function" ? _a : Object)
-], OpraServiceLoader.prototype, "i18n", void 0);
 exports.OpraServiceLoader = OpraServiceLoader;

package/esm/factories/service.factory.js

@@ -13,8 +13,9 @@ import { HandlerParamType } from '../enums/handler-paramtype.enum.js';
 import { NestExplorer } from '../services/nest-explorer.js';
 import { getNumberOfArguments } from '../utils/function.utils.js';
 import { OpraParamsFactory } from './params.factory.js';
-const entityHandlers = ['search', 'create', 'read', 'update', 'updateMany', 'delete', 'deleteMany'];
 const noOpFunction = () => void 0;
+const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
+const METHOD_PATCHED = 'ServiceFactory.method-patched';
 let ServiceFactory = class ServiceFactory {
     paramsFactory = new OpraParamsFactory();
     injector = new Injector();
@@ -41,49 +42,85 @@ let ServiceFactory = class ServiceFactory {
             /* Wrap resolver functions */
             const prototype = Object.getPrototypeOf(instance);
             const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            if (OpraSchema.isEntityResource(resourceDef)) {
-                for (const x of entityHandlers) {
-                    const fn = instance[x];
-                    if (typeof fn === 'function') {
-                        const methodName = fn.name || x;
-                        const callback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType);
-                        const newFn = instance[x] = (ctx) => {
-                            switch (ctx.type) {
-                                case 'http':
-                                    const http = ctx.switchToHttp();
-                                    return callback(http.getRequest().getInstance(), http.getResponse().getInstance(), noOpFunction, ctx);
-                                default:
-                                    throw new Error(`"${ctx.type}" context type is not implemented yet`);
-                            }
-                        };
-                        if (methodName && newFn.name !== methodName)
-                            Object.defineProperty(newFn, 'name', {
-                                configurable: false,
-                                writable: false,
-                                enumerable: true,
-                                value: methodName
-                            });
+            const methodsToWrap = OpraSchema.isEntityResource(resourceDef) ? entityMethods : [];
+            for (const methodName of methodsToWrap) {
+                const fn = prototype[methodName];
+                if (typeof fn !== 'function')
+                    continue;
+                // We add special non-operational "prepare" method to prototype.
+                // This allows us to call Guards, Interceptors etc, before calling handler method
+                const oldPreFn = prototype['pre_' + methodName] = noOpFunction;
+                // Copy all metadata info
+                Reflect.getMetadataKeys(fn).forEach(k => {
+                    const metadata = Reflect.getMetadata(k, fn);
+                    Reflect.defineMetadata(k, metadata, oldPreFn);
+                });
+                const preCallback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType, true);
+                const newPreFn = instance['pre_' + methodName] = function (ctx) {
+                    switch (ctx.type) {
+                        case 'http':
+                            const http = ctx.switchToHttp();
+                            const req = http.getRequest().getInstance();
+                            const res = http.getResponse().getInstance();
+                            return preCallback(req, res, noOpFunction, ctx);
+                        default:
+                            throw new Error(`"${ctx.type}" context type is not implemented yet`);
                     }
+                };
+                Object.defineProperty(newPreFn, 'name', {
+                    configurable: false,
+                    writable: false,
+                    enumerable: true,
+                    value: 'pre_' + methodName
+                });
+                if (!Reflect.hasMetadata(METHOD_PATCHED, fn)) {
+                    Reflect.defineMetadata(METHOD_PATCHED, true, fn);
+                    const patchedFn = prototype[methodName] = function (req, res, next, ctx) {
+                        return fn.call(this, ctx);
+                    };
+                    Reflect.getMetadataKeys(fn).forEach(k => {
+                        const metadata = Reflect.getMetadata(k, fn);
+                        Reflect.defineMetadata(k, metadata, patchedFn);
+                    });
                 }
+                const callback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType, false);
+                const newFn = instance[methodName] = function (ctx) {
+                    switch (ctx.type) {
+                        case 'http':
+                            const http = ctx.switchToHttp();
+                            const req = http.getRequest().getInstance();
+                            const res = http.getResponse().getInstance();
+                            return callback(req, res, noOpFunction, ctx);
+                        default:
+                            throw new Error(`"${ctx.type}" context type is not implemented yet`);
+                    }
+                };
+                Object.defineProperty(newFn, 'name', {
+                    configurable: false,
+                    writable: false,
+                    enumerable: true,
+                    value: methodName
+                });
             }
         }
         return await OpraService.create(serviceArgs);
     }
-    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = _.identity, contextType) {
+    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = _.identity, contextType, forPre) {
         const paramsFactory = this.paramsFactory;
+        const options = !forPre ?
+            { guards: false, interceptors: false, filters: false } : undefined;
+        const fnName = forPre ? 'pre_' + methodName : methodName;
         if (isRequestScoped) {
             return async (...args) => {
                 const opraContext = paramsFactory.exchangeKeyForValue(HandlerParamType.CONTEXT, undefined, args);
                 const contextId = this.getContextId(opraContext);
                 this.registerContextProvider(opraContext, contextId);
                 const contextInstance = await this.injector.loadPerContext(instance, moduleRef, moduleRef.providers, contextId);
-                const callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[methodName]), methodName, PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, undefined, // contextOptions
-                opraContext.type);
+                const callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[fnName]), methodName, PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.type);
                 return callback(...args);
             };
         }
-        return this.externalContextCreator.create(instance, prototype[methodName], methodName, PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, undefined, // contextOptions
-        contextType);
+        return this.externalContextCreator.create(instance, prototype[fnName], methodName, PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
     }
     // noinspection JSMethodCanBeStatic
     getContextId(gqlContext) {

package/esm/interfaces/opra-module-options.interface.d.ts

@@ -1,43 +1,13 @@
 import { ModuleMetadata, Type } from '@nestjs/common';
-import { FallbackLng, LanguageResource } from '@opra/i18n';
+import { OpraHttpAdapter } from '@opra/core';
 import { OpraSchema } from '@opra/schema';
-export declare type OpraModuleOptions = {
+export declare type OpraModuleOptions = OpraHttpAdapter.Options & {
     /**
      * @default true
      */
     useGlobalPrefix?: boolean;
-    prefix?: string;
     info?: OpraSchema.DocumentInfo;
-    i18n?: I18nInitOptions;
-    context?: object | ((request: any, platformName: string) => object | Promise<object>);
 };
-export interface I18nInitOptions {
-    /**
-     * Language to use
-     * @default undefined
-     */
-    lng?: string;
-    /**
-     * Language to use if translations in user language are not available.
-     * @default 'dev'
-     */
-    fallbackLng?: false | FallbackLng;
-    /**
-     * Default namespace used if not passed to translation function
-     * @default 'translation'
-     */
-    defaultNS?: string;
-    /**
-     * Resources to initialize with
-     * @default undefined
-     */
-    resources?: LanguageResource;
-    /**
-     * Resource directories to initialize with (if not using loading or not appending using addResourceBundle)
-     * @default undefined
-     */
-    resourceDirs?: string[];
-}
 export interface OpraModuleOptionsFactory {
     createOptions(): Promise<OpraModuleOptions> | OpraModuleOptions;
 }

package/esm/opra-core.module.d.ts

@@ -10,7 +10,6 @@ export declare class OpraCoreModule implements OnModuleInit, OnModuleDestroy {
     constructor(httpAdapterHost: HttpAdapterHost, modulesContainer: ModulesContainer, options: OpraModuleOptions, opraServiceLoader: OpraServiceLoader);
     static forRoot(options: OpraModuleOptions & Pick<DynamicModule, 'imports' | 'providers' | 'exports'>): DynamicModule;
     static forRootAsync(asyncOptions: OpraModuleAsyncOptions): DynamicModule;
-    private static createI18nProvider;
     private static createAsyncProviders;
     private static createAsyncOptionsProvider;
     onModuleInit(): Promise<void>;

package/esm/opra-core.module.js

@@ -4,7 +4,6 @@ import * as crypto from 'crypto';
 import { Inject, Module } from '@nestjs/common';
 import { HttpAdapterHost, ModulesContainer } from '@nestjs/core';
 import { MetadataScanner } from '@nestjs/core/metadata-scanner';
-import { I18n } from '@opra/i18n';
 import { OPRA_INITIALIZER, OPRA_MODULE_ID, OPRA_MODULE_OPTIONS } from './constants.js';
 import { ServiceFactory } from './factories/service.factory.js';
 import { NestExplorer } from './services/nest-explorer.js';
@@ -33,8 +32,7 @@ let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
                 {
                     provide: OPRA_INITIALIZER,
                     useClass: OpraServiceLoader
-                },
-                this.createI18nProvider()
+                }
             ],
             exports: [...(options.exports || [])]
         };
@@ -53,30 +51,10 @@ let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
                     provide: OPRA_INITIALIZER,
                     useClass: OpraServiceLoader
                 },
-                ...this.createAsyncProviders(asyncOptions),
-                this.createI18nProvider(),
+                ...this.createAsyncProviders(asyncOptions)
             ]
         };
     }
-    static createI18nProvider() {
-        return {
-            provide: I18n,
-            inject: [OPRA_MODULE_OPTIONS],
-            useFactory: async (options) => {
-                const opts = options.i18n;
-                const initOptions = {
-                    lng: opts?.lng,
-                    fallbackLng: opts?.fallbackLng,
-                    defaultNS: opts?.defaultNS,
-                    resources: opts?.resources,
-                    resourceDirs: opts?.resourceDirs
-                };
-                const instance = I18n.createInstance();
-                await instance.init(initOptions);
-                return instance;
-            }
-        };
-    }
     static createAsyncProviders(asyncOptions) {
         if (asyncOptions.useExisting || asyncOptions.useFactory)
             return [this.createAsyncOptionsProvider(asyncOptions)];

package/esm/services/service-loader.d.ts

@@ -1,7 +1,6 @@
 import { ApplicationConfig, HttpAdapterHost } from '@nestjs/core';
 import { Module } from '@nestjs/core/injector/module.js';
 import { OpraExpressAdapter, OpraService } from '@opra/core';
-import { I18n } from '@opra/i18n';
 import { ServiceFactory } from '../factories/service.factory.js';
 import { OpraModuleOptions } from '../interfaces/opra-module-options.interface.js';
 export declare class OpraServiceLoader {
@@ -11,7 +10,6 @@ export declare class OpraServiceLoader {
     protected readonly applicationConfig: ApplicationConfig;
     protected readonly opraFactory: ServiceFactory;
     protected readonly opraModuleOptions: OpraModuleOptions;
-    protected readonly i18n: I18n;
     initialize(rootModule: Module): Promise<void>;
     stop(): Promise<void>;
     protected registerExpress(service: OpraService, moduleOptions: OpraModuleOptions): Promise<OpraExpressAdapter | undefined>;

package/esm/services/service-loader.js

@@ -1,9 +1,7 @@
-var _a;
 import { __decorate, __metadata } from "tslib";
 import { Inject, Logger } from '@nestjs/common';
 import { ApplicationConfig, HttpAdapterHost } from '@nestjs/core';
 import { OpraExpressAdapter } from '@opra/core';
-import { I18n } from '@opra/i18n';
 import { joinPath, normalizePath } from '@opra/url';
 import { OPRA_MODULE_OPTIONS } from '../constants.js';
 import { ServiceFactory } from '../factories/service.factory.js';
@@ -14,7 +12,6 @@ export class OpraServiceLoader {
     applicationConfig;
     opraFactory;
     opraModuleOptions;
-    i18n;
     async initialize(rootModule) {
         const httpAdapter = this.httpAdapterHost?.httpAdapter;
         const globalPrefix = this.applicationConfig.getGlobalPrefix();
@@ -32,7 +29,6 @@ export class OpraServiceLoader {
                 this.logger.warn(`No resources found (${name})`);
                 return;
             }
-            // serviceConfiguration.i18n = this.i18n;
             if (platformName === 'express') {
                 this.adapter = await this.registerExpress(serviceHost, options);
                 // else if (platformName === 'fastify')
@@ -56,10 +52,7 @@ export class OpraServiceLoader {
         if (!httpAdapter)
             return;
         const app = httpAdapter.getInstance();
-        return OpraExpressAdapter.init(app, service, {
-            i18n: this.i18n,
-            prefix: moduleOptions.prefix
-        });
+        return OpraExpressAdapter.init(app, service, moduleOptions);
     }
 }
 __decorate([
@@ -78,7 +71,3 @@ __decorate([
     Inject(OPRA_MODULE_OPTIONS),
     __metadata("design:type", Object)
 ], OpraServiceLoader.prototype, "opraModuleOptions", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", typeof (_a = typeof I18n !== "undefined" && I18n) === "function" ? _a : Object)
-], OpraServiceLoader.prototype, "i18n", void 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/nestjs",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "description": "Opra NestJS module",
   "author": "Panates",
   "license": "MIT",
@@ -25,20 +25,20 @@
     "clean:cover": "rimraf ../../coverage/nestjs"
   },
   "dependencies": {
-    "@opra/url": "^0.x.x",
-    "@opra/i18n": "^0.x.x",
-    "@opra/core": "^0.x.x",
-    "@opra/schema": "^0.x.x",
+    "@opra/core": "^0.0.8",
+    "@opra/i18n": "^0.0.8",
+    "@opra/schema": "^0.0.8",
+    "@opra/url": "^0.0.8",
     "fast-tokenizer": "^1.1.0",
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13"
   },
   "peerDependencies": {
-    "@nestjs/common": "^8.x.x || ^9.x.x"
+    "@nestjs/common": "^9.0.11"
   },
   "devDependencies": {
-    "@nestjs/testing": "^9.0.11",
     "@nestjs/platform-express": "^9.0.11",
+    "@nestjs/testing": "^9.0.11",
     "@types/lodash": "^4.14.185",
     "filedirname": "^2.7.0",
     "supertest": "^6.2.4"