@clementine-solutions/jane-io 1.0.0 → 1.0.2

package/dist/core/validators/number/positive.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Positive
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a positive number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a positive number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but not strictly greater than zero, a number.not.positive
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const positive: ValidationRule;

package/dist/core/validators/number/positive.js

@@ -0,0 +1,38 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Positive
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a positive number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that the value is a positive number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but not strictly greater than zero, a number.not.positive
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const positive = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${structuralType}'.`, `Please enter a valid number.`, { expected: 'number', actual: structuralType }),
+        ];
+    }
+    if (!(value > 0)) {
+        return [
+            validationEvent('error', 'number.not.positive', path, `${safeStringify(value)} must be > 0.`, `Please enter a positive number.`, { expected: `> 0`, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/number/safe-integer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Safe Integer
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that a value is a safe integer.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that a value is a safe integer.
+ *
+ * Safe integers must be whole numbers that fall within JavaScript’s
+ * IEEE‑754 safe range. This protects downstream logic from precision loss,
+ * overflow‑adjacent behavior, and malformed numeric input that appears valid
+ * but cannot be represented exactly.
+ */
+export declare const safeInteger: ValidationRule;

package/dist/core/validators/number/safe-integer.js

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Safe Integer
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that a value is a safe integer.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that a value is a safe integer.
+ *
+ * Safe integers must be whole numbers that fall within JavaScript’s
+ * IEEE‑754 safe range. This protects downstream logic from precision loss,
+ * overflow‑adjacent behavior, and malformed numeric input that appears valid
+ * but cannot be represented exactly.
+ */
+export const safeInteger = async (value, path) => {
+    const type = detectStructuralType(value);
+    if (typeof value !== 'number') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${type}'.`, `Please enter a valid number.`, { value, expected: 'number', actual: type }),
+        ];
+    }
+    if (!Number.isInteger(value)) {
+        return [
+            validationEvent('error', 'number.not.integer', path, `${safeStringify(value)} must be an integer.`, `Please enter a whole number.`, { value, expected: 'integer', actual: value }),
+        ];
+    }
+    if (!Number.isSafeInteger(value)) {
+        return [
+            validationEvent('error', 'number.not.safe-integer', path, `${safeStringify(value)} must be a safe integer.`, `Please enter a whole number within safe bounds.`, { value, expected: 'safe integer', actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/deep-equals.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Deep Equals
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a value is deeply equal to an expected
+ *                  structural value.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that a value is deeply equal to an expected structural value.
+ *
+ * Deep equality is performed against JSON-compatible values only:
+ * - primitives
+ * - arrays
+ * - plain objects (no class instances, Maps, Sets, Dates, etc.)
+ *
+ * If the value is not structural, an object.not.plain-object event is emitted.
+ * If the value is structural but not deeply equal, an object.not.deeply-equal event is emitted.
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const deepEquals: (expected: unknown) => ValidationRule;

package/dist/core/validators/object/deep-equals.js

@@ -0,0 +1,47 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Deep Equals
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a value is deeply equal to an expected
+ *                  structural value.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { deepEqual, isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a value is deeply equal to an expected structural value.
+ *
+ * Deep equality is performed against JSON-compatible values only:
+ * - primitives
+ * - arrays
+ * - plain objects (no class instances, Maps, Sets, Dates, etc.)
+ *
+ * If the value is not structural, an object.not.plain-object event is emitted.
+ * If the value is structural but not deeply equal, an object.not.deeply-equal event is emitted.
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const deepEquals = (expected) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // Accept primitives, arrays, and plain objects
+    const isStructuralValue = value === null ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        isPlainObject(value);
+    if (!isStructuralValue) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Deep equality requires a structural value, but received '${structuralType}'.`, `Please provide a JSON-compatible value.`, { expected, actual: structuralType }),
+        ];
+    }
+    if (!deepEqual(value, expected)) {
+        return [
+            validationEvent('error', 'object.not.deeply-equal', path, `Value does not match the expected structure.`, `Please provide the correct value.`, { expected, actual: value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/has-key.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Has Key
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains a required own
+ *                  enumerable key.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that a plain object contains a required own enumerable key.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the required key is missing, an object.missing-key event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const hasKey: (requiredKey: string) => ValidationRule;

package/dist/core/validators/object/has-key.js

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Has Key
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains a required own
+ *                  enumerable key.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object contains a required own enumerable key.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the required key is missing, an object.missing-key event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const hasKey = (requiredKey) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!isPlainObject(value)) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Expected a plain object but received '${structuralType}'.`, `Please provide a JSON-compatible object.`, { expected: 'plain object', actual: structuralType }),
+        ];
+    }
+    const hasOwnKey = Object.prototype.hasOwnProperty.call(value, requiredKey);
+    if (!hasOwnKey) {
+        return [
+            validationEvent('error', 'object.has.missing-key', path, `Object must contain key '${requiredKey}'.`, `Please include the required key.`, { expected: requiredKey, actual: Object.keys(value) }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/has-value.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Has Value
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array or plain object contains a value
+ *                  deeply equal to the target.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that an array or plain object contains a value deeply equal to the target.
+ *
+ * This rule accepts only JSON-compatible arrays and plain objects.
+ * Primitives, null, class instances, Maps, Sets, Dates, and other non-collection
+ * values are rejected.
+ *
+ * Arrays are searched using deep equality on each element.
+ * Objects are searched using deep equality on each own enumerable value.
+ *
+ * If the value is not a collection, an object.not.collection event is emitted.
+ * If the target value is not found, a value.not.found event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const hasValue: (target: unknown) => ValidationRule;

package/dist/core/validators/object/has-value.js

@@ -0,0 +1,59 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Has Value
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array or plain object contains a value
+ *                  deeply equal to the target.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { deepEqual, isPlainObject, safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that an array or plain object contains a value deeply equal to the target.
+ *
+ * This rule accepts only JSON-compatible arrays and plain objects.
+ * Primitives, null, class instances, Maps, Sets, Dates, and other non-collection
+ * values are rejected.
+ *
+ * Arrays are searched using deep equality on each element.
+ * Objects are searched using deep equality on each own enumerable value.
+ *
+ * If the value is not a collection, an object.not.collection event is emitted.
+ * If the target value is not found, a value.not.found event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const hasValue = (target) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    const isArray = structuralType === 'array';
+    const isPlainObjectValue = structuralType === 'object' && isPlainObject(value);
+    if (!isArray && !isPlainObjectValue) {
+        return [
+            validationEvent('error', 'object.has.missing-value', path, `Expected array or plain object but received '${structuralType}'.`, `Please provide a collection value.`, { expected: 'array | plain object', actual: structuralType }),
+        ];
+    }
+    const found = deepContainsValue(value, target);
+    if (!found) {
+        return [
+            validationEvent('error', 'value.not.found', path, `Value does not contain ${safeStringify(target)}.`, `Please include the required value.`, { expected: target, actual: value }),
+        ];
+    }
+    return [];
+};
+function deepContainsValue(container, target) {
+    if (deepEqual(container, target))
+        return true;
+    if (Array.isArray(container)) {
+        return container.some((item) => deepContainsValue(item, target));
+    }
+    if (isPlainObject(container)) {
+        return Object.values(container).some((item) => deepContainsValue(item, target));
+    }
+    return false;
+}

package/dist/core/validators/object/keys-equal.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Keys Equal
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains exactly the expected
+ *                  set of keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that a plain object contains exactly the expected set of keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * The object must contain the same number of keys and the same key names as expectedKeys.
+ * Order does not matter. Keys must match exactly.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the key set does not match, an object.invalid-keys event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const keysEqual: (expectedKeys: readonly string[]) => ValidationRule;

package/dist/core/validators/object/keys-equal.js

@@ -0,0 +1,47 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Keys Equal
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains exactly the expected
+ *                  set of keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object contains exactly the expected set of keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * The object must contain the same number of keys and the same key names as expectedKeys.
+ * Order does not matter. Keys must match exactly.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the key set does not match, an object.invalid-keys event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const keysEqual = (expectedKeys) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!isPlainObject(value)) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Expected a plain object but received '${structuralType}'.`, `Please provide a JSON-compatible object.`, { expected: 'plain object', actual: structuralType }),
+        ];
+    }
+    const actualKeys = Object.keys(value);
+    const sameLength = actualKeys.length === expectedKeys.length;
+    const sameMembers = sameLength && expectedKeys.every((key) => actualKeys.includes(key));
+    if (!sameMembers) {
+        return [
+            validationEvent('error', 'object.has.invalid-key', path, `Object keys must match exactly: ${expectedKeys.join(', ')}.`, `Please provide the correct set of keys.`, { expected: expectedKeys, actual: actualKeys }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/max-keys.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Maximum Keys (Max Keys)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains no more than a
+ *                  specified number of keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that a plain object contains no more than a specified number of keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the object contains more than the allowed number of keys, an object.too.many-keys
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const maxKeys: (maximum: number) => ValidationRule;

package/dist/core/validators/object/max-keys.js

@@ -0,0 +1,43 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Maximum Keys (Max Keys)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains no more than a
+ *                  specified number of keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { isPlainObject } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object contains no more than a specified number of keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the object contains more than the allowed number of keys, an object.too.many-keys
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const maxKeys = (maximum) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!isPlainObject(value)) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Expected a plain object but received '${structuralType}'.`, `Please provide a JSON-compatible object.`, { expected: 'plain object', actual: structuralType }),
+        ];
+    }
+    const keyCount = Object.keys(value).length;
+    if (keyCount > maximum) {
+        return [
+            validationEvent('error', 'object.too.many-keys', path, `Object has ${keyCount} keys but must have ≤ ${maximum}.`, `Please provide no more than ${maximum} keys.`, { expected: `≤ ${maximum}`, actual: keyCount }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/min-keys.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Minimum Keys (Min Keys)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains at least a specified
+ *                  number of keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that a plain object contains at least a specified number of keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the object contains fewer than the required number of keys, an object.too.few-keys
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const minKeys: (minimum: number) => ValidationRule;

package/dist/core/validators/object/min-keys.js

@@ -0,0 +1,43 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Minimum Keys (Min Keys)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains at least a specified
+ *                  number of keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object contains at least a specified number of keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the object contains fewer than the required number of keys, an object.too.few-keys
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const minKeys = (minimum) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!isPlainObject(value)) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Expected a plain object but received '${structuralType}'.`, `Please provide a JSON-compatible object.`, { expected: 'plain object', actual: structuralType }),
+        ];
+    }
+    const keyCount = Object.keys(value).length;
+    if (keyCount < minimum) {
+        return [
+            validationEvent('error', 'object.too.few-keys', path, `Object has ${keyCount} keys but must have ≥ ${minimum}.`, `Please provide at least ${minimum} keys.`, { expected: `≥ ${minimum}`, actual: keyCount }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/object/missing-key.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Missing Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains all required own
+ *                  enumerable keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that a plain object contains all required own enumerable keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If one or more required keys are missing, an object.missing-keys event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const missingKey: (requiredKeys: readonly string[]) => ValidationRule;

package/dist/core/validators/object/missing-key.js

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Missing Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains all required own
+ *                  enumerable keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { isPlainObject } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validate that a plain object contains all required own enumerable keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If one or more required keys are missing, an object.missing-keys event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export const missingKey = (requiredKeys) => async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    if (!isPlainObject(value)) {
+        return [
+            validationEvent('error', 'object.not.plain-object', path, `Expected a plain object but received '${structuralType}'.`, `Please provide a JSON-compatible object.`, { expected: 'plain object', actual: structuralType }),
+        ];
+    }
+    const missing = requiredKeys.filter((key) => !Object.prototype.hasOwnProperty.call(value, key));
+    if (missing.length > 0) {
+        return [
+            validationEvent('error', 'object.has.missing-key', path, `Object is missing required keys: ${missing.join(', ')}.`, `Please include all required keys.`, { expected: requiredKeys, actual: Object.keys(value) }),
+        ];
+    }
+    return [];
+};