@lucania/schema 3.0.1 → 3.0.3

package/build/builder.d.ts

@@ -1,47 +1,158 @@
-import { BaseSchemaAny } from "./typing/extended";
-import { DefaultValue, ModelValue } from "./typing/toolbox";
+import { BaseSchema, SourceValue } from ".";
 import { AnySchema } from "./schema/AnySchema";
 import { ArraySchema, ArraySource } from "./schema/ArraySchema";
 import { BooleanSchema, BooleanSource } from "./schema/BooleanSchema";
+import { ConstantSchema, ConstantSource } from "./schema/ConstantSchema";
 import { DateSchema, DateSource } from "./schema/DateSchema";
 import { DynamicObjectSchema, DynamicObjectSource } from "./schema/DynamicObjectSchema";
 import { EnumerationSchema } from "./schema/EnumerationSchema";
+import { LenientObjectModel, LenientObjectSchema, LenientObjectSource, LenientObjectSubschema } from "./schema/LenientObject";
 import { NumberSchema, NumberSource } from "./schema/NumberSchema";
 import { ObjectSchema, ObjectSource, ObjectSubschema } from "./schema/ObjectSchema";
 import { OrSetSchema, OrSetSchemaSource } from "./schema/OrSetSchema";
 import { StringSchema, StringSource } from "./schema/StringSchema";
-import { BaseSchema, SourceValue } from ".";
+import { BaseSchemaAny } from "./typing/extended";
+import { DefaultValue, ModelValue } from "./typing/toolbox";
+/**
+ * A collection of helper functions used to create the standard set of schemas.
+ */
 export declare namespace Schema {
+    /**
+    * Creates a schema used to validate a string.
+    *
+    * @param required Flag representing whether the schema should enforce a value's presence.
+    * @param defaultValue A default the schema will use during validation if a value is not present.
+    * @returns A schema used to validate a string.
+    */
     function String(): StringSchema<true, undefined>;
     function String<Required extends boolean>(required: Required): StringSchema<Required, undefined>;
     function String<Required extends boolean, Default extends DefaultValue<StringSource>>(required: Required, defaultValue: Default): StringSchema<Required, Default>;
+    /**
+    * Creates a schema used to validate a number.
+    *
+    * @param required Flag representing whether the schema should enforce a value's presence.
+    * @param defaultValue A default the schema will use during validation if a value is not present.
+    * @returns A schema used to validate a number.
+    */
     function Number(): NumberSchema<true, undefined>;
     function Number<Required extends boolean>(required: Required): NumberSchema<Required, undefined>;
     function Number<Required extends boolean, Default extends DefaultValue<NumberSource>>(required: Required, defaultValue: Default): NumberSchema<Required, Default>;
+    /**
+    * Creates a schema used to validate a boolean.
+    *
+    * @param required Flag representing whether the schema should enforce a value's presence.
+    * @param defaultValue A default the schema will use during validation if a value is not present.
+    * @returns A schema used to validate a boolean.
+    */
     function Boolean(): BooleanSchema<true, undefined>;
     function Boolean<Required extends boolean>(required: Required): BooleanSchema<Required, undefined>;
     function Boolean<Required extends boolean, Default extends DefaultValue<BooleanSource>>(required: Required, defaultValue: Default): BooleanSchema<Required, Default>;
+    /**
+    * Creates a schema used to validate a Date.
+    *
+    * @param required Flag representing whether the schema should enforce a value's presence.
+    * @param defaultValue A default the schema will use during validation if a value is not present.
+    * @returns A schema used to validate a Date.
+    */
     function Date(): DateSchema<true, undefined>;
     function Date<Required extends boolean>(required: Required): DateSchema<Required, undefined>;
     function Date<Required extends boolean, Default extends DefaultValue<DateSource>>(required: Required, defaultValue: Default): DateSchema<Required, Default>;
+    /**
+    * Creates a schema used to validate anything! Any value will pass the validation provided by schemas created by this function.
+    *
+    * @param required Flag representing whether the schema should enforce a value's presence.
+    * @param defaultValue A default the schema will use during validation if a value is not present.
+    * @returns A schema used to validate anything.
+    */
     function Any(): AnySchema<true, undefined>;
     function Any<Required extends boolean>(required: Required): AnySchema<Required, undefined>;
     function Any<Required extends boolean, Default extends DefaultValue<any>>(required: Required, defaultValue: Default): AnySchema<Required, Default>;
+    /**
+    * Creates a schema used to validate an object.
+    *
+    * This function can be used to create schemas that describe a value's object hierarchy.
+    *
+    * @note Values validated by schemas created by this function will only retain properties specified by the schema.
+    *
+    * @example
+    * ```ts
+    * $.Object({ name: $.String() }).validate({ name: "Jeremy", age: 1 })
+    * ```
+    * ->
+    * ```ts
+    * { "name": "Jeremy" }
+    * ```
+    *
+    * @param subschema An object describing the sole keys and values that must be present within an object.
+    * @param required Flag representing whether the schema should enforce a value's presence.
+    * @param defaultValue A default the schema will use during validation if a value is not present.
+    * @returns A schema used to validate an object.
+    */
     function Object<Subschema extends ObjectSubschema>(subschema: Subschema): ObjectSchema<Subschema, true, undefined>;
     function Object<Subschema extends ObjectSubschema, Required extends boolean>(subschema: Subschema, required: Required): ObjectSchema<Subschema, Required, undefined>;
     function Object<Subschema extends ObjectSubschema, Required extends boolean, Default extends DefaultValue<ObjectSource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): ObjectSchema<Subschema, Required, Default>;
