@naturalcycles/nodejs-lib 15.78.2 → 15.80.0

package/dist/validation/ajv/getAjv.js

@@ -1,5 +1,5 @@
 import { _isBetween, _lazyValue } from '@naturalcycles/js-lib';
-import { Set2 } from '@naturalcycles/js-lib/object';
+import { _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';
@@ -477,6 +477,37 @@ export function createAjv(opt) {
             return true;
         },
     });
+    ajv.addKeyword({
+        keyword: 'anyOfBy',
+        type: 'object',
+        modifying: true,
+        errors: false,
+        schemaType: 'object',
+        compile(config, _parentSchema, _it) {
+            const { propertyName, schemaDictionary } = config;
+            const isValidFnByKey = _mapObject(schemaDictionary, (key, value) => {
+                return [key, ajv.compile(value)];
+            });
+            function validate(data, ctx) {
+                if (typeof data !== 'object' || data === null)
+                    return true;
+                const determinant = data[propertyName];
+                const isValidFn = isValidFnByKey[determinant];
+                if (!isValidFn) {
+                    ;
+                    validate.errors = [
+                        {
+                            instancePath: ctx?.instancePath ?? '',
+                            message: `could not find a suitable schema to validate against based on "${propertyName}"`,
+                        },
+                    ];
+                    return false;
+                }
+                return isValidFn(data);
+            }
+            return validate;
+        },
+    });
     return ajv;
 }
 const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

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

