@lucania/schema 1.0.8 → 2.0.1

package/build/index.js

@@ -1,352 +1,645 @@
-(function (factory) {
-    typeof define === 'function' && define.amd ? define(factory) :
-    factory();
-})((function () { 'use strict';
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.LucaniaSchema = {}));
+})(this, (function (exports) { 'use strict';
 
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Schema = void 0;
-    var Schema;
-    (function (Schema) {
-        const primitives = [
-            "undefined",
-            "boolean",
-            "number",
-            "bigint",
-            "string",
-            "symbol",
-            "any",
-            "Date"
-        ];
-        const converters = {
-            boolean: {
-                number: (value) => value ? 1 : 0,
-                bigint: (value) => value ? 1n : 0n,
-                string: (value) => value ? "true" : "false"
-            },
-            number: {
-                boolean: (value) => value === 0 ? false : true,
-                bigint: (value) => BigInt(value),
-                string: (value) => value.toString(),
-                Date: (value) => new Date(value)
-            },
-            bigint: {
-                number: (value) => Number(value),
-                string: (value) => value.toString()
-            },
-            string: {
-                boolean: (value) => value === "false" ? false : Boolean(value),
-                number: (value) => {
-                    const numberValue = parseFloat(value);
-                    if (Number.isNaN(numberValue)) {
-                        Schema.assert(value.length !== 0, `Failed to convert empty string to number.`);
-                        throw new Schema.Error(`Failed to convert "${value}" to number.`);
-                    }
-                    return numberValue;
-                },
-                bigint: (value) => BigInt(value),
-                any: (value) => JSON.parse(value),
-                Date: (value) => new Date(value)
-            },
-            any: {
-                string: (value) => JSON.stringify(value)
-            },
-            Date: {
-                number: (value) => value.getTime(),
-                bigint: (value) => BigInt(value.getTime()),
-                string: (value) => value.toISOString()
-            }
-        };
-        const untypedConverters = converters;
-        function registerConverter(fromTypeName, toTypeName, converter) {
-            if (!(fromTypeName in converters)) {
-                untypedConverters[fromTypeName] = [];
-            }
-            untypedConverters[fromTypeName][toTypeName] = converter;
-        }
-        Schema.registerConverter = registerConverter;
-        function registerPrimitive(typeName) {
-            primitives.push(typeName);
-        }
-        Schema.registerPrimitive = registerPrimitive;
-        function isSchemaPrimitive(value) {
-            return typeof value === "string" && primitives.includes(value);
-        }
-        Schema.isSchemaPrimitive = isSchemaPrimitive;
-        function isSchemaOrCompound(value) {
-            return Array.isArray(value) && value.length === 3 && isSchema(value[0]) && value[1] === "or" && isSchema(value[2]);
-        }
-        Schema.isSchemaOrCompound = isSchemaOrCompound;
-        function isSchemaAndCompound(value) {
-            return Array.isArray(value) && value.length === 3 && isSchema(value[0]) && value[1] === "and" && isSchema(value[2]);
-        }
-        Schema.isSchemaAndCompound = isSchemaAndCompound;
-        function isSchemaMeta(value) {
-            return typeof value === "object" && value !== null && isSchema(value.type) && typeof value.required === "boolean";
-        }
-        Schema.isSchemaMeta = isSchemaMeta;
-        function isSchemaDynamic(value) {
-            return typeof value === "object" && value !== null && isSchema(value.$);
-        }
-        Schema.isSchemaDynamic = isSchemaDynamic;
-        function isSchemaArray(value) {
-            return Array.isArray(value) && value.length > 0 && value.every(isSchema);
-        }
-        Schema.isSchemaArray = isSchemaArray;
-        function isSchemaHierarchy(value) {
-            return typeof value === "object" && value !== null && Object.values(value).every(isSchema);
-        }
-        Schema.isSchemaHierarchy = isSchemaHierarchy;
-        function isSchema(value) {
-            return (isSchemaPrimitive(value) ||
-                isSchemaOrCompound(value) ||
-                isSchemaAndCompound(value) ||
-                isSchemaDynamic(value) ||
-                isSchemaMeta(value) ||
-                isSchemaArray(value) ||
-                isSchemaHierarchy(value));
-        }
-        Schema.isSchema = isSchema;
-        function getType(value) {
-            return typeof value === "object" ? value === null ? "null" : value.constructor.name : typeof value;
-        }
-        Schema.getType = getType;
-        function build(schema) {
-            return schema;
-        }
-        Schema.build = build;
-        function validate(schema, source) {
-            const result = _validate(schema, source, [], schema, source, !isSchemaOrCompound(schema) && !isSchemaAndCompound(schema));
-            if (result instanceof ValidationError) {
-                throw result;
+    class ValidationError extends Error {
+        pass;
+        constructor(pass, message) {
+            super(message);
+            this.pass = pass;
+        }
+    }
+
+    class ValidationPass {
+        originalSchema;
+        originalSource;
+        _path;
+        _schema;
+        _source;
+        constructor(originalSchema, originalSource) {
+            this.originalSchema = originalSchema;
+            this.originalSource = originalSource;
+            this._path = [];
+            this._schema = originalSchema;
+            this._source = originalSource;
+        }
+        get path() { return this._path; }
+        get schema() { return this._schema; }
+        get source() { return this._source; }
+        next(path, schema, source) {
+            const nextPass = new ValidationPass(this.originalSchema, this.originalSource);
+            nextPass._path = path;
+            nextPass._source = source;
+            nextPass._schema = schema;
+            return nextPass;
+        }
+        assert(condition, message) {
+            if (!condition) {
+                throw this.getError(message);
             }
-            return result;
         }
-        Schema.validate = validate;
-        function _validate(schema, source, path, originalSchema, originalSource, convert = true) {
-            if (isSchemaPrimitive(schema)) {
-                const sourceType = getType(source);
-                if (sourceType === schema || schema === "any") {
-                    if (schema === "number" && isNaN(source)) {
-                        throw new ValidationError("incorrectType", schema, source, path, originalSchema, originalSource, `Missing required number.`);
-                    }
-                    return source;
+        getError(message) {
+            if (message === undefined) {
+                return this.getError(`Validation failed.`);
+            }
+            else {
+                return new ValidationError(this, message);
+            }
+        }
+    }
+
+    class BaseSchema {
+        type;
+        _required;
+        _default;
+        _additionalValidationPasses;
+        constructor(type, required, defaultValue, additionalValidationPasses) {
+            this.type = type;
+            this._required = required;
+            this._default = defaultValue;
+            this._additionalValidationPasses = additionalValidationPasses === undefined ? {
+                beforeAll: [],
+                beforeDefault: [],
+                afterDefault: [],
+                beforeConversion: [],
+                afterConversion: [],
+                afterAll: []
+            } : additionalValidationPasses;
+        }
+        validate(source, pass) {
+            pass = this._ensurePass(source, pass);
+            let result = source;
+            result = this._executeAdditionalValidator(result, pass, "beforeAll");
+            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);
                 }
-                else if (sourceType === "object" && source !== null && source.constructor.name === schema) {
-                    return source;
+                result = this._executeAdditionalValidator(result, pass, "afterConversion");
+            }
+            else {
+                result = this._executeAdditionalValidator(result, pass, "afterConversion");
+                if (this._required) {
+                    throw pass.getError(pass.path.length > 0 ? `Missing required value at "${pass.path.join(".")}".` : "Missing required value.");
                 }
-                else if (convert && sourceType in converters && schema in untypedConverters[sourceType]) {
-                    return untypedConverters[sourceType][schema](source);
+                else {
+                    result = undefined;
                 }
-                const errorType = source === undefined || source === null ? "missing" : "incorrectType";
-                return new ValidationError(errorType, schema, source, path, originalSchema, originalSource);
             }
-            else if (isSchemaOrCompound(schema)) {
-                const result = _validate(schema[0], source, path, originalSchema, originalSource, false);
-                if (result instanceof ValidationError) {
-                    return _validate(schema[2], source, path, originalSchema, originalSource, false);
-                }
-                return result;
+            if (this._required || result !== undefined) {
+                result = this._executeAdditionalValidator(result, pass, "afterAll");
             }
-            else if (isSchemaAndCompound(schema)) {
-                const result = _validate(schema[2], source, path, originalSchema, originalSource);
-                return _validate(schema[0], result, path, originalSchema, originalSource, false);
+            return result;
+        }
+        custom(additionalValidator, type = "afterAll") {
+            this._additionalValidationPasses[type].push(additionalValidator);
+            return this;
+        }
+        ensure(ensureValidator, message) {
+            this.custom((value, pass) => {
+                pass.assert(ensureValidator(value, pass), message === undefined ? `Failed to ensure value.` : message);
+                return value;
+            });
+            return this;
+        }
+        hasDefault() {
+            return this._default !== undefined && this._default !== null;
+        }
+        isDefaultRuntimeEvaluated() {
+            return typeof this._default === "function";
+        }
+        getDefault(pass) {
+            if (this.isDefaultRuntimeEvaluated()) {
+                return this._default(pass);
             }
-            else if (isSchemaMeta(schema)) {
-                if (schema.validate !== undefined) {
-                    try {
-                        source = schema.validate.call(originalSource, source, originalSource);
-                    }
-                    catch (error) {
-                        if (error instanceof Schema.Error) {
-                            throw new ValidationError("failedCustomValidator", schema, source, path, originalSchema, originalSource, error.message);
-                        }
-                        else {
-                            throw error;
-                        }
-                    }
+            else if (this.hasDefault()) {
+                return this._default;
+            }
+            else {
+                throw pass.getError(`Failed to get default. Invalid default value.`);
+            }
+        }
+        _getValueDisplay(value) {
+            return String(value);
+        }
+        _getJsonSchemaDescription() {
+            const pass = new ValidationPass(this, this._default);
+            const descriptionPieces = [];
+            descriptionPieces.push(`A ${this._required ? "required" : "optional"} ${this.type}`);
+            if (this.hasDefault()) {
+                let defaultValue = this.getDefault(pass);
+                if (BaseSchema.getType(defaultValue) !== this.type) {
+                    defaultValue = this.convert(defaultValue, pass);
                 }
-                const result = _validate(schema.type, source, path, originalSchema, originalSource);
-                if (result instanceof ValidationError && result.type === "missing") {
-                    if (!schema.required && source === undefined) {
-                        return undefined;
-                    }
-                    if ("default" in schema) {
-                        if (typeof schema.default === "function") {
-                            return _validate(schema.type, schema.default(), path, originalSchema, originalSource);
-                        }
-                        else {
-                            return _validate(schema.type, schema.default, path, originalSchema, originalSource);
-                        }
-                    }
-                    return result;
+                if (Array.isArray(defaultValue)) {
+                    defaultValue = `[${defaultValue.join(", ")}]`;
                 }
-                return result;
-            }
-            else if (isSchemaDynamic(schema)) {
-                const validated = {};
-                for (const key in source) {
-                    const result = _validate(schema.$, source[key], path, originalSchema, originalSource);
-                    if (result instanceof ValidationError) {
-                        return result;
-                    }
-                    validated[key] = result;
+                if (this.isDefaultRuntimeEvaluated()) {
+                    descriptionPieces.push(` that defaults to a run-time evaluated value (i.e. ${defaultValue})`);
                 }
-                return validated;
-            }
-            else if (isSchemaArray(schema)) {
-                if (Array.isArray(source)) {
-                    [schema] = schema;
-                    const validated = [];
-                    for (let i = 0; i < source.length; i++) {
-                        const result = _validate(schema, source[i], path, originalSchema, originalSource);
-                        if (result instanceof ValidationError) {
-                            return result;
-                        }
-                        validated[i] = result;
-                    }
-                    return validated;
+                else {
+                    descriptionPieces.push(` that defaults to ${defaultValue}`);
                 }
-                const errorType = source === undefined || source === null ? "missing" : "incorrectType";
-                return new ValidationError(errorType, schema, source, path, originalSchema, originalSource);
-            }
-            else if (isSchemaHierarchy(schema)) {
-                if (typeof source === "object" && source !== null) {
-                    const validated = {};
-                    for (const key in schema) {
-                        const result = _validate(schema[key], source[key], [...path, key], originalSchema, originalSource);
-                        if (result instanceof ValidationError) {
-                            return result;
-                        }
-                        validated[key] = result;
-                    }
-                    return validated;
+            }
+            descriptionPieces.push(".");
+            return descriptionPieces.join("");
+        }
+        _ensurePass(source, pass) {
+            if (pass === undefined) {
+                pass = new ValidationPass(this, source);
+            }
+            return pass;
+        }
+        _executeAdditionalValidator(source, pass, type) {
+            for (const additionalValidationPass of this._additionalValidationPasses[type]) {
+                source = additionalValidationPass(source, pass);
+            }
+            return source;
+        }
+        /**
+         * Checks to see if a value is present. (Not null or undefined)
+         * @param value The value to check the presence of.
+         * @returns true if value is not null or undefined, false otherwise.
+         */
+        static isPresent(value) {
+            return value !== undefined && value !== null;
+        }
+        static getType(value) {
+            if (value === null) {
+                return "null";
+            }
+            const type = typeof value;
+            if (type === "object") {
+                const constructor = value.constructor.name;
+                if (constructor === "Object") {
+                    return type;
+                }
+                else if (constructor === "Array") {
+                    return "array";
+                }
+                else {
+                    return constructor;
                 }
-                const errorType = source === undefined || source === null ? "missing" : "incorrectType";
-                return new ValidationError(errorType, schema, source, path, originalSchema, originalSource);
             }
             else {
-                return new ValidationError("invalidSchema", schema, source, path, originalSchema, originalSource);
+                return type;
+            }
+        }
+    }
+
+    class AnySchema extends BaseSchema {
+        constructor(required, defaultValue) {
+            super("any", required, defaultValue);
+        }
+        convert(value, pass) {
+            return value;
+        }
+        getJsonSchema() {
+            return { description: this._getJsonSchemaDescription() };
+        }
+    }
+
+    class ArraySchema extends BaseSchema {
+        subschema;
+        constructor(subschema, required, defaultValue) {
+            super("array", required, defaultValue);
+            this.subschema = subschema;
+        }
+        validate(source, pass) {
+            pass = this._ensurePass(source, pass);
+            const result = super.validate(source, pass);
+            if (result !== undefined) {
+                for (const key in result) {
+                    const nestedValue = result[key];
+                    result[key] = this.subschema.validate(result[key], pass.next([...pass.path, key], this.subschema, nestedValue));
+                }
             }
+            return result;
         }
-        function clone(schema) {
-            if (isSchemaPrimitive(schema)) {
-                return schema;
+        convert(value, pass) {
+            if (Array.isArray(value)) {
+                return value;
             }
-            else if (isSchemaOrCompound(schema)) {
-                const [a, _, b] = schema;
-                return [clone(a), "or", clone(b)];
+            else if (typeof value === "string") {
+                return [value];
             }
-            else if (isSchemaAndCompound(schema)) {
-                const [a, _, b] = schema;
-                return [clone(a), "and", clone(b)];
+            else {
+                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to array.`);
             }
-            else if (isSchemaMeta(schema)) {
-                const meta = {
-                    type: clone(schema.type),
-                    required: schema.required,
-                };
-                if ("default" in schema) {
-                    meta.default = schema.default;
+        }
+        getJsonSchema() {
+            return {
+                type: "array",
+                description: this._getJsonSchemaDescription(),
+                items: this.subschema.getJsonSchema()
+            };
+        }
+    }
+
+    class BooleanSchema extends BaseSchema {
+        constructor(required, defaultValue) {
+            super("boolean", required, defaultValue);
+        }
+        convert(value, pass) {
+            if (typeof value === "number") {
+                return value !== 0;
+            }
+            else if (typeof value === "string") {
+                if (value === "false" || value === "no" || value === "off") {
+                    return false;
                 }
-                if ("validate" in schema) {
-                    meta.validate = schema.validate;
+                else {
+                    return value.length > 0;
                 }
-                return meta;
             }
-            else if (isSchemaDynamic(schema)) {
-                return { $: clone(schema.$) };
+            else if (value === undefined || value === null) {
+                return false;
             }
-            else if (isSchemaArray(schema)) {
-                return schema.map(clone);
+            else {
+                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to boolean.`);
             }
-            else if (isSchemaHierarchy(schema)) {
-                const hierarchy = {};
-                for (const key in schema) {
-                    hierarchy[key] = clone(schema[key]);
-                }
-                return hierarchy;
+        }
+        getJsonSchema() {
+            return {
+                type: "boolean",
+                description: this._getJsonSchemaDescription(),
+            };
+        }
+    }
+
+    const StandardDate = globalThis.Date;
+    class DateSchema extends BaseSchema {
+        constructor(required, defaultValue) {
+            super("Date", required, defaultValue);
+        }
+        convert(value, pass) {
+            if (typeof value === "string") {
+                return value === "now" ? new StandardDate() : new StandardDate(value);
+            }
+            if (typeof value === "number") {
+                return new StandardDate(value);
             }
             else {
-                throw new Error("Invalid Schema.");
+                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to Date.`);
             }
         }
-        Schema.clone = clone;
-        function assert(condition, message) {
-            if (!condition) {
-                throw new Schema.Error(message);
-            }
-        }
-        Schema.assert = assert;
-        class Error extends globalThis.Error {
-            constructor(message) {
-                super(message);
-            }
-        }
-        Schema.Error = Error;
-        class ValidationError extends Error {
-            type;
-            source;
-            schema;
-            originalSource;
-            originalSchema;
-            path;
-            customMessage;
-            /**
-             * @param message The error message.
-             * @param type The type of validation error.
-             * @param source The data that failed validation.
-             * @param path The path to the value that failed validation.
-             */
-            constructor(type, schema, source, path, originalSchema, originalSource, customMessage) {
-                super(ValidationError.getMessage(type, source, schema, path));
-                this.name = this.constructor.name;
-                this.type = type;
-                this.source = source;
-                this.schema = schema;
-                this.originalSource = originalSource;
-                this.originalSchema = originalSchema;
-                this.path = path;
-                this.customMessage = customMessage;
-            }
-            static getExpectedString(schema) {
-                if (isSchemaPrimitive(schema)) {
-                    return schema;
-                }
-                else if (isSchemaMeta(schema)) {
-                    return ValidationError.getExpectedString(schema.type);
-                }
-                else if (isSchemaArray(schema)) {
-                    return "array";
-                }
-                else if (isSchemaHierarchy(schema)) {
-                    return "hierarchical object";
+        before(date, message) {
+            return this.custom((model, pass) => {
+                pass.assert(date.getTime() < model.getTime(), message === undefined ?
+                    `Date "${model.toLocaleString()}" failed check. (Must be before ${date.toLocaleString()})` : message);
+                return model;
+            }, "afterAll");
+        }
+        after(date, message) {
+            return this.custom((model, pass) => {
+                pass.assert(date.getTime() > model.getTime(), message === undefined ?
+                    `Date "${model.toLocaleString()}" failed check. (Must be after ${date.toLocaleString()})` : message);
+                return model;
+            }, "afterAll");
+        }
+        /**
+         * @param duration milliseconds
+         */
+        moreThanAgo(duration, message) {
+            return this.custom((model, pass) => {
+                pass.assert(Date.now() - model.getTime() > duration, message === undefined ?
+                    `Date "${model.toLocaleString()}" failed check. (Must be more than ${duration} millisecond(s) ago)` : message);
+                return model;
+            }, "afterAll");
+        }
+        /**
+        * @param duration milliseconds
+        */
+        lessThanAgo(duration, message) {
+            return this.custom((model, pass) => {
+                pass.assert(Date.now() - model.getTime() < duration, message === undefined ?
+                    `Date "${model.toLocaleString()}" failed check. (Must be less than ${duration} millisecond(s) ago)` : message);
+                return model;
+            }, "afterAll");
+        }
+        getJsonSchema() {
+            return {
+                type: "string",
+                description: this._getJsonSchemaDescription(),
+            };
+        }
+    }
+
+    class DynamicObjectSchema extends BaseSchema {
+        subschema;
+        constructor(subschema, required, defaultValue) {
+            super("object", required, defaultValue);
+            this.subschema = subschema;
+        }
+        validate(source, pass) {
+            pass = this._ensurePass(source, pass);
+            const result = super.validate(source, pass);
+            if (result !== undefined) {
+                for (const key in result) {
+                    const nestedValue = result[key];
+                    result[key] = this.subschema.validate(result[key], pass.next([...pass.path, key], this.subschema, nestedValue));
                 }
-                return "unfamiliar object";
             }
-            static getMessage(type, source, schema, path) {
-                let sourceRepresentation = JSON.stringify(source);
-                if (isNaN(source)) {
-                    sourceRepresentation = "NaN";
+            return result;
+        }
+        convert(source, pass) {
+            const model = {};
+            for (const key in source) {
+                const nestedValue = source[key];
+                model[key] = this.subschema.convert(nestedValue, pass.next([...pass.path, key], this.subschema, nestedValue));
+            }
+            return model;
+        }
+        getJsonSchema() {
+            return {
+                type: "object",
+                description: this._getJsonSchemaDescription(),
+                additionalProperties: this.subschema.getJsonSchema()
+            };
+        }
+    }
+
+    class EnumerationSchema extends BaseSchema {
+        members;
+        constructor(members, required, defaultValue) {
+            super("string", required, defaultValue);
+            this.members = members;
+        }
+        validate(source, pass) {
+            pass = this._ensurePass(source, pass);
+            const result = super.validate(source, pass);
+            pass.assert(this.members.includes(result), `"${result}" is not a valid enumeration value (Expected: ${this.members.join(", ")}).`);
+            return result;
+        }
+        convert(value, pass) {
+            return value;
+        }
+        getJsonSchema() {
+            return {
+                type: "string",
+                description: this._getJsonSchemaDescription(),
+                enum: this.members
+            };
+        }
+    }
+
+    class NumberSchema extends BaseSchema {
+        constructor(required, defaultValue) {
+            super("number", required, defaultValue);
+        }
+        convert(value, pass) {
+            if (typeof value === "bigint") {
+                return globalThis.Number(value);
+            }
+            if (typeof value === "string") {
+                return parseFloat(value);
+            }
+            else if (typeof value === "boolean") {
+                return value ? 1 : 0;
+            }
+            else if (value === undefined || value === null) {
+                return 0;
+            }
+            else if (value instanceof Date) {
+                return value.getTime();
+            }
+            else {
+                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to number.`);
+            }
+        }
+        min(minimum, message) {
+            return this.custom((model, pass) => {
+                pass.assert(model >= minimum, message === undefined ? `Number ${model} failed minimum check. (${minimum})` : message);
+                return model;
+            }, "afterAll");
+        }
+        max(maximum, message) {
+            return this.custom((model, pass) => {
+                pass.assert(model <= maximum, message === undefined ? `Number ${model} failed maximum check. (${maximum})` : message);
+                return model;
+            }, "afterAll");
+        }
+        clamp(minimum, maximum, messageA, messageB) {
+            return this.min(minimum, messageA).max(maximum, messageB === undefined ? messageA : messageB);
+        }
+        validNumber(notANumber = false, message) {
+            return this.custom((model, pass) => {
+                pass.assert(isNaN(model) === notANumber, message === undefined ? `Number ${model} failed not a number check. (${notANumber ? "Requires NaN" : "Requires valid number"})` : message);
+                return model;
+            }, "afterAll");
+        }
+        getJsonSchema() {
+            return {
+                type: "number",
+                description: this._getJsonSchemaDescription(),
+            };
+        }
+    }
+
+    class ObjectSchema extends BaseSchema {
+        subschema;
+        constructor(subschema, required, defaultValue) {
+            super("object", required, defaultValue);
+            this.subschema = subschema;
+        }
+        validate(source, pass) {
+            pass = this._ensurePass(source, pass);
+            const result = super.validate(source, pass);
+            if (result !== undefined) {
+                for (const key in this.subschema) {
+                    const nestedSchema = this.subschema[key];
+                    const nestedValue = result[key];
+                    result[key] = this.subschema[key].validate(result[key], pass.next([...pass.path, key], nestedSchema, nestedValue));
                 }
-                switch (type) {
-                    case "missing":
-                        return path.length === 0 ?
-                            `Attempted to validate "${sourceRepresentation}" as ${ValidationError.getExpectedString(schema)}.` :
-                            `Missing required field "${path.join(".")}".`;
-                    case "incorrectType":
-                        return (`${getType(source)}${sourceRepresentation !== source ? ` (${sourceRepresentation})` : ""} failed validation as ` +
-                            `${ValidationError.getExpectedString(schema)}${path.length === 0 ? "." : ` at path "${path.join(".")}".`}`);
-                    case "failedCustomValidator":
-                        return (`${getType(source)}${sourceRepresentation !== source ? ` (${sourceRepresentation})` : ""} failed custom validation pass as ` +
-                            `${ValidationError.getExpectedString(schema)}${path.length === 0 ? "." : ` at path "${path.join(".")}".`}`);
-                    case "invalidSchema":
-                        return `Invalid schema. Did you forget to register a custom primitive or converter?`;
-                    default:
-                        return `Validation failed. Reason: ${type}`;
+            }
+            return result;
+        }
+        convert(value, pass) {
+            const model = {};
+            for (const key in this.subschema) {
+                const nestedSchema = this.subschema[key];
+                const nestedValue = value[key];
+                model[key] = nestedSchema.convert(nestedValue, pass.next([...pass.path, key], nestedSchema, nestedValue));
+            }
+            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) {
+                properties[key] = this.subschema[key].getJsonSchema();
+            }
+            return {
+                type: "object",
+                description: this._getJsonSchemaDescription(),
+                properties
+            };
+        }
+    }
+
+    class OrSetSchema extends BaseSchema {
+        schemas;
+        constructor(schemas, required, defaultValue) {
+            super("string", required, defaultValue);
+            this.schemas = schemas;
+        }
+        validate(source, pass) {
+            pass = this._ensurePass(source, pass);
+            let result = super.validate(source, pass);
+            if (result !== undefined) {
+                let done = false;
+                const failureMessages = [];
+                for (let i = 0; i < this.schemas.length && !done; i++) {
+                    const schema = this.schemas[i];
+                    try {
+                        result = schema.validate(result, pass);
+                        done = true;
+                    }
+                    catch (error) {
+                        if (error instanceof Error) {
+                            failureMessages.push(`Schema #${i + 1}: ${error.message}`);
+                        }
+                        else {
+                            failureMessages.push(`Schema #${i + 1}: ${String(error)}`);
+                        }
+                        pass.assert(failureMessages.length !== this.schemas.length, `Supplied value didn't match any schemas in or-set.\n${failureMessages.join("\n")}`);
+                    }
                 }
             }
+            return result;
+        }
+        convert(value, pass) {
+            return value;
+        }
+        getJsonSchema() {
+            return { oneOf: this.schemas.map((schema) => schema.getJsonSchema()) };
+        }
+    }
+
+    class StringSchema extends BaseSchema {
+        constructor(required, defaultValue, additionalValidationPasses) {
+            super("string", required, defaultValue, additionalValidationPasses);
+        }
+        // Not sure if these will be needed with constructor option. If they are required, it adds a lot of boilerplate to all of the Schema classes.
+        // public required() { return new StringSchema(true, this._default, this._additionalValidationPasses); }
+        // public optional() { return new StringSchema(false, this._default, this._additionalValidationPasses); }
+        // public default<Default extends DefaultValue<StringSource>>(defaultValue: Default) { return new StringSchema(this._required, defaultValue, this._additionalValidationPasses); }
+        convert(value, pass) {
+            if (value instanceof Date) {
+                return value.toISOString();
+            }
+            else if (value === null) {
+                return "null";
+            }
+            else if (value === undefined) {
+                return "undefined";
+            }
+            return value.toString();
+        }
+        length(minimum, maximum, messageA, messageB) {
+            return this.custom((model, pass) => {
+                messageB = messageB === undefined ? messageA : messageB;
+                pass.assert(model.length > minimum, messageA === undefined ? `String "${model}: failed minimum length check. (${minimum})` : messageA);
+                pass.assert(model.length < maximum, messageB === undefined ? `String "${model}: failed maximum length check. (${maximum})` : messageB);
+                return model;
+            }, "afterAll");
+        }
+        regex(expression, message) {
+            return this.custom((model, pass) => {
+                pass.assert(expression.test(model), message === undefined ? `String "${model}" failed regular expression check. (${expression})` : message);
+                return model;
+            }, "afterAll");
+        }
+        getJsonSchema() {
+            return {
+                type: "string",
+                description: this._getJsonSchemaDescription(),
+            };
+        }
+    }
+
+    exports.Schema = void 0;
+    (function (Schema) {
+        function String(required = true, defaultValue = undefined) {
+            return new StringSchema(required, defaultValue);
+        }
+        Schema.String = String;
+        function Number(required = true, defaultValue = undefined) {
+            return new NumberSchema(required, defaultValue);
         }
-        Schema.ValidationError = ValidationError;
-    })(Schema || (exports.Schema = Schema = {}));
+        Schema.Number = Number;
+        function Boolean(required = true, defaultValue = undefined) {
+            return new BooleanSchema(required, defaultValue);
+        }
+        Schema.Boolean = Boolean;
+        function Date(required = true, defaultValue = undefined) {
+            return new DateSchema(required, defaultValue);
+        }
+        Schema.Date = Date;
+        function Any(required = true, defaultValue = undefined) {
+            return new AnySchema(required, defaultValue);
+        }
+        Schema.Any = Any;
+        function Object(subschema, required = true, defaultValue = undefined) {
+            return new ObjectSchema(subschema, required, defaultValue);
+        }
+        Schema.Object = Object;
+        function Array(subschema, required = true, defaultValue = undefined) {
+            return new ArraySchema(subschema, required, defaultValue);
+        }
+        Schema.Array = Array;
+        function Enumeration(members, required = true, defaultValue = undefined) {
+            return new EnumerationSchema(members.data, 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.data, required, defaultValue);
+        }
+        Schema.OrSet = OrSet;
+        function Members(...members) {
+            return { data: members };
+        }
+        Schema.Members = Members;
+    })(exports.Schema || (exports.Schema = {}));
+
+    exports.$ = exports.Schema;
+    exports.AnySchema = AnySchema;
+    exports.ArraySchema = ArraySchema;
+    exports.BaseSchema = BaseSchema;
+    exports.BooleanSchema = BooleanSchema;
+    exports.DateSchema = DateSchema;
+    exports.DynamicObjectSchema = DynamicObjectSchema;
+    exports.EnumerationSchema = EnumerationSchema;
+    exports.NumberSchema = NumberSchema;
+    exports.ObjectSchema = ObjectSchema;
+    exports.OrSetSchema = OrSetSchema;
+    exports.StringSchema = StringSchema;
+    exports.ValidationError = ValidationError;
+    exports.ValidationPass = ValidationPass;
 
 }));