@versionzero/schema 1.0.0

package/src/core-library/processors/sequence-processors.js

@@ -0,0 +1,406 @@
+
+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 { SequenceExecutor } from '../../executor/sequence-executor.js';
+import { ConstraintError, ResolverError } from '../../errors.js';
+import { formatValue } from '../../helpers/format.js';
+
+/**
+ * @import {ValueProcessorDefinition} from '../../value-processor/value-processor.js'
+ */
+
+/**
+ *
+ * @param {string} keyword
+ * @param {string} joiner
+ * @param {(processors:ValueProcessor[], spec:any, description:string) => ValueProcessor} builder
+ * @returns {function(*): *}
+ * @package
+ */
+function generateBuilderFunction(keyword, joiner, builder) {
+  return (args) => {
+
+    let processors;
+    if (Array.isArray(args)) {
+      processors = args;
+    }
+    else if (typeof args === 'object' && args !== null) {
+      processors = Object.values(args);
+    }
+    if (!Array.isArray(processors)) {
+      throw new ResolverError(`${keyword} requires an array of processors`);
+    }
+    const spec = {[keyword]: processors.map(a => a.spec)};
+    const descriptions = processors.map(c => c.description).filter((d) => d !== undefined);
+    const description = descriptions.length > 1
+                        ? descriptions.map(d => d.includes('&') ? `(${d})` : d).join(joiner)
+                        : descriptions[0]
+
+    return builder(processors, spec, description);
+  }
+}
+
+
+/**
+ * ## $or
+ *
+ * A constraint that checks whether any of the provided processors return a truthy value.
+ *
+ * Returns the first truthy value from the processors, or throws if none are truthy.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$any` if you want to check for success (defined value) instead of truthiness
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, at least one of which must return a truthy value.
+ *
+ * ### Example
+ * ```js
+ * // Accept either a valid hostname or a valid IPv4 address
+ * new Schema('string').validator({$or: ['$hostname', '$ipv4']})
+ *
+ * // Accept a port number OR the string 'auto'
+ * new Schema('any').validator({
+ *   $or: [
+ *     {$range: {min: 1, max: 65535}},
+ *     {$eq: 'auto'},
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const OR_CONSTRAINT = {
+  keyword: 'or',
+  build: generateBuilderFunction('$or', ' | ',
+    (processors, spec, description) => (
+      new ComposedValueProcessor(
+        new ConditionalExecutor(
+          new SequenceExecutor(processors, [
+            SequenceExecutor.TRUTHY_CHECK,
+            SequenceExecutor.ANY_CRITERIA,
+            SequenceExecutor.RESULT_RETURN,
+            SequenceExecutor.CAPTURE_ERRORS
+          ]),
+          {
+            failure: (value) => {
+              throw new ConstraintError(`None of the $or conditions ${formatValue(description)} matched`,{value});
+            }
+          },
+          [ConditionalExecutor.CHECK_TRUTHY]
+        ), spec, description)
+    )
+  )
+};
+
+/**
+ * ## $and
+ *
+ * A constraint that checks whether all the provided processors return a truthy value.
+ *
+ * Returns the last truthy value from the processors, or throws if any are falsey.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$all` if you want to check for success (defined value) instead of truthiness
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, all of which must return a truthy value.
+ *
+ * ### Example
+ * ```js
+ * // Require a string to be both non-empty and a valid email
+ * new Schema('string').validator({$and: ['$non-empty', '$email']})
+ *
+ * // Require a number to be positive and within range
+ * new Schema('number').validator({
+ *   $and: ['$positive', {$range: {max: 1000}}]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const AND_CONSTRAINT = {
+  keyword: 'and',
+  build: generateBuilderFunction('$and', ' & ',
+    (processors, spec, description) => (
+      new ComposedValueProcessor(
+        new ConditionalExecutor(
+          new SequenceExecutor(processors, [
+            SequenceExecutor.TRUTHY_CHECK,
+            SequenceExecutor.ALL_CRITERIA,
+            SequenceExecutor.RESULT_RETURN,
+            SequenceExecutor.CAPTURE_ERRORS
+          ]),
+          {
+            failure: (value) => {
+              throw new ConstraintError(`Not all $and conditions ${formatValue(description)} matched`, {value});
+            }
+          },
+          [ConditionalExecutor.CHECK_TRUTHY]
+        ), spec, description)
+    )
+  )
+};
+
+/**
+ * ## $any
+ *
+ * A constraint that checks whether any of the provided processors return a defined value.
+ * (Not to be confused with the unrelated "any" schema!)
+ *
+ * Returns the first defined value from the processors, or throws if none returned a defined value.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$or` if you want to check for truthiness instead of a defined value.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, at least one of which must return a defined value.
+ *
+ * ### Example
+ * ```js
+ * // Accept a value that matches any of several pattern-based normalizations
+ * new Schema('string').normalizer({
+ *   $any: [
+ *     {$match: /^\d+$/},
+ *     {$match: /^[a-f0-9]+$/i},
+ *   ]
+ * })
+ *
+ * // Require a value that can be processed by at least one schema
+ * new Schema('any').validator({$any: ['$numeric', '$boolean', '$date']})
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const ANY_CONSTRAINT = {
+  keyword: 'any',
+  build: generateBuilderFunction('$any', ' ∧ ',
+    (processors, spec, description) => (
+      new ComposedValueProcessor(
+        new ConditionalExecutor(
+          new SequenceExecutor(processors, [
+            SequenceExecutor.DEFINED_CHECK,
+            SequenceExecutor.ANY_CRITERIA,
+            SequenceExecutor.RESULT_RETURN,
+            SequenceExecutor.CAPTURE_ERRORS
+          ]),
+        {
+          failure: (value) => {
+            throw new ConstraintError(`None of the $any conditions ${formatValue(description)} succeeded`, {value});
+          }
+        },
+        [ConditionalExecutor.CHECK_DEFINED]
+        ), spec, description)
+    )
+  )
+};
+
+/**
+ * ## $all
+ *
+ * A constraint that checks whether all the provided processors return a defined value.
+ *
+ * Returns the last defined value returned from the processors, or throws if any returned undefined or threw an error.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$and` if you want to check for truthiness instead of defined values.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, all of which must return a defined value.
+ *
+ * ### Example
+ * ```js
+ * // Validate that all normalizations succeed for a value that must satisfy multiple constraints
+ * new Schema('string').validator({
+ *   $all: ['$non-empty', '$email', {$matches: /\.com$/}]
+ * })
+ *
+ * // Ensure a value passes both a type check and a range constraint
+ * new Schema('any').validator({$all: ['$numeric', {$range: {min: 0, max: 100}}]})
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const ALL_CONSTRAINT = {
+  keyword: 'all',
+  build: generateBuilderFunction('$all', ' · ',
+    (processors, spec, description) => (
+      new ComposedValueProcessor(
+        new ConditionalExecutor(
+          new SequenceExecutor(processors, [
+            SequenceExecutor.DEFINED_CHECK,
+            SequenceExecutor.ALL_CRITERIA,
+            SequenceExecutor.RESULT_RETURN,
+            SequenceExecutor.CAPTURE_ERRORS
+          ]),
+          {
+            failure: (value) => {
+              throw new ConstraintError(`Not all $all conditions ${formatValue(description)} succeeded`, {value})
+            }
+          },
+          [ConditionalExecutor.CHECK_DEFINED]
+        ), spec, description)
+    )
+  )
+
+};
+
+
+/**
+ * ## $exclusive
+ *
+ * A constraint that checks whether exactly one of the provided processors returns a truthy value.
+ *
+ * Returns the single truthy value, or throws if zero or more than one are truthy.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$one` if you want to check for success (defined value) instead of truthiness.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, exactly one of which must return a truthy value.
+ *
+ * ### Example
+ * ```js
+ * // A form field must have either an email or a phone number, but not both
+ * new Schema('object').validator({
+ *   $exclusive: [
+ *     {$property: 'email'},
+ *     {$property: 'phone'},
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const EXCLUSIVE_CONSTRAINT = {
+  keyword: 'exclusive',
+  build: generateBuilderFunction('$exclusive', ' ⊕ ',
+    (processors, spec, description) => (
+      new ComposedValueProcessor(
+        new ConditionalExecutor(
+          new SequenceExecutor(processors, [
+            SequenceExecutor.TRUTHY_CHECK,
+            SequenceExecutor.EXCLUSIVE_CRITERIA,
+            SequenceExecutor.RESULT_RETURN,
+            SequenceExecutor.CAPTURE_ERRORS
+          ]),
+          {
+            failure: (value) => {
+              throw new ConstraintError(`Exactly one of the $exclusive conditions ${formatValue(description)} must match`, {value});
+            }
+          },
+          [ConditionalExecutor.CHECK_TRUTHY]
+        ), spec, description)
+    )
+  )
+};
+
+/**
+ * ## $one
+ *
+ * A constraint that checks whether exactly one of the provided processors returns a defined value.
+ *
+ * Returns the single defined value, or throws if zero or more than one succeed.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * See `$exclusive` if you want to check for truthiness instead of a defined value.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications, exactly one of which must return a defined value.
+ *
+ * ### Example
+ * ```js
+ * // Exactly one authentication method must be configured
+ * new Schema('object').validator({
+ *   $one: [
+ *     {$property: 'apiKey'},
+ *     {$property: 'oauth'},
+ *     {$property: 'basicAuth'},
+ *   ]
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const ONE_CONSTRAINT = {
+  keyword: 'one',
+  build: generateBuilderFunction('$one', ' ⊕ ',
+    (processors, spec, description) => (
+      new ComposedValueProcessor(
+        new ConditionalExecutor(
+          new SequenceExecutor(processors, [
+            SequenceExecutor.DEFINED_CHECK,
+            SequenceExecutor.EXCLUSIVE_CRITERIA,
+            SequenceExecutor.RESULT_RETURN,
+            SequenceExecutor.CAPTURE_ERRORS
+          ]),
+          {
+            failure: (value) => {
+              throw new ConstraintError(`Exactly one of the $one conditions ${formatValue(description)} must succeed`, {value});
+            }
+          },
+          [ConditionalExecutor.CHECK_DEFINED]
+        ), spec, description)
+    )
+  )
+};
+/**
+ * ## $first
+ *
+ * An operator that returns the first defined value successfully returned from a sequence of processors.
+ *
+ * Unlike `$any`, no exception is thrown if there are no defined results, it simply returns `undefined`.
+ * Be careful to not use this in a situation where the provided processors may require late-resolved values!
+ * This works best in finalizers, validators, or in opaque schema transformers.
+ *
+ * There is no truthy variant of `$first`, as there generally isn't much value in differentiating which
+ * truthy value to return; use constructs like `{$if: {$or: [...]}}` to wrap truthy sequence constraints as operators.
+ * `$first` is basically an alias for `{$gate: {$any: [...]}}`.
+ *
+ * ### Parameters
+ * - `processors` (`Array<ProcessorSpec>`, required): Array of processor specifications to try in order.
+ *
+ * ### Example
+ * ```js
+ * // Try several environment variable names and return the first one that has a value
+ * new Schema('object').transformer({
+ *   $first: [
+ *     {$reference: 'DATABASE_URL'},
+ *     {$reference: 'DB_URL'},
+ *     {$reference: 'POSTGRES_URL'},
+ *   ]
+ * })
+ *
+ * // Return the first successfully parsed format
+ * new Schema('string').normalizer({
+ *   $first: ['$number', '$date', '$boolean']
+ * })
+ * ```
+ *
+ * @type {ValueProcessorDefinition}
+ */
+export const FIRST_OPERATOR = {
+  keyword: 'first',
+  build: generateBuilderFunction('$first', ' ?? ',
+    (processors, spec, description) => (
+      new ComposedValueProcessor(
+        new ConditionalExecutor(
+          new SequenceExecutor(processors, [
+            SequenceExecutor.DEFINED_CHECK,
+            SequenceExecutor.ANY_CRITERIA,
+            SequenceExecutor.RESULT_RETURN,
+            SequenceExecutor.CAPTURE_ERRORS
+          ]),
+          {},
+          [ConditionalExecutor.CHECK_DEFINED, ConditionalExecutor.PASS_RESULT]
+        ), spec, description)
+    )
+  )
+};

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

