@opra/nestjs 1.10.0 → 1.11.1

package/esm/http/services/opra-middleware.js

@@ -1,30 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { Injectable } from '@nestjs/common';
-import { HttpContext, HttpIncoming, HttpOutgoing } from '@opra/http';
-import { OpraHttpNestjsAdapter } from '../opra-http-nestjs-adapter.js';
-let OpraMiddleware = class OpraMiddleware {
-    constructor(opraAdapter) {
-        this.opraAdapter = opraAdapter;
-    }
-    use(req, res, next) {
-        const request = HttpIncoming.from(req);
-        const response = HttpOutgoing.from(res);
-        /** Create the HttpContext */
-        const context = new HttpContext({
-            adapter: this.opraAdapter,
-            platform: req.route ? 'express' : 'fastify',
-            request,
-            response,
-        });
-        req.opraContext = context;
-        this.opraAdapter
-            .emitAsync('createContext', context)
-            .then(() => next())
-            .catch(next);
-    }
-};
-OpraMiddleware = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [OpraHttpNestjsAdapter])
-], OpraMiddleware);
-export { OpraMiddleware };

package/esm/kafka/opra-kafka-core.module.js

@@ -1,134 +0,0 @@
-var OpraKafkaCoreModule_1;
-import { __decorate, __metadata, __param } from "tslib";
-import { isConstructor } from '@jsopen/objects';
-import { Global, Inject, Logger, Module, } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import { ApiDocumentFactory } from '@opra/common';
-import { KafkaAdapter } from '@opra/kafka';
-import { OPRA_KAFKA_MODULE_CONFIG } from '../constants.js';
-import { RpcControllerFactory } from '../helpers/rpc-controller-factory.service.js';
-const opraKafkaNestjsAdapterToken = Symbol('OpraKafkaNestjsAdapter');
-let OpraKafkaCoreModule = OpraKafkaCoreModule_1 = class OpraKafkaCoreModule {
-    constructor(controllerFactory, adapter, config) {
-        this.controllerFactory = controllerFactory;
-        this.adapter = adapter;
-        this.config = config;
-    }
-    static forRoot(moduleOptions) {
-        return this._getDynamicModule({
-            ...moduleOptions,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                {
-                    provide: OPRA_KAFKA_MODULE_CONFIG,
-                    useValue: {
-                        ...moduleOptions,
-                        logger: moduleOptions.logger || new Logger(moduleOptions.name),
-                    },
-                },
-            ],
-        });
-    }
-    static forRootAsync(moduleOptions) {
-        if (!moduleOptions.useFactory)
-            throw new Error('Invalid configuration. Must provide "useFactory"');
-        return this._getDynamicModule({
-            ...moduleOptions,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                {
-                    provide: OPRA_KAFKA_MODULE_CONFIG,
-                    inject: moduleOptions.inject,
-                    useFactory: async (...args) => {
-                        const result = await moduleOptions.useFactory(...args);
-                        result.logger = result.logger || new Logger(result.name);
-                        return result;
-                    },
-                },
-            ],
-        });
-    }
-    static _getDynamicModule(moduleOptions) {
-        const token = moduleOptions.id || KafkaAdapter;
-        const adapterProvider = {
-            provide: token,
-            inject: [RpcControllerFactory, ModuleRef, OPRA_KAFKA_MODULE_CONFIG],
-            useFactory: async (controllerFactory, moduleRef, config) => {
-                const controllers = controllerFactory
-                    .exploreControllers()
-                    .map(x => x.wrapper.instance.constructor);
-                const document = await ApiDocumentFactory.createDocument({
-                    info: config.info,
-                    types: config.types,
-                    references: config.references,
-                    api: {
-                        name: config.name,
-                        description: config.description,
-                        transport: 'rpc',
-                        platform: KafkaAdapter.PlatformName,
-                        controllers,
-                    },
-                });
-                const interceptors = moduleOptions.interceptors
-                    ? moduleOptions.interceptors.map(x => {
-                        if (isConstructor(x)) {
-                            return async (ctx, next) => {
-                                const interceptor = moduleRef.get(x);
-                                if (typeof interceptor.intercept === 'function')
-                                    return interceptor.intercept(ctx, next);
-                            };
-                        }
-                        return x;
-                    })
-                    : undefined;
-                return new KafkaAdapter(document, { ...config, interceptors });
-            },
-        };
-        return {
-            global: moduleOptions.global,
-            module: OpraKafkaCoreModule_1,
-            controllers: moduleOptions.controllers,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                RpcControllerFactory,
-                adapterProvider,
-                {
-                    provide: opraKafkaNestjsAdapterToken,
-                    useExisting: token,
-                },
-            ],
-            imports: [...(moduleOptions?.imports || [])],
-            exports: [...(moduleOptions?.exports || []), adapterProvider],
-        };
-    }
-    onModuleInit() {
-        /** NestJS initialize controller instances on init stage.
-         * So we should update instance properties */
-        const rpcApi = this.adapter.document.rpcApi;
-        const controllers = Array.from(rpcApi.controllers.values());
-        for (const { wrapper } of this.controllerFactory
-            .exploreControllers()
-            .values()) {
-            const ctor = wrapper.instance.constructor;
-            const controller = controllers.find(x => x.ctor === ctor);
-            if (controller) {
-                controller.instance = wrapper.instance;
-            }
-        }
-    }
-    async onApplicationBootstrap() {
-        await this.adapter.start();
-    }
-    async onApplicationShutdown() {
-        await this.adapter.close();
-    }
-};
-OpraKafkaCoreModule = OpraKafkaCoreModule_1 = __decorate([
-    Module({}),
-    Global(),
-    __param(1, Inject(opraKafkaNestjsAdapterToken)),
-    __param(2, Inject(OPRA_KAFKA_MODULE_CONFIG)),
-    __metadata("design:paramtypes", [RpcControllerFactory,
-        KafkaAdapter, Object])
-], OpraKafkaCoreModule);
-export { OpraKafkaCoreModule };

