nestjs-cryptography 2.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Marc Jorge 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const CRYPTOGRAPHY_OPTIONS = "CRYPTOGRAPHY_OPTIONS";

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRYPTOGRAPHY_OPTIONS = void 0;
+exports.CRYPTOGRAPHY_OPTIONS = 'CRYPTOGRAPHY_OPTIONS';

package/dist/cryptography.module-definition.d.ts

@@ -0,0 +1,4 @@
+import { CryptographyOptionsInterface } from './interfaces';
+export declare const ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<CryptographyOptionsInterface, "register", "create", {
+    isGlobal: boolean;
+}>, MODULE_OPTIONS_TOKEN: string | symbol;

package/dist/cryptography.module-definition.js

@@ -0,0 +1,13 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_OPTIONS_TOKEN = exports.ConfigurableModuleClass = void 0;
+const common_1 = require("@nestjs/common");
+_a = new common_1.ConfigurableModuleBuilder()
+    .setExtras({
+    isGlobal: true,
+}, (definition, extras) => ({
+    ...definition,
+    global: extras.isGlobal,
+}))
+    .build(), exports.ConfigurableModuleClass = _a.ConfigurableModuleClass, exports.MODULE_OPTIONS_TOKEN = _a.MODULE_OPTIONS_TOKEN;

package/dist/cryptography.module.d.ts

@@ -0,0 +1,3 @@
+import { ConfigurableModuleClass } from './cryptography.module-definition';
+export declare class CryptographyModule extends ConfigurableModuleClass {
+}

package/dist/cryptography.module.js

@@ -0,0 +1,21 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptographyModule = void 0;
+const common_1 = require("@nestjs/common");
+const cryptography_module_definition_1 = require("./cryptography.module-definition");
+const cryptography_service_1 = require("./cryptography.service");
+let CryptographyModule = class CryptographyModule extends cryptography_module_definition_1.ConfigurableModuleClass {
+};
+exports.CryptographyModule = CryptographyModule;
+exports.CryptographyModule = CryptographyModule = __decorate([
+    (0, common_1.Module)({
+        providers: [cryptography_service_1.CryptographyService],
+        exports: [cryptography_service_1.CryptographyService],
+    })
+], CryptographyModule);

package/dist/cryptography.service.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as crypto from 'node:crypto';
+import { CryptographyOptionsInterface } from './interfaces';
+export declare class CryptographyService {
+    private options;
+    constructor(options: CryptographyOptionsInterface);
+    private convertDataToBuffer;
+    private extractIV;
+    private extractAuthTagFromCypheredData;
+    private extractCipheredData;
+    private extractSalt;
+    private extractCipheredDEK;
+    private extractCipheredDataWithDEK;
+    private createSaferRandomData;
+    private generateKeyDEK;
+    genUUID(secure?: boolean): string;
+    genRandomPassword(length: number, encoding: 'base64' | 'hex'): string;
+    generateSymmetricKey(length?: number): crypto.KeyObject;
+    deriveMasterKey(masterKey: string | Buffer, salt: Buffer, length: number): Promise<Buffer>;
+    createArgonHashFromPassword(data: string | Buffer): Promise<Buffer>;
+    verifyArgonHashFromPassword(hash: string, data: string | Buffer): Promise<boolean>;
+    createCustomHash(algorithm: string, data: string, outputLength?: number): Buffer;
+    verifyCustomHash(algorithm: string, data: string, oldHash: string | Buffer, outputLength?: number): boolean;
+    createSecureHash(data: string): Buffer;
+    verifySecureHash(data: string, oldHash: string | Buffer): boolean;
+    createCustomHmac(algorithm: string, key: Buffer, data: string): Buffer;
+    verifyCustomHmac(algorithm: string, key: Buffer, data: string, oldHmac: string | Buffer): boolean;
+    createSecureHmac(data: string): Buffer;
+    verifySecureHmac(data: string, oldHmac: Buffer | string): boolean;
+    createInsecureFastHash(data: string): Buffer;
+    private symmetricDataEncrypt;
+    private symmetricDataDecrypt;
+    symmetricSecureDataEncrypt(data: string | Buffer): Promise<Buffer>;
+    symmetricSecureDataDecrypt(data: string | Buffer): Promise<Buffer>;
+}

