@naturalcycles/nodejs-lib 15.46.3 → 15.47.1

package/dist/validation/ajv/getAjv.d.ts

@@ -13,6 +13,13 @@ export declare const getAjv: any;
  * and are not interested in transforming the data.
  */
 export declare const getNonMutatingAjv: any;
+/**
+ * Returns cached instance of Ajv, which is coercing data.
+ *
+ * To be used in places where we know that we are going to receive data with the wrong type,
+ * typically: request path params and request query params.
+ */
+export declare const getCoercingAjv: any;
 /**
  * Create Ajv with modified defaults.
  *

package/dist/validation/ajv/getAjv.js

@@ -19,6 +19,10 @@ const AJV_NON_MUTATING_OPTIONS = {
     removeAdditional: false,
     useDefaults: false,
 };
+const AJV_MUTATING_COERCING_OPTIONS = {
+    ...AJV_OPTIONS,
+    coerceTypes: true,
+};
 /**
  * Return cached instance of Ajv with default (recommended) options.
  *
@@ -33,6 +37,13 @@ export const getAjv = _lazyValue(createAjv);
  * and are not interested in transforming the data.
  */
 export const getNonMutatingAjv = _lazyValue(() => createAjv(AJV_NON_MUTATING_OPTIONS));
+/**
+ * Returns cached instance of Ajv, which is coercing data.
+ *
+ * To be used in places where we know that we are going to receive data with the wrong type,
+ * typically: request path params and request query params.
+ */
+export const getCoercingAjv = _lazyValue(() => createAjv(AJV_MUTATING_COERCING_OPTIONS));
 /**
  * Create Ajv with modified defaults.
  *
@@ -233,17 +244,67 @@ export function createAjv(opt) {
         type: 'string',
         modifying: false,
         errors: true,
-        schemaType: 'boolean',
-        validate: function validate(_opt, data, _schema, ctx) {
+        schemaType: 'object',
+        validate: function validate(opt, data, _schema, ctx) {
+            const hasOptions = Object.keys(opt).length > 0;
             const isValid = isIsoDateValid(data);
-            if (isValid)
+            if (!isValid) {
+                ;
+                validate.errors = [
+                    {
+                        instancePath: ctx?.instancePath ?? '',
+                        message: `is an invalid IsoDate`,
+                    },
+                ];
+                return false;
+            }
+            if (!hasOptions)
                 return true;
-            validate.errors = [
-                {
-                    instancePath: ctx?.instancePath ?? '',
-                    message: `is an invalid IsoDate`,
-                },
-            ];
+            const { before, sameOrBefore, after, sameOrAfter } = opt;
+            const errors = [];
+            if (before) {
+                const isParamValid = isIsoDateValid(before);
+                const isRuleValid = isParamValid && before > data;
+                if (!isRuleValid) {
+                    errors.push({
+                        instancePath: ctx?.instancePath ?? '',
+                        message: `is not before ${before}`,
+                    });
+                }
+            }
+            if (sameOrBefore) {
+                const isParamValid = isIsoDateValid(sameOrBefore);
+                const isRuleValid = isParamValid && sameOrBefore >= data;
+                if (!isRuleValid) {
+                    errors.push({
+                        instancePath: ctx?.instancePath ?? '',
+                        message: `is not the same or before ${sameOrBefore}`,
+                    });
+                }
+            }
+            if (after) {
+                const isParamValid = isIsoDateValid(after);
+                const isRuleValid = isParamValid && after < data;
+                if (!isRuleValid) {
+                    errors.push({
+                        instancePath: ctx?.instancePath ?? '',
+                        message: `is not after ${after}`,
+                    });
+                }
+            }
+            if (sameOrAfter) {
+                const isParamValid = isIsoDateValid(sameOrAfter);
+                const isRuleValid = isParamValid && sameOrAfter <= data;
+                if (!isRuleValid) {
+                    errors.push({
+                        instancePath: ctx?.instancePath ?? '',
+                        message: `is not the same or after ${sameOrAfter}`,
+                    });
+                }
+            }
+            if (errors.length === 0)
+                return true;
+            validate.errors = errors;
             return false;
         },
     });

package/dist/validation/ajv/jsonSchemaBuilder.d.ts

@@ -75,7 +75,13 @@ export declare class JsonSchemaStringBuilder<IN extends string = string, OUT = I
     toUpperCase(): this;
     truncate(toLength: number): this;
     branded<B extends string>(): JsonSchemaStringBuilder<B, B, Opt>;
-    isoDate(): JsonSchemaStringBuilder<IsoDate | IN, IsoDate, Opt>;
+    /**
+     * Validates that the input is a fully-specified YYYY-MM-DD formatted valid IsoDate value.
+     *
+     * All previous expectations in the schema chain are dropped - including `.optional()` -
+     * because this call effectively starts a new schema chain.
+     */
+    isoDate(): JsonSchemaIsoDateBuilder;
     isoDateTime(): JsonSchemaStringBuilder<IsoDateTime | IN, IsoDateTime, Opt>;
     /**
      * Validates the string format to be JWT.
@@ -102,6 +108,20 @@ export declare class JsonSchemaStringBuilder<IN extends string = string, OUT = I
 export interface JsonSchemaStringEmailOptions {
     checkTLD: boolean;
 }
+export declare class JsonSchemaIsoDateBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<string | IsoDate, IsoDate, Opt> {
+    constructor();
+    before(date: string): this;
+    sameOrBefore(date: string): this;
+    after(date: string): this;
+    sameOrAfter(date: string): this;
+    between(fromDate: string, toDate: string, incl: Inclusiveness): this;
+}
+export interface JsonSchemaIsoDateOptions {
+    before?: string;
+    sameOrBefore?: string;
+    after?: string;
+    sameOrAfter?: string;
+}
 export declare class JsonSchemaNumberBuilder<IN extends number = number, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
     constructor();
     integer(): this;
@@ -177,7 +197,7 @@ export declare class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyB
     maxLength(maxItems: number): this;
     length(minItems: number, maxItems: number): this;
     exactLength(length: number): this;
-    unique(uniqueItems: number): this;
+    unique(): this;
 }
 export declare class JsonSchemaSet2Builder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<Iterable<IN>, Set2<OUT>, Opt> {
     constructor(itemsSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>);
@@ -188,13 +208,14 @@ export declare class JsonSchemaBufferBuilder extends JsonSchemaAnyBuilder<string
     constructor();
 }
 export declare class JsonSchemaEnumBuilder<IN extends string | number | boolean | null, OUT extends IN = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
-    constructor(enumValues: readonly IN[], opt?: JsonBuilderRuleOpt);
+    constructor(enumValues: readonly IN[], baseType: EnumBaseType, opt?: JsonBuilderRuleOpt);
     branded<B extends IN>(): JsonSchemaEnumBuilder<B | IN, B, Opt>;
 }
+type EnumBaseType = 'string' | 'number' | 'other';
 export interface JsonSchema<IN = unknown, OUT = IN> {
     readonly in?: IN;
     readonly out?: OUT;
-    $schema?: AnyObject;
+    $schema?: string;
     $id?: string;
     title?: string;
     description?: string;
@@ -232,10 +253,14 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
     exclusiveMinimum?: number;
     maximum?: number;
     exclusiveMaximum?: number;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
     enum?: any;
+    email?: JsonSchemaStringEmailOptions;
     Set2?: JsonSchema;
     Buffer?: true;
-    IsoDate?: true;
+    IsoDate?: JsonSchemaIsoDateOptions;
     IsoDateTime?: true;
     instanceof?: string | string[];
     transform?: {

package/dist/validation/ajv/jsonSchemaBuilder.js

@@ -4,9 +4,9 @@ import { _isUndefined, _numberEnumValues, _stringEnumValues, getEnumType, } from
 import { _uniq } from '@naturalcycles/js-lib/array';
 import { _assert } from '@naturalcycles/js-lib/error';
 import { _deepCopy, _sortObject } from '@naturalcycles/js-lib/object';
-import { JWT_REGEX, } from '@naturalcycles/js-lib/types';
+import { _objectAssign, JWT_REGEX, } from '@naturalcycles/js-lib/types';
 import { TIMEZONES } from '../timezones.js';
-import { JSON_SCHEMA_ORDER, mergeJsonSchemaObjects } from './jsonSchemaBuilder.util.js';
+import { isEveryItemNumber, isEveryItemString, JSON_SCHEMA_ORDER, mergeJsonSchemaObjects, } from './jsonSchemaBuilder.util.js';
 export const j = {
     string() {
         return new JsonSchemaStringBuilder();
@@ -35,20 +35,29 @@ export const j = {
     },
     enum(input, opt) {
         let enumValues;
+        let baseType = 'other';
         if (Array.isArray(input)) {
             enumValues = input;
+            if (isEveryItemNumber(input)) {
+                baseType = 'number';
+            }
+            else if (isEveryItemString(input)) {
+                baseType = 'string';
+            }
         }
         else if (typeof input === 'object') {
             const enumType = getEnumType(input);
             if (enumType === 'NumberEnum') {
                 enumValues = _numberEnumValues(input);
+                baseType = 'number';
             }
             else if (enumType === 'StringEnum') {
                 enumValues = _stringEnumValues(input);
+                baseType = 'string';
             }
         }
         _assert(enumValues, 'Unsupported enum input');
-        return new JsonSchemaEnumBuilder(enumValues, opt);
+        return new JsonSchemaEnumBuilder(enumValues, baseType, opt);
     },
     oneOf(items) {
         const schemas = items.map(b => b.build());
@@ -94,14 +103,14 @@ export class JsonSchemaAnyBuilder {
      * ```
      */
     isOfType() {
-        Object.assign(this.schema, { hasIsOfTypeCheck: true });
+        _objectAssign(this.schema, { hasIsOfTypeCheck: true });
         return this;
     }
     getSchema() {
         return this.schema;
     }
     $schema($schema) {
-        Object.assign(this.schema, { $schema });
+        _objectAssign(this.schema, { $schema });
         return this;
     }
     $schemaDraft7() {
@@ -109,31 +118,31 @@ export class JsonSchemaAnyBuilder {
         return this;
     }
     $id($id) {
-        Object.assign(this.schema, { $id });
+        _objectAssign(this.schema, { $id });
         return this;
     }
     title(title) {
-        Object.assign(this.schema, { title });
+        _objectAssign(this.schema, { title });
         return this;
     }
     description(description) {
-        Object.assign(this.schema, { description });
+        _objectAssign(this.schema, { description });
         return this;
     }
     deprecated(deprecated = true) {
-        Object.assign(this.schema, { deprecated });
+        _objectAssign(this.schema, { deprecated });
         return this;
     }
     type(type) {
-        Object.assign(this.schema, { type });
+        _objectAssign(this.schema, { type });
         return this;
     }
     default(v) {
-        Object.assign(this.schema, { default: v });
+        _objectAssign(this.schema, { default: v });
         return this;
     }
     instanceof(of) {
-        Object.assign(this.schema, { type: 'object', instanceof: of });
+        _objectAssign(this.schema, { type: 'object', instanceof: of });
         return this;
     }
     optional() {
@@ -182,53 +191,59 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
             this.setErrorMessage('pattern', `is not a valid ${opt.name}`);
         if (opt?.msg)
             this.setErrorMessage('pattern', opt.msg);
-        Object.assign(this.schema, { pattern });
+        _objectAssign(this.schema, { pattern });
         return this;
     }
     minLength(minLength) {
-        Object.assign(this.schema, { minLength });
+        _objectAssign(this.schema, { minLength });
         return this;
     }
     maxLength(maxLength) {
-        Object.assign(this.schema, { maxLength });
+        _objectAssign(this.schema, { maxLength });
         return this;
     }
     length(minLength, maxLength) {
-        Object.assign(this.schema, { minLength, maxLength });
+        _objectAssign(this.schema, { minLength, maxLength });
         return this;
     }
     email(opt) {
         const defaultOptions = { checkTLD: true };
-        Object.assign(this.schema, { email: { ...defaultOptions, ...opt } });
+        _objectAssign(this.schema, { email: { ...defaultOptions, ...opt } });
         // from `ajv-formats`
         const regex = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
         return this.regex(regex, { msg: 'is not a valid email address' }).trim().toLowerCase();
     }
     trim() {
-        Object.assign(this.schema, { transform: { ...this.schema.transform, trim: true } });
+        _objectAssign(this.schema, { transform: { ...this.schema.transform, trim: true } });
         return this;
     }
     toLowerCase() {
-        Object.assign(this.schema, { transform: { ...this.schema.transform, toLowerCase: true } });
+        _objectAssign(this.schema, { transform: { ...this.schema.transform, toLowerCase: true } });
         return this;
     }
     toUpperCase() {
-        Object.assign(this.schema, { transform: { ...this.schema.transform, toUpperCase: true } });
+        _objectAssign(this.schema, { transform: { ...this.schema.transform, toUpperCase: true } });
         return this;
     }
     truncate(toLength) {
-        Object.assign(this.schema, { transform: { ...this.schema.transform, truncate: toLength } });
+        _objectAssign(this.schema, { transform: { ...this.schema.transform, truncate: toLength } });
         return this;
     }
     branded() {
         return this;
     }
+    /**
+     * Validates that the input is a fully-specified YYYY-MM-DD formatted valid IsoDate value.
+     *
+     * All previous expectations in the schema chain are dropped - including `.optional()` -
+     * because this call effectively starts a new schema chain.
+     */
     isoDate() {
-        Object.assign(this.schema, { IsoDate: true });
-        return this.branded();
+        _objectAssign(this.schema, { IsoDate: {} });
+        return new JsonSchemaIsoDateBuilder();
     }
     isoDateTime() {
-        Object.assign(this.schema, { IsoDateTime: true });
+        _objectAssign(this.schema, { IsoDateTime: true });
         return this.branded();
     }
     /**
@@ -289,6 +304,39 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
         return j.enum(TIMEZONES, { msg: 'is an invalid IANA timezone' }).branded();
     }
 }
+export class JsonSchemaIsoDateBuilder extends JsonSchemaAnyBuilder {
+    constructor() {
+        super({
+            type: 'string',
+            IsoDate: {},
+        });
+    }
+    before(date) {
+        _objectAssign(this.schema.IsoDate, { before: date });
+        return this;
+    }
+    sameOrBefore(date) {
+        _objectAssign(this.schema.IsoDate, { sameOrBefore: date });
+        return this;
+    }
+    after(date) {
+        _objectAssign(this.schema.IsoDate, { after: date });
+        return this;
+    }
+    sameOrAfter(date) {
+        _objectAssign(this.schema.IsoDate, { sameOrAfter: date });
+        return this;
+    }
+    between(fromDate, toDate, incl) {
+        if (incl === '[)') {
+            _objectAssign(this.schema.IsoDate, { sameOrAfter: fromDate, before: toDate });
+        }
+        else if (incl === '[]') {
+            _objectAssign(this.schema.IsoDate, { sameOrAfter: fromDate, sameOrBefore: toDate });
+        }
+        return this;
+    }
+}
 export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
     constructor() {
         super({
@@ -296,30 +344,30 @@ export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
         });
     }
     integer() {
-        Object.assign(this.schema, { type: 'integer' });
+        _objectAssign(this.schema, { type: 'integer' });
         return this;
     }
     branded() {
         return this;
     }
     multipleOf(multipleOf) {
-        Object.assign(this.schema, { multipleOf });
+        _objectAssign(this.schema, { multipleOf });
         return this;
     }
     min(minimum) {
-        Object.assign(this.schema, { minimum });
+        _objectAssign(this.schema, { minimum });
         return this;
     }
     exclusiveMin(exclusiveMinimum) {
-        Object.assign(this.schema, { exclusiveMinimum });
+        _objectAssign(this.schema, { exclusiveMinimum });
         return this;
     }
     max(maximum) {
-        Object.assign(this.schema, { maximum });
+        _objectAssign(this.schema, { maximum });
         return this;
     }
     exclusiveMax(exclusiveMaximum) {
-        Object.assign(this.schema, { exclusiveMaximum });
+        _objectAssign(this.schema, { exclusiveMaximum });
         return this;
     }
     lessThan(value) {
@@ -427,12 +475,12 @@ export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
      * When set, the validation will not strip away properties that are not specified explicitly in the schema.
      */
     allowAdditionalProperties() {
-        Object.assign(this.schema, { additionalProperties: true });
+        _objectAssign(this.schema, { additionalProperties: true });
         return this;
     }
     extend(props) {
         const newBuilder = new JsonSchemaObjectBuilder();
-        Object.assign(newBuilder.schema, _deepCopy(this.schema));
+        _objectAssign(newBuilder.schema, _deepCopy(this.schema));
         const incomingSchemaBuilder = new JsonSchemaObjectBuilder(props);
         mergeJsonSchemaObjects(newBuilder.schema, incomingSchemaBuilder.schema);
         return newBuilder;
@@ -481,12 +529,12 @@ export class JsonSchemaObjectInferringBuilder extends JsonSchemaAnyBuilder {
      * When set, the validation will not strip away properties that are not specified explicitly in the schema.
      */
     allowAdditionalProperties() {
-        Object.assign(this.schema, { additionalProperties: true });
+        _objectAssign(this.schema, { additionalProperties: true });
         return this;
     }
     extend(props) {
         const newBuilder = new JsonSchemaObjectInferringBuilder();
-        Object.assign(newBuilder.schema, _deepCopy(this.schema));
+        _objectAssign(newBuilder.schema, _deepCopy(this.schema));
         const incomingSchemaBuilder = new JsonSchemaObjectInferringBuilder(props);
         mergeJsonSchemaObjects(newBuilder.schema, incomingSchemaBuilder.schema);
         return newBuilder;
@@ -511,11 +559,11 @@ export class JsonSchemaArrayBuilder extends JsonSchemaAnyBuilder {
         });
     }
     minLength(minItems) {
-        Object.assign(this.schema, { minItems });
+        _objectAssign(this.schema, { minItems });
         return this;
     }
     maxLength(maxItems) {
-        Object.assign(this.schema, { maxItems });
+        _objectAssign(this.schema, { maxItems });
         return this;
     }
     length(minItems, maxItems) {
@@ -524,8 +572,8 @@ export class JsonSchemaArrayBuilder extends JsonSchemaAnyBuilder {
     exactLength(length) {
         return this.minLength(length).maxLength(length);
     }
-    unique(uniqueItems) {
-        Object.assign(this.schema, { uniqueItems });
+    unique() {
+        _objectAssign(this.schema, { uniqueItems: true });
         return this;
     }
 }
@@ -537,11 +585,11 @@ export class JsonSchemaSet2Builder extends JsonSchemaAnyBuilder {
         });
     }
     min(minItems) {
-        Object.assign(this.schema, { minItems });
+        _objectAssign(this.schema, { minItems });
         return this;
     }
     max(maxItems) {
-        Object.assign(this.schema, { maxItems });
+        _objectAssign(this.schema, { maxItems });
         return this;
     }
 }
@@ -553,8 +601,15 @@ export class JsonSchemaBufferBuilder extends JsonSchemaAnyBuilder {
     }
 }
 export class JsonSchemaEnumBuilder extends JsonSchemaAnyBuilder {
-    constructor(enumValues, opt) {
-        super({ enum: enumValues });
+    constructor(enumValues, baseType, opt) {
+        const jsonSchema = { enum: enumValues };
+        // Specifying the base type helps in cases when we ask Ajv to coerce the types.
+        // Having only the `enum` in the schema does not trigger a coercion in Ajv.
+        if (baseType === 'string')
+            jsonSchema.type = 'string';
+        if (baseType === 'number')
+            jsonSchema.type = 'number';
+        super(jsonSchema);
         if (opt?.name)
             this.setErrorMessage('pattern', `is not a valid ${opt.name}`);
         if (opt?.msg)

package/dist/validation/ajv/jsonSchemaBuilder.util.d.ts

@@ -7,3 +7,5 @@ export declare const JSON_SCHEMA_ORDER: string[];
  * API similar to Object.assign(s1, s2)
  */
 export declare function mergeJsonSchemaObjects<T1 extends AnyObject, T2 extends AnyObject>(schema1: JsonSchema<T1>, schema2: JsonSchema<T2>): JsonSchema<T1 & T2>;
+export declare function isEveryItemString(arr: any[]): boolean;
+export declare function isEveryItemNumber(arr: any[]): boolean;

package/dist/validation/ajv/jsonSchemaBuilder.util.js

@@ -63,3 +63,17 @@ export function mergeJsonSchemaObjects(schema1, schema2) {
     // `additionalProperties` remains the same
     return _filterNullishValues(s1, { mutate: true });
 }
+export function isEveryItemString(arr) {
+    for (let i = 0; i <= arr.length; ++i) {
+        if (typeof arr[i] !== 'string')
+            return false;
+    }
+    return true;
+}
+export function isEveryItemNumber(arr) {
+    for (let i = 0; i <= arr.length; ++i) {
+        if (typeof arr[i] !== 'number')
+            return false;
+    }
+    return true;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.46.3",
+  "version": "15.47.1",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@types/js-yaml": "^4",

package/src/validation/ajv/getAjv.ts

@@ -3,7 +3,7 @@ import { Set2 } from '@naturalcycles/js-lib/object'
 import { _substringAfterLast } from '@naturalcycles/js-lib/string'
 import { _, Ajv, type Options, type ValidateFunction } from 'ajv'
 import { validTLDs } from '../tlds.js'
-import type { JsonSchemaStringEmailOptions } from './jsonSchemaBuilder.js'
+import type { JsonSchemaIsoDateOptions, JsonSchemaStringEmailOptions } from './jsonSchemaBuilder.js'
 
 /* eslint-disable @typescript-eslint/prefer-string-starts-ends-with */
 // oxlint-disable unicorn/prefer-code-point
@@ -24,6 +24,11 @@ const AJV_NON_MUTATING_OPTIONS: Options = {
   useDefaults: false,
 }
 
+const AJV_MUTATING_COERCING_OPTIONS: Options = {
+  ...AJV_OPTIONS,
+  coerceTypes: true,
+}
+
 /**
  * Return cached instance of Ajv with default (recommended) options.
  *
@@ -40,6 +45,14 @@ export const getAjv = _lazyValue(createAjv)
  */
 export const getNonMutatingAjv = _lazyValue(() => createAjv(AJV_NON_MUTATING_OPTIONS))
 
+/**
+ * Returns cached instance of Ajv, which is coercing data.
+ *
+ * To be used in places where we know that we are going to receive data with the wrong type,
+ * typically: request path params and request query params.
+ */
+export const getCoercingAjv = _lazyValue(() => createAjv(AJV_MUTATING_COERCING_OPTIONS))
+
 /**
  * Create Ajv with modified defaults.
  *
@@ -255,16 +268,77 @@ export function createAjv(opt?: Options): Ajv {
     type: 'string',
     modifying: false,
     errors: true,
-    schemaType: 'boolean',
-    validate: function validate(_opt: true, data: string, _schema, ctx) {
+    schemaType: 'object',
+    validate: function validate(opt: JsonSchemaIsoDateOptions, data: string, _schema, ctx) {
+      const hasOptions = Object.keys(opt).length > 0
+
       const isValid = isIsoDateValid(data)
-      if (isValid) return true
-      ;(validate as any).errors = [
-        {
-          instancePath: ctx?.instancePath ?? '',
-          message: `is an invalid IsoDate`,
-        },
-      ]
+      if (!isValid) {
+        ;(validate as any).errors = [
+          {
+            instancePath: ctx?.instancePath ?? '',
+            message: `is an invalid IsoDate`,
+          },
+        ]
+
+        return false
+      }
+
+      if (!hasOptions) return true
+
+      const { before, sameOrBefore, after, sameOrAfter } = opt
+      const errors: any[] = []
+
+      if (before) {
+        const isParamValid = isIsoDateValid(before)
+        const isRuleValid = isParamValid && before > data
+
+        if (!isRuleValid) {
+          errors.push({
+            instancePath: ctx?.instancePath ?? '',
+            message: `is not before ${before}`,
+          })
+        }
+      }
+
+      if (sameOrBefore) {
+        const isParamValid = isIsoDateValid(sameOrBefore)
+        const isRuleValid = isParamValid && sameOrBefore >= data
+
+        if (!isRuleValid) {
+          errors.push({
+            instancePath: ctx?.instancePath ?? '',
+            message: `is not the same or before ${sameOrBefore}`,
+          })
+        }
+      }
+
+      if (after) {
+        const isParamValid = isIsoDateValid(after)
+        const isRuleValid = isParamValid && after < data
+
+        if (!isRuleValid) {
+          errors.push({
+            instancePath: ctx?.instancePath ?? '',
+            message: `is not after ${after}`,
+          })
+        }
+      }
+
+      if (sameOrAfter) {
+        const isParamValid = isIsoDateValid(sameOrAfter)
+        const isRuleValid = isParamValid && sameOrAfter <= data
+
+        if (!isRuleValid) {
+          errors.push({
+            instancePath: ctx?.instancePath ?? '',
+            message: `is not the same or after ${sameOrAfter}`,
+          })
+        }
+      }
+
+      if (errors.length === 0) return true
+      ;(validate as any).errors = errors
       return false
     },
   })

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -12,6 +12,7 @@ import { _assert } from '@naturalcycles/js-lib/error'
 import type { Set2 } from '@naturalcycles/js-lib/object'
 import { _deepCopy, _sortObject } from '@naturalcycles/js-lib/object'
 import {
+  _objectAssign,
   type AnyObject,
   type BaseDBEntity,
   type IANATimezone,
@@ -26,7 +27,12 @@ import {
   type UnixTimestampMillis,
 } from '@naturalcycles/js-lib/types'
 import { TIMEZONES } from '../timezones.js'
-import { JSON_SCHEMA_ORDER, mergeJsonSchemaObjects } from './jsonSchemaBuilder.util.js'
+import {
+  isEveryItemNumber,
+  isEveryItemString,
+  JSON_SCHEMA_ORDER,
+  mergeJsonSchemaObjects,
+} from './jsonSchemaBuilder.util.js'
 
 export const j = {
   string(): JsonSchemaStringBuilder<string, string, false> {
@@ -78,20 +84,28 @@ export const j = {
           : never
   > {
     let enumValues: readonly (string | number | boolean | null)[] | undefined
+    let baseType: EnumBaseType = 'other'
 
     if (Array.isArray(input)) {
       enumValues = input
+      if (isEveryItemNumber(input)) {
+        baseType = 'number'
+      } else if (isEveryItemString(input)) {
+        baseType = 'string'
+      }
     } else if (typeof input === 'object') {
       const enumType = getEnumType(input)
       if (enumType === 'NumberEnum') {
         enumValues = _numberEnumValues(input as NumberEnum)
+        baseType = 'number'
       } else if (enumType === 'StringEnum') {
         enumValues = _stringEnumValues(input as StringEnum)
+        baseType = 'string'
       }
     }
 
     _assert(enumValues, 'Unsupported enum input')
-    return new JsonSchemaEnumBuilder(enumValues as any, opt)
+    return new JsonSchemaEnumBuilder(enumValues as any, baseType, opt)
   },
 
   oneOf<
@@ -144,7 +158,7 @@ export class JsonSchemaAnyBuilder<IN, OUT, Opt> {
    * ```
    */
   isOfType<ExpectedType>(): ExactMatch<ExpectedType, OUT> extends true ? this : never {
-    Object.assign(this.schema, { hasIsOfTypeCheck: true })
+    _objectAssign(this.schema, { hasIsOfTypeCheck: true })
     return this as any
   }
 
@@ -153,7 +167,7 @@ export class JsonSchemaAnyBuilder<IN, OUT, Opt> {
   }
 
   $schema($schema: string): this {
-    Object.assign(this.schema, { $schema })
+    _objectAssign(this.schema, { $schema })
     return this
   }
 
@@ -163,37 +177,37 @@ export class JsonSchemaAnyBuilder<IN, OUT, Opt> {
   }
 
   $id($id: string): this {
-    Object.assign(this.schema, { $id })
+    _objectAssign(this.schema, { $id })
     return this
   }
 
   title(title: string): this {
-    Object.assign(this.schema, { title })
+    _objectAssign(this.schema, { title })
     return this
   }
 
   description(description: string): this {
-    Object.assign(this.schema, { description })
+    _objectAssign(this.schema, { description })
     return this
   }
 
   deprecated(deprecated = true): this {
-    Object.assign(this.schema, { deprecated })
+    _objectAssign(this.schema, { deprecated })
     return this
   }
 
   type(type: string): this {
-    Object.assign(this.schema, { type })
+    _objectAssign(this.schema, { type })
     return this
   }
 
   default(v: any): this {
-    Object.assign(this.schema, { default: v })
+    _objectAssign(this.schema, { default: v })
     return this
   }
 
   instanceof(of: string): this {
-    Object.assign(this.schema, { type: 'object', instanceof: of })
+    _objectAssign(this.schema, { type: 'object', instanceof: of })
     return this
   }
 
@@ -253,28 +267,28 @@ export class JsonSchemaStringBuilder<
   pattern(pattern: string, opt?: JsonBuilderRuleOpt): this {
     if (opt?.name) this.setErrorMessage('pattern', `is not a valid ${opt.name}`)
     if (opt?.msg) this.setErrorMessage('pattern', opt.msg)
-    Object.assign(this.schema, { pattern })
+    _objectAssign(this.schema, { pattern })
     return this
   }
 
   minLength(minLength: number): this {
-    Object.assign(this.schema, { minLength })
+    _objectAssign(this.schema, { minLength })
     return this
   }
 
   maxLength(maxLength: number): this {
-    Object.assign(this.schema, { maxLength })
+    _objectAssign(this.schema, { maxLength })
     return this
   }
 
   length(minLength: number, maxLength: number): this {
-    Object.assign(this.schema, { minLength, maxLength })
+    _objectAssign(this.schema, { minLength, maxLength })
     return this
   }
 
   email(opt?: Partial<JsonSchemaStringEmailOptions>): this {
     const defaultOptions: JsonSchemaStringEmailOptions = { checkTLD: true }
-    Object.assign(this.schema, { email: { ...defaultOptions, ...opt } })
+    _objectAssign(this.schema, { email: { ...defaultOptions, ...opt } })
 
     // from `ajv-formats`
     const regex =
@@ -283,22 +297,22 @@ export class JsonSchemaStringBuilder<
   }
 
   trim(): this {
-    Object.assign(this.schema, { transform: { ...this.schema.transform, trim: true } })
+    _objectAssign(this.schema, { transform: { ...this.schema.transform, trim: true } })
     return this
   }
 
   toLowerCase(): this {
-    Object.assign(this.schema, { transform: { ...this.schema.transform, toLowerCase: true } })
+    _objectAssign(this.schema, { transform: { ...this.schema.transform, toLowerCase: true } })
     return this
   }
 
   toUpperCase(): this {
-    Object.assign(this.schema, { transform: { ...this.schema.transform, toUpperCase: true } })
+    _objectAssign(this.schema, { transform: { ...this.schema.transform, toUpperCase: true } })
     return this
   }
 
   truncate(toLength: number): this {
-    Object.assign(this.schema, { transform: { ...this.schema.transform, truncate: toLength } })
+    _objectAssign(this.schema, { transform: { ...this.schema.transform, truncate: toLength } })
     return this
   }
 
@@ -306,13 +320,19 @@ export class JsonSchemaStringBuilder<
     return this as unknown as JsonSchemaStringBuilder<B, B, Opt>
   }
 
-  isoDate(): JsonSchemaStringBuilder<IsoDate | IN, IsoDate, Opt> {
-    Object.assign(this.schema, { IsoDate: true })
-    return this.branded<IsoDate>()
+  /**
+   * Validates that the input is a fully-specified YYYY-MM-DD formatted valid IsoDate value.
+   *
+   * All previous expectations in the schema chain are dropped - including `.optional()` -
+   * because this call effectively starts a new schema chain.
+   */
+  isoDate(): JsonSchemaIsoDateBuilder {
+    _objectAssign(this.schema, { IsoDate: {} })
+    return new JsonSchemaIsoDateBuilder()
   }
 
   isoDateTime(): JsonSchemaStringBuilder<IsoDateTime | IN, IsoDateTime, Opt> {
-    Object.assign(this.schema, { IsoDateTime: true })
+    _objectAssign(this.schema, { IsoDateTime: true })
     return this.branded<IsoDateTime>()
   }
 
@@ -392,6 +412,56 @@ export interface JsonSchemaStringEmailOptions {
   checkTLD: boolean
 }
 
+export class JsonSchemaIsoDateBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<
+  string | IsoDate,
+  IsoDate,
+  Opt
+> {
+  constructor() {
+    super({
+      type: 'string',
+      IsoDate: {},
+    })
+  }
+
+  before(date: string): this {
+    _objectAssign(this.schema.IsoDate!, { before: date })
+    return this
+  }
+
+  sameOrBefore(date: string): this {
+    _objectAssign(this.schema.IsoDate!, { sameOrBefore: date })
+    return this
+  }
+
+  after(date: string): this {
+    _objectAssign(this.schema.IsoDate!, { after: date })
+    return this
+  }
+
+  sameOrAfter(date: string): this {
+    _objectAssign(this.schema.IsoDate!, { sameOrAfter: date })
+    return this
+  }
+
+  between(fromDate: string, toDate: string, incl: Inclusiveness): this {
+    if (incl === '[)') {
+      _objectAssign(this.schema.IsoDate!, { sameOrAfter: fromDate, before: toDate })
+    } else if (incl === '[]') {
+      _objectAssign(this.schema.IsoDate!, { sameOrAfter: fromDate, sameOrBefore: toDate })
+    }
+
+    return this
+  }
+}
+
+export interface JsonSchemaIsoDateOptions {
+  before?: string
+  sameOrBefore?: string
+  after?: string
+  sameOrAfter?: string
+}
+
 export class JsonSchemaNumberBuilder<
   IN extends number = number,
   OUT = IN,
@@ -404,7 +474,7 @@ export class JsonSchemaNumberBuilder<
   }
 
   integer(): this {
-    Object.assign(this.schema, { type: 'integer' })
+    _objectAssign(this.schema, { type: 'integer' })
     return this
   }
 
@@ -413,27 +483,27 @@ export class JsonSchemaNumberBuilder<
   }
 
   multipleOf(multipleOf: number): this {
-    Object.assign(this.schema, { multipleOf })
+    _objectAssign(this.schema, { multipleOf })
     return this
   }
 
   min(minimum: number): this {
-    Object.assign(this.schema, { minimum })
+    _objectAssign(this.schema, { minimum })
     return this
   }
 
   exclusiveMin(exclusiveMinimum: number): this {
-    Object.assign(this.schema, { exclusiveMinimum })
+    _objectAssign(this.schema, { exclusiveMinimum })
     return this
   }
 
   max(maximum: number): this {
-    Object.assign(this.schema, { maximum })
+    _objectAssign(this.schema, { maximum })
     return this
   }
 
   exclusiveMax(exclusiveMaximum: number): this {
-    Object.assign(this.schema, { exclusiveMaximum })
+    _objectAssign(this.schema, { exclusiveMaximum })
     return this
   }
 
@@ -575,7 +645,7 @@ export class JsonSchemaObjectBuilder<
    * When set, the validation will not strip away properties that are not specified explicitly in the schema.
    */
   allowAdditionalProperties(): this {
-    Object.assign(this.schema, { additionalProperties: true })
+    _objectAssign(this.schema, { additionalProperties: true })
     return this
   }
 
@@ -583,7 +653,7 @@ export class JsonSchemaObjectBuilder<
     props: AnyObject,
   ): JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, Opt> {
     const newBuilder = new JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, Opt>()
-    Object.assign(newBuilder.schema, _deepCopy(this.schema))
+    _objectAssign(newBuilder.schema, _deepCopy(this.schema))
 
     const incomingSchemaBuilder = new JsonSchemaObjectBuilder<IN2, IN2, false>(props)
     mergeJsonSchemaObjects(newBuilder.schema as any, incomingSchemaBuilder.schema as any)
@@ -675,7 +745,7 @@ export class JsonSchemaObjectInferringBuilder<
    * When set, the validation will not strip away properties that are not specified explicitly in the schema.
    */
   allowAdditionalProperties(): this {
-    Object.assign(this.schema, { additionalProperties: true })
+    _objectAssign(this.schema, { additionalProperties: true })
     return this
   }
 
@@ -692,7 +762,7 @@ export class JsonSchemaObjectInferringBuilder<
     Opt
   > {
     const newBuilder = new JsonSchemaObjectInferringBuilder<PROPS, Opt>()
-    Object.assign(newBuilder.schema, _deepCopy(this.schema))
+    _objectAssign(newBuilder.schema, _deepCopy(this.schema))
 
     const incomingSchemaBuilder = new JsonSchemaObjectInferringBuilder<NEW_PROPS, false>(props)
     mergeJsonSchemaObjects(newBuilder.schema as any, incomingSchemaBuilder.schema as any)
@@ -731,12 +801,12 @@ export class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<I
   }
 
   minLength(minItems: number): this {
-    Object.assign(this.schema, { minItems })
+    _objectAssign(this.schema, { minItems })
     return this
   }
 
   maxLength(maxItems: number): this {
-    Object.assign(this.schema, { maxItems })
+    _objectAssign(this.schema, { maxItems })
     return this
   }
 
@@ -748,8 +818,8 @@ export class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<I
     return this.minLength(length).maxLength(length)
   }
 
-  unique(uniqueItems: number): this {
-    Object.assign(this.schema, { uniqueItems })
+  unique(): this {
+    _objectAssign(this.schema, { uniqueItems: true })
     return this
   }
 }
@@ -767,12 +837,12 @@ export class JsonSchemaSet2Builder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<
   }
 
   min(minItems: number): this {
-    Object.assign(this.schema, { minItems })
+    _objectAssign(this.schema, { minItems })
     return this
   }
 
   max(maxItems: number): this {
-    Object.assign(this.schema, { maxItems })
+    _objectAssign(this.schema, { maxItems })
     return this
   }
 }
