type-fns 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Uladzimir Kasacheuski
+
+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/README.md

@@ -0,0 +1,170 @@
+# type-fns
+
+![ci_on_commit](https://github.com/ehmpathy/type-fns/workflows/ci_on_commit/badge.svg)
+![deploy_on_tag](https://github.com/ehmpathy/type-fns/workflows/deploy_on_tag/badge.svg)
+
+Narrow your codepaths with generic types, type checks, and type guards for simpler, safer, and easier to read code.
+
+# Purpose
+
+Narrow your codepaths for simpler, safer, and easier to read code.
+- simplify your code paths with type narrowing using type checks (e.g., `isPresent`, `isAPromise`, `isAFunction`, `isOfEnum`, etc)
+- declare your types more readably with powerful extended types (e.g., `PickOne`, `HasMetadata`, etc)
+
+This library is a collection of generic types, type guards, and type checks we've found the need to define over and over again across different domains, collected in one spot for reusability.
+
+
+
+# Background
+
+Type guards are built from type checks, built on a type predicate.
+- type predicate: `value is 'blue'`
+- type check: `const isBlue(value: any): value is 'blue' = value === 'blue'`
+- type guard: `if (isBlue(color)) throw new Error('should be blue')`
+
+Type guards allow us to to inform typescript we've checked the type of a variable at runtime, enabling type narrowing.
+
+_For more information about typescripts type guards, type checks, and type predicates, [see this section in the typescript docs on "narrowing"](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates)_
+
+
+# Install
+
+```sh
+npm install --save type-fns
+```
+
+# Examples
+
+## generic types
+
+### `PickOne`
+
+The generic type `PickOne` allows you to specify that only one of the keys in the object can be defined, the others must be undefined.
+
+This is very useful when working with an interface where you have exclusive settings. For example:
+```ts
+import { PickOne } from 'type-fns';
+
+const findWrench = async ({
+  size,
+}: {
+  /**
+   * specify the size of the wrench in either `imperial` or `metric` units
+   *
+   * note
+   * - we "PickOne" because this is an exclusive option, a size cant be defined in both
+   */
+  size: PickOne<{
+    metric: {
+      millimeters: number,
+    }
+    imperial: {
+      inches: string,
+    }
+  }>
+}) => {
+  // ...
+}
+
+// you can find by metric
+await findWrench({
+  size: {
+    metric: { millimeters: 16 }
+  }
+})
+
+// you can find by imperial
+await findWrench({
+  size: {
+    imperial: { inches: '5/16' }
+  }
+})
+
+// you can't find by both
+await findWrench({
+  size: {
+    metric: { millimeters: 16 } , // 🛑 typescript error: `Type '{ millimeters: number; }' is not assignable to type 'undefined'.ts(2322)`
+    imperial: { inches: '5/16' }
+  }
+})
+```
+
+## type guards
+
+### `isPresent`
+
+The type predicate of `isPresent` any informs typescript that if a value passes this type check, the value is _not_ `null` or `undefined`:
+
+This is most useful for filtering, to inform typescript that we have removed all `null` or `undefined` values from an array. For example:
+```ts
+import { isPresent } from 'type-fns';
+
+// you have an array that contains strings or nulls
+const stringsOrNulls = ['success:1', 'success:2', null, 'success:3', null]; // type = `(string | null)[]`
+
+// now you want to get rid of all the nulls and only think about the strings: use `isPresent`
+const strings = stringsOrNulls.filter(isPresent); // type = string[]
+
+// the type predicate on the `isPresent` function informs typescript that all of the nulls and undefineds have been removed
+strings.map((string) => string.toUpperCase()); // now you can operate on the strings without typescript complaining!
+```
+
+### `isOfEnum`
+
+The type predicate of `isOfEnum` allows you to check whether a value is a valid member of an enum. For example:
+```ts
+import { createIsOfEnum } from 'type-fns';
+
+// you have an enum
+enum Planet {
+  ...
+  VENUS = 'VENUS',
+  EARTH = 'EARTH',
+  MARS = 'MARS',
+  ...
+}
+
+// define a type check for your enum
+const isPlanet = createIsOfEnum(Planet);
+
+// use your new type check for a type guard
+if (!isPlanet(potentialPlanet)) throw new Error('is not a planet');
+```
+
+### `isAPromise`
+
+The type predicate of `isAPromise` allows you to narrow down the type of any variable that may be a promise
+
+```ts
+import { isAPromise } from 'type-fns';
+
+// imagine we didn't know whether soonerOrLater is a promise or a string
+const soonerOrLater: Promise<string> | string = Promise.resolve('hello') as any;
+
+// typescript wont let you do things not common between the two types, rightly so
+soonerOrLater.toLowerCase(); //  🛑 typescript error: `Property 'toLowerCase' does not exist on type 'string | Promise<string>'.`
+
+// use the type-check to narrow down the the type to operate specifically per type
+if (isAPromise(soonerOrLater)) {
+  soonerOrLater.then((value) => value.toLowerCase()); // no error since type was narrowed to `Promise<string>`
+} else {
+  soonerOrLater.toLowerCase();  // no error since type was narrowed to `string`
+}
+```
+
+### `isAFunction`
+
+The type predicate of `isAFunction` allows you to narrow down the type of any variable that may be a function
+
+This is super helpful when writing apis that can take a literal or a function that creates the literal. For example
+```ts
+const superCoolApi = async ({
+  getConfig
+}: {
+  getConfig: Config | () => Promise<Config>  // this can be the `Config` object or a function which resolves the `Config` object
+}) => {
+  const config: Config = isAFunction(getConfig)
+    ? await getConfig() // if getConfig is a function, then execut it and await it to grab the config
+    : getConfig; // otherwise, it is the config object already
+}
+```

package/changelog.md

@@ -0,0 +1,30 @@
+# Changelog
+
+## [0.4.0](https://www.github.com/ehmpathy/type-fns/compare/v0.3.0...v0.4.0) (2022-11-24)
+
+
+### Features
+
+* **checks:** add isAFunction, isAPromise, and PickOne type checks and generic type ([981ae42](https://www.github.com/ehmpathy/type-fns/commit/981ae4275530bdae203b9013bed193f1afda6b8d))
+
+
+### Bug Fixes
+
+* **cicd:** update github actions, test scripts, and swap repo org to ehmpathy ([b6a1458](https://www.github.com/ehmpathy/type-fns/commit/b6a1458b6d2d5423255fc8eaee2e3181d0c14850))
+* **doc:** fix comment describing has metadata in code ([d7d2e55](https://www.github.com/ehmpathy/type-fns/commit/d7d2e556ba03ad5a573f90d6ea75c5696f493058))
+* **name:** rename package to type-fns ([66258d9](https://www.github.com/ehmpathy/type-fns/commit/66258d93e7964c675b92f50061ddcb11a79f2b69))
+* **tests:** remove example of type error from tests ([326123c](https://www.github.com/ehmpathy/type-fns/commit/326123cf845b31e82edb0d3d50cd6034217df2fa))
+
+## [0.3.0](https://www.github.com/ehmpathy/type-fns/compare/v0.2.1...v0.3.0) (2022-01-03)
+
+
+### Features
+
+* **checks:** add the HasMetadata type modifier ([85f0ca4](https://www.github.com/ehmpathy/type-fns/commit/85f0ca467983ea6f1fc5845990f98dbe9cbe5e8f))
+
+### [0.2.1](https://www.github.com/ehmpathy/type-fns/compare/v0.2.0...v0.2.1) (2021-11-16)
+
+
+### Bug Fixes
+
+* **enum:** forbid giving isOfEnum functions null or undefined as an input ([98ec621](https://www.github.com/ehmpathy/type-fns/commit/98ec6216bc5775cbb2015f400358fe7d5fffc303))

package/dist/checks/hasId.d.ts

@@ -0,0 +1,12 @@
+/**
+ * asserts that an object has an id
+ */
+export declare type HasId<T> = T & {
+    id: number;
+};
+/**
+ * checks whether not an object that may have an id does have the id, at runtime
+ */
+export declare const hasId: <T extends {
+    id?: undefined | number;
+}>(obj: T) => obj is HasId<T>;

package/dist/checks/hasId.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasId = void 0;
+/**
+ * checks whether not an object that may have an id does have the id, at runtime
+ */
+exports.hasId = (obj) => {
+    return !!obj.id;
+};
+//# sourceMappingURL=hasId.js.map

package/dist/checks/hasId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasId.js","sourceRoot":"","sources":["../../src/checks/hasId.ts"],"names":[],"mappings":";;;AAKA;;GAEG;AACU,QAAA,KAAK,GAAG,CAAwC,GAAM,EAAmB,EAAE;IACtF,OAAO,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;AAClB,CAAC,CAAC"}

package/dist/checks/hasMetadata.d.ts

@@ -0,0 +1,23 @@
+/**
+ * these are the keys most commonly used metadata keys
+ */
+declare type TypicalMetadataKeys = 'id' | 'uuid' | 'createdAt' | 'updatedAt' | 'effectiveAt';
+/**
+ * asserts that any optional metadata keys of the object will now be required
+ *
+ * by default, the following keys are considered to be metadata:
+ * - `id`
+ * - `uuid`
+ * - `createdAt`
+ * - `updatedAt`
+ * - `effectiveAt`
+ *
+ * note:
+ * - this type does not make any other optional, non-metadata keys required
+ *   - i.e., any optional types on the object that are not specified as metadata keys will not be made required
+ * - this type does not _add_ any database-generated properties to the type definition
+ *   - i.e., if a metadata key was not already present on the object's type - it will not be added
+ */
+export declare type HasMetadata<T extends Record<string, any>, MetadataKeys = TypicalMetadataKeys> = T & Required<Pick<T, keyof T & // that are on the object
+MetadataKeys>>;
+export {};

package/dist/checks/hasMetadata.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=hasMetadata.js.map

package/dist/checks/hasMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasMetadata.js","sourceRoot":"","sources":["../../src/checks/hasMetadata.ts"],"names":[],"mappings":""}

package/dist/checks/hasUuid.d.ts

@@ -0,0 +1,12 @@
+/**
+ * asserts that an object has a uuid
+ */
+export declare type HasUuid<T> = T & {
+    uuid: string;
+};
+/**
+ * checks whether not an object that may have a uuid does have the uuid, at runtime
+ */
+export declare const hasUuid: <T extends {
+    uuid?: undefined | string;
+}>(obj: T) => obj is HasUuid<T>;

package/dist/checks/hasUuid.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasUuid = void 0;
+/**
+ * checks whether not an object that may have a uuid does have the uuid, at runtime
+ */
+exports.hasUuid = (obj) => {
+    return typeof obj.uuid === 'string';
+};
+//# sourceMappingURL=hasUuid.js.map

package/dist/checks/hasUuid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasUuid.js","sourceRoot":"","sources":["../../src/checks/hasUuid.ts"],"names":[],"mappings":";;;AAKA;;GAEG;AACU,QAAA,OAAO,GAAG,CAA0C,GAAM,EAAqB,EAAE;IAC5F,OAAO,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAC;AACtC,CAAC,CAAC"}

package/dist/checks/isAFunction.d.ts

@@ -0,0 +1 @@
+export declare const isAFunction: (obj: any) => obj is Function;

package/dist/checks/isAFunction.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAFunction = void 0;
+exports.isAFunction = (obj) => typeof obj === 'function';
+//# sourceMappingURL=isAFunction.js.map

package/dist/checks/isAFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAFunction.js","sourceRoot":"","sources":["../../src/checks/isAFunction.ts"],"names":[],"mappings":";;;AAAa,QAAA,WAAW,GAAG,CAAC,GAAQ,EAAmB,EAAE,CAAC,OAAO,GAAG,KAAK,UAAU,CAAC"}

package/dist/checks/isAPromise.d.ts

@@ -0,0 +1,4 @@
+/**
+ * checks whether the value is a promise
+ */
+export declare const isAPromise: <T extends unknown = any>(obj: any) => obj is Promise<T>;

package/dist/checks/isAPromise.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAPromise = void 0;
+/**
+ * checks whether the value is a promise
+ */
+exports.isAPromise = (obj) => Promise.resolve(obj) === obj;
+//# sourceMappingURL=isAPromise.js.map

package/dist/checks/isAPromise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAPromise.js","sourceRoot":"","sources":["../../src/checks/isAPromise.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACU,QAAA,UAAU,GAAG,CAAsB,GAAQ,EAAqB,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC"}

package/dist/checks/isOfEnum.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `Something` = `any`, with the exclusion of `null` and `undefined`
+ */
+declare type Something = {};
+/**
+ * a generic fn that allows us to create type checks for enums. for example:
+ * ```ts
+ *   // you have an enum
+ *   enum Planet {
+ *     ...
+ *     VENUS = 'VENUS',
+ *     EARTH = 'EARTH',
+ *     MARS = 'MARS',
+ *     ...
+ *   }
+ *
+ *   // define a type check for your enum
+ *   const isPlanet = createIsOfEnum(Planet);
+ *
+ *   // use your new type check for a type guard
+ *   if (!isPlanet(potentialPlanet)) throw new Error('is not a planet');
+ * ```
+ *
+ * ref: https://stackoverflow.com/a/58278753/3068233
+ */
+export declare const createIsOfEnum: <T>(e: T) => (token: Something) => token is T[keyof T];
+export {};

package/dist/checks/isOfEnum.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIsOfEnum = void 0;
+/**
+ * a generic fn that allows us to create type checks for enums. for example:
+ * ```ts
+ *   // you have an enum
+ *   enum Planet {
+ *     ...
+ *     VENUS = 'VENUS',
+ *     EARTH = 'EARTH',
+ *     MARS = 'MARS',
+ *     ...
+ *   }
+ *
+ *   // define a type check for your enum
+ *   const isPlanet = createIsOfEnum(Planet);
+ *
+ *   // use your new type check for a type guard
+ *   if (!isPlanet(potentialPlanet)) throw new Error('is not a planet');
+ * ```
+ *
+ * ref: https://stackoverflow.com/a/58278753/3068233
+ */
+exports.createIsOfEnum = (e) => (token) => Object.values(e).includes(token);
+//# sourceMappingURL=isOfEnum.js.map

package/dist/checks/isOfEnum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isOfEnum.js","sourceRoot":"","sources":["../../src/checks/isOfEnum.ts"],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACU,QAAA,cAAc,GAAG,CAAI,CAAI,EAAE,EAAE,CAAC,CAAC,KAAgB,EAAuB,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAmB,CAAC,CAAC"}

package/dist/checks/isPresent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * checks whether the value is defined and is not null
+ *
+ * https://github.com/microsoft/TypeScript/issues/16069#issuecomment-566222173
+ */
+export declare const isPresent: <T>(t: void | T | null | undefined) => t is T;

package/dist/checks/isPresent.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPresent = void 0;
+/**
+ * checks whether the value is defined and is not null
+ *
+ * https://github.com/microsoft/TypeScript/issues/16069#issuecomment-566222173
+ */
+exports.isPresent = (t) => t !== undefined && t !== null;
+//# sourceMappingURL=isPresent.js.map

package/dist/checks/isPresent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPresent.js","sourceRoot":"","sources":["../../src/checks/isPresent.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACU,QAAA,SAAS,GAAG,CAAI,CAA8B,EAAU,EAAE,CAAC,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,IAAI,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './checks/hasId';
+export * from './checks/hasUuid';
+export * from './checks/hasMetadata';
+export * from './checks/isPresent';
+export * from './checks/isOfEnum';
+export * from './wrappers/withNot';

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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./checks/hasId"), exports);
+__exportStar(require("./checks/hasUuid"), exports);
+__exportStar(require("./checks/hasMetadata"), exports);
+__exportStar(require("./checks/isPresent"), exports);
+__exportStar(require("./checks/isOfEnum"), exports);
+__exportStar(require("./wrappers/withNot"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,iDAA+B;AAC/B,mDAAiC;AACjC,uDAAqC;AACrC,qDAAmC;AACnC,oDAAkC;AAClC,qDAAmC"}

package/dist/types/PickOne.d.ts

@@ -0,0 +1,9 @@
+/**
+ * creates a type which allows specifying one, and only one, key of an object
+ *
+ * ref:
+ * - https://stackoverflow.com/a/56933182/3068233
+ */
+export declare type PickOne<T> = {
+    [P in keyof T]: Record<P, T[P]> & Partial<Record<Exclude<keyof T, P>, undefined>>;
+}[keyof T];

package/dist/types/PickOne.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PickOne.js.map

package/dist/types/PickOne.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PickOne.js","sourceRoot":"","sources":["../../src/types/PickOne.ts"],"names":[],"mappings":""}

package/dist/wrappers/withNot.d.ts

@@ -0,0 +1,11 @@
+/**
+ * a wrapper that enables you to easily negate the result of a type check function
+ *
+ * for example:
+ * ```ts
+ * const withoutIds = objects.filter(withNot(hasUuid));
+ *
+ * const invalidOptions = objects.filter(withNot(isOfStatus));
+ * ```
+ */
+export declare const withNot: <T>(is: (args: T) => boolean) => (args: T) => boolean;

package/dist/wrappers/withNot.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withNot = void 0;
+/**
+ * a wrapper that enables you to easily negate the result of a type check function
+ *
+ * for example:
+ * ```ts
+ * const withoutIds = objects.filter(withNot(hasUuid));
+ *
+ * const invalidOptions = objects.filter(withNot(isOfStatus));
+ * ```
+ */
+exports.withNot = (is) => (args) => !is(args);
+//# sourceMappingURL=withNot.js.map

package/dist/wrappers/withNot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withNot.js","sourceRoot":"","sources":["../../src/wrappers/withNot.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACU,QAAA,OAAO,GAAG,CAAI,EAAwB,EAA0B,EAAE,CAAC,CAAC,IAAO,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "type-fns",
+  "version": "0.4.0",
+  "description": "A set of types, type checks, and type guards for simpler, safer, and easier to read code.",
+  "author": "UladKasach @uladkasach",
+  "license": "MIT",
+  "repository": "ehmpathy/type-fns",
+  "homepage": "https://github.com/ehmpathy/type-fns",
+  "keywords": [
+    "types",
+    "type guards",
+    "guards",
+    "type checks",
+    "checks",
+    "type",
+    "checking",
+    "typescript"
+  ],
+  "bugs": "https://github.com/ehmpathy/type-fns/issues",
+  "main": "dist/index.js",
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "build:clean": "rm -rf ./dist",
+    "build:ts": "tsc -p ./tsconfig.build.json",
+    "build": "npm run build:clean && npm run build:ts",
+    "test:types": "tsc --noEmit",
+    "test:format": "prettier --parser typescript --check 'src/**/*.ts' --config ./prettier.config.js",
+    "test:lint": "eslint -c ./.eslintrc.js src/**/*.ts",
+    "test:unit": "jest --forceExit --verbose --passWithNoTests",
+    "test:integration": "jest -c ./jest.integration.config.js --forceExit --verbose --passWithNoTests",
+    "test": "npm run test:types && npm run test:lint && npm run test:unit && npm run test:integration",
+    "prepublish": "npm run build",
+    "preversion": "npm run prepublish && npm run test",
+    "postversion": "git push origin HEAD --tags --no-verify"
+  },
+  "devDependencies": {
+    "@types/jest": "^24.0.18",
+    "@types/lodash.pick": "^4.4.6",
+    "@types/uuid": "^3.4.5",
+    "@typescript-eslint/eslint-plugin": "2.19.0",
+    "@typescript-eslint/parser": "2.19.0",
+    "dotenv": "^8.1.0",
+    "eslint": "6.1.0",
+    "eslint-config-airbnb-base": "14.0.0",
+    "eslint-config-airbnb-typescript": "7.0.0",
+    "eslint-config-prettier": "6.10.0",
+    "eslint-plugin-import": "2.20.1",
+    "eslint-plugin-prettier": "3.1.2",
+    "husky": "^1.3.1",
+    "jest": "^25.5.4",
+    "joi": "^17.2.1",
+    "prettier": "^2.0.4",
+    "ts-jest": "^25.4.0",
+    "typescript": "^3.8.3",
+    "uuid": "^3.3.3",
+    "yup": "^0.29.3"
+  },
+  "dependencies": {}
+}