@@ -54,17 +54,35 @@ export declare const j: {
     set<IN, OUT, Opt>(itemSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>): JsonSchemaSet2Builder<IN, OUT, Opt>;
     buffer(): JsonSchemaBufferBuilder;
     enum<const T extends readonly (string | number | boolean | null)[] | StringEnum | NumberEnum>(input: T, opt?: JsonBuilderRuleOpt): JsonSchemaEnumBuilder<T extends readonly (infer U)[] ? U : T extends StringEnum ? T[keyof T] : T extends NumberEnum ? T[keyof T] : never>;
+    /**
+     * Use only with primitive values, otherwise this function will throw to avoid bugs.
+     * To validate objects, use `anyOfBy`.
+     *
+     * Our Ajv is configured to strip unexpected properties from objects,
+     * and since Ajv is mutating the input, this means that it cannot
+     * properly validate the same data over multiple schemas.
+     *
+     * Use `anyOf` when schemas may overlap (e.g., AccountId | PartnerId with same format).
+     * Use `oneOf` when schemas are mutually exclusive.
+     */
     oneOf<B extends readonly JsonSchemaAnyBuilder<any, any, boolean>[], IN = BuilderInUnion<B>, OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false>;
     /**
-     * Value must match at least one of the provided schemas.
+     * Use only with primitive values, otherwise this function will throw to avoid bugs.
+     * To validate objects, use `anyOfBy`.
+     *
+     * Our Ajv is configured to strip unexpected properties from objects,
+     * and since Ajv is mutating the input, this means that it cannot
+     * properly validate the same data over multiple schemas.
      *
      * Use `anyOf` when schemas may overlap (e.g., AccountId | PartnerId with same format).
      * 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>;
+    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>;
     and(): {
         silentBob: () => never;
     };
+    literal<const V extends string | number | boolean | null>(v: V): JsonSchemaEnumBuilder<V, V, false>;
 };
 export declare class JsonSchemaTerminal<IN, OUT, Opt> {
     protected schema: JsonSchema;
@@ -347,6 +365,10 @@ export declare class JsonSchemaTupleBuilder<ITEMS extends JsonSchemaAnyBuilder<a
     private readonly _items;
     constructor(items: ITEMS);
 }
+export declare class JsonSchemaAnyOfByBuilder<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;
@@ -414,6 +436,10 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
     keySchema?: JsonSchema;
     minProperties2?: number;
     exclusiveProperties?: (readonly string[])[];
+    anyOfBy?: {
+        propertyName: string;
+        schemaDictionary: Record<string, JsonSchema>;
+    };
 }
 declare function object(props: AnyObject): never;
 declare function object<IN extends AnyObject>(props: {
@@ -475,6 +501,18 @@ type BuilderOutUnion<B extends readonly JsonSchemaAnyBuilder<any, any, any>[]> =
 type BuilderInUnion<B extends readonly JsonSchemaAnyBuilder<any, any, any>[]> = {
     [K in keyof B]: B[K] extends JsonSchemaAnyBuilder<infer I, any, any> ? I : never;
 }[number];
+type AnyOfByIn<D extends Record<PropertyKey, JsonSchemaTerminal<any, any, any>>> = {
+    [K in keyof D]: D[K] extends JsonSchemaTerminal<infer I, any, any> ? I : never;
+}[keyof D];
+type AnyOfByOut<D extends Record<PropertyKey, JsonSchemaTerminal<any, any, any>>> = {
+    [K in keyof D]: D[K] extends JsonSchemaTerminal<any, infer O, any> ? O : never;
+}[keyof D];
+type AnyOfByDiscriminant<IN, P extends string> = IN extends {
+    [K in P]: infer V;
+} ? V : never;
+type AnyOfByInput<IN, P extends string, D = AnyOfByDiscriminant<IN, P>> = IN extends unknown ? Omit<Partial<IN>, P> & {
+    [K in P]?: D;
+} : never;
 type BuilderFor<T> = JsonSchemaAnyBuilder<any, T, any>;
 interface JsonBuilderRuleOpt {
     /**

package/dist/validation/ajv/jsonSchemaBuilder.js

@@ -113,24 +113,45 @@ export const j = {
         _assert(enumValues, 'Unsupported enum input');
         return new JsonSchemaEnumBuilder(enumValues, baseType, opt);
     },
+    /**
+     * Use only with primitive values, otherwise this function will throw to avoid bugs.
+     * To validate objects, use `anyOfBy`.
+     *
+     * Our Ajv is configured to strip unexpected properties from objects,
+     * and since Ajv is mutating the input, this means that it cannot
+     * properly validate the same data over multiple schemas.
+     *
+     * Use `anyOf` when schemas may overlap (e.g., AccountId | PartnerId with same format).
+     * Use `oneOf` when schemas are mutually exclusive.
+     */
     oneOf(items) {
         const schemas = items.map(b => b.build());
+        _assert(schemas.every(hasOnlySchemasForPrimitives), 'Do not use `oneOf` validation with non-primitive types!');
         return new JsonSchemaAnyBuilder({
             oneOf: schemas,
         });
     },
     /**
-     * Value must match at least one of the provided schemas.
+     * Use only with primitive values, otherwise this function will throw to avoid bugs.
+     * To validate objects, use `anyOfBy`.
+     *
+     * Our Ajv is configured to strip unexpected properties from objects,
+     * and since Ajv is mutating the input, this means that it cannot
+     * properly validate the same data over multiple schemas.
      *
      * Use `anyOf` when schemas may overlap (e.g., AccountId | PartnerId with same format).
      * Use `oneOf` when schemas are mutually exclusive.
      */
     anyOf(items) {
         const schemas = items.map(b => b.build());
+        _assert(schemas.every(hasOnlySchemasForPrimitives), 'Do not use `anyOf` validation with non-primitive types!');
         return new JsonSchemaAnyBuilder({
             anyOf: schemas,
         });
     },
+    anyOfBy(propertyName, schemaDictionary) {
+        return new JsonSchemaAnyOfByBuilder(propertyName, schemaDictionary);
+    },
     and() {
         return {
             silentBob: () => {
@@ -138,6 +159,14 @@ export const j = {
             },
         };
     },
+    literal(v) {
+        let baseType = 'other';
+        if (typeof v === 'string')
+            baseType = 'string';
+        if (typeof v === 'number')
+            baseType = 'number';
+        return new JsonSchemaEnumBuilder([v], baseType);
+    },
 };
 const TS_2500 = 16725225600; // 2500-01-01
 const TS_2500_MILLIS = TS_2500 * 1000;
@@ -792,6 +821,22 @@ export class JsonSchemaTupleBuilder extends JsonSchemaAnyBuilder {
         this._items = items;
     }
 }