package/esm/kafka/opra-kafka.module.js

@@ -1,30 +0,0 @@
-var OpraKafkaModule_1;
-import { __decorate } from "tslib";
-import { Module } from '@nestjs/common';
-import { OpraKafkaCoreModule } from './opra-kafka-core.module.js';
-let OpraKafkaModule = OpraKafkaModule_1 = class OpraKafkaModule {
-    /**
-     *
-     * @param options
-     */
-    static forRoot(options) {
-        return {
-            module: OpraKafkaModule_1,
-            imports: [OpraKafkaCoreModule.forRoot(options)],
-        };
-    }
-    /**
-     *
-     * @param options
-     */
-    static forRootAsync(options) {
-        return {
-            module: OpraKafkaModule_1,
-            imports: [OpraKafkaCoreModule.forRootAsync(options)],
-        };
-    }
-};
-OpraKafkaModule = OpraKafkaModule_1 = __decorate([
-    Module({})
-], OpraKafkaModule);
-export { OpraKafkaModule };

package/esm/rabbitmq/opra-rabbitmq-core.module.js

@@ -1,134 +0,0 @@
-var OpraRabbitmqCoreModule_1;
-import { __decorate, __metadata, __param } from "tslib";
-import { isConstructor } from '@jsopen/objects';
-import { Global, Inject, Logger, Module, } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import { ApiDocumentFactory } from '@opra/common';
-import { RabbitmqAdapter } from '@opra/rabbitmq';
-import { OPRA_RMQ_MODULE_CONFIG } from '../constants.js';
-import { RpcControllerFactory } from '../helpers/rpc-controller-factory.service.js';
-const opraRabbitmqNestjsAdapterToken = Symbol('OpraRabbitmqNestjsAdapter');
-let OpraRabbitmqCoreModule = OpraRabbitmqCoreModule_1 = class OpraRabbitmqCoreModule {
-    constructor(controllerFactory, adapter, config) {
-        this.controllerFactory = controllerFactory;
-        this.adapter = adapter;
-        this.config = config;
-    }
-    static forRoot(moduleOptions) {
-        return this._getDynamicModule({
-            ...moduleOptions,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                {
-                    provide: OPRA_RMQ_MODULE_CONFIG,
-                    useValue: {
-                        ...moduleOptions,
-                        logger: moduleOptions.logger || new Logger(moduleOptions.name),
-                    },
-                },
-            ],
-        });
-    }
-    static forRootAsync(moduleOptions) {
-        if (!moduleOptions.useFactory)
-            throw new Error('Invalid configuration. Must provide "useFactory"');
-        return this._getDynamicModule({
-            ...moduleOptions,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                {
-                    provide: OPRA_RMQ_MODULE_CONFIG,
-                    inject: moduleOptions.inject,
-                    useFactory: async (...args) => {
-                        const result = await moduleOptions.useFactory(...args);
-                        result.logger = result.logger || new Logger(result.name);
-                        return result;
-                    },
-                },
-            ],
-        });
-    }
-    static _getDynamicModule(moduleOptions) {
-        const token = moduleOptions.id || RabbitmqAdapter;
-        const adapterProvider = {
-            provide: token,
-            inject: [RpcControllerFactory, ModuleRef, OPRA_RMQ_MODULE_CONFIG],
-            useFactory: async (controllerFactory, moduleRef, config) => {
-                const controllers = controllerFactory
-                    .exploreControllers()
-                    .map(x => x.wrapper.instance.constructor);
-                const document = await ApiDocumentFactory.createDocument({
-                    info: config.info,
-                    types: config.types,
-                    references: config.references,
-                    api: {
-                        name: config.name,
-                        description: config.description,
-                        transport: 'rpc',
-                        platform: RabbitmqAdapter.PlatformName,
-                        controllers,
-                    },
-                });
-                const interceptors = moduleOptions.interceptors
-                    ? moduleOptions.interceptors.map(x => {
-                        if (isConstructor(x)) {
-                            return async (ctx, next) => {
-                                const interceptor = moduleRef.get(x);
-                                if (typeof interceptor.intercept === 'function')
-                                    return interceptor.intercept(ctx, next);
-                            };
-                        }
-                        return x;
-                    })
-                    : undefined;
-                return new RabbitmqAdapter(document, { ...config, interceptors });
-            },
-        };
-        return {
-            global: moduleOptions.global,
-            module: OpraRabbitmqCoreModule_1,
-            controllers: moduleOptions.controllers,
-            providers: [
-                ...(moduleOptions?.providers || []),
-                RpcControllerFactory,
-                adapterProvider,
-                {
-                    provide: opraRabbitmqNestjsAdapterToken,
-                    useExisting: token,
-                },
-            ],
-            imports: [...(moduleOptions?.imports || [])],
-            exports: [...(moduleOptions?.exports || []), adapterProvider],
-        };
-    }
-    onModuleInit() {
-        /** NestJS initialize controller instances on init stage.
-         * So we should update instance properties */
-        const rpcApi = this.adapter.document.rpcApi;
-        const controllers = Array.from(rpcApi.controllers.values());
-        for (const { wrapper } of this.controllerFactory
-            .exploreControllers()
-            .values()) {
-            const ctor = wrapper.instance.constructor;
-            const controller = controllers.find(x => x.ctor === ctor);
-            if (controller) {
-                controller.instance = wrapper.instance;
-            }
-        }
-    }
-    async onApplicationBootstrap() {
-        await this.adapter.start();
-    }
-    async onApplicationShutdown() {
-        await this.adapter.close();
-    }
-};
-OpraRabbitmqCoreModule = OpraRabbitmqCoreModule_1 = __decorate([
-    Module({}),
-    Global(),
-    __param(1, Inject(opraRabbitmqNestjsAdapterToken)),
-    __param(2, Inject(OPRA_RMQ_MODULE_CONFIG)),
-    __metadata("design:paramtypes", [RpcControllerFactory,
-        RabbitmqAdapter, Object])
-], OpraRabbitmqCoreModule);
-export { OpraRabbitmqCoreModule };

