@impactor/nest 3.0.0

package/src/decorators/controller/utils/reflect.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get applyDecorators () {
+        return applyDecorators;
+    },
+    get get () {
+        return get;
+    },
+    get getAll () {
+        return getAll;
+    },
+    get getKeys () {
+        return getKeys;
+    },
+    get has () {
+        return has;
+    },
+    get set () {
+        return set;
+    }
+});
+const _common = require("@nestjs/common");
+function has(property, factory, route) {
+    if (route && !route.methodName) {
+        throw new Error(`route's methodName is not provided (${route.httpMethod?.toUpperCase()} ${route.path})`);
+    }
+    return route ? Reflect.hasMetadata(property, factory.controller.prototype[route.methodName]) : Reflect.hasMetadata(property, factory.controller.prototype) || Reflect.hasMetadata(property, factory.controller);
+}
+function get(property, factory, route) {
+    if (route && !route.methodName) {
+        throw new Error(`route's methodName is not provided (${route.httpMethod?.toUpperCase()} ${route.path})`);
+    }
+    return route ? Reflect.getMetadata(property, factory.controller.prototype[route.methodName]) : Reflect.getMetadata(property, factory.controller.prototype) || Reflect.getMetadata(property, factory.controller);
+}
+function set(property, value, factory, route) {
+    if (route && !route.methodName) {
+        throw new Error(`route's methodName is not provided (${route.httpMethod?.toUpperCase()} ${route.path})`);
+    }
+    return route ? Reflect.defineMetadata(property, value, factory.controller.prototype[route.methodName]) : Reflect.defineMetadata(property, value, factory.controller.prototype);
+}
+function getKeys(factory, route) {
+    if (route && !route.methodName) {
+        throw new Error(`route's methodName is not provided (${route.httpMethod?.toUpperCase()} ${route.path})`);
+    }
+    return route ? Reflect.getMetadataKeys(factory.controller.prototype[route.methodName]) : [
+        ...new Set([
+            ...Reflect.getMetadataKeys(factory.controller.prototype),
+            ...Reflect.getMetadataKeys(factory.controller)
+        ])
+    ];
+}
+function getAll(factory, route) {
+    let keys = getKeys(factory, route);
+    let map = {};
+    for (let key of keys){
+        map[key] = get(key, factory, route);
+    }
+    return map;
+}
+function applyDecorators(factory) {
+    if (factory.decorators?.length) {
+        Reflect.decorate(factory.decorators, factory.controller);
+    }
+    for (let route of factory.options.routes){
+        // without reflect-metadata use: `decorator(target, method, descriptor)`
+        if (route.decorators?.length) {
+            Reflect.decorate(route.decorators, factory.controller.prototype, route.methodName, Reflect.getOwnPropertyDescriptor(factory.controller.prototype, route.methodName));
+            if (route.interceptors?.length) {
+                Reflect.decorate([
+                    (0, _common.UseInterceptors)(...route.interceptors)
+                ], factory.controller.prototype, route.methodName, Reflect.getOwnPropertyDescriptor(factory.controller.prototype, route.methodName));
+            }
+        }
+    }
+}
+
+//# sourceMappingURL=reflect.js.map