+    /**
+    * Creates a schema used to validate an object.
+    *
+    * This function can be used to create schemas that describe a value's object hierarchy.
+    *
+    * @note This function creates schemas that differ from that of `$.Object` in that the values validated by schemas created by this function
+    * will RETAIN the properties not specified by the schema.
+    *
+    * @example
+    * ```ts
+    * $.LenientObject({ name: $.String() }).validate({ name: "Jeremy", age: 1 })
+    * ```
+    * ->
+    * ```ts
+    * { "name": "Jeremy", "age": 1 }
+    * ```
+    *
+    * @param subschema An object describing keys and values that must be present amongst any other keys and values within an object.
+    * @param required Flag representing whether the schema should enforce a value's presence.
+    * @param defaultValue A default the schema will use during validation if a value is not present.
+    * @returns A schema used to validate an object.
+    */
+    function LenientObject<Subschema extends LenientObjectSubschema>(subschema: Subschema): LenientObjectSchema<Subschema, LenientObjectSource<Subschema>, LenientObjectModel<Subschema>, true, undefined>;
+    function LenientObject<Subschema extends LenientObjectSubschema, Required extends boolean>(subschema: Subschema, required: Required): LenientObjectSchema<Subschema, LenientObjectSource<Subschema>, LenientObjectModel<Subschema>, Required, undefined>;
+    function LenientObject<Subschema extends LenientObjectSubschema, Required extends boolean, Default extends DefaultValue<LenientObjectSource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): LenientObjectSchema<Subschema, LenientObjectSource<Subschema>, LenientObjectModel<Subschema>, Required, Default>;
+    /**
+    * Creates a schema used to validate an object.
+    *
+    * This function can be used to create schemas that describe a value's object hierarchy.
+    *
+    * @note This function creates schemas that differ from that of `$.Object` in that schemas created by this function can have ANY string keys
+    * and only their values will be validated against the supplied `subschema`.
+    *
+    * @example
+    * ```ts
+    * $.DynamicObject($.String()).validate({ name: "Jeremy", age: 1, randomKey: true })
+    * ```
+    * ->
+    * ```ts
+    * { "name": "Jeremy", "age": "1", "randomKey": "true" }
+    * ```
+    *
+    * @param subschema Schema used to validate values within an object with dynamic keys.
+    * @param required Flag representing whether the schema should enforce a value's presence.
+    * @param defaultValue A default the schema will use during validation if a value is not present.
+    * @returns A schema used to validate an object.
+    */
+    function DynamicObject<Subschema extends BaseSchemaAny>(subschema: Subschema): DynamicObjectSchema<Subschema, true, undefined>;
+    function DynamicObject<Subschema extends BaseSchemaAny, Required extends boolean>(subschema: Subschema, required: Required): DynamicObjectSchema<Subschema, Required, undefined>;
+    function DynamicObject<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<DynamicObjectSource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): DynamicObjectSchema<Subschema, Required, Default>;
     function Array<Subschema extends BaseSchemaAny>(subschema: Subschema): ArraySchema<Subschema, true, undefined>;
     function Array<Subschema extends BaseSchemaAny, Required extends boolean>(subschema: Subschema, required: Required): ArraySchema<Subschema, Required, undefined>;
     function Array<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<ArraySource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): ArraySchema<Subschema, Required, Default>;
     function Enumeration<Member extends string>(subschema: TypedMembers<Member>): EnumerationSchema<Member, true, undefined>;
     function Enumeration<Member extends string, Required extends boolean>(subschema: TypedMembers<Member>, required: Required): EnumerationSchema<Member, Required, undefined>;
     function Enumeration<Member extends string, Required extends boolean, Default extends DefaultValue<Member>>(subschema: TypedMembers<Member>, required: Required, defaultValue: Default): EnumerationSchema<Member, Required, Default>;
