jr-common-micro 0.6.1-dev

package/dist/common/factory/module_metadata_factory.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpServer = exports.createTestingModule = exports.createGrpcMicro = exports.AppMicroModule = exports.moduleMetadataTestingFactory = exports.moduleMetadataFactory = exports.getDefaultCacheModule = exports.getTestingConfigModule = exports.getDefaultConfigModule = void 0;
+const tslib_1 = require("tslib");
+const cache_manager_1 = require("@nestjs/cache-manager");
+const config_1 = require("@nestjs/config");
+const core_1 = require("@nestjs/core");
+const jwt_1 = require("@nestjs/jwt");
+const testing_1 = require("@nestjs/testing");
+const path_1 = tslib_1.__importDefault(require("path"));
+const getDefaultConfigModule = (appConfig) => {
+    const result = config_1.ConfigModule.forRoot({
+        isGlobal: true,
+        load: appConfig,
+        envFilePath: ['.env'],
+        cache: true,
+        expandVariables: true,
+        validationOptions: {
+            allowUnknown: true,
+            abortEarly: true,
+        },
+    });
+    return result;
+};
+exports.getDefaultConfigModule = getDefaultConfigModule;
+const getTestingConfigModule = (appConfig) => config_1.ConfigModule.forRoot({
+    isGlobal: true,
+    load: appConfig,
+    envFilePath: ['.env.test'],
+    cache: true,
+    expandVariables: true,
+    validationOptions: {
+        allowUnknown: true,
+        abortEarly: true,
+    },
+});
+exports.getTestingConfigModule = getTestingConfigModule;
+const getDefaultCacheModule = () => cache_manager_1.CacheModule.registerAsync({
+    imports: [config_1.ConfigModule],
+    useFactory: async (configService) => {
+        const options = {};
+        options.ttl = 60;
+        options.isGlobal = true;
+        return options;
+    },
+    inject: [config_1.ConfigService],
+});
+exports.getDefaultCacheModule = getDefaultCacheModule;
+const moduleMetadataFactory = (inputMeta, appConfig) => {
+    const moduleMetadata = {
+        imports: [
+            (0, exports.getDefaultConfigModule)(appConfig),
+            (0, exports.getDefaultCacheModule)(),
+            ...(inputMeta.imports ?? []),
+        ],
+        controllers: [...(inputMeta.controllers ?? [])],
+        providers: [...(inputMeta.providers ?? [])],
+    };
+    return moduleMetadata;
+};
+exports.moduleMetadataFactory = moduleMetadataFactory;
+const moduleMetadataTestingFactory = (inputMeta, appConfig) => {
+    const moduleMetadata = {
+        imports: [
+            config_1.ConfigModule.forRoot({
+                isGlobal: true,
+                load: appConfig,
+                envFilePath: ['.env.test'],
+                cache: true,
+                expandVariables: true,
+                validationOptions: {
+                    allowUnknown: true,
+                    abortEarly: true,
+                },
+            }),
+            cache_manager_1.CacheModule.register({
+                isGlobal: true,
+            }),
+            ...(inputMeta.imports ?? []),
+        ],
+        controllers: [...(inputMeta.controllers ?? [])],
+        providers: [...(inputMeta.providers ?? [])],
+    };
+    return moduleMetadata;
+};
+exports.moduleMetadataTestingFactory = moduleMetadataTestingFactory;
+class AppMicroModule {
+}
+exports.AppMicroModule = AppMicroModule;
+const createGrpcMicro = async (moduleMetadata, config, grpcOptions) => {
+    const objectAppModule = {
+        module: AppMicroModule,
+        imports: [
+            config_1.ConfigModule.forRoot({
+                isGlobal: true,
+                validate: () => config,
+                envFilePath: [path_1.default.join(process.cwd(), '.env')],
+                cache: true,
+                expandVariables: true,
+                validationOptions: {
+                    allowUnknown: true,
+                    abortEarly: true,
+                },
+            }),
+            cache_manager_1.CacheModule.register({
+                isGlobal: true,
+                ttl: 60,
+            }),
+            ...(moduleMetadata.imports ?? []),
+        ],
+        controllers: [...(moduleMetadata.controllers ?? [])],
+        providers: [...(moduleMetadata.providers ?? [])],
+    };
+    const app = await core_1.NestFactory.createMicroservice(objectAppModule, {
+        abortOnError: true,
+        ...grpcOptions,
+    });
+    app.enableShutdownHooks();
+    return app;
+};
+exports.createGrpcMicro = createGrpcMicro;
+const createTestingModule = async (moduleMetadata, config) => {
+    const objectAppModule = {
+        module: AppMicroModule,
+        imports: [
+            config_1.ConfigModule.forRoot({
+                isGlobal: true,
+                validate: () => config,
+                envFilePath: [path_1.default.join(process.cwd(), '.env')],
+                cache: true,
+                expandVariables: true,
+                validationOptions: {
+                    allowUnknown: true,
+                    abortEarly: true,
+                },
+            }),
+            cache_manager_1.CacheModule.register({
+                isGlobal: true,
+                ttl: 60,
+            }),
+            ...(moduleMetadata.imports ?? []),
+        ],
+        controllers: [...(moduleMetadata.controllers ?? [])],
+        providers: [...(moduleMetadata.providers ?? [])],
+    };
+    const module = await testing_1.Test.createTestingModule(objectAppModule);
+    return await module.compile();
+};
+exports.createTestingModule = createTestingModule;
+const createHttpServer = async (moduleMetadata, config, fastifyAdapter) => {
+    const objectAppModule = {
+        module: AppMicroModule,
+        imports: [
+            config_1.ConfigModule.forRoot({
+                isGlobal: true,
+                validate: () => config,
+                envFilePath: [path_1.default.join(process.cwd(), '.env')],
+                cache: true,
+                expandVariables: true,
+                validationOptions: {
+                    allowUnknown: true,
+                    abortEarly: true,
+                },
+            }),
+            cache_manager_1.CacheModule.register({
+                isGlobal: true,
+                ttl: 60,
+            }),
+            jwt_1.JwtModule.register({
+                global: true,
+                secret: config.jwt_secret,
+                signOptions: { expiresIn: '3h' },
+            }),
+            ...(moduleMetadata.imports ?? []),
+        ],
+        controllers: [...(moduleMetadata.controllers ?? [])],
+        providers: [...(moduleMetadata.providers ?? [])],
+    };
+    const app = await core_1.NestFactory.create(objectAppModule, fastifyAdapter, {
+        forceCloseConnections: true,
+        abortOnError: true,
+    });
+    app.enableShutdownHooks();
+    return app;
+};
+exports.createHttpServer = createHttpServer;