package/src/decorators/controller/utils/reflect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/decorators/controller/utils/reflect.ts"],"sourcesContent":["import { UseInterceptors } from '@nestjs/common';\nimport { ControllerFactory } from '../controller.factory';\nimport { IRoute } from '../types';\n\n/**\n * Check if the class or a method has a metadata property\n * @param property the metadata property to be checked\n * @param factory the class\n * @param route if provided, the method's metadata is checked, otherwise the class's metadata is checked\n * @returns\n */\nexport function has(\n  property: string,\n  factory: ControllerFactory,\n  route?: IRoute,\n) {\n  if (route && !route.methodName) {\n    throw new Error(\n      `route's methodName is not provided (${route.httpMethod?.toUpperCase()} ${route.path})`,\n    );\n  }\n\n  return route\n    ? Reflect.hasMetadata(\n        property,\n        factory.controller.prototype[route.methodName],\n      )\n    : Reflect.hasMetadata(property, factory.controller.prototype) ||\n        Reflect.hasMetadata(property, factory.controller);\n}\n\nexport function get(\n  property: string,\n  factory: ControllerFactory,\n  route?: IRoute,\n) {\n  if (route && !route.methodName) {\n    throw new Error(\n      `route's methodName is not provided (${route.httpMethod?.toUpperCase()} ${route.path})`,\n    );\n  }\n\n  return route\n    ? Reflect.getMetadata(\n        property,\n        factory.controller.prototype[route.methodName],\n      )\n    : Reflect.getMetadata(property, factory.controller.prototype) ||\n        Reflect.getMetadata(property, factory.controller);\n}\n\nexport function set<T extends Object>(\n  property: string,\n  value: T,\n  factory: ControllerFactory,\n  route?: IRoute,\n) {\n  if (route && !route.methodName) {\n    throw new Error(\n      `route's methodName is not provided (${route.httpMethod?.toUpperCase()} ${route.path})`,\n    );\n  }\n\n  return route\n    ? Reflect.defineMetadata(\n        property,\n        value,\n        factory.controller.prototype[route.methodName],\n      )\n    : Reflect.defineMetadata(property, value, factory.controller.prototype);\n}\n\n/**\n * get all metadata keys\n * @param factory\n * @param route\n */\nexport function getKeys(factory: ControllerFactory, route?: IRoute) {\n  if (route && !route.methodName) {\n    throw new Error(\n      `route's methodName is not provided (${route.httpMethod?.toUpperCase()} ${route.path})`,\n    );\n  }\n\n  return route\n    ? Reflect.getMetadataKeys(factory.controller.prototype[route.methodName])\n    : [\n        ...new Set([\n          ...Reflect.getMetadataKeys(factory.controller.prototype),\n          ...Reflect.getMetadataKeys(factory.controller),\n        ]),\n      ];\n}\n\n/**\n * get all metadata key-value pairs\n * @param factory\n * @param route\n */\nexport function getAll(factory: ControllerFactory, route?: IRoute) {\n  let keys = getKeys(factory, route);\n  let map: { [key: string]: unknown } = {};\n\n  for (let key of keys) {\n    map[key] = get(key, factory, route);\n  }\n\n  return map;\n}\n\n/**\n * apply the provided decorators to the method\n */\nexport function applyDecorators(factory: ControllerFactory) {\n  if (factory.decorators?.length) {\n    Reflect.decorate(factory.decorators, factory.controller);\n  }\n\n  for (let route of factory.options.routes) {\n    // without reflect-metadata use: `decorator(target, method, descriptor)`\n    if (route.decorators?.length) {\n      Reflect.decorate(\n        route.decorators,\n        factory.controller.prototype,\n        route.methodName,\n        Reflect.getOwnPropertyDescriptor(\n          factory.controller.prototype,\n          route.methodName,\n        ),\n      );\n\n      if (route.interceptors?.length) {\n        Reflect.decorate(\n          [UseInterceptors(...route.interceptors)],\n          factory.controller.prototype,\n          route.methodName,\n          Reflect.getOwnPropertyDescriptor(\n            factory.controller.prototype,\n            route.methodName,\n          ),\n        );\n      }\n    }\n  }\n}\n"],"names":["applyDecorators","get","getAll","getKeys","has","set","property","factory","route","methodName","Error","httpMethod","toUpperCase","path","Reflect","hasMetadata","controller","prototype","getMetadata","value","defineMetadata","getMetadataKeys","Set","keys","map","key","decorators","length","decorate","options","routes","getOwnPropertyDescriptor","interceptors","UseInterceptors"],"mappings":"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"}

package/src/decorators/prop.decorator.d.ts

@@ -0,0 +1,9 @@
+import { type PipeTransform, type Type } from '@nestjs/common';
+import { type ApiParamOptions } from '@nestjs/swagger';
+export interface IdParamDecoratorOptions {
+    name?: string;
+    scope?: 'params' | 'query' | 'body' | 'payload' | 'messageBody';
+}
+export declare function Prop(name: string, scope?: IdParamDecoratorOptions['scope'], pipes?: (Type<PipeTransform> | PipeTransform)[]): ParameterDecorator;
+export declare function Uuid(name?: string, scope?: IdParamDecoratorOptions['scope'], pipes?: (Type<PipeTransform> | PipeTransform)[]): ParameterDecorator;
+export declare function UuidApi(name?: string, scope?: IdParamDecoratorOptions['scope'], apiOptions?: ApiParamOptions): ParameterDecorator;

package/src/decorators/prop.decorator.js

@@ -0,0 +1,80 @@
+/* eslint unicorn/prevent-abbreviations: 0 */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Prop () {
+        return Prop;
+    },
+    get Uuid () {
+        return Uuid;
+    },
+    get UuidApi () {
+        return UuidApi;
+    }
+});
+const _common = require("@nestjs/common");
+const _swagger = require("@nestjs/swagger");
+const _microservices = require("@nestjs/microservices");
+const _websockets = require("@nestjs/websockets");
+function Prop(name, scope = 'params', pipes = []) {
+    return (target, propertyKey, parameterIndex)=>{
+        if (scope === 'payload') {
+            return (0, _microservices.Payload)(name, ...pipes)(target, propertyKey, parameterIndex);
+        } else if (scope === 'messageBody') {
+            return (0, _websockets.MessageBody)(name, ...pipes)(target, propertyKey, parameterIndex);
+        } else if (scope === 'params') {
+            return (0, _common.Param)(name, ...pipes)(target, propertyKey, parameterIndex);
+        } else if (scope === 'query') {
+            return (0, _common.Query)(name, ...pipes)(target, propertyKey, parameterIndex);
+        } else if (scope === 'body') {
+            return (0, _common.Body)(name, ...pipes)(target, propertyKey, parameterIndex);
+        }
+    };
+}
+function Uuid(name = 'id', scope = 'params', pipes) {
+    return Prop(name, scope, pipes || [
+        new _common.ParseUUIDPipe()
+    ]);
+}
+function UuidApi(name = 'id', scope = 'params', // TODO: accept options based on the scope's value
+// TODO: allow swapping between scope and apiOptions
+apiOptions) {
+    return (target, propertyKey, parameterIndex)=>{
+        // TODO: add swagger docs for other scopes
+        // TODO: auto detect if the property is optional -> `@Uuid() id?: string`
+        if (scope === 'params') {
+            (0, _swagger.ApiParam)({
+                name,
+                type: 'string',
+                format: 'uuid',
+                example: '4eae7b32-9065-42b0-a025-5cb967011e65',
+                ...apiOptions
+            })(target.constructor, propertyKey, Object.getOwnPropertyDescriptor(target, propertyKey));
+        }
+        let IdParamDecorator = (0, _common.createParamDecorator)((opts, ctx)=>{
+            let { name = 'id', scope = 'params' } = opts;
+            let req = ctx.switchToHttp().getRequest();
+            let id = req[scope][name];
+            if (!id) throw new _common.BadRequestException(`${name} is required`);
+            // Use ParseUUIDPipe to validate the UUID
+            let parseUUIDPipe = new _common.ParseUUIDPipe();
+            return parseUUIDPipe.transform(id, {
+                type: 'param',
+                metatype: String
+            });
+        });
+        return IdParamDecorator({
+            name,
+            scope
+        })(target, propertyKey, parameterIndex);
+    };
+}
+
+//# sourceMappingURL=prop.decorator.js.map