-    function DynamicObject<Subschema extends BaseSchemaAny>(subschema: Subschema): DynamicObjectSchema<Subschema, true, undefined>;
-    function DynamicObject<Subschema extends BaseSchemaAny, Required extends boolean>(subschema: Subschema, required: Required): DynamicObjectSchema<Subschema, Required, undefined>;
-    function DynamicObject<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<DynamicObjectSource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): DynamicObjectSchema<Subschema, Required, Default>;
     function OrSet<MemberSchema extends BaseSchemaAny>(subschema: TypedMembers<MemberSchema>): OrSetSchema<MemberSchema, true, undefined>;
     function OrSet<MemberSchema extends BaseSchemaAny, Required extends boolean>(subschema: TypedMembers<MemberSchema>, required: Required): OrSetSchema<MemberSchema, Required, undefined>;
     function OrSet<MemberSchema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<OrSetSchemaSource<MemberSchema>>>(subschema: TypedMembers<MemberSchema>, required: Required, defaultValue: Default): OrSetSchema<MemberSchema, Required, Default>;
+    function Constant<Constant extends ConstantSource>(constant: Constant): ConstantSchema<Constant, true, undefined>;
+    function Constant<Constant extends ConstantSource, Required extends boolean>(constant: Constant, required: Required): ConstantSchema<Constant, Required, undefined>;
+    function Constant<Constant extends ConstantSource, Required extends boolean, Default extends DefaultValue<Constant>>(constant: Constant, required: Required, defaultValue: Default): ConstantSchema<Constant, Required, Default>;
     type TypedMembers<Member extends any> = {
         $members: Member[];
     };

package/build/index.d.ts

@@ -5,9 +5,11 @@ export * from "./schema/AnySchema";
 export * from "./schema/ArraySchema";
 export * from "./schema/BaseSchema";
 export * from "./schema/BooleanSchema";
+export * from "./schema/ConstantSchema";
 export * from "./schema/DateSchema";
 export * from "./schema/DynamicObjectSchema";
 export * from "./schema/EnumerationSchema";
+export * from "./schema/LenientObject";
 export * from "./schema/NumberSchema";
 export * from "./schema/ObjectSchema";
 export * from "./schema/OrSetSchema";

package/build/index.js