package/dist/common/factory/redis_client_factory.d.ts

@@ -0,0 +1,5 @@
+import { FactoryProvider } from '@nestjs/common';
+import { Redis, RedisOptions } from 'ioredis';
+export type RedisClientCreatorFnType = () => Redis;
+export declare const REDIS_CLIENT_CREATOR = "REDIS_CLIENT_CREATOR";
+export declare const redisClientFactory: (config: RedisOptions) => FactoryProvider<RedisClientCreatorFnType>;

package/dist/common/factory/redis_client_factory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redisClientFactory = exports.REDIS_CLIENT_CREATOR = void 0;
+const ioredis_1 = require("ioredis");
+exports.REDIS_CLIENT_CREATOR = 'REDIS_CLIENT_CREATOR';
+const redisClientFactory = (config) => {
+    const obj = {
+        provide: exports.REDIS_CLIENT_CREATOR,
+        useFactory: () => {
+            return () => {
+                const redisInstance = new ioredis_1.Redis(config);
+                redisInstance.on('error', (e) => {
+                    throw new Error(`Redis connection failed: ${e}`);
+                });
+                return redisInstance;
+            };
+        },
+        inject: [],
+    };
+    return obj;
+};
+exports.redisClientFactory = redisClientFactory;

package/dist/common/factory/redis_cluster_factory.d.ts

