@naturalcycles/nodejs-lib 15.82.1 → 15.83.0

package/dist/validation/ajv/getAjv.js

@@ -1,5 +1,5 @@
 import { _isBetween, _lazyValue } from '@naturalcycles/js-lib';
-import { _mapObject, Set2 } from '@naturalcycles/js-lib/object';
+import { _deepCopy, _mapObject, Set2 } from '@naturalcycles/js-lib/object';
 import { _substringAfterLast } from '@naturalcycles/js-lib/string';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import { validTLDs } from '../tlds.js';
@@ -513,6 +513,53 @@ export function createAjv(opt) {
             return validate;
         },
     });
+    ajv.addKeyword({
+        keyword: 'anyOfThese',
+        modifying: true,
+        errors: true,
+        schemaType: 'array',
+        compile(schemas, _parentSchema, _it) {
+            const validators = schemas.map(schema => ajv.compile(schema));
+            function validate(data, ctx) {
+                let correctValidator;
+                let result = false;
+                let clonedData;
+                // Try each validator until we find one that works!
+                for (const validator of validators) {
+                    clonedData = isPrimitive(data) ? _deepCopy(data) : data;
+                    result = validator(clonedData);
+                    if (result) {
+                        correctValidator = validator;
+                        break;
+                    }
+                }
+                if (result && ctx?.parentData && ctx.parentDataProperty) {
+                    // If we found a validator and the data is valid and we are validating a property inside an object,
+                    // then we can inject our result and be done with it.
+                    ctx.parentData[ctx.parentDataProperty] = clonedData;
+                }
+                else if (result) {
+                    // If we found a validator but we are not validating a property inside an object,
+                    // then we must re-run the validation so that the mutations caused by Ajv
+                    // will be done on the input data, not only on the clone.
+                    result = correctValidator(data);
+                }
+                else {
+                    // If we didn't find a fitting schema,
+                    // we add our own error.
+                    ;
+                    validate.errors = [
+                        {
+                            instancePath: ctx?.instancePath ?? '',
+                            message: `could not find a suitable schema to validate against`,
+                        },
+                    ];
+                }
+                return result;
+            }
+            return validate;
+        },
+    });
     return ajv;
 }
 const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
@@ -652,3 +699,6 @@ function isIsoMonthValid(s) {
     const month = (s.charCodeAt(5) - ZERO_CODE) * 10 + (s.charCodeAt(6) - ZERO_CODE);
     return _isBetween(year, 1900, 2500, '[]') && _isBetween(month, 1, 12, '[]');
 }
+function isPrimitive(data) {
+    return data !== null && typeof data === 'object';
+}

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

@@ -68,7 +68,7 @@ export declare const j: {
     oneOf<B extends readonly JsonSchemaAnyBuilder<any, any, boolean>[], IN = BuilderInUnion<B>, OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false>;
     /**
      * Use only with primitive values, otherwise this function will throw to avoid bugs.
-     * To validate objects, use `anyOfBy`.
+     * To validate objects, use `anyOfBy` or `anyOfThese`.
      *
      * Our Ajv is configured to strip unexpected properties from objects,
      * and since Ajv is mutating the input, this means that it cannot
@@ -78,7 +78,28 @@ export declare const j: {
      * Use `oneOf` when schemas are mutually exclusive.
      */
     anyOf<B extends readonly JsonSchemaAnyBuilder<any, any, boolean>[], IN = BuilderInUnion<B>, OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false>;
+    /**
+     * Pick validation schema for an object based on the value of a specific property.
+     *
+     * ```
+     * const schemaMap = {
+     *   true: successSchema,
+     *   false: errorSchema
+     * }
+     *
+     * const schema = j.anyOfBy('success', schemaMap)
+     * ```
+     */
     anyOfBy<P extends string, D extends Record<PropertyKey, JsonSchemaTerminal<any, any, any>>, IN = AnyOfByIn<D>, OUT = AnyOfByOut<D>>(propertyName: P, schemaDictionary: D): JsonSchemaAnyOfByBuilder<IN, OUT, P>;
+    /**
+     * Custom version of `anyOf` which - in contrast to the original function - does not mutate the input.
+     * This comes with a performance penalty, so do not use it where performance matters.
+     *
+     * ```
+     * const schema = j.anyOfThese([successSchema, errorSchema])
+     * ```
+     */
+    anyOfThese<B extends readonly JsonSchemaAnyBuilder<any, any, boolean>[], IN = BuilderInUnion<B>, OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false>;
     and(): {
         silentBob: () => never;
     };
@@ -369,6 +390,10 @@ export declare class JsonSchemaAnyOfByBuilder<IN, OUT, _P extends string = strin
     in: IN;
     constructor(propertyName: string, schemaDictionary: Record<PropertyKey, JsonSchemaTerminal<any, any, any>>);
 }