@@ -99,28 +99,32 @@
             };
             try {
                 result = this._executeAdditionalValidator(result, pass, "beforeAll");
+                // Handle Default
                 result = this._executeAdditionalValidator(result, pass, "beforeDefault");
                 if (!BaseSchema.isPresent(result) && this.hasDefault()) {
                     result = this.getDefault(pass);
                 }
                 result = this._executeAdditionalValidator(result, pass, "afterDefault");
-                result = this._executeAdditionalValidator(result, pass, "beforeConversion");
-                if (BaseSchema.isPresent(result)) {
-                    if (BaseSchema.getType(result) !== this.type) {
-                        result = this.convert(result, pass);
-                    }
-                    result = this._validate(result, presentOptions, pass);
-                    result = this._executeAdditionalValidator(result, pass, "afterConversion");
-                }
-                else {
-                    if (this._required) {
-                        throw pass.causeError(pass.path.length > 0 ? `Missing required value at "${pass.path.join(".")}".` : "Missing required value.");
+                // Handle Required
+                if (!BaseSchema.isPresent(result)) {
+                    if (this.isRequired()) {
+                        throw pass.causeError(pass.path.length > 0 ? `Missing required ${this.type} at path "${pass.path.join(".")}".` : `Missing required ${this.type}.`);
                     }
                     else {
                         result = undefined;
                     }
                 }
-                if (this._required || result !== undefined) {
+                // Handle Conversion
+                if (result !== undefined) {
+                    result = this._executeAdditionalValidator(result, pass, "beforeConversion");
+                    if (BaseSchema.getType(result) !== this.type) {
+                        result = this.convert(result, pass);
+                    }
+                    result = this._executeAdditionalValidator(result, pass, "afterConversion");
+                }
+                // Handle Validation
+                if (this.isRequired() || result !== undefined) {
+                    result = this._validate(result, presentOptions, pass);
                     result = this._executeAdditionalValidator(result, pass, "afterAll");
                 }
             }
@@ -245,12 +249,12 @@
             }
         }
         /**
-         * Checks to see if a value is present. (Not null or undefined)
+         * Checks to see if a value is present. (Not undefined)
          * @param value The value to check the presence of.
-         * @returns true if value is not null or undefined, false otherwise.
+         * @returns true if value is undefined, false otherwise.
          */
         static isPresent(value) {
-            return value !== undefined && value !== null;
+            return value !== undefined;
         }
         static getType(value) {
             if (value === null) {
@@ -315,6 +319,15 @@
             else if (typeof value === "string") {
                 return [value];
             }
+            else if (typeof value === "object") {
+                return Object.entries(value).reduce((array, [key, item]) => {
+                    const index = parseInt(key);
+                    pass.assert(!isNaN(index), `Unable to convert ${BaseSchema.getType(value)} to array. ` +
+                        `Encountered key that is not a valid array index: "${key}"`);
+                    array[index] = item;
+                    return array;
+                }, []);
+            }
             else {
                 throw pass.causeError(`Unable to convert ${BaseSchema.getType(value)} to array.`);
             }
@@ -369,6 +382,31 @@
         }
     }
 
+    class ConstantSchema extends BaseSchema {
+        value;
+        constructor(subschema, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
+            this.value = subschema;
+        }
+        get type() { return BaseSchema.getType(this.value); }
+        _validate(source, options, pass) {
+            pass.assert(this.value === source, `Supplied source (${JSON.stringify(source)}) did not match expected constant value (${JSON.stringify(this.value)}).`);
+            return source;
+        }
+        convert(value, pass) {
+            return value;
+        }
+        clone() {
+            return new ConstantSchema(this.value, this._required, this._default, this._additionalValidationPasses);
+        }
+        getJsonSchema() {
+            return {
+                type: "string",
+                description: this._getJsonSchemaDescription(),
+            };
+        }
+    }
+
     const StandardDate = globalThis.Date;
     class DateSchema extends BaseSchema {
         get type() { return "Date"; }
@@ -500,6 +538,97 @@
         }
     }
 