@@ -0,0 +1,5 @@
+import { FactoryProvider } from '@nestjs/common';
+import { Cluster, ClusterNode, ClusterOptions } from 'ioredis';
+export type RedisClusterCreatorFnType = () => Cluster;
+export declare const REDIS_CLUSTER_CREATOR = "REDIS_CLUSTER_CREATOR";
+export declare const redisClusterFactory: (nodes: ClusterNode[], clusterOptions: ClusterOptions) => FactoryProvider<RedisClusterCreatorFnType>;

package/dist/common/factory/redis_cluster_factory.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redisClusterFactory = exports.REDIS_CLUSTER_CREATOR = void 0;
+const ioredis_1 = require("ioredis");
+exports.REDIS_CLUSTER_CREATOR = 'REDIS_CLUSTER_CREATOR';
+const redisClusterFactory = (nodes, clusterOptions) => {
+    return {
+        provide: exports.REDIS_CLUSTER_CREATOR,
+        useFactory: () => {
+            return () => {
+                const clusterInstance = new ioredis_1.Cluster(nodes, clusterOptions);
+                clusterInstance.on('error', (err) => {
+                    console.error(`KeyDB Cluster connection error: ${err.message}`);
+                });
+                clusterInstance.on('connect', () => {
+                    console.log('Connected to KeyDB Cluster');
+                });
+                return clusterInstance;
+            };
+        },
+        inject: [],
+    };
+};
+exports.redisClusterFactory = redisClusterFactory;
+;

package/dist/common/filters/grpc_exceptions_filter.d.ts