@@ -794,8 +864,15 @@ export class JsonSchemaEnumBuilder<
   OUT extends IN = IN,
   Opt extends boolean = false,
 > extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
-  constructor(enumValues: readonly IN[], opt?: JsonBuilderRuleOpt) {
-    super({ enum: enumValues })
+  constructor(enumValues: readonly IN[], baseType: EnumBaseType, opt?: JsonBuilderRuleOpt) {
+    const jsonSchema: JsonSchema = { enum: enumValues }
+    // Specifying the base type helps in cases when we ask Ajv to coerce the types.
+    // Having only the `enum` in the schema does not trigger a coercion in Ajv.
+    if (baseType === 'string') jsonSchema.type = 'string'
+    if (baseType === 'number') jsonSchema.type = 'number'
+
+    super(jsonSchema)
+
     if (opt?.name) this.setErrorMessage('pattern', `is not a valid ${opt.name}`)
     if (opt?.msg) this.setErrorMessage('enum', opt.msg)
   }
@@ -805,11 +882,13 @@ export class JsonSchemaEnumBuilder<
   }
 }
 
+type EnumBaseType = 'string' | 'number' | 'other'
+
 export interface JsonSchema<IN = unknown, OUT = IN> {
   readonly in?: IN
   readonly out?: OUT
 
-  $schema?: AnyObject
+  $schema?: string
   $id?: string
   title?: string
   description?: string
@@ -857,14 +936,18 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
   exclusiveMinimum?: number
   maximum?: number
   exclusiveMaximum?: number
+  minItems?: number
+  maxItems?: number
+  uniqueItems?: boolean
 
   enum?: any
 
   // Below we add custom Ajv keywords
 
+  email?: JsonSchemaStringEmailOptions
   Set2?: JsonSchema
   Buffer?: true
-  IsoDate?: true
+  IsoDate?: JsonSchemaIsoDateOptions
   IsoDateTime?: true
   instanceof?: string | string[]
   transform?: { trim?: true; toLowerCase?: true; toUpperCase?: true; truncate?: number }

package/src/validation/ajv/jsonSchemaBuilder.util.ts

@@ -76,3 +76,17 @@ export function mergeJsonSchemaObjects<T1 extends AnyObject, T2 extends AnyObjec
 
   return _filterNullishValues(s1, { mutate: true })
 }
+
+export function isEveryItemString(arr: any[]): boolean {
+  for (let i = 0; i <= arr.length; ++i) {
+    if (typeof arr[i] !== 'string') return false
+  }
+  return true
+}
+
+export function isEveryItemNumber(arr: any[]): boolean {
+  for (let i = 0; i <= arr.length; ++i) {
+    if (typeof arr[i] !== 'number') return false
+  }
+  return true
+}