package/esm/rabbitmq/opra-rabbitmq.module.js

@@ -1,30 +0,0 @@
-var OpraRabbitmqModule_1;
-import { __decorate } from "tslib";
-import { Module } from '@nestjs/common';
-import { OpraRabbitmqCoreModule } from './opra-rabbitmq-core.module.js';
-let OpraRabbitmqModule = OpraRabbitmqModule_1 = class OpraRabbitmqModule {
-    /**
-     *
-     * @param options
-     */
-    static forRoot(options) {
-        return {
-            module: OpraRabbitmqModule_1,
-            imports: [OpraRabbitmqCoreModule.forRoot(options)],
-        };
-    }
-    /**
-     *
-     * @param options
-     */
-    static forRootAsync(options) {
-        return {
-            module: OpraRabbitmqModule_1,
-            imports: [OpraRabbitmqCoreModule.forRootAsync(options)],
-        };
-    }
-};
-OpraRabbitmqModule = OpraRabbitmqModule_1 = __decorate([
-    Module({})
-], OpraRabbitmqModule);
-export { OpraRabbitmqModule };

package/types/http/opra-http-core.module.d.ts

@@ -1,12 +0,0 @@
-import { type DynamicModule, type MiddlewareConsumer, type NestModule, type OnModuleDestroy } from '@nestjs/common';
-import type { OpraHttpModule } from './opra-http.module.js';
-import { OpraHttpNestjsAdapter } from './opra-http-nestjs-adapter.js';
-export declare class OpraHttpCoreModule implements OnModuleDestroy, NestModule {
-    protected opraAdapter: OpraHttpNestjsAdapter;
-    constructor(opraAdapter: OpraHttpNestjsAdapter);
-    configure(consumer: MiddlewareConsumer): void;
-    static forRoot(moduleOptions: OpraHttpModule.ModuleOptions): DynamicModule;
-    static forRootAsync(moduleOptions: OpraHttpModule.AsyncModuleOptions): DynamicModule;
-    protected static _getDynamicModule(moduleOptions: OpraHttpModule.ModuleOptions | OpraHttpModule.AsyncModuleOptions): DynamicModule;
-    onModuleDestroy(): Promise<void>;
-}