@@ -0,0 +1,6 @@
+import { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
+import { RpcException } from '@nestjs/microservices';
+import { EmptyResponse } from '../../proto/micro/v1/general_nest';
+export declare class GrpcExceptionFilter implements ExceptionFilter {
+    catch(exception: RpcException, host: ArgumentsHost): Promise<EmptyResponse>;
+}

package/dist/common/filters/grpc_exceptions_filter.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcExceptionFilter = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+let GrpcExceptionFilter = class GrpcExceptionFilter {
+    async catch(exception, host) {
+        const ctx = host.switchToRpc();
+        const data = ctx.getData();
+        const message = exception.message;
+        console.log('>>  GrpcExceptionFilter  exception', exception);
+        const errors = [message];
+        const inputs = {};
+        const result = {
+            status: {
+                code: 400,
+                error: { errors, inputs },
+            },
+        };
+        return result;
+    }
+};
+exports.GrpcExceptionFilter = GrpcExceptionFilter;
+exports.GrpcExceptionFilter = GrpcExceptionFilter = tslib_1.__decorate([
+    (0, common_1.Catch)()
+], GrpcExceptionFilter);

package/dist/common/filters/index.d.ts

@@ -0,0 +1 @@
+export * as grpc_exceptions_filter from './grpc_exceptions_filter';

package/dist/common/filters/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpc_exceptions_filter = void 0;
+const tslib_1 = require("tslib");
+exports.grpc_exceptions_filter = tslib_1.__importStar(require("./grpc_exceptions_filter"));

package/dist/common/guards/app_auth_guard.d.ts

@@ -0,0 +1,5 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+export declare class AppAuthGuard implements CanActivate {
+    private readonly logger;
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/common/guards/app_auth_guard.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppAuthGuard = void 0;
+const common_1 = require("@nestjs/common");
+const functions_1 = require("../../utils/functions");
+class AppAuthGuard {
+    logger = new common_1.Logger(AppAuthGuard.name);
+    async canActivate(context) {
+        const type = context.getType();
+        const prefix = 'Bearer ';
+        let header = '';
+        if (type === 'rpc') {
+            const metadata = context.getArgByIndex(1);
+            if (!metadata) {
+                return false;
+            }
+            header = metadata.get('Authorization')[0];
+        }
+        else if (type === 'http') {
+            const request = context.switchToHttp().getRequest();
+            header = request.headers.authorization + '';
+        }
+        if (!header || !header?.startsWith(prefix)) {
+            return false;
+        }
+        const user = (0, functions_1.getBearerUser)(header);
+        if (user) {
+            if (type === 'rpc') {
+                context.switchToRpc().getData().user = user;
+            }
+            else if (type === 'http') {
+                context.switchToHttp().getRequest().user = user;
+            }
+        }
+        return !!user;
+    }
+}
+exports.AppAuthGuard = AppAuthGuard;

package/dist/common/guards/app_internal_guard.d.ts

@@ -0,0 +1,5 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+export declare class AppInternalGuard implements CanActivate {
+    private readonly logger;
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/common/guards/app_internal_guard.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppInternalGuard = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const constants_1 = require("../../utils/constants");
+const functions_1 = require("../../utils/functions");
+class AppInternalGuard {
+    logger = new common_1.Logger(AppInternalGuard.name);
+    async canActivate(context) {
+        const type = context.getType();
+        const prefix = 'Bearer ';
+        let header = '';
+        if (type === 'rpc') {
+            const metadata = context.getArgByIndex(1);
+            if (!metadata) {
+                return false;
+            }
+            header = metadata.get(constants_1.X_INTERNAL_HASH)[0] + '';
+        }
+        else if (type === 'http') {
+            const request = context.switchToHttp().getRequest();
+            header = request.headers[constants_1.X_INTERNAL_HASH] + '';
+        }
+        if (!header || !header?.startsWith(prefix)) {
+            return false;
+        }
+        const token = header.slice(header.indexOf(' ') + 1);
+        const validHash = crypto_1.default
+            .createHash('md5')
+            .update((0, functions_1.getEnv)('JWT_SECRET'))
+            .digest('hex')
+            .toLowerCase();
+        return token === validHash;
+    }
+}
+exports.AppInternalGuard = AppInternalGuard;

package/dist/common/guards/app_role_guard.d.ts

@@ -0,0 +1,5 @@
+import { ExecutionContext, Logger } from '@nestjs/common';
+export declare const AppRoleGuard: (rawRole: string | string[]) => import("@nestjs/common").Type<{
+    readonly logger: Logger;
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}>;

package/dist/common/guards/app_role_guard.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppRoleGuard = void 0;
+const common_1 = require("@nestjs/common");
+const functions_1 = require("../../utils/functions");
+const AppRoleGuard = (rawRole) => {
+    class AppRoleGuardMixin {
+        logger = new common_1.Logger(AppRoleGuardMixin.name);
+        async canActivate(context) {
+            const type = context.getType();
+            const prefix = 'Bearer ';
+            const requiredRoles = typeof rawRole === 'string'
+                ? rawRole.split('|').map((item) => item.trim())
+                : rawRole.map((item) => item.trim());
+            let header = '';
+            if (type === 'rpc') {
+                const metadata = context.getArgByIndex(1);
+                if (!metadata) {
+                    return false;
+                }
+                header = metadata.get('Authorization')[0];
+            }
+            else if (type === 'http') {
+                const request = context.switchToHttp().getRequest();
+                header = request.headers.authorization + '';
+            }
+            if (!header || !header?.startsWith(prefix)) {
+                return false;
+            }
+            const user = (0, functions_1.getBearerUser)(header);
+            if (user && user.roles) {
+                const foundRoles = user.roles.filter((userRole) => requiredRoles.includes(userRole.trim()));
+                if (foundRoles.length > 0) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    const guard = (0, common_1.mixin)(AppRoleGuardMixin);
+    return guard;
+};
+exports.AppRoleGuard = AppRoleGuard;

package/dist/common/guards/index.d.ts

@@ -0,0 +1,4 @@
+export * as app_auth_guard from './app_auth_guard';
+export * as app_internal_guard from './app_internal_guard';
+export * as app_role_guard from './app_role_guard';
+export * as jwt_auth_user_decorator from './jwt_auth_user_decorator';

package/dist/common/guards/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jwt_auth_user_decorator = exports.app_role_guard = exports.app_internal_guard = exports.app_auth_guard = void 0;
+const tslib_1 = require("tslib");
+exports.app_auth_guard = tslib_1.__importStar(require("./app_auth_guard"));
+exports.app_internal_guard = tslib_1.__importStar(require("./app_internal_guard"));
+exports.app_role_guard = tslib_1.__importStar(require("./app_role_guard"));
+exports.jwt_auth_user_decorator = tslib_1.__importStar(require("./jwt_auth_user_decorator"));

package/dist/common/guards/jwt_auth_user_decorator.d.ts

@@ -0,0 +1 @@
+export declare const JwtAuthUser: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/dist/common/guards/jwt_auth_user_decorator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtAuthUser = void 0;
+const common_1 = require("@nestjs/common");
+const functions_1 = require("../../utils/functions");
+exports.JwtAuthUser = (0, common_1.createParamDecorator)(async (data, context) => {
+    const type = context.getType();
+    const prefix = 'Bearer ';
+    let header = '';
+    if (type === 'rpc') {
+        const metadata = context.getArgByIndex(1);
+        if (!metadata) {
+            return false;
+        }
+        header = metadata.get('Authorization')[0];
+    }
+    else if (type === 'http') {
+        const request = context.switchToHttp().getRequest();
+        header = request.headers.authorization + '';
+    }
+    if (!header || !header?.startsWith(prefix)) {
+        throw new Error('Invalid jwt token.');
+    }
+    const user = (0, functions_1.getBearerUser)(header);
+    if (user) {
+        return user;
+    }
+    else {
+        throw new Error('Invalid jwt token.');
+    }
+});

package/dist/common/index.d.ts

@@ -0,0 +1,8 @@
+export * as dto from './dto';
+export * as exception from './exception';
+export * as factory from './factory';
+export * as filters from './filters';
+export * as guards from './guards';
+export * as interceptors from './interceptors';
+export * as kafka from './kafka';
+export * as service from './service';

package/dist/common/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.service = exports.kafka = exports.interceptors = exports.guards = exports.filters = exports.factory = exports.exception = exports.dto = void 0;
+const tslib_1 = require("tslib");
+exports.dto = tslib_1.__importStar(require("./dto"));
+exports.exception = tslib_1.__importStar(require("./exception"));
+exports.factory = tslib_1.__importStar(require("./factory"));
+exports.filters = tslib_1.__importStar(require("./filters"));
+exports.guards = tslib_1.__importStar(require("./guards"));
+exports.interceptors = tslib_1.__importStar(require("./interceptors"));
+exports.kafka = tslib_1.__importStar(require("./kafka"));
+exports.service = tslib_1.__importStar(require("./service"));

package/dist/common/interceptors/grpc/grpc_error_interceptors.d.ts

@@ -0,0 +1,7 @@
+import { CallHandler, ExecutionContext, HttpException, NestInterceptor } from '@nestjs/common';
+import { BaseException } from '../../exception/base_exception';
+export declare class GrpcErrorsInterceptor implements NestInterceptor {
+    private readonly logger;
+    intercept(_context: ExecutionContext, next: CallHandler): import("rxjs").Observable<any>;
+    getHttpException(httpException: HttpException): BaseException;
+}

package/dist/common/interceptors/grpc/grpc_error_interceptors.js

@@ -0,0 +1,35 @@
+"use strict";
+var GrpcErrorsInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcErrorsInterceptor = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const base_exception_1 = require("../../exception/base_exception");
+let GrpcErrorsInterceptor = GrpcErrorsInterceptor_1 = class GrpcErrorsInterceptor {
+    logger = new common_1.Logger(GrpcErrorsInterceptor_1.name);
+    intercept(_context, next) {
+        return next.handle().pipe((0, operators_1.catchError)((err) => {
+            if (err instanceof common_1.InternalServerErrorException) {
+                this.logger.error(err.message, err.stack);
+            }
+            else {
+                this.logger.log(err.message, err.stack);
+            }
+            if (err instanceof common_1.HttpException) {
+                return (0, rxjs_1.throwError)(() => this.getHttpException(err));
+            }
+            return (0, rxjs_1.throwError)(() => err);
+        }));
+    }
+    getHttpException(httpException) {
+        const status = httpException.getStatus();
+        const response = httpException.getResponse();
+        return new base_exception_1.BaseException('error', status, response);
+    }
+};
+exports.GrpcErrorsInterceptor = GrpcErrorsInterceptor;
+exports.GrpcErrorsInterceptor = GrpcErrorsInterceptor = GrpcErrorsInterceptor_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], GrpcErrorsInterceptor);

package/dist/common/interceptors/grpc/index.d.ts

@@ -0,0 +1 @@
+export * as grpc_error_interceptors from './grpc_error_interceptors';

package/dist/common/interceptors/grpc/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpc_error_interceptors = void 0;
+const tslib_1 = require("tslib");
+exports.grpc_error_interceptors = tslib_1.__importStar(require("./grpc_error_interceptors"));

package/dist/common/interceptors/http/http_error_interceptors.d.ts

@@ -0,0 +1,7 @@
+import { CallHandler, ExecutionContext, HttpException, NestInterceptor } from '@nestjs/common';
+import { BaseException } from '../../exception/base_exception';
+export declare class HttpErrorsInterceptor implements NestInterceptor {
+    private readonly logger;
+    intercept(_context: ExecutionContext, next: CallHandler): import("rxjs").Observable<any>;
+    getHttpException(httpException: HttpException): BaseException;
+}

package/dist/common/interceptors/http/http_error_interceptors.js

@@ -0,0 +1,30 @@
+"use strict";
+var HttpErrorsInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpErrorsInterceptor = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const base_exception_1 = require("../../exception/base_exception");
+let HttpErrorsInterceptor = HttpErrorsInterceptor_1 = class HttpErrorsInterceptor {
+    logger = new common_1.Logger(HttpErrorsInterceptor_1.name);
+    intercept(_context, next) {
+        return next.handle().pipe((0, operators_1.catchError)((err) => {
+            this.logger.error(err.message, err.stack);
+            if (err instanceof common_1.HttpException) {
+                return (0, rxjs_1.throwError)(() => this.getHttpException(err));
+            }
+            return (0, rxjs_1.throwError)(() => err);
+        }));
+    }
+    getHttpException(httpException) {
+        const status = httpException.getStatus();
+        const response = httpException.getResponse();
+        return new base_exception_1.BaseException('', status, response);
+    }
+};
+exports.HttpErrorsInterceptor = HttpErrorsInterceptor;
+exports.HttpErrorsInterceptor = HttpErrorsInterceptor = HttpErrorsInterceptor_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], HttpErrorsInterceptor);

package/dist/common/interceptors/http/http_response_interceptors.d.ts

@@ -0,0 +1,7 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+export declare class HttpResponseInterceptor implements NestInterceptor {
+    intercept(_context: ExecutionContext, next: CallHandler): import("rxjs").Observable<{
+        status: string;
+        data: any;
+    }>;
+}

package/dist/common/interceptors/http/http_response_interceptors.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponseInterceptor = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const operators_1 = require("rxjs/operators");
+let HttpResponseInterceptor = class HttpResponseInterceptor {
+    intercept(_context, next) {
+        return next.handle().pipe((0, operators_1.map)((response) => {
+            return {
+                status: 'success',
+                data: response,
+            };
+        }));
+    }
+};
+exports.HttpResponseInterceptor = HttpResponseInterceptor;
+exports.HttpResponseInterceptor = HttpResponseInterceptor = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], HttpResponseInterceptor);

package/dist/common/interceptors/http/index.d.ts

@@ -0,0 +1,2 @@
+export * as http_error_interceptors from './http_error_interceptors';
+export * as http_response_interceptors from './http_response_interceptors';

package/dist/common/interceptors/http/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.http_response_interceptors = exports.http_error_interceptors = void 0;
+const tslib_1 = require("tslib");
+exports.http_error_interceptors = tslib_1.__importStar(require("./http_error_interceptors"));
+exports.http_response_interceptors = tslib_1.__importStar(require("./http_response_interceptors"));

package/dist/common/interceptors/index.d.ts

@@ -0,0 +1,2 @@
+export * as grpc from './grpc';
+export * as http from './http';