+    class LenientObjectSchema extends BaseSchema {
+        subschema;
+        constructor(subschema, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
+            this.subschema = subschema;
+        }
+        get type() { return "object"; }
+        _validate(source, options, pass) {
+            const inputObject = source;
+            let outputObject = { ...inputObject };
+            for (const key in this.subschema) {
+                const nestedSchema = this.subschema[key];
+                const nestedValue = inputObject[key];
+                outputObject[key] = this.subschema[key].validate(inputObject[key], options, pass.next([...pass.path, key], nestedSchema, nestedValue));
+            }
+            return outputObject;
+        }
+        convert(value, pass) {
+            pass.assert(typeof value === "object", `Unable to convert ${LenientObjectSchema.getType(value)} to object.`);
+            const inputObject = value;
+            const outputObject = { ...inputObject };
+            for (const key in this.subschema) {
+                const nestedSchema = this.subschema[key];
+                const nestedValue = inputObject[key];
+                outputObject[key] = nestedSchema.convert(nestedValue, pass.next([...pass.path, key], nestedSchema, nestedValue));
+            }
+            return outputObject;
+        }
+        // Works at runtime, can't figure out typing.
+        // public extend<
+        //     ExtensionSubschema extends LenientObjectSubschema,
+        //     ExtensionSource extends LenientObjectSource<ExtensionSubschema>,
+        //     ExtensionModel extends LenientObjectModel<ExtensionSubschema>,
+        //     ExtensionDefault extends DefaultValue<ExtensionSource>
+        // >(schema: LenientObjectSchema<ExtensionSubschema, ExtensionSource, ExtensionModel, Required, ExtensionDefault>):
+        //     // LenientObjectSchema<ExtensionSubschema & Subschema, ExtensionSource & Source, ExtensionModel & Model, Required, DefaultValue<ExtensionSource & Source>>
+        //     ExtendedLenientObjectSchema<this, LenientObjectSchema<ExtensionSubschema, ExtensionSource, ExtensionModel, Required, ExtensionDefault>> {
+        //     let defaultValue: any = undefined;
+        //     if (this.hasDefault() !== schema.hasDefault()) {
+        //         throw new Error("Both or neither default values must be specified in order to extend a schema!");
+        //     }
+        //     if (this.hasDefault() && schema.hasDefault()) {
+        //         defaultValue = (pass: ValidationPass) => {
+        //             return {
+        //                 ...this.getDefault(pass),
+        //                 ...schema.getDefault(pass)
+        //             };
+        //         };
+        //     }
+        //     const subschema: any = { ...this.subschema };
+        //     for (const key in schema.subschema) {
+        //         if (key in this.subschema) {
+        //             this.subschema[key].extend(schema.subschema[key]);
+        //         } else {
+        //             subschema[key] = schema.subschema[key];
+        //         }
+        //     }
+        //     return new LenientObjectSchema(subschema, this._required, defaultValue) as any;
+        // }
+        getJsonSchema() {
+            const properties = {};
+            for (const key in this.subschema) {
+                properties[key] = this.subschema[key].getJsonSchema();
+            }
+            return {
+                type: "object",
+                description: this._getJsonSchemaDescription(),
+                properties
+            };
+        }
+        clone() {
+            const subschema = {};
+            for (const key in this.subschema) {
+                subschema[key] = this.subschema[key].clone();
+            }
+            return new LenientObjectSchema(subschema, this._required, this._default, this._additionalValidationPasses);
+        }
+        toString(level = 0) {
+            const indent = "  ";
+            const prefix = indent.repeat(level);
+            const pieces = [];
+            pieces.push(`${super.toString()}({\n`);
+            for (const schemaKey in this.subschema) {
+                const subschema = this.subschema[schemaKey];
+                pieces.push(`${prefix}${indent}${schemaKey}: ${subschema.toString(level + 1)}\n`);
+            }
+            pieces.push(`${prefix}})`);
+            return pieces.join("");
+        }
+    }
+
     class NumberSchema extends BaseSchema {
         get type() { return "number"; }
         _validate(source, options, pass) {
@@ -587,21 +716,6 @@
             }
             return model;
         }