package/src/decorators/prop.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/decorators/prop.decorator.ts"],"sourcesContent":["/* eslint unicorn/prevent-abbreviations: 0 */\nimport {\n  BadRequestException,\n  Body,\n  type ExecutionContext,\n  Param,\n  type PipeTransform,\n  Query,\n  type Type,\n  createParamDecorator,\n} from '@nestjs/common';\nimport { ParseUUIDPipe } from '@nestjs/common';\nimport { ApiParam, type ApiParamOptions } from '@nestjs/swagger';\nimport { Payload } from '@nestjs/microservices';\nimport { MessageBody } from '@nestjs/websockets';\n\nexport interface IdParamDecoratorOptions {\n  /**\n   * The property that is wanted to be extracted\n   */\n  name?: string;\n  /**\n   * The scope to extract the property from\n   * @example @Params('id')\n   * @example @Payload('id')\n   */\n  scope?: 'params' | 'query' | 'body' | 'payload' | 'messageBody';\n}\n\n/**\n * a param decorator that extracts a field from the request\n * and validates it using pipes\n * and add the suitable Swagger's docs\n *\n * @param name the field's name\n * @param scope the scope where the prop is defined in\n *\n * @example\n * extract userId from params\n * ```\n * @Get(':userId')\n * findUserById(@Prop('userId') userId: string){\n *  this.service.findUserById(userId);\n * }\n * ```\n *\n * @example\n * extract the id from the query string\n * ```\n * @Get()\n * filterByTenant(@Prop('tenantId', 'query') tenantId: string){ ... }\n * ```\n *\n * @example\n * extract the product id from the request's body\n * ```\n * @Post()\n * createOrder(@Prop('productId','body') productId: string){ ... }\n * ```\n *\n * @example\n * manipulate the swagger's docs: make the id optional\n * ```\n * @Get('id')\n * find(@Prop('id', 'params', <any>{ required: false }) id?: string){\n *   return id?: this.service.findById(id) : this.service.find()\n * }\n * ```\n *\n * @returns the field value\n * @throws BadRequestException\n */\nexport function Prop(\n  name: string,\n  scope: IdParamDecoratorOptions['scope'] = 'params',\n  pipes: (Type<PipeTransform> | PipeTransform)[] = [],\n): ParameterDecorator {\n  return (\n    target: Object,\n    propertyKey: string | symbol | undefined,\n    parameterIndex: number,\n  ) => {\n    if (scope === 'payload') {\n      return Payload(name, ...pipes)(target, propertyKey, parameterIndex);\n    } else if (scope === 'messageBody') {\n      return MessageBody(name, ...pipes)(target, propertyKey, parameterIndex);\n    } else if (scope === 'params') {\n      return Param(name, ...pipes)(target, propertyKey, parameterIndex);\n    } else if (scope === 'query') {\n      return Query(name, ...pipes)(target, propertyKey, parameterIndex);\n    } else if (scope === 'body') {\n      return Body(name, ...pipes)(target, propertyKey, parameterIndex);\n    }\n  };\n}\n\n/**\n * apply @prop() to extract the id field and validate its value as uuid *\n * to customize the Swagger's docs use uuidApi()\n * @returns the UUID value\n * @throws BadRequestException\n */\nexport function Uuid(\n  name = 'id',\n  scope: IdParamDecoratorOptions['scope'] = 'params',\n  pipes?: (Type<PipeTransform> | PipeTransform)[],\n): ParameterDecorator {\n  return Prop(name, scope, pipes || [new ParseUUIDPipe()]);\n}\n\n/**\n * same as Uuid() but can provide additional options for Swagger's docs\n *\n * @example\n * if the prop name is id, it is optional\n * ```\n * @Get('id)\n * findById(@Uuid() id: string){}\n * ```\n *\n * @param name\n * @param scope\n * @param apiOptions additional options for swagger's docs\n * @returns\n */\nexport function UuidApi(\n  name = 'id',\n  scope: IdParamDecoratorOptions['scope'] = 'params',\n  // TODO: accept options based on the scope's value\n  // TODO: allow swapping between scope and apiOptions\n  apiOptions?: ApiParamOptions,\n): ParameterDecorator {\n  return (\n    target: Object,\n    propertyKey: string | symbol | undefined,\n    parameterIndex: number,\n  ) => {\n    // TODO: add swagger docs for other scopes\n    // TODO: auto detect if the property is optional -> `@Uuid() id?: string`\n    if (scope === 'params') {\n      ApiParam({\n        name,\n        type: 'string',\n        format: 'uuid',\n        example: '4eae7b32-9065-42b0-a025-5cb967011e65',\n        ...apiOptions,\n      })(\n        target.constructor,\n        propertyKey as string,\n        Object.getOwnPropertyDescriptor(target, propertyKey!)!,\n      );\n    }\n\n    let IdParamDecorator = createParamDecorator(\n      (opts: IdParamDecoratorOptions, ctx: ExecutionContext) => {\n        let { name = 'id', scope = 'params' } = opts;\n\n        let req = ctx.switchToHttp().getRequest();\n        let id = req[scope][name];\n\n        if (!id) throw new BadRequestException(`${name} is required`);\n\n        // Use ParseUUIDPipe to validate the UUID\n        let parseUUIDPipe = new ParseUUIDPipe();\n        return parseUUIDPipe.transform(id, {\n          type: 'param',\n          metatype: String,\n        });\n      },\n    );\n\n    return IdParamDecorator({ name, scope })(\n      target,\n      propertyKey,\n      parameterIndex,\n    );\n  };\n}\n"],"names":["Prop","Uuid","UuidApi","name","scope","pipes","target","propertyKey","parameterIndex","Payload","MessageBody","Param","Query","Body","ParseUUIDPipe","apiOptions","ApiParam","type","format","example","Object","getOwnPropertyDescriptor","IdParamDecorator","createParamDecorator","opts","ctx","req","switchToHttp","getRequest","id","BadRequestException","parseUUIDPipe","transform","metatype","String"],"mappings":"AAAA,2CAA2C;;;;;;;;;;;QAwE3BA;eAAAA;;QA8BAC;eAAAA;;QAuBAC;eAAAA;;;wBAnHT;yBAEwC;+BACvB;4BACI;AA0DrB,SAASF,KACdG,IAAY,EACZC,QAA0C,QAAQ,EAClDC,QAAiD,EAAE;IAEnD,OAAO,CACLC,QACAC,aACAC;QAEA,IAAIJ,UAAU,WAAW;YACvB,OAAOK,IAAAA,sBAAO,EAACN,SAASE,OAAOC,QAAQC,aAAaC;QACtD,OAAO,IAAIJ,UAAU,eAAe;YAClC,OAAOM,IAAAA,uBAAW,EAACP,SAASE,OAAOC,QAAQC,aAAaC;QAC1D,OAAO,IAAIJ,UAAU,UAAU;YAC7B,OAAOO,IAAAA,aAAK,EAACR,SAASE,OAAOC,QAAQC,aAAaC;QACpD,OAAO,IAAIJ,UAAU,SAAS;YAC5B,OAAOQ,IAAAA,aAAK,EAACT,SAASE,OAAOC,QAAQC,aAAaC;QACpD,OAAO,IAAIJ,UAAU,QAAQ;YAC3B,OAAOS,IAAAA,YAAI,EAACV,SAASE,OAAOC,QAAQC,aAAaC;QACnD;IACF;AACF;AAQO,SAASP,KACdE,OAAO,IAAI,EACXC,QAA0C,QAAQ,EAClDC,KAA+C;IAE/C,OAAOL,KAAKG,MAAMC,OAAOC,SAAS;QAAC,IAAIS,qBAAa;KAAG;AACzD;AAiBO,SAASZ,QACdC,OAAO,IAAI,EACXC,QAA0C,QAAQ,EAClD,kDAAkD;AAClD,oDAAoD;AACpDW,UAA4B;IAE5B,OAAO,CACLT,QACAC,aACAC;QAEA,0CAA0C;QAC1C,yEAAyE;QACzE,IAAIJ,UAAU,UAAU;YACtBY,IAAAA,iBAAQ,EAAC;gBACPb;gBACAc,MAAM;gBACNC,QAAQ;gBACRC,SAAS;gBACT,GAAGJ,UAAU;YACf,GACET,OAAO,WAAW,EAClBC,aACAa,OAAOC,wBAAwB,CAACf,QAAQC;QAE5C;QAEA,IAAIe,mBAAmBC,IAAAA,4BAAoB,EACzC,CAACC,MAA+BC;YAC9B,IAAI,EAAEtB,OAAO,IAAI,EAAEC,QAAQ,QAAQ,EAAE,GAAGoB;YAExC,IAAIE,MAAMD,IAAIE,YAAY,GAAGC,UAAU;YACvC,IAAIC,KAAKH,GAAG,CAACtB,MAAM,CAACD,KAAK;YAEzB,IAAI,CAAC0B,IAAI,MAAM,IAAIC,2BAAmB,CAAC,GAAG3B,KAAK,YAAY,CAAC;YAE5D,yCAAyC;YACzC,IAAI4B,gBAAgB,IAAIjB,qBAAa;YACrC,OAAOiB,cAAcC,SAAS,CAACH,IAAI;gBACjCZ,MAAM;gBACNgB,UAAUC;YACZ;QACF;QAGF,OAAOZ,iBAAiB;YAAEnB;YAAMC;QAAM,GACpCE,QACAC,aACAC;IAEJ;AACF"}

package/src/exceptions/rpc-bad-request.exception.d.ts

@@ -0,0 +1,4 @@
+import { RpcBaseException } from './rpc-base.exception';
+export declare class RpcBadRequestException extends RpcBaseException {
+    constructor(message?: string);
+}

package/src/exceptions/rpc-bad-request.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RpcBadRequestException", {
+    enumerable: true,
+    get: function() {
+        return RpcBadRequestException;
+    }
+});
+const _common = require("@nestjs/common");
+const _rpcbaseexception = require("./rpc-base.exception");
+let RpcBadRequestException = class RpcBadRequestException extends _rpcbaseexception.RpcBaseException {
+    constructor(message = 'Bad request'){
+        super(message, _common.HttpStatus.BAD_REQUEST);
+    }
+};
+
+//# sourceMappingURL=rpc-bad-request.exception.js.map