+export class JsonSchemaAnyOfByBuilder 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);
 }
@@ -854,3 +899,18 @@ function withEnumKeys(keys, schema) {
     const props = Object.fromEntries(typedValues.map(key => [key, schema]));
     return new JsonSchemaObjectBuilder(props, { hasIsOfTypeCheck: false });
 }
+function hasOnlySchemasForPrimitives(schema) {
+    if (Array.isArray(schema.type)) {
+        schema.type.every(type => ['string', 'number', 'integer', 'boolean', 'null'].includes(type));
+    }
+    else if (schema.anyOf) {
+        return schema.anyOf.every(hasOnlySchemasForPrimitives);
+    }
+    else if (schema.oneOf) {
+        return schema.oneOf.every(hasOnlySchemasForPrimitives);
+    }
+    else {
+        return !!schema.type && ['string', 'number', 'integer', 'boolean', 'null'].includes(schema.type);
+    }
+    return false;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.78.2",
+  "version": "15.80.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 { Set2 } from '@naturalcycles/js-lib/object'
+import { _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'
@@ -8,6 +8,7 @@ import type {
   JsonSchemaIsoDateOptions,
   JsonSchemaIsoMonthOptions,
   JsonSchemaStringEmailOptions,
+  JsonSchemaTerminal,
 } from './jsonSchemaBuilder.js'
 
 /* eslint-disable @typescript-eslint/prefer-string-starts-ends-with */
@@ -542,6 +543,44 @@ export function createAjv(opt?: Options): Ajv2020 {
     },
   })
 
+  ajv.addKeyword({
+    keyword: 'anyOfBy',
+    type: 'object',
+    modifying: true,
+    errors: false,
+    schemaType: 'object',
+    compile(config, _parentSchema, _it) {
+      const { propertyName, schemaDictionary } = config
+
+      const isValidFnByKey: Record<any, ValidateFunction> = _mapObject(
+        schemaDictionary as Record<any, JsonSchemaTerminal<any, any, any>>,
+        (key, value) => {
+          return [key, ajv.compile(value)]
+        },
+      )
+
+      function validate(data: AnyObject, ctx: any): boolean {
+        if (typeof data !== 'object' || data === null) return true
+
+        const determinant = data[propertyName]
+        const isValidFn = isValidFnByKey[determinant]
+        if (!isValidFn) {
+          ;(validate as any).errors = [
+            {
+              instancePath: ctx?.instancePath ?? '',
+              message: `could not find a suitable schema to validate against based on "${propertyName}"`,
+            },
+          ]
+          return false
+        }
+
+        return isValidFn(data)
+      }
+
+      return validate
+    },
+  })
+
   return ajv
 }
 

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -188,19 +188,40 @@ export const j = {
     return new JsonSchemaEnumBuilder(enumValues as any, baseType, opt)
   },
 
