feat(n4s): added 'isKeyOf' rule

packages/n4s/docs/rules.md

@@ -51,6 +51,8 @@ Enforce rules are functions that allow you to test your data against different c
 - [doesNotStartWith](#doesnotstartwith)
 - [isNegative](#isnegative)
 - [isPositive](#ispositive)
+- [isKeyOf](#iskeyof)
+- [isNotKeyOf](#isnotkeyof)
 
 ## equals
 
@@ -1280,3 +1282,52 @@ enforce('10.12').isPositive(); //passes
 enforce(-10).isPositive(); // throws
 enforce('-10.12').isPositive(); // throws
 ```
+
+## isKeyOf
+
+### Description
+
+Determines whether a value is a key of an object
+
+### Usage examples:
+
+```js
+enforce('banans').isKeyOf({ banans: 5 });
+enforce(1976).isKeyOf({ 1976: 'Rocky' });
+
+// passes
+```
+
+```js
+enforce('avocados').isKeyOf({ cantelopes: 5 });
+enforce(1967).isKeyOf({ 1988: 'Rain Man' });
+enforce('key').isKeyOf(undefined);
+enforce(15).isKeyOf(null);
+enforce('star').isKeyOf(false);
+enforce('triangle').isKeyOf(true);
+// throws
+```
+
+## isNotKeyOf
+
+### Description
+
+Determines whether a value **is not** a key of an object
+
+### Usage examples:
+
+```js
+enforce('avocados').isNotKeyOf({ cantelopes: 5 });
+enforce(1967).isNotKeyOf({ 1988: 'Rain Man' });
+enforce('key').isNotKeyOf(undefined);
+enforce(15).isNotKeyOf(null);
+enforce('star').isNotKeyOf(false);
+enforce('triangle').isNotKeyOf(true);
+// passes
+```
+
+```js
+enforce('banans').isNotKeyOf({ banans: 5 });
+enforce(1976).isNotKeyOf({ 1976: 'Rocky' });
+// throws
+```

packages/n4s/src/rules/__tests__/isKeyOf.test.ts

@@ -0,0 +1,36 @@
+import { isKeyOf } from 'isKeyOf';
+
+const FRUITES = {
+  apples: 5,
+  bananas: 2,
+  cantelopes: 0,
+};
+
+const TOP_GROSSING_MOVIES = {
+  1976: 'Rocky',
+  1988: 'Rain Man',
+  2008: 'The Dark Knight',
+};
+
+const DUMMY_KEY = 'key';
+
+describe('Tests isKeyOf rule', () => {
+  it('When the key exists in the object', () => {
+    expect(isKeyOf('bananas', FRUITES)).toBe(true);
+  });
+
+  it('When the key not exists in the object', () => {
+    expect(isKeyOf('avocados', FRUITES)).toBe(false);
+  });
+
+  it('When the key exists in the object (numeric)', () => {
+    expect(isKeyOf(1976, TOP_GROSSING_MOVIES)).toBe(true);
+  });
+
+  it.each([undefined, null, false, true, Object, [], '', Function.prototype])(
+    'Should return false for %s object',
+    v => {
+      expect(isKeyOf(DUMMY_KEY, v)).toBe(false);
+    }
+  );
+});

packages/n4s/src/rules/isKeyOf.ts

@@ -0,0 +1,13 @@
+import bindNot from 'bindNot';
+import { isBoolean } from 'isBooleanValue';
+import { isNullish } from 'isNullish';
+import { isStringValue } from 'isStringValue';
+
+export function isKeyOf(key: string | symbol | number, obj: any): boolean {
+  const shouldTerminate =
+    isNullish(obj) || isBoolean(obj) || isStringValue(obj);
+
+  return shouldTerminate ? false : key in obj;
+}
+
+export const isNotKeyOf = bindNot(isKeyOf);

packages/n4s/src/runtime/rules.ts

@@ -11,6 +11,7 @@ import { isBlank, isNotBlank } from 'isBlank';
 import { isBoolean, isNotBoolean } from 'isBoolean';
 import { isEmpty, isNotEmpty } from 'isEmpty';
 import { isEven } from 'isEven';
+import { isKeyOf, isNotKeyOf } from 'isKeyOf';
 import { isNaN, isNotNaN } from 'isNaN';
 import { isPositive, isNegative } from 'isNegative';
 import { isNull, isNotNull } from 'isNull';
@@ -52,13 +53,15 @@ export default function rules() {
     isEmpty,
     isEven,
     isFalsy,
+    isKeyOf,
     isNaN,
     isNegative,
     isNotArray,
     isNotBetween,
     isNotBlank,
     isNotBoolean,
     isNotEmpty,
+    isNotKeyOf,
     isNotNaN,
     isNotNull,
     isNotNullish,