package/src/exceptions/rpc-bad-request.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions/rpc-bad-request.exception.ts"],"sourcesContent":["import { HttpStatus } from '@nestjs/common';\nimport { RpcBaseException } from './rpc-base.exception';\n\nexport class RpcBadRequestException extends RpcBaseException {\n  constructor(message = 'Bad request') {\n    super(message, HttpStatus.BAD_REQUEST);\n  }\n}\n"],"names":["RpcBadRequestException","RpcBaseException","message","HttpStatus","BAD_REQUEST"],"mappings":";;;;+BAGaA;;;eAAAA;;;wBAHc;kCACM;AAE1B,IAAA,AAAMA,yBAAN,MAAMA,+BAA+BC,kCAAgB;IAC1D,YAAYC,UAAU,aAAa,CAAE;QACnC,KAAK,CAACA,SAASC,kBAAU,CAACC,WAAW;IACvC;AACF"}

package/src/exceptions/rpc-base.exception.d.ts

@@ -0,0 +1,6 @@
+import { RpcException } from '@nestjs/microservices';
+import { HttpStatus } from '@nestjs/common';
+export declare class RpcBaseException extends RpcException {
+    statusCode: HttpStatus;
+    constructor(message: string, statusCode?: HttpStatus);
+}

package/src/exceptions/rpc-base.exception.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RpcBaseException", {
+    enumerable: true,
+    get: function() {
+        return RpcBaseException;
+    }
+});
+const _microservices = require("@nestjs/microservices");
+const _common = require("@nestjs/common");
+let RpcBaseException = class RpcBaseException extends _microservices.RpcException {
+    constructor(message, statusCode = _common.HttpStatus.INTERNAL_SERVER_ERROR){
+        super({
+            message
+        });
+        this.statusCode = statusCode;
+    }
+};
+
+//# sourceMappingURL=rpc-base.exception.js.map