package/dist/cryptography.service.js

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptographyService = void 0;
+const crypto = __importStar(require("node:crypto"));
+const argon2 = __importStar(require("argon2"));
+const common_1 = require("@nestjs/common");
+const cryptography_module_definition_1 = require("./cryptography.module-definition");
+let CryptographyService = class CryptographyService {
+    constructor(options) {
+        this.options = options;
+    }
+    convertDataToBuffer(data) {
+        return Buffer.isBuffer(data) ? data : Buffer.from(data, 'hex');
+    }
+    extractIV(data) {
+        return data.subarray(0, 12);
+    }
+    extractAuthTagFromCypheredData(data) {
+        return data.subarray(76, 92);
+    }
+    extractCipheredData(data) {
+        return data.subarray(92, data.length);
+    }
+    extractSalt(data) {
+        return data.subarray(12, 76);
+    }
+    extractCipheredDEK(data) {
+        return data.subarray(0, 124);
+    }
+    extractCipheredDataWithDEK(data) {
+        return data.subarray(124, data.length);
+    }
+    createSaferRandomData(length) {
+        return Buffer.from(crypto.hkdfSync('sha3-256', crypto.createSecretKey(crypto.randomBytes(64)), crypto.randomBytes(64), Buffer.alloc(0), length));
+    }
+    generateKeyDEK() {
+        return crypto.createSecretKey(this.createSaferRandomData(32));
+    }
+    genUUID(secure = false) {
+        return crypto.randomUUID({
+            disableEntropyCache: secure,
+        });
+    }
+    genRandomPassword(length, encoding) {
+        return crypto.randomBytes(length).toString(encoding).slice(0, length);
+    }
+    generateSymmetricKey(length = 256) {
+        return crypto.generateKeySync('hmac', { length });
+    }
+    async deriveMasterKey(masterKey, salt, length) {
+        return await argon2.hash(masterKey, {
+            hashLength: length ? length : this.options.kdf.defaultOutputKeyLength,
+            salt: salt,
+            type: this.options.kdf.argon2Type,
+            memoryCost: this.options.kdf.memoryCost,
+            timeCost: this.options.kdf.timeCost,
+            raw: true,
+        });
+    }
+    async createArgonHashFromPassword(data) {
+        const tmpData = await argon2.hash(data, {
+            hashLength: this.options.hashing.password.outputKeyLength,
+            type: this.options.hashing.password.argon2Type,
+            memoryCost: this.options.hashing.password.memoryCost,
+            timeCost: this.options.hashing.password.timeCost,
+            raw: false,
+        });
+        return Buffer.isBuffer(tmpData) ? tmpData : Buffer.from(tmpData);
+    }
+    async verifyArgonHashFromPassword(hash, data) {
+        return await argon2.verify(hash, data);
+    }
+    createCustomHash(algorithm, data, outputLength = 0) {
+        const hash = crypto.createHash(algorithm, {
+            ...(outputLength && { outputLength }),
+        });
+        hash.update(data);
+        return hash.digest();
+    }
+    verifyCustomHash(algorithm, data, oldHash, outputLength = 0) {
+        const hash = this.createCustomHash(algorithm, data, outputLength);
+        if (Buffer.isBuffer(oldHash)) {
+            return crypto.timingSafeEqual(hash, oldHash);
+        }
+        else {
+            return crypto.timingSafeEqual(Buffer.from(oldHash, 'hex'), hash);
+        }
+    }
+    createSecureHash(data) {
+        return this.createCustomHash('shake256', data, 48);
+    }
+    verifySecureHash(data, oldHash) {
+        const hash = this.createCustomHash('shake256', data, 48);
+        const buffOldHash = Buffer.isBuffer(oldHash)
+            ? oldHash
+            : Buffer.from(oldHash, 'hex');
+        return crypto.timingSafeEqual(hash, buffOldHash);
+    }
+    createCustomHmac(algorithm, key, data) {
+        const hmac = crypto.createHmac(algorithm, crypto.createSecretKey(key));
+        hmac.update(data);
+        key = null;
+        return hmac.digest();
+    }
+    verifyCustomHmac(algorithm, key, data, oldHmac) {
+        const hmac = this.createCustomHmac(algorithm, key, data);
+        if (Buffer.isBuffer(oldHmac)) {
+            return crypto.timingSafeEqual(hmac, oldHmac);
+        }
+        else {
+            return crypto.timingSafeEqual(Buffer.from(oldHmac, 'hex'), hmac);
+        }
+    }
+    createSecureHmac(data) {
+        const key = Buffer.from(this.options.hashing.hmac.masterKey, 'hex');
+        const salt = crypto.randomBytes(16);
+        const secureKey = Buffer.from(crypto.hkdfSync('sha3-256', crypto.createSecretKey(key), salt, Buffer.alloc(0), 64));
+        const hmac = this.createCustomHmac('sha3-256', secureKey, data);
+        return Buffer.concat([Buffer.from(salt), Buffer.from(hmac)], salt.length + hmac.length);
+    }
+    verifySecureHmac(data, oldHmac) {
+        const key = Buffer.from(this.options.hashing.hmac.masterKey, 'hex');
+        const buffOldHmac = Buffer.isBuffer(oldHmac)
+            ? oldHmac
+            : Buffer.from(oldHmac, 'hex');
+        const saltOldHmac = buffOldHmac.subarray(0, 16);
+        const hashOldHmac = buffOldHmac.subarray(16, buffOldHmac.length);
+        const secureKey = Buffer.from(crypto.hkdfSync('sha3-256', crypto.createSecretKey(key), saltOldHmac, Buffer.alloc(0), 64));
+        const hmac = this.createCustomHmac('sha3-256', secureKey, data);
+        return crypto.timingSafeEqual(hmac, hashOldHmac);
+    }
+    createInsecureFastHash(data) {
+        return crypto.createHash('sha1').update(data).digest();
+    }
+    async symmetricDataEncrypt(data, key) {
+        const iv = this.createSaferRandomData(12);
+        const salt = this.createSaferRandomData(64);
+        const secureEncryptionKey = await this.deriveMasterKey(key, salt, 32);
+        const cipher = crypto.createCipheriv('aes-256-gcm', crypto.createSecretKey(secureEncryptionKey), iv, {
+            authTagLength: 16,
+        });
+        let cipheredData = cipher.update(data);
+        cipheredData = Buffer.concat([
+            Buffer.from(cipheredData),
+            Buffer.from(cipher.final()),
+        ]);
+        return Buffer.concat([iv, salt, cipher.getAuthTag(), cipheredData]);
+    }
+    async symmetricDataDecrypt(data, key) {
+        data = Buffer.isBuffer(data) ? data : Buffer.from(data, 'hex');
+        const iv = this.extractIV(data);
+        const salt = this.extractSalt(data);
+        const authTag = this.extractAuthTagFromCypheredData(data);
+        const cipheredData = this.extractCipheredData(data);
+        const decryptionKey = await this.deriveMasterKey(key, salt, 32);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', crypto.createSecretKey(decryptionKey), iv, {
+            authTagLength: 16,
+        });
+        decipher.setAuthTag(authTag);
+        let decipheredData = decipher.update(cipheredData);
+        decipheredData = Buffer.concat([
+            Buffer.from(decipheredData),
+            Buffer.from(decipher.final()),
+        ]);
+        return decipheredData;
+    }
+    async symmetricSecureDataEncrypt(data) {
+        const dek = this.createSaferRandomData(32);
+        const cipheredData = await this.symmetricDataEncrypt(data, dek);
+        const cipheredDek = await this.symmetricDataEncrypt(dek, this.options.encryption.symmetric.masterKey);
+        return Buffer.concat([cipheredDek, cipheredData]);
+    }
+    async symmetricSecureDataDecrypt(data) {
+        data = Buffer.isBuffer(data) ? data : Buffer.from(data, 'hex');
+        const cipheredDek = this.extractCipheredDEK(data);
+        const cipheredData = this.extractCipheredDataWithDEK(data);
+        const decipheredDek = await this.symmetricDataDecrypt(cipheredDek, this.options.encryption.symmetric.masterKey);
+        return await this.symmetricDataDecrypt(cipheredData, decipheredDek);
+    }
+};
+exports.CryptographyService = CryptographyService;
+exports.CryptographyService = CryptographyService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(cryptography_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], CryptographyService);

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cryptography.module';
+export * from './interfaces';
+export * from './cryptography.service';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cryptography.module"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./cryptography.service"), exports);

