@naturalcycles/nodejs-lib 15.44.0 → 15.46.0

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -14,6 +14,7 @@ import { _deepCopy, _sortObject } from '@naturalcycles/js-lib/object'
 import {
   type AnyObject,
   type IANATimezone,
+  type Inclusiveness,
   type IsoDate,
   type IsoDateTime,
   JWT_REGEX,
@@ -23,6 +24,7 @@ import {
   type UnixTimestamp,
   type UnixTimestampMillis,
 } from '@naturalcycles/js-lib/types'
+import { TIMEZONES } from '../timezones.js'
 import { JSON_SCHEMA_ORDER, mergeJsonSchemaObjects } from './jsonSchemaBuilder.util.js'
 
 export const j = {
@@ -248,17 +250,18 @@ 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 })
     return this
   }
 
-  min(minLength: number): this {
+  minLength(minLength: number): this {
     Object.assign(this.schema, { minLength })
     return this
   }
 
-  max(maxLength: number): this {
+  maxLength(maxLength: number): this {
     Object.assign(this.schema, { maxLength })
     return this
   }
@@ -380,9 +383,7 @@ export class JsonSchemaStringBuilder<
    */
   ianaTimezone(): JsonSchemaEnumBuilder<string | IANATimezone, IANATimezone, false> {
     // UTC is added to assist unit-testing, which uses UTC by default (not technically a valid Iana timezone identifier)
-    return j
-      .enum([...Intl.supportedValuesOf('timeZone'), 'UTC'], { msg: 'is an invalid IANA timezone' })
-      .branded<IANATimezone>()
+    return j.enum(TIMEZONES, { msg: 'is an invalid IANA timezone' }).branded<IANATimezone>()
   }
 }
 
@@ -435,12 +436,31 @@ export class JsonSchemaNumberBuilder<
     return this
   }
 
-  /**
-   * Both ranges are inclusive.
-   */
-  range(minimum: number, maximum: number): this {
-    Object.assign(this.schema, { minimum, maximum })
-    return this
+  lessThan(value: number): this {
+    return this.exclusiveMax(value)
+  }
+
+  lessThanOrEqual(value: number): this {
+    return this.max(value)
+  }
+
+  moreThan(value: number): this {
+    return this.exclusiveMin(value)
+  }
+
+  moreThanOrEqual(value: number): this {
+    return this.min(value)
+  }
+
+  equal(value: number): this {
+    return this.min(value).max(value)
+  }
+
+  range(minimum: number, maximum: number, incl: Inclusiveness): this {
+    if (incl === '[)') {
+      return this.moreThanOrEqual(minimum).lessThan(maximum)
+    }
+    return this.moreThanOrEqual(minimum).lessThanOrEqual(maximum)
   }
 
   int32(): this {
@@ -709,16 +729,24 @@ export class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<I
     })
   }
 
-  min(minItems: number): this {
+  minLength(minItems: number): this {
     Object.assign(this.schema, { minItems })
     return this
   }
 
-  max(maxItems: number): this {
+  maxLength(maxItems: number): this {
     Object.assign(this.schema, { maxItems })
     return this
   }
 
+  length(minItems: number, maxItems: number): this {
+    return this.minLength(minItems).maxLength(maxItems)
+  }
+
+  exactLength(length: number): this {
+    return this.minLength(length).maxLength(length)
+  }
+
   unique(uniqueItems: number): this {
     Object.assign(this.schema, { uniqueItems })
     return this
@@ -767,7 +795,7 @@ export class JsonSchemaEnumBuilder<
 > extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
   constructor(enumValues: readonly IN[], opt?: JsonBuilderRuleOpt) {
     super({ enum: enumValues })
-
+    if (opt?.name) this.setErrorMessage('pattern', `is not a valid ${opt.name}`)
     if (opt?.msg) this.setErrorMessage('enum', opt.msg)
   }
 
@@ -900,5 +928,16 @@ type BuilderInUnion<B extends readonly JsonSchemaAnyBuilder<any, any, any>[]> =
 }[number]
 
 interface JsonBuilderRuleOpt {
+  /**
+   * Text of error message to return when the validation fails for the given rule:
+   *
+   * `{ msg: "is not a valid Oompa-loompa" } => "Object.property is not a valid Oompa-loompa"`
+   */
   msg?: string
+  /**
+   * A friendly name for what we are validating, that will be used in error messages:
+   *
+   * `{ name: "Oompa-loompa" } => "Object.property is not a valid Oompa-loompa"`
+   */
+  name?: string
 }