package/src/exceptions/rpc-base.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions/rpc-base.exception.ts"],"sourcesContent":["import { RpcException } from '@nestjs/microservices';\nimport { HttpStatus } from '@nestjs/common';\n\n/**\n * Base Error class for RPC exceptions.\n * This exception resembles the behavior of HTTP exceptions, but for RPC errors.\n */\n// todo: use `RpcException(new BadRequestException(message))` instead of creating custom RPC exceptions\n// https://stackoverflow.com/a/75335979\nexport class RpcBaseException extends RpcException {\n  statusCode: HttpStatus;\n\n  constructor(\n    message: string,\n    statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR,\n  ) {\n    super({ message });\n    this.statusCode = statusCode;\n  }\n}\n"],"names":["RpcBaseException","RpcException","message","statusCode","HttpStatus","INTERNAL_SERVER_ERROR"],"mappings":";;;;+BASaA;;;eAAAA;;;+BATgB;wBACF;AAQpB,IAAA,AAAMA,mBAAN,MAAMA,yBAAyBC,2BAAY;IAGhD,YACEC,OAAe,EACfC,aAAyBC,kBAAU,CAACC,qBAAqB,CACzD;QACA,KAAK,CAAC;YAAEH;QAAQ;QAChB,IAAI,CAACC,UAAU,GAAGA;IACpB;AACF"}

package/src/exceptions/rpc-conflict.exception.d.ts

@@ -0,0 +1,4 @@
+import { RpcBaseException } from './rpc-base.exception';
+export declare class RpcConflictException extends RpcBaseException {
+    constructor(message?: string);
+}

package/src/exceptions/rpc-conflict.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RpcConflictException", {
+    enumerable: true,
+    get: function() {
+        return RpcConflictException;
+    }
+});
+const _common = require("@nestjs/common");
+const _rpcbaseexception = require("./rpc-base.exception");
+let RpcConflictException = class RpcConflictException extends _rpcbaseexception.RpcBaseException {
+    constructor(message = 'Conflict'){
+        super(message, _common.HttpStatus.CONFLICT);
+    }
+};
+
+//# sourceMappingURL=rpc-conflict.exception.js.map

package/src/exceptions/rpc-conflict.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions/rpc-conflict.exception.ts"],"sourcesContent":["import { HttpStatus } from '@nestjs/common';\nimport { RpcBaseException } from './rpc-base.exception';\n\nexport class RpcConflictException extends RpcBaseException {\n  constructor(message = 'Conflict') {\n    super(message, HttpStatus.CONFLICT);\n  }\n}\n"],"names":["RpcConflictException","RpcBaseException","message","HttpStatus","CONFLICT"],"mappings":";;;;+BAGaA;;;eAAAA;;;wBAHc;kCACM;AAE1B,IAAA,AAAMA,uBAAN,MAAMA,6BAA6BC,kCAAgB;IACxD,YAAYC,UAAU,UAAU,CAAE;QAChC,KAAK,CAACA,SAASC,kBAAU,CAACC,QAAQ;IACpC;AACF"}

package/src/exceptions/rpc-internal-server-error.exception.d.ts

@@ -0,0 +1,4 @@
+import { RpcBaseException } from './rpc-base.exception';
+export declare class RpcInternalServerErrorException extends RpcBaseException {
+    constructor(message?: string);
+}

package/src/exceptions/rpc-internal-server-error.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RpcInternalServerErrorException", {
+    enumerable: true,
+    get: function() {
+        return RpcInternalServerErrorException;
+    }
+});
+const _common = require("@nestjs/common");
+const _rpcbaseexception = require("./rpc-base.exception");
+let RpcInternalServerErrorException = class RpcInternalServerErrorException extends _rpcbaseexception.RpcBaseException {
+    constructor(message = 'Internal server error'){
+        super(message, _common.HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+};
+
+//# sourceMappingURL=rpc-internal-server-error.exception.js.map

package/src/exceptions/rpc-internal-server-error.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions/rpc-internal-server-error.exception.ts"],"sourcesContent":["import { HttpStatus } from '@nestjs/common';\nimport { RpcBaseException } from './rpc-base.exception';\n\nexport class RpcInternalServerErrorException extends RpcBaseException {\n  constructor(message = 'Internal server error') {\n    super(message, HttpStatus.INTERNAL_SERVER_ERROR);\n  }\n}\n"],"names":["RpcInternalServerErrorException","RpcBaseException","message","HttpStatus","INTERNAL_SERVER_ERROR"],"mappings":";;;;+BAGaA;;;eAAAA;;;wBAHc;kCACM;AAE1B,IAAA,AAAMA,kCAAN,MAAMA,wCAAwCC,kCAAgB;IACnE,YAAYC,UAAU,uBAAuB,CAAE;QAC7C,KAAK,CAACA,SAASC,kBAAU,CAACC,qBAAqB;IACjD;AACF"}

package/src/exceptions/rpc-method-not-allowed.exception.d.ts

@@ -0,0 +1,4 @@
+import { RpcBaseException } from './rpc-base.exception';
+export declare class RpcMethodNotAllowedException extends RpcBaseException {
+    constructor(message?: string);
+}

package/src/exceptions/rpc-method-not-allowed.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RpcMethodNotAllowedException", {
+    enumerable: true,
+    get: function() {
+        return RpcMethodNotAllowedException;
+    }
+});
+const _common = require("@nestjs/common");
+const _rpcbaseexception = require("./rpc-base.exception");
+let RpcMethodNotAllowedException = class RpcMethodNotAllowedException extends _rpcbaseexception.RpcBaseException {
+    constructor(message = 'Method not allowed'){
+        super(message, _common.HttpStatus.METHOD_NOT_ALLOWED);
+    }
+};
+
+//# sourceMappingURL=rpc-method-not-allowed.exception.js.map