package/types/http/opra-http-nestjs-adapter.d.ts

@@ -1,12 +0,0 @@
-import { type Type } from '@nestjs/common';
-import { HttpAdapter } from '@opra/http';
-export declare class OpraHttpNestjsAdapter extends HttpAdapter {
-    readonly nestControllers: Type[];
-    constructor(options: HttpAdapter.Options & {
-        schemaIsPublic?: boolean;
-        controllers?: Type[];
-    });
-    close(): Promise<void>;
-    protected _addRootController(isPublic?: boolean): void;
-    protected _addToNestControllers(sourceClass: Type, currentPath: string, parentTree: Type[]): void;
-}

package/types/http/opra-http.module.d.ts

@@ -1,36 +0,0 @@
-import { type DynamicModule, Logger, type Type } from '@nestjs/common';
-import { ApiDocumentFactory } from '@opra/common';
-import { HttpAdapter } from '@opra/http';
-export declare namespace OpraHttpModule {
-    export interface ModuleOptions extends BaseModuleOptions, ApiConfig {
-    }
-    export interface AsyncModuleOptions extends BaseModuleOptions {
-        inject?: any[];
-        useFactory?: (...args: any[]) => Promise<ApiConfig> | ApiConfig;
-    }
-    interface BaseModuleOptions extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers' | 'global'> {
-        token?: any;
-        basePath?: string;
-        schemaIsPublic?: boolean;
-        interceptors?: (HttpAdapter.InterceptorFunction | HttpAdapter.IHttpInterceptor | Type<HttpAdapter.IHttpInterceptor>)[];
-    }
-    export interface ApiConfig extends Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'> {
-        name: string;
-        description?: string;
-        scope?: string;
-        logger?: Logger;
-    }
-    export {};
-}
-export declare class OpraHttpModule {
-    /**
-     *
-     * @param init
-     */
-    static forRoot(init: OpraHttpModule.ModuleOptions): DynamicModule;
-    /**
-     *
-     * @param options
-     */
-    static forRootAsync(options: OpraHttpModule.AsyncModuleOptions): DynamicModule;
-}