@@ -0,0 +1,52 @@
+import { ConstraintError } from '../../errors.js';
+import { formatValue } from '../../helpers/format.js';
+
+/**
+ * ## $sort
+ *
+ * Returns a new sorted array. Non-mutating. Numbers are compared numerically;
+ * all other values are compared lexicographically as strings.
+ * Throws if the input is not an array.
+ *
+ * ### Parameters
+ * - `key` (string|null, optional, default `null`): Object property key to sort by.
+ * - `direction` (`'asc'`|`'desc'`, optional, default `'asc'`): Sort direction.
+ *
+ * ### Example
+ * ```js
+ * // Sort an array of numbers in ascending order
+ * new Schema('array').transformer('$sort')
+ * // [3, 1, 2] → [1, 2, 3]
+ *
+ * // Sort strings in descending order
+ * new Schema('array').transformer({$sort: {direction: 'desc'}})
+ *
+ * // Sort an array of objects by a property
+ * new Schema('array').transformer({$sort: {key: 'name'}})
+ * // [{name: 'Charlie'}, {name: 'Alice'}] → [{name: 'Alice'}, {name: 'Charlie'}]
+ *
+ * // Sort objects by a numeric property descending
+ * new Schema('array').transformer({$sort: {key: 'score', direction: 'desc'}})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const SORT_OPERATOR = {
+  keyword: 'sort',
+  parameters: [ { parameter: 'key', default: null }, { parameter: 'direction', default: 'asc' } ],
+
+  process: (value, _target, location, options) => {
+    if (!Array.isArray(value)) {
+      throw new ConstraintError(`$sort requires an array, got ${formatValue(value)}`, {location});
+    }
+    const key = options.args?.['key'] ?? null;
+    const direction = options.args?.['direction'] ?? 'asc';
+
+    const cmp = (a, b) => (typeof a === 'number' && typeof b === 'number')
+      ? a - b
+      : String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0;
+
+    const sorted = [...value].sort(key ? (a, b) => cmp(a[key], b[key]) : cmp);
+    return direction === 'desc' ? sorted.reverse() : sorted;
+  }
+};

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

@@ -0,0 +1,43 @@
+/**
+ * ## $split
+ *
+ * Stringify the input and split on the provided separator, returning an array.
+ *
+ * ### Parameters
+ * - `separator` (string, optional, defaults to ","): The value to use for splitting
+ * - `limit` (integer, optional): The maximum number of elements to return.
+ *
+ * Note that RegExp separators must be wrapped in a `$literal` to prevent evaluation as constraints.
+ * Otherwise, follows the behavior of JavaScript's String.prototype.split.
+ *
+ * ### Example
+ * ```js
+ * // Split a comma-separated list into an array
+ * new Schema('string').transformer('$split')
+ * // 'a,b,c' → ['a', 'b', 'c']
+ *
+ * // Split on a custom separator
+ * new Schema('string').transformer({$split: {separator: ':'}})
+ * // 'host:port' → ['host', 'port']
+ *
+ * // Split then normalize each element
+ * new Schema('string').normalizer([{$split: {separator: ','}}, {$each: '$trim'}])
+ * // '  a , b , c  ' → ['a', 'b', 'c']
+ *
+ * // Split a PATH-style variable, limiting to 5 segments
+ * new Schema('string').transformer({$split: {separator: '/', limit: 5}})
+ * ```
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}*
+ */
+export const SPLIT_OPERATOR = {
+  keyword: 'split',
+  parameters: [ { parameter: 'separator', default: ',' }, { parameter: 'limit', default: undefined } ],
+
+  process: (value, _target, _location, options) => {
+    const separator = options.args?.['separator'];
+    const limit = options.args?.['limit'];
+
+    return `${value}`.split(separator, limit);
+  }
+}