package/src/exceptions/rpc-method-not-allowed.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions/rpc-method-not-allowed.exception.ts"],"sourcesContent":["import { HttpStatus } from '@nestjs/common';\nimport { RpcBaseException } from './rpc-base.exception';\n\nexport class RpcMethodNotAllowedException extends RpcBaseException {\n  constructor(message = 'Method not allowed') {\n    super(message, HttpStatus.METHOD_NOT_ALLOWED);\n  }\n}\n"],"names":["RpcMethodNotAllowedException","RpcBaseException","message","HttpStatus","METHOD_NOT_ALLOWED"],"mappings":";;;;+BAGaA;;;eAAAA;;;wBAHc;kCACM;AAE1B,IAAA,AAAMA,+BAAN,MAAMA,qCAAqCC,kCAAgB;IAChE,YAAYC,UAAU,oBAAoB,CAAE;QAC1C,KAAK,CAACA,SAASC,kBAAU,CAACC,kBAAkB;IAC9C;AACF"}

package/src/exceptions/rpc-not-found.exception.d.ts

@@ -0,0 +1,4 @@
+import { RpcBaseException } from './rpc-base.exception';
+export declare class RpcNotFoundException extends RpcBaseException {
+    constructor(message?: string);
+}

package/src/exceptions/rpc-not-found.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RpcNotFoundException", {
+    enumerable: true,
+    get: function() {
+        return RpcNotFoundException;
+    }
+});
+const _common = require("@nestjs/common");
+const _rpcbaseexception = require("./rpc-base.exception");
+let RpcNotFoundException = class RpcNotFoundException extends _rpcbaseexception.RpcBaseException {
+    constructor(message = 'Not Found'){
+        super(message, _common.HttpStatus.NOT_FOUND);
+    }
+};
+
+//# sourceMappingURL=rpc-not-found.exception.js.map

package/src/exceptions/rpc-not-found.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions/rpc-not-found.exception.ts"],"sourcesContent":["import { HttpStatus } from '@nestjs/common';\nimport { RpcBaseException } from './rpc-base.exception';\n\nexport class RpcNotFoundException extends RpcBaseException {\n  constructor(message = 'Not Found') {\n    super(message, HttpStatus.NOT_FOUND);\n  }\n}\n"],"names":["RpcNotFoundException","RpcBaseException","message","HttpStatus","NOT_FOUND"],"mappings":";;;;+BAGaA;;;eAAAA;;;wBAHc;kCACM;AAE1B,IAAA,AAAMA,uBAAN,MAAMA,6BAA6BC,kCAAgB;IACxD,YAAYC,UAAU,WAAW,CAAE;QACjC,KAAK,CAACA,SAASC,kBAAU,CAACC,SAAS;IACrC;AACF"}

package/src/exceptions/rpc-not-implemented.exception.d.ts

@@ -0,0 +1,4 @@
+import { RpcBaseException } from './rpc-base.exception';
+export declare class RpcNotImplementedException extends RpcBaseException {
+    constructor(message?: string);
+}

package/src/exceptions/rpc-not-implemented.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RpcNotImplementedException", {
+    enumerable: true,
+    get: function() {
+        return RpcNotImplementedException;
+    }
+});
+const _common = require("@nestjs/common");
+const _rpcbaseexception = require("./rpc-base.exception");
+let RpcNotImplementedException = class RpcNotImplementedException extends _rpcbaseexception.RpcBaseException {
+    constructor(message = 'Not implemented'){
+        super(message, _common.HttpStatus.NOT_IMPLEMENTED);
+    }
+};
+
+//# sourceMappingURL=rpc-not-implemented.exception.js.map

package/src/exceptions/rpc-not-implemented.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions/rpc-not-implemented.exception.ts"],"sourcesContent":["import { HttpStatus } from '@nestjs/common';\nimport { RpcBaseException } from './rpc-base.exception';\n\nexport class RpcNotImplementedException extends RpcBaseException {\n  constructor(message = 'Not implemented') {\n    super(message, HttpStatus.NOT_IMPLEMENTED);\n  }\n}\n"],"names":["RpcNotImplementedException","RpcBaseException","message","HttpStatus","NOT_IMPLEMENTED"],"mappings":";;;;+BAGaA;;;eAAAA;;;wBAHc;kCACM;AAE1B,IAAA,AAAMA,6BAAN,MAAMA,mCAAmCC,kCAAgB;IAC9D,YAAYC,UAAU,iBAAiB,CAAE;QACvC,KAAK,CAACA,SAASC,kBAAU,CAACC,eAAe;IAC3C;AACF"}

package/src/exceptions/rpc-unauthorized.exception.d.ts

@@ -0,0 +1,4 @@
+import { RpcBaseException } from './rpc-base.exception';
+export declare class RpcUnauthorizedException extends RpcBaseException {
+    constructor(message?: string);
+}