package/dist/interfaces/cryptography-options.interface.d.ts

@@ -0,0 +1,29 @@
+export declare enum Argon2Type {
+    argon2d = 0,
+    argon2i = 1,
+    argon2id = 2
+}
+export interface CryptographyOptionsInterface {
+    kdf: {
+        defaultOutputKeyLength: number;
+        argon2Type: Argon2Type;
+        memoryCost: number;
+        timeCost: number;
+    };
+    hashing: {
+        password: {
+            outputKeyLength: number;
+            argon2Type: Argon2Type;
+            memoryCost: number;
+            timeCost: number;
+        };
+        hmac: {
+            masterKey: string;
+        };
+    };
+    encryption: {
+        symmetric: {
+            masterKey: string;
+        };
+    };
+}

package/dist/interfaces/cryptography-options.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Argon2Type = void 0;
+var Argon2Type;
+(function (Argon2Type) {
+    Argon2Type[Argon2Type["argon2d"] = 0] = "argon2d";
+    Argon2Type[Argon2Type["argon2i"] = 1] = "argon2i";
+    Argon2Type[Argon2Type["argon2id"] = 2] = "argon2id";
+})(Argon2Type || (exports.Argon2Type = Argon2Type = {}));

package/dist/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './cryptography-options.interface';