package/src/core-library/processors/string-extra-operators.js

@@ -0,0 +1,141 @@
+
+import { FunctionValueProcessor } from '../../value-processor/function-value-processor.js';
+import { ConstraintError, SchemaError } from '../../errors.js';
+import { formatValue } from '../../helpers/format.js';
+
+/**
+ * ## $replace
+ *
+ * Replaces occurrences of a pattern in a string.
+ *
+ * - Pattern may be a string (replaced globally via `replaceAll`) or a RegExp (flags control global).
+ * - Replacement must be a string.
+ *
+ * ### Parameters
+ * - First positional: pattern (string or RegExp, required)
+ * - Second positional: replacement (string, required)
+ *
+ * ### Example
+ * ```js
+ * // Replace all underscores with hyphens
+ * new Schema('string').transformer({$replace: ['_', '-']})
+ * // 'hello_world' → 'hello-world'
+ *
+ * // Strip all non-digit characters using a RegExp
+ * new Schema('string').normalizer({$replace: [/\D+/g, '']})
+ * // '+1 (800) 555-1234' → '18005551234'
+ *
+ * // Redact sensitive patterns
+ * new Schema('string').transformer({$replace: [/\b\d{4}-\d{4}-\d{4}-\d{4}\b/g, '[REDACTED]']})
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const REPLACE_OPERATOR = {
+  keyword: 'replace',
+  parameters: [{parameter: 'pattern', required: true}, {parameter: 'replacement', required: true, type: 'string'}],
+  process: (value, _target, location, options) => {
+    const {pattern, replacement} = options.args;
+    if (typeof pattern !== 'string' && !(pattern instanceof RegExp)) {
+      throw new SchemaError(`$replace pattern must be a string or RegExp, got ${formatValue(pattern)}`);
+    }
+    if (typeof replacement !== 'string') {
+      throw new SchemaError(`$replace replacement must be a string, got ${formatValue(replacement)}`);
+    }
+    if (typeof value !== 'string') {
+      throw new ConstraintError(`$replace requires a string input, got ${formatValue(value)}`, {location});
+    }
+    return typeof pattern === 'string'
+           ? value.replaceAll(pattern, replacement)
+           : value.replace(pattern, replacement);
+  }
+};
+
+/**
+ * ## $substring
+ *
+ * Extracts a portion of a string by start index and optional length.
+ *
+ * ### Parameters
+ * - `start` (number, required): Start index (0-based).
+ * - `length` (number, optional): Number of characters to extract. If omitted, extracts to end of string.
+ *
+ * ### Example
+ * ```js
+ * // Extract the first 8 characters of a hash
+ * new Schema('string').transformer({$substring: {start: 0, length: 8}})
+ * // 'abcdef1234567890' → 'abcdef12'
+ *
+ * // Strip a known prefix (e.g. 'Bearer ')
+ * new Schema('string').transformer({$substring: {start: 7}})
+ *
+ * // Extract a fixed-position field from a formatted string
+ * new Schema('string').transformer({$substring: {start: 4, length: 2}})
+ * // '2026-03-21' → '03' (month)
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const SUBSTRING_OPERATOR = {
+  keyword: 'substring',
+  parameters: [ { parameter: 'start', required: true, type: 'number' }, { parameter: 'length', type: 'number', default: undefined } ],
+
+  process: (value, _target, location, options) => {
+    if (typeof value !== 'string') {
+      throw new ConstraintError(`$substring requires a string input, got ${formatValue(value)}`, {location});
+    }
+    const start = options.args['start'];
+    const length = options.args['length'];
+    return length !== undefined
+      ? value.substring(start, start + length)
+      : value.substring(start);
+  }
+};
+
+/**
+ * ## $pad
+ *
+ * Pads a string to a minimum width.
+ *
+ * ### Parameters
+ * - `width` (number, required): Target minimum length.
+ * - `char` (string, optional): Pad character. Defaults to `' '`.
+ * - `side` (`'left'`|`'right'`, optional): Which side to pad. Defaults to `'left'`.
+ *
+ * ### Example
+ * ```js
+ * // Zero-pad a numeric string to 6 digits
+ * new Schema('string').transformer({$pad: {width: 6, char: '0'}})
+ * // '42' → '000042'
+ *
+ * // Right-pad a string to fill a fixed-width column
+ * new Schema('string').transformer({$pad: {width: 20, side: 'right'}})
+ * // 'Alice' → 'Alice               '
+ *
+ * // Pad a month/day to 2 digits
+ * new Schema('number').transformer(['$string', {$pad: {width: 2, char: '0'}}])
+ * // 3 → '03'
+ * ```
+ *
+ * @type {import('../../value-processor/value-processor.js').ValueProcessorDefinition}
+ */
+export const PAD_OPERATOR = {
+  keyword: 'pad',
+  parameters: [
+    { parameter: 'width', required: true },
+    { parameter: 'char', default: ' ' },
+    { parameter: 'side', default: 'left' }
+  ],
+
+  process: (value, _target, location, options) => {
+    if (typeof value !== 'string') {
+      throw new ConstraintError(`$pad requires a string input, got ${formatValue(value)}`, {location});
+    }
+    const width = options.args['width'];
+    const char = options.args['char'];
+    const side = options.args['side'];
+    return side === 'right'
+      ? value.padEnd(width, char)
+      : value.padStart(width, char);
+  }
+};

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

@@ -0,0 +1,34 @@
+import { stringify } from '../../helpers/stringify.js';
+import { EMPTY } from '../../constants.js';
+import { ConstraintError } from '../../errors.js';
+
+/**
+ * ## $string
+ *
+ * Ensures value is a string, stringifying as necessary.  Everything other than null and undefined can be converted.
+ *
+ * See `$is-string` for strict string validation.
+ *
+ * @type {import("../../value-processor/value-processor.js").ValueProcessorDefinition}
+ */
+export const STRING_OPERATOR = {
+  keyword: 'string',
+  process: (value) => {
+    if (typeof value === 'string') {
+      return value;
+    }
+    else if (value === null || value === undefined) {
+      throw new ConstraintError(`Invalid string`, {value})
+    }
+    else if (value === EMPTY) {
+      return '';
+    }
+    else if (typeof value === 'object') {
+      if (value instanceof Date) return value.toISOString();
+      return stringify(value);
+    }
+    else {
+      return String(value)
+    }
+  }
+};