package/src/exceptions/rpc-unauthorized.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RpcUnauthorizedException", {
+    enumerable: true,
+    get: function() {
+        return RpcUnauthorizedException;
+    }
+});
+const _common = require("@nestjs/common");
+const _rpcbaseexception = require("./rpc-base.exception");
+let RpcUnauthorizedException = class RpcUnauthorizedException extends _rpcbaseexception.RpcBaseException {
+    constructor(message = 'Invalid credentials'){
+        super(message, _common.HttpStatus.UNAUTHORIZED);
+    }
+};
+
+//# sourceMappingURL=rpc-unauthorized.exception.js.map

package/src/exceptions/rpc-unauthorized.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions/rpc-unauthorized.exception.ts"],"sourcesContent":["import { HttpStatus } from '@nestjs/common';\nimport { RpcBaseException } from './rpc-base.exception';\n\nexport class RpcUnauthorizedException extends RpcBaseException {\n  constructor(message = 'Invalid credentials') {\n    super(message, HttpStatus.UNAUTHORIZED);\n  }\n}\n"],"names":["RpcUnauthorizedException","RpcBaseException","message","HttpStatus","UNAUTHORIZED"],"mappings":";;;;+BAGaA;;;eAAAA;;;wBAHc;kCACM;AAE1B,IAAA,AAAMA,2BAAN,MAAMA,iCAAiCC,kCAAgB;IAC5D,YAAYC,UAAU,qBAAqB,CAAE;QAC3C,KAAK,CAACA,SAASC,kBAAU,CAACC,YAAY;IACxC;AACF"}

package/src/filters/error-to-rpc-exception.filter.d.ts

@@ -0,0 +1,4 @@
+import { type RpcExceptionFilter } from '@nestjs/common';
+export declare class ErrorToRpcExceptionFilter implements RpcExceptionFilter<Error> {
+    catch(exception: Error): import("rxjs").Observable<never>;
+}

package/src/filters/error-to-rpc-exception.filter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ErrorToRpcExceptionFilter", {
+    enumerable: true,
+    get: function() {
+        return ErrorToRpcExceptionFilter;
+    }
+});
+const _common = require("@nestjs/common");
+const _microservices = require("@nestjs/microservices");
+const _rxjs = require("rxjs");
+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;
+}
+let ErrorToRpcExceptionFilter = class ErrorToRpcExceptionFilter {
+    catch(exception) {
+        if (process.env.NODE_ENV === 'development') {
+            let logger = new _common.Logger('ErrorToRpc');
+            logger.debug(exception);
+        }
+        // HttpException is converted by NestJs into a response object with a statusCode
+        // The response object contains the error message and the statusCode,
+        // and the exception itself contains the exception name such as NoFoundError
+        if (exception instanceof _common.HttpException) {
+            let res = exception.getResponse(), error = typeof res === 'string' ? {
+                message: res
+            } : res;
+            return (0, _rxjs.throwError)(()=>({
+                    ...exception,
+                    ...error
+                }));
+        }
+        if (exception instanceof _microservices.RpcException) {
+            return (0, _rxjs.throwError)(()=>exception);
+        }
+        return (0, _rxjs.throwError)(()=>new _microservices.RpcException(exception));
+    }
+};
+ErrorToRpcExceptionFilter = _ts_decorate([
+    (0, _common.Catch)()
+], ErrorToRpcExceptionFilter);
+
+//# sourceMappingURL=error-to-rpc-exception.filter.js.map

package/src/filters/error-to-rpc-exception.filter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/filters/error-to-rpc-exception.filter.ts"],"sourcesContent":["import {\n  Catch,\n  HttpException,\n  Logger,\n  type RpcExceptionFilter,\n} from '@nestjs/common';\nimport { RpcException } from '@nestjs/microservices';\nimport { throwError } from 'rxjs';\n\n/**\n * convert Error to RpcException\n */\n@Catch()\nexport class ErrorToRpcExceptionFilter implements RpcExceptionFilter<Error> {\n  catch(exception: Error) {\n    if (process.env.NODE_ENV === 'development') {\n      let logger = new Logger('ErrorToRpc');\n      logger.debug(exception);\n    }\n\n    // HttpException is converted by NestJs into a response object with a statusCode\n    // The response object contains the error message and the statusCode,\n    // and the exception itself contains the exception name such as NoFoundError\n    if (exception instanceof HttpException) {\n      let res = exception.getResponse(),\n        error = typeof res === 'string' ? { message: res } : res;\n      return throwError(() => ({ ...exception, ...error }));\n    }\n\n    if (exception instanceof RpcException) {\n      return throwError(() => exception);\n    }\n\n    return throwError(() => new RpcException(exception));\n  }\n}\n"],"names":["ErrorToRpcExceptionFilter","catch","exception","process","env","NODE_ENV","logger","Logger","debug","HttpException","res","getResponse","error","message","throwError","RpcException"],"mappings":";;;;+BAaaA;;;eAAAA;;;wBARN;+BACsB;sBACF;;;;;;;AAMpB,IAAA,AAAMA,4BAAN,MAAMA;IACXC,MAAMC,SAAgB,EAAE;QACtB,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;YAC1C,IAAIC,SAAS,IAAIC,cAAM,CAAC;YACxBD,OAAOE,KAAK,CAACN;QACf;QAEA,gFAAgF;QAChF,qEAAqE;QACrE,4EAA4E;QAC5E,IAAIA,qBAAqBO,qBAAa,EAAE;YACtC,IAAIC,MAAMR,UAAUS,WAAW,IAC7BC,QAAQ,OAAOF,QAAQ,WAAW;gBAAEG,SAASH;YAAI,IAAIA;YACvD,OAAOI,IAAAA,gBAAU,EAAC,IAAO,CAAA;oBAAE,GAAGZ,SAAS;oBAAE,GAAGU,KAAK;gBAAC,CAAA;QACpD;QAEA,IAAIV,qBAAqBa,2BAAY,EAAE;YACrC,OAAOD,IAAAA,gBAAU,EAAC,IAAMZ;QAC1B;QAEA,OAAOY,IAAAA,gBAAU,EAAC,IAAM,IAAIC,2BAAY,CAACb;IAC3C;AACF"}

package/src/filters/error-to-ws-exception.filter.d.ts

@@ -0,0 +1,4 @@
+import { ArgumentsHost, type WsExceptionFilter } from '@nestjs/common';
+export declare class ErrorToWsExceptionFilter implements WsExceptionFilter<Error> {
+    catch(exception: Error, host: ArgumentsHost): import("rxjs").Observable<never>;
+}

package/src/filters/error-to-ws-exception.filter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ErrorToWsExceptionFilter", {
+    enumerable: true,
+    get: function() {
+        return ErrorToWsExceptionFilter;
+    }
+});
+const _common = require("@nestjs/common");
+const _rxjs = require("rxjs");
+const _websockets = require("@nestjs/websockets");
+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;
+}
+let ErrorToWsExceptionFilter = class ErrorToWsExceptionFilter {
+    catch(exception, host) {
+        let ctx = host.switchToWs(), client = ctx.getClient(), pattern = ctx.getPattern(), data = ctx.getData();
+        client.emit('exception', {
+            pattern,
+            message: exception.message,
+            data
+        });
+        if (process.env.NODE_ENV === 'development') {
+            let logger = new _common.Logger(`WebSocket @${pattern}`);
+            logger.debug(`WS Error in ${pattern}`, exception, {
+                data
+            });
+        }
+        // todo: this doesn't trigger the next filter, similar to RpcExceptionFilter does,
+        // so we need to handle WsException here, i.e. emit 'exception' event here
+        // instead of relying on the custom WebSocketExceptionFilter
+        if (exception instanceof _websockets.WsException) {
+            return (0, _rxjs.throwError)(()=>exception);
+        }
+        return (0, _rxjs.throwError)(()=>new _websockets.WsException(exception));
+    }
+};
+ErrorToWsExceptionFilter = _ts_decorate([
+    (0, _common.Catch)()
+], ErrorToWsExceptionFilter);
+
+//# sourceMappingURL=error-to-ws-exception.filter.js.map

