@naturalcycles/nodejs-lib 15.44.0 → 15.46.0

package/dist/validation/ajv/getAjv.js

@@ -2,7 +2,7 @@ import { _lazyValue } from '@naturalcycles/js-lib';
 import { Set2 } from '@naturalcycles/js-lib/object';
 import { _substringAfterLast } from '@naturalcycles/js-lib/string';
 import { _, Ajv } from 'ajv';
-import { validTLDs } from './tlds.js';
+import { validTLDs } from '../tlds.js';
 /* eslint-disable @typescript-eslint/prefer-string-starts-ends-with */
 // oxlint-disable unicorn/prefer-code-point
 const AJV_OPTIONS = {

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

@@ -1,5 +1,5 @@
 import type { Set2 } from '@naturalcycles/js-lib/object';
-import { type AnyObject, type IANATimezone, type IsoDate, type IsoDateTime, type NumberEnum, type StringEnum, type StringMap, type UnixTimestamp, type UnixTimestampMillis } from '@naturalcycles/js-lib/types';
+import { type AnyObject, type IANATimezone, type Inclusiveness, type IsoDate, type IsoDateTime, type NumberEnum, type StringEnum, type StringMap, type UnixTimestamp, type UnixTimestampMillis } from '@naturalcycles/js-lib/types';
 export declare const j: {
     string(): JsonSchemaStringBuilder<string, string, false>;
     number(): JsonSchemaNumberBuilder<number, number, false>;
@@ -66,8 +66,8 @@ export declare class JsonSchemaStringBuilder<IN extends string = string, OUT = I
     constructor();
     regex(pattern: RegExp, opt?: JsonBuilderRuleOpt): this;
     pattern(pattern: string, opt?: JsonBuilderRuleOpt): this;
-    min(minLength: number): this;
-    max(maxLength: number): this;
+    minLength(minLength: number): this;
+    maxLength(maxLength: number): this;
     length(minLength: number, maxLength: number): this;
     email(opt?: Partial<JsonSchemaStringEmailOptions>): this;
     trim(): this;
@@ -111,10 +111,12 @@ export declare class JsonSchemaNumberBuilder<IN extends number = number, OUT = I
     exclusiveMin(exclusiveMinimum: number): this;
     max(maximum: number): this;
     exclusiveMax(exclusiveMaximum: number): this;
-    /**
-     * Both ranges are inclusive.
-     */
-    range(minimum: number, maximum: number): this;
+    lessThan(value: number): this;
+    lessThanOrEqual(value: number): this;
+    moreThan(value: number): this;
+    moreThanOrEqual(value: number): this;
+    equal(value: number): this;
+    range(minimum: number, maximum: number, incl: Inclusiveness): this;
     int32(): this;
     int64(): this;
     float(): this;
@@ -163,7 +165,7 @@ export declare class JsonSchemaObjectInferringBuilder<PROPS extends Record<strin
     /**
      * Extends the current schema with `id`, `created` and `updated` according to NC DB conventions.
      */
-    dbEntity(): JsonSchemaObjectInferringBuilder<{ [K in keyof PROPS | "id" | "created" | "updated"]: K extends "id" | "created" | "updated" ? {
+    dbEntity(): JsonSchemaObjectInferringBuilder<{ [K in "id" | keyof PROPS | "created" | "updated"]: K extends "id" | "created" | "updated" ? {
         id: JsonSchemaStringBuilder<string, string, false>;
         created: JsonSchemaNumberBuilder<UnixTimestamp, UnixTimestamp, false>;
         updated: JsonSchemaNumberBuilder<UnixTimestamp, UnixTimestamp, false>;
@@ -171,8 +173,10 @@ export declare class JsonSchemaObjectInferringBuilder<PROPS extends Record<strin
 }
 export declare class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<IN[], OUT[], Opt> {
     constructor(itemsSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>);
-    min(minItems: number): this;
-    max(maxItems: number): this;
+    minLength(minItems: number): this;
+    maxLength(maxItems: number): this;
+    length(minItems: number, maxItems: number): this;
+    exactLength(length: number): this;
     unique(uniqueItems: number): this;
 }
 export declare class JsonSchemaSet2Builder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<Iterable<IN>, Set2<OUT>, Opt> {
@@ -264,6 +268,17 @@ type BuilderInUnion<B extends readonly JsonSchemaAnyBuilder<any, any, any>[]> =
     [K in keyof B]: B[K] extends JsonSchemaAnyBuilder<infer I, any, any> ? I : never;
 }[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;
 }
 export {};

package/dist/validation/ajv/jsonSchemaBuilder.js

@@ -5,6 +5,7 @@ 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 { TIMEZONES } from '../timezones.js';
 import { JSON_SCHEMA_ORDER, mergeJsonSchemaObjects } from './jsonSchemaBuilder.util.js';
 export const j = {
     string() {
@@ -177,16 +178,18 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
         return this.pattern(pattern.source, opt);
     }
     pattern(pattern, opt) {
+        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) {
+    minLength(minLength) {
         Object.assign(this.schema, { minLength });
         return this;
     }
-    max(maxLength) {
+    maxLength(maxLength) {
         Object.assign(this.schema, { maxLength });
         return this;
     }
@@ -283,9 +286,7 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
      */
     ianaTimezone() {
         // 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();
+        return j.enum(TIMEZONES, { msg: 'is an invalid IANA timezone' }).branded();
     }
 }
 export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
@@ -321,12 +322,26 @@ export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
         Object.assign(this.schema, { exclusiveMaximum });
         return this;
     }
-    /**
-     * Both ranges are inclusive.
-     */
-    range(minimum, maximum) {
-        Object.assign(this.schema, { minimum, maximum });
-        return this;
+    lessThan(value) {
+        return this.exclusiveMax(value);
+    }
+    lessThanOrEqual(value) {
+        return this.max(value);
+    }
+    moreThan(value) {
+        return this.exclusiveMin(value);
+    }
+    moreThanOrEqual(value) {
+        return this.min(value);
+    }
+    equal(value) {
+        return this.min(value).max(value);
+    }
+    range(minimum, maximum, incl) {
+        if (incl === '[)') {
+            return this.moreThanOrEqual(minimum).lessThan(maximum);
+        }
+        return this.moreThanOrEqual(minimum).lessThanOrEqual(maximum);
     }
     int32() {
         const MIN_INT32 = -(2 ** 31);
@@ -495,14 +510,20 @@ export class JsonSchemaArrayBuilder extends JsonSchemaAnyBuilder {
             items: itemsSchema.build(),
         });
     }
-    min(minItems) {
+    minLength(minItems) {
         Object.assign(this.schema, { minItems });
         return this;
     }
-    max(maxItems) {
+    maxLength(maxItems) {
         Object.assign(this.schema, { maxItems });
         return this;
     }
+    length(minItems, maxItems) {
+        return this.minLength(minItems).maxLength(maxItems);
+    }
+    exactLength(length) {
+        return this.minLength(length).maxLength(length);
+    }
     unique(uniqueItems) {
         Object.assign(this.schema, { uniqueItems });
         return this;
@@ -534,6 +555,8 @@ export class JsonSchemaBufferBuilder extends JsonSchemaAnyBuilder {
 export class JsonSchemaEnumBuilder extends JsonSchemaAnyBuilder {
     constructor(enumValues, opt) {
         super({ enum: enumValues });
+        if (opt?.name)
+            this.setErrorMessage('pattern', `is not a valid ${opt.name}`);
         if (opt?.msg)
             this.setErrorMessage('enum', opt.msg);
     }

package/dist/validation/timezones.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A complicated merge of timezones from the underlying Javascript engine
+ * and a list exported from Wikipedia.
+ *
+ * Why? The `Int.supportedValuesOf('timeZone')` we use provide only
+ * canonical/standardized timezone values like `Europe/Stockholm`
+ * but does not list accepted aliases like `ETC/Gmt`, `CET` or `Canada/Atlantic`.
+ */
+export declare const TIMEZONES: any;