package/types/http/services/opra-exception-filter.d.ts

@@ -1,7 +0,0 @@
-import { type ArgumentsHost } from '@nestjs/common';
-import { BaseExceptionFilter, ModuleRef } from '@nestjs/core';
-export declare class OpraExceptionFilter extends BaseExceptionFilter {
-    private moduleRef;
-    constructor(moduleRef: ModuleRef);
-    catch(exception: any, host: ArgumentsHost): Promise<void> | undefined;
-}

package/types/http/services/opra-middleware.d.ts

@@ -1,8 +0,0 @@
-import { type NestMiddleware } from '@nestjs/common';
-import type { NextFunction, Request, Response } from 'express';
-import { OpraHttpNestjsAdapter } from '../opra-http-nestjs-adapter.js';
-export declare class OpraMiddleware implements NestMiddleware {
-    protected opraAdapter: OpraHttpNestjsAdapter;
-    constructor(opraAdapter: OpraHttpNestjsAdapter);
-    use(req: Request, res: Response, next: NextFunction): void;
-}

package/types/kafka/opra-kafka-core.module.d.ts

@@ -1,16 +0,0 @@
-import { type DynamicModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleInit } from '@nestjs/common';
-import { KafkaAdapter } from '@opra/kafka';
-import { RpcControllerFactory } from '../helpers/rpc-controller-factory.service.js';
-import type { OpraKafkaModule } from './opra-kafka.module.js';
-export declare class OpraKafkaCoreModule implements OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown {
-    private controllerFactory;
-    protected adapter: KafkaAdapter;
-    protected config: OpraKafkaModule.ApiConfig;
-    constructor(controllerFactory: RpcControllerFactory, adapter: KafkaAdapter, config: OpraKafkaModule.ApiConfig);
-    static forRoot(moduleOptions: OpraKafkaModule.ModuleOptions): DynamicModule;
-    static forRootAsync(moduleOptions: OpraKafkaModule.AsyncModuleOptions): DynamicModule;
-    protected static _getDynamicModule(moduleOptions: OpraKafkaModule.ModuleOptions | OpraKafkaModule.AsyncModuleOptions): DynamicModule;
-    onModuleInit(): any;
-    onApplicationBootstrap(): Promise<void>;
-    onApplicationShutdown(): Promise<void>;
-}

package/types/kafka/opra-kafka.module.d.ts