package/src/filters/error-to-ws-exception.filter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/filters/error-to-ws-exception.filter.ts"],"sourcesContent":["import {\n  ArgumentsHost,\n  Catch,\n  Logger,\n  type WsExceptionFilter,\n} from '@nestjs/common';\nimport { throwError } from 'rxjs';\nimport { WsException } from '@nestjs/websockets';\n\n/**\n * convert Error to WsException\n */\n@Catch()\nexport class ErrorToWsExceptionFilter implements WsExceptionFilter<Error> {\n  catch(exception: Error, host: ArgumentsHost) {\n    let ctx = host.switchToWs(),\n      client = ctx.getClient(),\n      pattern = ctx.getPattern(),\n      data = ctx.getData();\n\n    client.emit('exception', {\n      pattern,\n      message: exception.message,\n      data,\n    });\n\n    if (process.env.NODE_ENV === 'development') {\n      let logger = new Logger(`WebSocket @${pattern}`);\n      logger.debug(`WS Error in ${pattern}`, exception, {\n        data,\n      });\n    }\n\n    // todo: this doesn't trigger the next filter, similar to RpcExceptionFilter does,\n    // so we need to handle WsException here, i.e. emit 'exception' event here\n    // instead of relying on the custom WebSocketExceptionFilter\n    if (exception instanceof WsException) {\n      return throwError(() => exception);\n    }\n\n    return throwError(() => new WsException(exception));\n  }\n}\n"],"names":["ErrorToWsExceptionFilter","catch","exception","host","ctx","switchToWs","client","getClient","pattern","getPattern","data","getData","emit","message","process","env","NODE_ENV","logger","Logger","debug","WsException","throwError"],"mappings":";;;;+BAaaA;;;eAAAA;;;wBARN;sBACoB;4BACC;;;;;;;AAMrB,IAAA,AAAMA,2BAAN,MAAMA;IACXC,MAAMC,SAAgB,EAAEC,IAAmB,EAAE;QAC3C,IAAIC,MAAMD,KAAKE,UAAU,IACvBC,SAASF,IAAIG,SAAS,IACtBC,UAAUJ,IAAIK,UAAU,IACxBC,OAAON,IAAIO,OAAO;QAEpBL,OAAOM,IAAI,CAAC,aAAa;YACvBJ;YACAK,SAASX,UAAUW,OAAO;YAC1BH;QACF;QAEA,IAAII,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;YAC1C,IAAIC,SAAS,IAAIC,cAAM,CAAC,CAAC,WAAW,EAAEV,SAAS;YAC/CS,OAAOE,KAAK,CAAC,CAAC,YAAY,EAAEX,SAAS,EAAEN,WAAW;gBAChDQ;YACF;QACF;QAEA,kFAAkF;QAClF,0EAA0E;QAC1E,4DAA4D;QAC5D,IAAIR,qBAAqBkB,uBAAW,EAAE;YACpC,OAAOC,IAAAA,gBAAU,EAAC,IAAMnB;QAC1B;QAEA,OAAOmB,IAAAA,gBAAU,EAAC,IAAM,IAAID,uBAAW,CAAClB;IAC1C;AACF"}

package/src/filters/typeorm-exception.filter.d.ts

@@ -0,0 +1,6 @@
+import { type ArgumentsHost, type ExceptionFilter } from '@nestjs/common';
+import { TypeORMError } from 'typeorm';
+import { Observable } from 'rxjs';
+export declare class TypeORMExceptionFilter implements ExceptionFilter<TypeORMError> {
+    catch(exception: TypeORMError, _host: ArgumentsHost): Observable<any>;
+}