-        extend(schema) {
-            let defaultValue = undefined;
-            if (this.hasDefault() !== schema.hasDefault()) {
-                throw new Error("Both or neither default values must be specified in order to extend a schema!");
-            }
-            if (this.hasDefault() && schema.hasDefault()) {
-                defaultValue = (pass) => {
-                    return {
-                        ...this.getDefault(pass),
-                        ...schema.getDefault(pass)
-                    };
-                };
-            }
-            return new ObjectSchema({ ...this.subschema, ...schema.subschema }, this._required, defaultValue);
-        }
         getJsonSchema() {
             const properties = {};
             for (const key in this.subschema) {
@@ -644,34 +758,52 @@
             return "string";
         }
         _validate(source, options, pass) {
-            let result = source;
-            if (result !== undefined) {
-                let done = false;
-                const failureMessages = [];
-                for (let i = 0; i < this.schemas.length && !done; i++) {
-                    const schema = this.schemas[i];
-                    try {
-                        if (BaseSchema.getType(result) === schema.type) {
-                            result = schema.validate(result, options, pass);
-                            done = true;
-                        }
-                    }
-                    catch (error) {
-                        if (error instanceof Error) {
-                            failureMessages.push(`Schema #${i + 1}: ${error.message}`);
-                        }
-                        else {
-                            failureMessages.push(`Schema #${i + 1}: ${String(error)}`);
-                        }
+            const errors = {};
+            for (let i = 0; i < this.schemas.length; i++) {
+                const schema = this.schemas[i];
+                try {
+                    if (BaseSchema.getType(source) !== schema.type) {
+                        throw new ValidationError(new ValidationPass(schema, source, undefined), `Conversions for schemas in an OrSet are disabled.`);
                     }
+                    return schema.validate(source);
                 }
-                if (!done) {
-                    failureMessages.push(`Conversions for schemas in an OrSet are disabled.`);
+                catch (error) {
+                    errors[i] = error;
                 }
-                pass.assert(failureMessages.length === 0, `Provided value (${BaseSchema.getType(result)}) matched no schemas ` +
-                    `(${this.schemas.map((schema) => schema.type).join(", ")}).\n${failureMessages.join("\n")}`);
             }
-            return result;
+            const errorMessages = Object.entries(errors).map(([index, error]) => `Schema #${parseInt(index) + 1}: ${error === undefined ? "Unknown error." : error.message}`);
+            throw pass.causeError(`Provided value (${BaseSchema.getType(source)}) matched no schemas ` +
+                `(${this.schemas.map((schema) => schema.type).join(", ")}).\n` +
+                `${errorMessages.join("\n")}`);
+            // let result = source;
+            // if (result !== undefined) {
+            //     let done = false;
+            //     const failureMessages: string[] = [];
+            //     for (let i = 0; i < this.schemas.length && !done; i++) {
+            //         const schema = this.schemas[i];
+            //         try {
+            //             if (BaseSchema.getType(result) === schema.type) {
+            //                 result = schema.validate(result, options, pass);
+            //                 done = true;
+            //             }
+            //         } catch (error) {
+            //             if (error instanceof Error) {
+            //                 failureMessages.push(`Schema #${i + 1}: ${error.message}`);
+            //             } else {
+            //                 failureMessages.push(`Schema #${i + 1}: ${String(error)}`);
+            //             }
+            //         }
+            //     }
+            //     if (!done) {
+            //         failureMessages.push(`Conversions for schemas in an OrSet are disabled.`);
+            //     }
+            //     pass.assert(
+            //         failureMessages.length === 0,
+            //         `Provided value (${BaseSchema.getType(result)}) matched no schemas ` +
+            //         `(${this.schemas.map((schema) => schema.type).join(", ")}).\n${failureMessages.join("\n")}`
+            //     );
+            // }
+            // return result;
         }
         convert(value, pass) {
             return value;
@@ -753,6 +885,9 @@
         }
     }
 
+    /**
+     * A collection of helper functions used to create the standard set of schemas.
+     */
     exports.Schema = void 0;
     (function (Schema) {
         function String(required = true, defaultValue = undefined) {
@@ -779,6 +914,14 @@
             return new ObjectSchema(subschema, required, defaultValue);
         }
         Schema.Object = Object;
+        function LenientObject(subschema, required = true, defaultValue = undefined) {
+            return new LenientObjectSchema(subschema, required, defaultValue);
+        }
+        Schema.LenientObject = LenientObject;
+        function DynamicObject(subschema, required = true, defaultValue = undefined) {
+            return new DynamicObjectSchema(subschema, required, defaultValue);
+        }
+        Schema.DynamicObject = DynamicObject;
         function Array(subschema, required = true, defaultValue = undefined) {
             return new ArraySchema(subschema, required, defaultValue);
         }
@@ -787,14 +930,14 @@
             return new EnumerationSchema(members.$members, required, defaultValue);
         }
         Schema.Enumeration = Enumeration;
-        function DynamicObject(subschema, required = true, defaultValue = undefined) {
-            return new DynamicObjectSchema(subschema, required, defaultValue);
-        }
-        Schema.DynamicObject = DynamicObject;
         function OrSet(members, required = true, defaultValue = undefined) {
             return new OrSetSchema(members.$members, required, defaultValue);
         }
         Schema.OrSet = OrSet;
+        function Constant(value, required = true, defaultValue = undefined) {
+            return new ConstantSchema(value, required, defaultValue);
+        }
+        Schema.Constant = Constant;
         function Members(...members) {
             /*
              * HACK START: The hermes JS engine doesn't use globalThis.Array when interpreting `...members`
@@ -823,9 +966,11 @@
     exports.ArraySchema = ArraySchema;
     exports.BaseSchema = BaseSchema;
     exports.BooleanSchema = BooleanSchema;
+    exports.ConstantSchema = ConstantSchema;
     exports.DateSchema = DateSchema;
     exports.DynamicObjectSchema = DynamicObjectSchema;
     exports.EnumerationSchema = EnumerationSchema;
+    exports.LenientObjectSchema = LenientObjectSchema;
     exports.NumberSchema = NumberSchema;
     exports.ObjectSchema = ObjectSchema;
     exports.OrSetSchema = OrSetSchema;

package/build/schema/ArraySchema.d.ts

@@ -2,7 +2,7 @@ import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
 import type { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
-export type ArraySource<Subschema extends BaseSchemaAny> = (Subschema extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>[]) : never);
+export type ArraySource<Subschema extends BaseSchemaAny> = (Subschema extends BaseSchema<infer Source, any, infer Required, infer Default> ? (Record<number, SourceValue<Source, Required, Default>> | SourceValue<Source, Required, Default>[]) : never);
 export type ArrayModel<Subschema extends BaseSchemaAny> = (Subschema extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>[]) : never);
 export declare class ArraySchema<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<ArraySource<Subschema>>> extends BaseSchema<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default> {
     readonly subschema: Subschema;

package/build/schema/BaseSchema.d.ts

@@ -8,6 +8,17 @@ export declare abstract class BaseSchema<Source, Model, Required extends boolean
     constructor(required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<Source, Model>);
     abstract get type(): string;
     validate(source: SourceValue<Source, Required, Default>, options?: OptionalValidationOptions, pass?: ValidationPass): ModelValue<Source, Model, Required, Default>;
+    /**
+     * Responsible for validating that a supplied source matches the schema this class represents.
+     *
+     * Some assumptions can be made about `source`:
+     *  * It will never be `null`/`undefined`.
+     *  * Its type returned by `BaseSchema.getType` will match that of this classes `type` property.
+     *
+     * @param source Source to be validated.
+     * @param options Validation options.
+     * @param pass Validation pass.
+     */
     protected abstract _validate(source: ModelValue<Source, Model, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<Source, Model, Required, Default>;
     abstract convert(value: Source, pass: ValidationPass): Model;
     custom(additionalValidator: AdditionalValidator<SourceValue<Source, Required, Default>>, type: AdditionalValidatorBeforeType): this;
@@ -47,10 +58,10 @@ export declare abstract class BaseSchema<Source, Model, Required extends boolean
      */
     toString(level?: number): string;
     /**
-     * Checks to see if a value is present. (Not null or undefined)
+     * Checks to see if a value is present. (Not undefined)
      * @param value The value to check the presence of.
-     * @returns true if value is not null or undefined, false otherwise.
+     * @returns true if value is undefined, false otherwise.
      */
-    static isPresent(value: any): value is Exclude<Exclude<any, null>, undefined>;
+    static isPresent(value: any): value is Exclude<any, undefined>;
     static getType(value: any): any;
 }

package/build/schema/ConstantSchema.d.ts

@@ -0,0 +1,13 @@
+import { ValidationPass } from "../error/ValidationPass";
+import { AdditionalValidationPasses, DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
+import { BaseSchema } from "./BaseSchema";
+export type ConstantSource = string | number | boolean | null;
+export declare class ConstantSchema<Constant extends ConstantSource, Required extends boolean, Default extends DefaultValue<Constant>> extends BaseSchema<Constant, Constant, Required, Default> {
+    readonly value: Constant;
+    constructor(subschema: Constant, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<Constant, Constant>);
+    get type(): any;
+    protected _validate(source: ModelValue<Constant, Constant, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<Constant, Constant, Required, Default>;
+    convert(value: Constant, pass: ValidationPass): Constant;
+    clone(): ConstantSchema<Constant, Required, Default>;
+    getJsonSchema(): object;
+}

package/build/schema/LenientObject.d.ts

@@ -0,0 +1,31 @@
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchemaAny } from "../typing/extended";
+import type { AdditionalValidationPasses, DefaultValue, Merge, ModelRequirement, ModelValue, SourceRequirement, SourceValue, ValidationOptions } from "../typing/toolbox";
+import { BaseSchema } from "./BaseSchema";
+export type LenientObjectSubschema = {
+    [Key: string]: BaseSchemaAny;
+};
+export type LenientObjectSource<Subschema extends LenientObjectSubschema> = ({
+    [Key: string]: any;
+} & Merge<{
+    [Key in keyof Subschema as SourceRequirement<Subschema[Key]> extends true ? Key : never]: (Subschema[Key] extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
+}, {
+    [Key in keyof Subschema as SourceRequirement<Subschema[Key]> extends false ? Key : never]?: (Subschema[Key] extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
+}>);
+export type LenientObjectModel<Subschema extends LenientObjectSubschema> = ({
+    [Key: string]: any;
+} & Merge<{
+    [Key in keyof Subschema as ModelRequirement<Subschema[Key]> extends true ? Key : never]: (Subschema[Key] extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>) : never);
+}, {
+    [Key in keyof Subschema as ModelRequirement<Subschema[Key]> extends false ? Key : never]?: (Subschema[Key] extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>) : never);
+}>);
+export declare class LenientObjectSchema<Subschema extends LenientObjectSubschema, Source extends LenientObjectSource<Subschema>, Model extends LenientObjectModel<Subschema>, Required extends boolean, Default extends DefaultValue<Source>> extends BaseSchema<Source, Model, Required, Default> {
+    readonly subschema: Subschema;
+    constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<Source, Model>);
+    get type(): string;
+    protected _validate(source: ModelValue<Source, Model, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<Source, Model, Required, Default>;
+    convert(value: Source, pass: ValidationPass): Model;
+    getJsonSchema(): object;
+    clone(): LenientObjectSchema<Subschema, Source, Model, Required, Default>;
+    toString(level?: number): string;
+}

package/build/schema/ObjectSchema.d.ts

@@ -21,7 +21,6 @@ export declare class ObjectSchema<Subschema extends ObjectSubschema, Required ex
     get type(): string;
     protected _validate(source: ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>;
     convert(value: ObjectSource<Subschema>, pass: ValidationPass): ObjectModel<Subschema>;
-    extend<ExtensionSubschema extends ObjectSubschema, ExtensionDefault extends DefaultValue<ObjectSource<ExtensionSubschema>>>(schema: ObjectSchema<ExtensionSubschema, Required, ExtensionDefault>): ObjectSchema<Subschema & ExtensionSubschema, Required, any>;
     getJsonSchema(): object;
     clone(): ObjectSchema<Subschema, Required, Default>;
     toString(level?: number): string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lucania/schema",
-    "version": "3.0.1",
+    "version": "3.0.3",
     "description": "A schema module for compile-time and runtime type checking.",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",