+  /**
+   * Use only with primitive values, otherwise this function will throw to avoid bugs.
+   * To validate objects, use `anyOfBy`.
+   *
+   * Our Ajv is configured to strip unexpected properties from objects,
+   * and since Ajv is mutating the input, this means that it cannot
+   * properly validate the same data over multiple schemas.
+   *
+   * Use `anyOf` when schemas may overlap (e.g., AccountId | PartnerId with same format).
+   * Use `oneOf` when schemas are mutually exclusive.
+   */
   oneOf<
     B extends readonly JsonSchemaAnyBuilder<any, any, boolean>[],
     IN = BuilderInUnion<B>,
     OUT = BuilderOutUnion<B>,
   >(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false> {
     const schemas = items.map(b => b.build())
+    _assert(
+      schemas.every(hasOnlySchemasForPrimitives),
+      'Do not use `oneOf` validation with non-primitive types!',
+    )
+
     return new JsonSchemaAnyBuilder<IN, OUT, false>({
       oneOf: schemas,
     })
   },
 
   /**
-   * Value must match at least one of the provided schemas.
+   * Use only with primitive values, otherwise this function will throw to avoid bugs.
+   * To validate objects, use `anyOfBy`.
+   *
+   * Our Ajv is configured to strip unexpected properties from objects,
+   * and since Ajv is mutating the input, this means that it cannot
+   * properly validate the same data over multiple schemas.
    *
    * Use `anyOf` when schemas may overlap (e.g., AccountId | PartnerId with same format).
    * Use `oneOf` when schemas are mutually exclusive.
@@ -211,11 +232,25 @@ export const j = {
     OUT = BuilderOutUnion<B>,
   >(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false> {
     const schemas = items.map(b => b.build())
+    _assert(
+      schemas.every(hasOnlySchemasForPrimitives),
+      'Do not use `anyOf` validation with non-primitive types!',
+    )
+
     return new JsonSchemaAnyBuilder<IN, OUT, false>({
       anyOf: schemas,
     })
   },
 
+  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> {
+    return new JsonSchemaAnyOfByBuilder<IN, OUT, P>(propertyName, schemaDictionary)
+  },
+
   and() {
     return {
       silentBob: () => {
@@ -223,6 +258,13 @@ export const j = {
       },
     }
   },
+
+  literal<const V extends string | number | boolean | null>(v: V) {
+    let baseType: EnumBaseType = 'other'
+    if (typeof v === 'string') baseType = 'string'
+    if (typeof v === 'number') baseType = 'number'
+    return new JsonSchemaEnumBuilder<V>([v], baseType)
+  },
 }
 
 const TS_2500 = 16725225600 // 2500-01-01
@@ -1197,6 +1239,34 @@ export class JsonSchemaTupleBuilder<
   }
 }
 
+export class JsonSchemaAnyOfByBuilder<
+  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> {
@@ -1276,6 +1346,10 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
   keySchema?: JsonSchema
   minProperties2?: number
   exclusiveProperties?: (readonly string[])[]
+  anyOfBy?: {
+    propertyName: string
+    schemaDictionary: Record<string, JsonSchema>
+  }
 }
 
 function object(props: AnyObject): never
@@ -1441,6 +1515,20 @@ function withEnumKeys<
   >(props, { hasIsOfTypeCheck: false })
 }
 
+function hasOnlySchemasForPrimitives(schema: JsonSchema): boolean {
+  if (Array.isArray(schema.type)) {
+    schema.type.every(type => ['string', 'number', 'integer', 'boolean', 'null'].includes(type))
+  } else if (schema.anyOf) {
+    return schema.anyOf.every(hasOnlySchemasForPrimitives)
+  } else if (schema.oneOf) {
+    return schema.oneOf.every(hasOnlySchemasForPrimitives)
+  } else {
+    return !!schema.type && ['string', 'number', 'integer', 'boolean', 'null'].includes(schema.type)
+  }
+
+  return false
+}
+
 type Expand<T> = { [K in keyof T]: T[K] }
 
 type StripIndexSignatureDeep<T> = T extends readonly unknown[]
@@ -1504,6 +1592,20 @@ type BuilderInUnion<B extends readonly JsonSchemaAnyBuilder<any, any, any>[]> =
   [K in keyof B]: B[K] extends JsonSchemaAnyBuilder<infer I, any, any> ? I : never
 }[number]
 
+type AnyOfByIn<D extends Record<PropertyKey, JsonSchemaTerminal<any, any, any>>> = {
+  [K in keyof D]: D[K] extends JsonSchemaTerminal<infer I, any, any> ? I : never
+}[keyof D]
+
+type AnyOfByOut<D extends Record<PropertyKey, JsonSchemaTerminal<any, any, any>>> = {
+  [K in keyof D]: D[K] extends JsonSchemaTerminal<any, infer O, any> ? O : never
+}[keyof D]
+
+type AnyOfByDiscriminant<IN, P extends string> = IN extends { [K in P]: infer V } ? V : never
+
+type AnyOfByInput<IN, P extends string, D = AnyOfByDiscriminant<IN, P>> = IN extends unknown
+  ? Omit<Partial<IN>, P> & { [K in P]?: D }
+  : never
+
 type BuilderFor<T> = JsonSchemaAnyBuilder<any, T, any>
 
 interface JsonBuilderRuleOpt {