+export declare class JsonSchemaAnyOfTheseBuilder<IN, OUT, _P extends string = string> extends JsonSchemaAnyBuilder<AnyOfByInput<IN, _P> | IN, OUT, false> {
+    in: IN;
+    constructor(propertyName: string, schemaDictionary: Record<PropertyKey, JsonSchemaTerminal<any, any, any>>);
+}
 type EnumBaseType = 'string' | 'number' | 'other';
 export interface JsonSchema<IN = unknown, OUT = IN> {
     readonly in?: IN;
@@ -440,6 +465,7 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
         propertyName: string;
         schemaDictionary: Record<string, JsonSchema>;
     };
+    anyOfThese?: JsonSchema[];
 }
 declare function object(props: AnyObject): never;
 declare function object<IN extends AnyObject>(props: {

package/dist/validation/ajv/jsonSchemaBuilder.js

@@ -133,7 +133,7 @@ export const j = {
     },
     /**
      * Use only with primitive values, otherwise this function will throw to avoid bugs.
-     * To validate objects, use `anyOfBy`.
+     * To validate objects, use `anyOfBy` or `anyOfThese`.
      *
      * Our Ajv is configured to strip unexpected properties from objects,
      * and since Ajv is mutating the input, this means that it cannot
@@ -149,9 +149,34 @@ export const j = {
             anyOf: schemas,
         });
     },
+    /**
+     * Pick validation schema for an object based on the value of a specific property.
+     *
+     * ```
+     * const schemaMap = {
+     *   true: successSchema,
+     *   false: errorSchema
+     * }
+     *
+     * const schema = j.anyOfBy('success', schemaMap)
+     * ```
+     */
     anyOfBy(propertyName, schemaDictionary) {
         return new JsonSchemaAnyOfByBuilder(propertyName, schemaDictionary);
     },
+    /**
+     * Custom version of `anyOf` which - in contrast to the original function - does not mutate the input.
+     * This comes with a performance penalty, so do not use it where performance matters.
+     *
+     * ```
+     * const schema = j.anyOfThese([successSchema, errorSchema])
+     * ```
+     */
+    anyOfThese(items) {
+        return new JsonSchemaAnyBuilder({
+            anyOfThese: items.map(b => b.build()),
+        });
+    },
     and() {
         return {
             silentBob: () => {
@@ -837,6 +862,22 @@ export class JsonSchemaAnyOfByBuilder extends JsonSchemaAnyBuilder {
         });
     }
 }
+export class JsonSchemaAnyOfTheseBuilder extends JsonSchemaAnyBuilder {
+    constructor(propertyName, schemaDictionary) {
+        const builtSchemaDictionary = {};
+        for (const [key, schema] of Object.entries(schemaDictionary)) {
+            builtSchemaDictionary[key] = schema.build();
+        }
+        super({
+            type: 'object',
+            hasIsOfTypeCheck: true,
+            anyOfBy: {
+                propertyName,
+                schemaDictionary: builtSchemaDictionary,
+            },
+        });
+    }
+}
 function object(props) {
     return new JsonSchemaObjectBuilder(props);
 }

package/package.json

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

package/src/validation/ajv/getAjv.ts

@@ -1,5 +1,5 @@
 import { _isBetween, _lazyValue } from '@naturalcycles/js-lib'
-import { _mapObject, Set2 } from '@naturalcycles/js-lib/object'
+import { _deepCopy, _mapObject, Set2 } from '@naturalcycles/js-lib/object'
 import { _substringAfterLast } from '@naturalcycles/js-lib/string'
 import type { AnyObject } from '@naturalcycles/js-lib/types'
 import { Ajv2020, type Options, type ValidateFunction } from 'ajv/dist/2020.js'
@@ -585,6 +585,56 @@ export function createAjv(opt?: Options): Ajv2020 {
     },
   })
 