@@ -1,34 +0,0 @@
-import { type DynamicModule, Logger, type Type } from '@nestjs/common';
-import { ApiDocumentFactory } from '@opra/common';
-import type { KafkaAdapter } from '@opra/kafka';
-export declare namespace OpraKafkaModule {
-    export interface ModuleOptions extends BaseModuleOptions, ApiConfig {
-    }
-    export interface AsyncModuleOptions extends BaseModuleOptions {
-        inject?: any[];
-        useFactory?: (...args: any[]) => Promise<ApiConfig> | ApiConfig;
-    }
-    interface BaseModuleOptions extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers' | 'global'> {
-        id?: any;
-        interceptors?: (KafkaAdapter.InterceptorFunction | KafkaAdapter.IKafkaInterceptor | Type<KafkaAdapter.IKafkaInterceptor>)[];
-    }
-    export interface ApiConfig extends Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'>, Pick<KafkaAdapter.Config, 'client' | 'consumers' | 'logExtra' | 'defaults'> {
-        name: string;
-        description?: string;
-        scope?: string;
-        logger?: Logger;
-    }
-    export {};
-}
-export declare class OpraKafkaModule {
-    /**
-     *
-     * @param options
-     */
-    static forRoot(options: OpraKafkaModule.ModuleOptions): DynamicModule;
-    /**
-     *
-     * @param options
-     */
-    static forRootAsync(options: OpraKafkaModule.AsyncModuleOptions): DynamicModule;
-}

package/types/rabbitmq/opra-rabbitmq-core.module.d.ts

@@ -1,16 +0,0 @@
-import { type DynamicModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleInit } from '@nestjs/common';
-import { RabbitmqAdapter } from '@opra/rabbitmq';
-import { RpcControllerFactory } from '../helpers/rpc-controller-factory.service.js';
-import type { OpraRabbitmqModule } from './opra-rabbitmq.module.js';
-export declare class OpraRabbitmqCoreModule implements OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown {
-    private controllerFactory;
-    protected adapter: RabbitmqAdapter;
-    protected config: OpraRabbitmqModule.ApiConfig;
-    constructor(controllerFactory: RpcControllerFactory, adapter: RabbitmqAdapter, config: OpraRabbitmqModule.ApiConfig);
-    static forRoot(moduleOptions: OpraRabbitmqModule.ModuleOptions): DynamicModule;
-    static forRootAsync(moduleOptions: OpraRabbitmqModule.AsyncModuleOptions): DynamicModule;
-    protected static _getDynamicModule(moduleOptions: OpraRabbitmqModule.ModuleOptions | OpraRabbitmqModule.AsyncModuleOptions): DynamicModule;
-    onModuleInit(): any;
-    onApplicationBootstrap(): Promise<void>;
-    onApplicationShutdown(): Promise<void>;
-}

package/types/rabbitmq/opra-rabbitmq.module.d.ts

@@ -1,38 +0,0 @@
-import { type DynamicModule, Logger, type Type } from '@nestjs/common';
-import { ApiDocumentFactory } from '@opra/common';
-import type { RabbitmqAdapter } from '@opra/rabbitmq';
-export declare namespace OpraRabbitmqModule {
-    export interface ModuleOptions extends BaseModuleOptions, ApiConfig {
-    }
-    export interface AsyncModuleOptions extends BaseModuleOptions {
-        inject?: any[];
-        useFactory?: (...args: any[]) => Promise<ApiConfig> | ApiConfig;
-    }
-    interface BaseModuleOptions extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers' | 'global'> {
-        id?: any;
-        interceptors?: (RabbitmqAdapter.InterceptorFunction | RabbitmqAdapter.IRabbitmqInterceptor | Type<RabbitmqAdapter.IRabbitmqInterceptor>)[];
-    }
-    export interface ApiConfig extends Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'> {
-        connection: RabbitmqAdapter.Config['connection'];
-        queues?: RabbitmqAdapter.Config['queues'];
-        logExtra?: RabbitmqAdapter.Config['logExtra'];
-        defaults?: RabbitmqAdapter.Config['defaults'];
-        name: string;
-        description?: string;
-        scope?: string;
-        logger?: Logger;
-    }
-    export {};
-}
-export declare class OpraRabbitmqModule {
-    /**
-     *
-     * @param options
-     */
-    static forRoot(options: OpraRabbitmqModule.ModuleOptions): DynamicModule;
-    /**
-     *
-     * @param options
-     */
-    static forRootAsync(options: OpraRabbitmqModule.AsyncModuleOptions): DynamicModule;
-}