@versionzero/schema 1.0.0

package/src/core-library/processors/compile-operator.js

@@ -0,0 +1,65 @@
+import { ParametersValueProcessor } from '../../value-processor/parameters-value-processor.js';
+import { ParameterizedValueProcessor } from '../../value-processor/parameterized-value-processor.js';
+import { FunctionValueProcessor } from '../../value-processor/function-value-processor.js';
+import { SchemaError } from '../../errors.js';
+import { formatValue } from '../../helpers/format.js';
+
+/**
+ * ## $compile
+ *
+ * Compiles a `Schema` (or `CompiledSchema`) into a `CompiledSchema` ready for use
+ * in value processing. If a schema argument is provided, that schema is compiled and
+ * the input value is ignored. If no argument is given, the input value itself is treated
+ * as the schema to compile — useful when a schema is being passed through as data.
+ *
+ * Typically used together with `$process` to dynamically select and apply a schema.
+ *
+ * ### Parameters
+ * - `schema` (Schema|CompiledSchema, optional): The schema to compile. If omitted, the input
+ *   value is compiled instead.
+ *
+ * ### Example
+ * ```js
+ * import { Schema } from '@versionzero/schema';
+ *
+ * // Compile a fixed schema and feed it into $process
+ * const portSchema = new Schema('number').validator({$range: {min: 1, max: 65535}});
+ *
+ * new Schema('object', {
+ *   port: new Schema('any')
+ *     .normalizer({$compile: portSchema})
+ *     .transformer('$process'),
+ * })
+ *
+ * // Compile the input value itself when schemas arrive as data
+ * new Schema('any').transformer(['$compile', '$process'])
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const COMPILE_OPERATOR = {
+  keyword: 'compile',
+  parameters: [{parameter: 'schema', required: false}, {parameter: 'compiler', required: false}],
+  build: (args, options) => {
+
+    const compiler = options.compiler;
+
+    const paramsProcessor = new ParametersValueProcessor(COMPILE_OPERATOR.parameters, args);
+
+    return new ParameterizedValueProcessor(
+      new FunctionValueProcessor((schema, _target, location, options) => {
+        const c = options.args.compiler ?? compiler;
+        if (typeof c?.compile !== 'function') {
+          throw new SchemaError(`Invalid compiler provided to $compile ${formatValue(c)}`, {location})
+        }
+        if (options.args.schema !== undefined) {
+          schema = options.args.schema;
+        }
+        return c.compile(schema)
+      }),
+      paramsProcessor,
+      {$compile: paramsProcessor.spec}
+    );
+  }
+};
+

package/src/core-library/processors/concat-operator.js

@@ -0,0 +1,51 @@
+
+import { ComposedValueProcessor } from '../../value-processor/composed-value-processor.js';
+import { FunctionValueProcessor } from '../../value-processor/function-value-processor.js';
+import { ArrayExecutor } from '../../executor/array-executor.js';
+import { map } from '../../helpers/object.js';
+import { ConstraintError, SchemaError } from '../../errors.js';
+
+/**
+ * ## $concat
+ *
+ * Returns a new array with the specified values appended to the input array.
+ * Throws `SchemaError` at compile time if no arguments are provided.
+ * Throws `ConstraintError` at runtime if the input is not an array.
+ *
+ * ### Parameters
+ * - Array of values to append (required, at least one).
+ *
+ * ### Example
+ * ```js
+ * // Append default scopes to a user-supplied scopes array
+ * new Schema('array').transformer({$concat: ['read:profile', 'read:email']})
+ * // ['custom:scope'] → ['custom:scope', 'read:profile', 'read:email']
+ *
+ * // Always include a sentinel value at the end of an array
+ * new Schema('array').transformer({$concat: [null]})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const CONCAT_OPERATOR = {
+  keyword: 'concat',
+
+  build: (args) => {
+    if (!Array.isArray(args) || args.length === 0) {
+      throw new SchemaError('$concat requires a non-empty array of values to append');
+    }
+
+    const argsSpec = map(args, v => v.spec);
+
+    return new FunctionValueProcessor(
+      (value, _target, location, options) => {
+        const items = Array.isArray(options.args) ? options.args : [];
+        if (!Array.isArray(value)) {
+          throw new ConstraintError(`$concat requires an array input, got ${value}`, {location});
+        }
+        return [...value, ...items];
+      },
+      new ComposedValueProcessor(new ArrayExecutor(args), argsSpec)
+    );
+  }
+};

package/src/core-library/processors/conditional-operators.js

@@ -0,0 +1,301 @@
+import { Executor, UNDEFINED_EXECUTOR } from "../../executor/executor.js";
+import { ConditionalExecutor } from '../../executor/conditional-executor.js';
+import { ValueProcessor } from '../../value-processor/value-processor.js';
+import { ComposedValueProcessor } from '../../value-processor/composed-value-processor.js';
+import { ResolverError } from '../../errors.js';
+
+/**
+ * @import {ValueProcessorDefinition} from '../../value-processor/value-processor.js'
+ */
+
+/**
+ * @param {string} keyword
+ * @param {symbol[]} [flags]
+ * @returns {function(any): ValueProcessor}
+ * @package
+ */
+function generateBuilderFunction(keyword, flags) {
+
+  return (args) => {
+
+    /** @type {ValueProcessor} */
+    let predicate;
+    /** @type {ValueProcessor} */
+    let success;
+    /** @type {ValueProcessor} */
+    let failure;
+
+    if (Array.isArray(args)) {
+      if (args.length > 3) {
+        throw new ResolverError(`${keyword} array requires 0-3 processors [predicate, success, failure]`);
+      }
+      predicate = args[0];
+      success = args[1];
+      failure = args[2];
+    }
+    else if (typeof args === 'object' && args !== null) {
+      predicate = args.predicate ?? args.condition ?? args.cond;
+      success = args.success;
+      failure = args.failure;
+    }
+    else if (args !== undefined) {
+      throw new ResolverError(`${keyword} requires predicate/success/failure processors specified as an array or object`);
+    }
+
+    predicate ??= new ComposedValueProcessor(new Executor(), []);
+    success ??= new ComposedValueProcessor(new Executor(), []);
+    failure ??= new ComposedValueProcessor(UNDEFINED_EXECUTOR, '$undefined');
+
+    const spec = {[`${keyword}`]: [predicate.spec, success?.spec, failure?.spec]}
+
+    let description = `(${predicate.description ?? ''})?`;
+    if (success.description) {
+      description += `(${success.description})`;
+    }
+    if (failure.description) {
+      description += `:(${failure.description})`
+    }
+
+    return new ComposedValueProcessor(
+      new ConditionalExecutor(predicate, {success, failure}, flags),
+      spec, description
+    );
+  }
+}
+
+/**
+ * ## $if
+ *
+ * This is a conditional operator that evaluates a predicate for truthiness.
+ *
+ * If the predicate returns a truthy value, $if will invoke any provided success action
+ * with the original input.  If not provided, the default success action will simply return the original input.
+ *
+ * If the predicate returns a falsey value or rejects/throws, $if will return the result of invoking the failure
+ * action on the original input.  The default failure action will return undefined.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * To pass the predicate results to the actions instead of the input, see $check.
+ * To test for success rather than truthiness, see $gate.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Evaluated for truthiness. If omitted, the input itself is used as the predicate.
+ * - `success` (processor, optional): Invoked with the original input on truthy predicate result. Default: returns input as-is.
+ * - `failure` (processor, optional): Invoked with the original input on falsey predicate result or throw. Default: returns undefined.
+ *
+ * Array form: `{$if: [predicate, success, failure]}`
+ * Object form: `{$if: {predicate: ..., success: ..., failure: ...}}`
+ * Aliases: `predicate` may also be written as `condition` or `cond`.
+ *
+ * ### Example
+ * ```js
+ * // Normalize an optional port — keep it if numeric, otherwise drop it
+ * new Schema('object', {
+ *   port: new Schema('number').normalizer({
+ *     $if: ['$numeric', '$number', null]
+ *   }),
+ * })
+ *
+ * // Conditionally require an API key when a flag is set
+ * new Schema('object', {
+ *   useApiKey: new Schema('boolean'),
+ *   apiKey: new Schema('string').validator({
+ *     $if: [
+ *       {$reference: 'useApiKey'},
+ *       '$non-empty',
+ *     ]
+ *   }),
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const IF_OPERATOR = {
+  keyword: 'if',
+  build: generateBuilderFunction('$if', [ConditionalExecutor.CHECK_TRUTHY])
+};
+/**
+ * ## $gate
+ *
+ * This is a conditional operator that evaluates a predicate for whether it returns a defined value.
+ *
+ * If the predicate returns a defined value, $gate will return the result of invoking any provided success action
+ * with the original input.  If not provided, the default success action will simply return the original input.
+ *
+ * If the predicate returns undefined or rejects/throws, $gate will return the result of invoking the failure
+ * action on the original input.  The default failure action will return undefined.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * To pass the original input to the actions instead of the predicate results, see $if.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Evaluated for defined-ness. If omitted, the input itself is tested.
+ * - `success` (processor, optional): Invoked with the original input when predicate returns a defined value. Default: returns input as-is.
+ * - `failure` (processor, optional): Invoked with the original input when predicate returns undefined or throws. Default: returns undefined.
+ *
+ * Array form: `{$gate: [predicate, success, failure]}`
+ * Object form: `{$gate: {predicate: ..., success: ..., failure: ...}}`
+ *
+ * ### Example
+ * ```js
+ * // Only process the value through $uppercase if it was provided
+ * new Schema('string').normalizer({
+ *   $gate: ['$defined', '$uppercase']
+ * })
+ *
+ * // Use the first resolvable property as a value
+ * new Schema('object', {
+ *   host: new Schema('string'),
+ *   fallbackHost: new Schema('string'),
+ * }).transformer({
+ *   $gate: [{$property: 'host'}, {$property: 'host'}, {$property: 'fallbackHost'}]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const GATE_OPERATOR = {
+  keyword: 'gate',
+  build: generateBuilderFunction('$gate',[ConditionalExecutor.CHECK_DEFINED])
+};
+/**
+ * ## $check
+ *
+ * This is a conditional operator that evaluates a predicate for truthiness.
+ *
+ * If the predicate returns a truthy value, $check will return the result of invoking any provided success action
+ * with the predicate result.  If not provided, the default success action will simply return the predicate result.
+ *
+ * If the predicate returns a falsey value or rejects/throws, $check will return the result of invoking the failure
+ * action on the predicate result.  The default failure action will return undefined.  Since the predicate result
+ * is already falsey, the failure action is best used to either return a default value or throw an error.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Evaluated for truthiness. The predicate result (not the original input) is passed to success/failure.
+ * - `success` (processor, optional): Invoked with the predicate result on truthy outcome. Default: returns predicate result.
+ * - `failure` (processor, optional): Invoked with the predicate result on falsey outcome or throw. Default: returns undefined.
+ *
+ * Array form: `{$check: [predicate, success, failure]}`
+ * Object form: `{$check: {predicate: ..., success: ..., failure: ...}}`
+ *
+ * ### Example
+ * ```js
+ * // Extract and validate an environment key, returning the matched value or undefined
+ * new Schema('string').transformer({
+ *   $check: [
+ *     {$match: /^(production|staging|development)$/},
+ *   ]
+ * })
+ *
+ * // Validate a regex match and throw on failure
+ * new Schema('string').validator({
+ *   $check: [
+ *     {$match: /^\d{4}-\d{2}-\d{2}$/},
+ *     null,
+ *     () => { throw new Error('Expected YYYY-MM-DD date format') }
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const CHECK_OPERATOR = {
+  keyword: 'check',
+  build: generateBuilderFunction('$check',[ConditionalExecutor.CHECK_TRUTHY, ConditionalExecutor.PASS_RESULT])
+};
+/**
+ * ## $when
+ *
+ * This is a conditional operator that evaluates a predicate for whether it returns a defined value.
+ *
+ * If the predicate returns a defined value, $when will return the result of invoking any provided success action
+ * with the predicate result.  If not provided, the default success action will simply return the predicate result.
+ *
+ * If the predicate returns undefined or rejects/throws, $when will return the result of invoking the failure
+ * action on the predicate result.  The default failure action will return undefined.  Since the predicate result
+ * is undefined, the failure action is best used to either return a default value or throw an error.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * To check truthiness instead of defined/undefined, see $check.
+ * To pass the original input to the actions instead of the predicate result, see $gate.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Evaluated for defined-ness. The predicate result (not the original input) is passed to success/failure.
+ * - `success` (processor, optional): Invoked with the predicate result when it is defined. Default: returns predicate result.
+ * - `failure` (processor, optional): Invoked with the predicate result (undefined) when predicate returns undefined or throws. Default: returns undefined.
+ *
+ * Array form: `{$when: [predicate, success, failure]}`
+ * Object form: `{$when: {predicate: ..., success: ..., failure: ...}}`
+ *
+ * ### Example
+ * ```js
+ * // Extract a nested value, providing a default when not found
+ * new Schema('object').transformer({
+ *   $when: [
+ *     {$get: 'config.timeout'},
+ *     null,
+ *     () => 5000   // default 5s when config.timeout not set
+ *   ]
+ * })
+ *
+ * // Chain: extract the match groups object if the pattern matched, otherwise drop
+ * new Schema('string').transformer({
+ *   $when: [{$match: /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/}]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const WHEN_OPERATOR = {
+  keyword: 'when',
+  build: generateBuilderFunction('$when',[ConditionalExecutor.CHECK_DEFINED, ConditionalExecutor.PASS_RESULT]),
+};
+
+/**
+ * ## $try
+ *
+ * This is a conditional operator that evaluates a predicate for whether it throws/rejects.
+ *
+ * If the predicate does not throw, $try will return the result of invoking any provided success action
+ * with the predicate result.  If not provided, the default success action will simply return the predicate result.
+ *
+ * If the predicate rejects/throws, $try will return the result of invoking the failure action with the error returned.
+ * The default failure action will return undefined.  Since the predicate result is an error, the failure action is
+ * best used to either intercept errors and return a default value, or to propagate or wrap the error.
+ *
+ * This processor can act as a constraint if the success or failure actions throw when triggered.
+ *
+ * ### Parameters
+ * - `predicate` (processor, optional): Executed and observed for throw/rejection.
+ * - `success` (processor, optional): Invoked with the predicate result if it did not throw. Default: returns predicate result.
+ * - `failure` (processor, optional): Invoked with the thrown error if the predicate threw. Default: returns undefined.
+ *
+ * Array form: `{$try: [predicate, success, failure]}`
+ * Object form: `{$try: {predicate: ..., success: ..., failure: ...}}`
+ *
+ * ### Example
+ * ```js
+ * // Attempt JSON parsing, fall back to raw string on failure
+ * new Schema('string').normalizer({
+ *   $try: ['$json-decode', null, (err) => err.input]
+ * })
+ *
+ * // Attempt to parse a number, silently drop value on error
+ * new Schema('string').normalizer({
+ *   $try: ['$number']
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+
+export const TRY_OPERATOR = {
+  keyword: 'try',
+  build: generateBuilderFunction('$try',[ConditionalExecutor.PASS_ERROR, ConditionalExecutor.PASS_RESULT]),
+};
+

package/src/core-library/processors/constant-case-operator.js

@@ -0,0 +1,16 @@
+import { toConstantCase } from '../../helpers/case.js';
+
+/**
+ * ## $constant-case
+ *
+ * Converts a string to CONSTANT_CASE format (uppercase letters with underscores).
+ * Safe to use in normalize phase (non-throwing).
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const CONSTANT_CASE_OPERATOR = {
+  keyword: 'constant-case',
+  process: (value) => {
+    return toConstantCase(String(value));
+  }
+};

package/src/core-library/processors/data-size-operator.js

@@ -0,0 +1,86 @@
+import { ConstraintError, ResolverError } from '../../errors.js';
+import { parseDataSize, formatDataSize } from '../../helpers/data-size.js';
+
+const VALID_STANDARDS = new Set(['iec', 'si', 'any']);
+const VALID_FORMATS = new Set(['iec', 'si']);
+
+/**
+ * ## $data-size
+ *
+ * Parses data-size strings (e.g. `'20KiB'`, `'1.5 MB'`, `'512'`) into byte
+ * counts. Bare numbers and numeric strings without a suffix are treated as bytes.
+ *
+ * ### Parameters
+ * - `standard` (string, optional): Which unit standard to accept when parsing.
+ *   `'iec'` (binary: KiB, MiB, ...), `'si'` (decimal: KB, MB, ...), or
+ *   `'any'` (both). Default: `'any'`.
+ * - `format` (string, optional): When set, returns a formatted string instead
+ *   of a byte count. Accepts `'iec'` or `'si'` to control the output standard.
+ *
+ * ### Example
+ * ```js
+ * // Parse to bytes (normalizer)
+ * new Schema().normalizer('$data-size')
+ *
+ * // Strict IEC only
+ * new Schema().normalizer({'$data-size': {standard: 'iec'}})
+ *
+ * // Parse and format back as SI string
+ * new Schema().normalizer({'$data-size': {format: 'si'}})
+ *
+ * // Use as normalizer ahead of number validation
+ * new Schema().normalizer(['$data-size']).validator('$is-number')
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const DATA_SIZE_OPERATOR = {
+  keyword: 'data-size',
+
+  parameters: [
+    { parameter: 'standard', default: 'any', type: 'string' },
+    { parameter: 'format',   default: undefined, type: 'string' },
+  ],
+
+  process: (value, _target, _location, options) => {
+    const { standard, format } = options?.args ?? {};
+
+    if (standard !== undefined && !VALID_STANDARDS.has(standard)) {
+      throw new ResolverError(`$data-size: unknown standard "${standard}" (expected iec, si, or any)`);
+    }
+    if (format !== undefined && !VALID_FORMATS.has(format)) {
+      throw new ResolverError(`$data-size: unknown format "${format}" (expected iec or si)`);
+    }
+
+    // passthrough numbers when no format is requested
+    if (typeof value === 'number' && format === undefined) {
+      if (!Number.isFinite(value) || value < 0) {
+        throw new ConstraintError(`Invalid data size: ${value}`);
+      }
+      return value;
+    }
+
+    const bytes = parseDataSize(value, standard === 'any' ? undefined : standard);
+
+    if (format !== undefined) {
+      return formatDataSize(bytes, format);
+    }
+
+    return bytes;
+  },
+
+  describe: (args) => {
+    if (!args) return undefined;
+
+    const standardProcessor = (Array.isArray(args) ? args[0] : args.standard);
+    const formatProcessor = (Array.isArray(args) ? args[1] : args.format);
+
+    const standard = standardProcessor?.description;
+    const format = formatProcessor?.description;
+
+    const parts = [];
+    if (standard !== undefined && standard !== 'any') parts.push(standard.toUpperCase());
+    if (format !== undefined) parts.push(`\u2192 ${format.toUpperCase()}`);
+    return parts.length ? parts.join(', ') : undefined;
+  }
+};

package/src/core-library/processors/date-object-operator.js

@@ -0,0 +1,54 @@
+import { ConstraintError } from '../../errors.js';
+import { formatValue } from '../../helpers/format.js';
+
+/**
+ * ## $date-object
+ *
+ * Expands a Date into a plain object with named calendar fields.
+ *
+ * - `'$date-object'` or `{'$date-object': 'utc'}` — UTC fields (default)
+ * - `{'$date-object': 'local'}` — local-timezone fields
+ *
+ * Output shape: `{year, month, day, hour, minute, second, ms, zone}`
+ * where `month` is 1–12 (not 0-based), and `zone` is `'utc'` or `'local'`.
+ *
+ * The output is accepted by `$date` for round-trip reassembly.
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const DATE_OBJECT_OPERATOR = {
+  keyword: 'date-object',
+  parameters: [{parameter: 'zone'}],
+
+  process: (value, _target, location, options) => {
+    if (!(value instanceof Date)) {
+      throw new ConstraintError(`$date-object requires a Date, got ${formatValue(value)}`, {location});
+    }
+    const zone = options.args['zone'] ?? 'utc';
+    if (zone !== 'utc' && zone !== 'local') {
+      throw new ConstraintError(`$date-object zone must be 'utc' or 'local', got ${formatValue(zone)}`, {location});
+    }
+    if (zone === 'local') {
+      return {
+        year:   value.getFullYear(),
+        month:  value.getMonth() + 1,
+        day:    value.getDate(),
+        hour:   value.getHours(),
+        minute: value.getMinutes(),
+        second: value.getSeconds(),
+        ms:     value.getMilliseconds(),
+        zone:   'local',
+      };
+    }
+    return {
+      year:   value.getUTCFullYear(),
+      month:  value.getUTCMonth() + 1,
+      day:    value.getUTCDate(),
+      hour:   value.getUTCHours(),
+      minute: value.getUTCMinutes(),
+      second: value.getUTCSeconds(),
+      ms:     value.getUTCMilliseconds(),
+      zone:   'utc',
+    };
+  }
+};

package/src/core-library/processors/date-operator.js

@@ -0,0 +1,67 @@
+import { parseDate } from '../../helpers/parse-date.js';
+import { ConstraintError } from '../../errors.js';
+
+/**
+ * Reassemble a date from a `$date-object` field object.
+ * @param {{year:number, month:number, day:number, hour?:number, minute?:number, second?:number, ms?:number, zone?:string}} obj
+ * @returns {Date}
+ */
+function fromDateObject(obj) {
+  const {year, month, day, hour = 0, minute = 0, second = 0, ms = 0, zone = 'utc'} = obj;
+  if (zone === 'local') {
+    return new Date(year, month - 1, day, hour, minute, second, ms);
+  }
+  return new Date(Date.UTC(year, month - 1, day, hour, minute, second, ms));
+}
+
+/**
+ * ## $date
+ *
+ * Normalize the input value as a Date.  Accepts strings, numbers, Date instances, and
+ * date-field objects produced by `$date-object`.
+ *
+ * - `'now'` — returns the current timestamp
+ * - `'+1h'`, `'-30m'`, etc. — relative offsets from now
+ * - ISO strings and numeric epoch values are parsed automatically
+ * - `{year, month, day, ...zone}` — reassembled from a `$date-object` output
+ *
+ * Output type is inferred from the schema's `type` option:
+ * - `'string'` → ISO string
+ * - `'number'` → epoch milliseconds
+ * - otherwise → `Date` instance
+ *
+ * See `$is-date` for strict Date validation.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const DATE_OPERATOR = {
+  keyword: 'date',
+
+  process: (value, _target, location) => {
+    // Accept date-field objects produced by $date-object
+    if (typeof value === 'object' && value !== null && !(value instanceof Date)
+        && Number.isInteger(value.year) && Number.isInteger(value.month)) {
+      const date = fromDateObject(value);
+      if (isNaN(date.getTime())) {
+        throw new ConstraintError(`Invalid date object: ${JSON.stringify(value)}`);
+      }
+      if (location.schema.options.type === 'string') return date.toISOString();
+      if (location.schema.options.type === 'number') return date.getTime();
+      return date;
+    }
+    if (typeof value !== 'string' && typeof value !== 'number' && !(value instanceof Date)) {
+      throw new ConstraintError(`Invalid input for date: ${value}`);
+    }
+    const date = parseDate(value);
+
+    if (location.schema.options.type === 'string') {
+      return date.toISOString();
+    }
+    else if (location.schema.options.type === 'number') {
+      return date.getTime();
+    }
+    else {
+      return date;
+    }
+  }
+};