+  ajv.addKeyword({
+    keyword: 'anyOfThese',
+    modifying: true,
+    errors: true,
+    schemaType: 'array',
+    compile(schemas: JsonSchemaTerminal<any, any, any>[], _parentSchema, _it) {
+      const validators = schemas.map(schema => ajv.compile(schema))
+
+      function validate(data: AnyObject, ctx: any): boolean {
+        let correctValidator: ValidateFunction<unknown> | undefined
+        let result = false
+        let clonedData: any
+
+        // Try each validator until we find one that works!
+        for (const validator of validators) {
+          clonedData = isPrimitive(data) ? _deepCopy(data) : data
+          result = validator(clonedData)
+          if (result) {
+            correctValidator = validator
+            break
+          }
+        }
+
+        if (result && ctx?.parentData && ctx.parentDataProperty) {
+          // If we found a validator and the data is valid and we are validating a property inside an object,
+          // then we can inject our result and be done with it.
+          ctx.parentData[ctx.parentDataProperty] = clonedData
+        } else if (result) {
+          // If we found a validator but we are not validating a property inside an object,
+          // then we must re-run the validation so that the mutations caused by Ajv
+          // will be done on the input data, not only on the clone.
+          result = correctValidator!(data)
+        } else {
+          // If we didn't find a fitting schema,
+          // we add our own error.
+          ;(validate as any).errors = [
+            {
+              instancePath: ctx?.instancePath ?? '',
+              message: `could not find a suitable schema to validate against`,
+            },
+          ]
+        }
+
+        return result
+      }
+
+      return validate
+    },
+  })
+
   return ajv
 }
 
@@ -728,3 +778,7 @@ function isIsoMonthValid(s: string): boolean {
 
   return _isBetween(year, 1900, 2500, '[]') && _isBetween(month, 1, 12, '[]')
 }
+
+function isPrimitive(data: any): boolean {
+  return data !== null && typeof data === 'object'
+}

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -217,7 +217,7 @@ export const j = {
 
   /**
    * Use only with primitive values, otherwise this function will throw to avoid bugs.
-   * To validate objects, use `anyOfBy`.
+   * To validate objects, use `anyOfBy` or `anyOfThese`.
    *
    * Our Ajv is configured to strip unexpected properties from objects,
    * and since Ajv is mutating the input, this means that it cannot
@@ -242,6 +242,18 @@ export const j = {
     })
   },
 
+  /**
+   * Pick validation schema for an object based on the value of a specific property.
+   *
+   * ```
+   * const schemaMap = {
+   *   true: successSchema,
+   *   false: errorSchema
+   * }
+   *
+   * const schema = j.anyOfBy('success', schemaMap)
+   * ```
+   */
   anyOfBy<
     P extends string,
     D extends Record<PropertyKey, JsonSchemaTerminal<any, any, any>>,
@@ -251,6 +263,24 @@ export const j = {
     return new JsonSchemaAnyOfByBuilder<IN, OUT, P>(propertyName, schemaDictionary)
   },
 
+  /**
+   * Custom version of `anyOf` which - in contrast to the original function - does not mutate the input.
+   * This comes with a performance penalty, so do not use it where performance matters.
+   *
+   * ```
+   * const schema = j.anyOfThese([successSchema, errorSchema])
+   * ```
+   */
+  anyOfThese<
+    B extends readonly JsonSchemaAnyBuilder<any, any, boolean>[],
+    IN = BuilderInUnion<B>,
+    OUT = BuilderOutUnion<B>,
+  >(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false> {
+    return new JsonSchemaAnyBuilder<IN, OUT, false>({
+      anyOfThese: items.map(b => b.build()),
+    })
+  },
+
   and() {
     return {
       silentBob: () => {
@@ -1267,6 +1297,34 @@ export class JsonSchemaAnyOfByBuilder<
   }
 }
 
+export class JsonSchemaAnyOfTheseBuilder<
+  IN,
+  OUT,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  _P extends string = string,
+> extends JsonSchemaAnyBuilder<AnyOfByInput<IN, _P> | IN, OUT, false> {
+  declare in: IN
+
+  constructor(
+    propertyName: string,
+    schemaDictionary: Record<PropertyKey, JsonSchemaTerminal<any, any, any>>,
+  ) {
+    const builtSchemaDictionary: Record<string, JsonSchema> = {}
+    for (const [key, schema] of Object.entries(schemaDictionary)) {
+      builtSchemaDictionary[key] = schema.build()
+    }
+
+    super({
+      type: 'object',
+      hasIsOfTypeCheck: true,
+      anyOfBy: {
+        propertyName,
+        schemaDictionary: builtSchemaDictionary,
+      },
+    })
+  }
+}
+
 type EnumBaseType = 'string' | 'number' | 'other'
 
 export interface JsonSchema<IN = unknown, OUT = IN> {
@@ -1350,6 +1408,7 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
     propertyName: string
     schemaDictionary: Record<string, JsonSchema>
   }
+  anyOfThese?: JsonSchema[]
 }
 
 function object(props: AnyObject): never