package/dist/interfaces/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cryptography-options.interface"), exports);

package/index.d.ts

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

package/index.js

@@ -0,0 +1,6 @@
+"use strict";
+function __export(m) {
+  for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+exports.__esModule = true;
+__export(require("./dist"));

package/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "nestjs-cryptography",
+  "version": "2.2.1",
+  "author": {
+    "name": "Marc Jorge Gonzalez",
+    "url": "https://github.com/mjorgegulab"
+  },
+  "license": "MIT",
+  "description": "Secure NestJS cryptography module 🔐",
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com/"
+  },
+  "homepage": "https://github.com/mjorgegulab/nestjs-cryptography",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mjorgegulab/nestjs-cryptography.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mjorgegulab/nestjs-cryptography/issues"
+  },
+  "scripts": {
+    "build": "rimraf -rf dist && tsc -p tsconfig.json",
+    "format": "prettier --write \"lib/**/*.ts\" \"test/**/*.ts\"",
+    "lint": "eslint --fix",
+    "publish:npm": "npm publish --access=public",
+    "prepublish": "yarn run build",
+    "prepack": "yarn run build"
+  },
+  "dependencies": {
+    "argon2": "^0.41.1"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^10.4.1",
+    "@nestjs/core": "^10.4.1",
+    "@nestjs/cli": "^10.4.5",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "@nestjs/platform-express": "^10.4.1",
+    "@nestjs/schematics": "^10.1.4",
+    "@nestjs/testing": "^10.4.1",
+    "@types/express": "^4.17.21",
+    "@types/jest": "29.5.12",
+    "@types/node": "22.5.4",
+    "@types/supertest": "^6.0.2",
+    "@typescript-eslint/eslint-plugin": "^7.12.0",
+    "@typescript-eslint/parser": "^7.12.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "jest": "29.7.0",
+    "prettier": "^3.3.3",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "ts-jest": "29.2.5",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "4.2.0",
+    "typescript": "^5.4.5",
+    "rimraf": "^5.0.7"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^9.0.0 || ^10.0.0",
+    "@nestjs/core": "^9.0.0 || ^10.0.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}