@naturalcycles/nodejs-lib 15.56.1 → 15.57.1

package/dist/validation/ajv/ajvSchema.js

@@ -53,6 +53,7 @@ export class AjvSchema {
         }
         let jsonSchema;
         if (AjvSchema.isJsonSchemaBuilder(schema)) {
+            // oxlint-disable typescript-eslint(no-unnecessary-type-assertion)
             jsonSchema = schema.build();
             AjvSchema.requireValidJsonSchema(jsonSchema);
         }

package/dist/validation/ajv/getAjv.js

@@ -1,7 +1,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 { Ajv } from 'ajv';
 import { validTLDs } from '../tlds.js';
 /* eslint-disable @typescript-eslint/prefer-string-starts-ends-with */
 // oxlint-disable unicorn/prefer-code-point
@@ -66,27 +66,30 @@ export function createAjv(opt) {
         modifying: true,
         schemaType: 'object',
         errors: true,
-        code(ctx) {
-            const { gen, data, schema, it } = ctx;
-            const { parentData, parentDataProperty } = it;
-            if (schema.trim) {
-                gen.assign(_ `${data}`, _ `${data}.trim()`);
+        validate: function validate(transform, data, _schema, ctx) {
+            if (!data)
+                return true;
+            let transformedData = data;
+            if (transform.trim) {
+                transformedData = transformedData.trim();
             }
-            if (schema.toLowerCase) {
-                gen.assign(_ `${data}`, _ `${data}.toLowerCase()`);
+            if (transform.toLowerCase) {
+                transformedData = transformedData.toLocaleLowerCase();
             }
-            if (schema.toUpperCase) {
-                gen.assign(_ `${data}`, _ `${data}.toUpperCase()`);
+            if (transform.toUpperCase) {
+                transformedData = transformedData.toLocaleUpperCase();
             }
-            if (typeof schema.truncate === 'number' && schema.truncate >= 0) {
-                gen.assign(_ `${data}`, _ `${data}.slice(0, ${schema.truncate})`);
-                if (schema.trim) {
-                    gen.assign(_ `${data}`, _ `${data}.trim()`);
+            if (typeof transform.truncate === 'number' && transform.truncate >= 0) {
+                transformedData = transformedData.slice(0, transform.truncate);
+                if (transform.trim) {
+                    transformedData = transformedData.trim();
                 }
             }
-            gen.if(_ `${parentData} !== undefined`, () => {
-                gen.assign(_ `${parentData}[${parentDataProperty}]`, data);
-            });
+            // Explicit check for `undefined` because parentDataProperty can be `0` when it comes to arrays.
+            if (ctx?.parentData && typeof ctx.parentDataProperty !== 'undefined') {
+                ctx.parentData[ctx.parentDataProperty] = transformedData;
+            }
+            return true;
         },
     });
     ajv.addKeyword({
@@ -366,7 +369,7 @@ export function createAjv(opt) {
             if (!optionalValues.includes(data))
                 return true;
             if (ctx?.parentData && ctx.parentDataProperty) {
-                ctx.parentData[ctx.parentDataProperty] = undefined;
+                delete ctx.parentData[ctx.parentDataProperty];
             }
             return true;
         },

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

@@ -49,6 +49,8 @@ export declare class JsonSchemaAnyBuilder<IN, OUT, Opt> extends JsonSchemaTermin
      *
      * const schemaBad = j.string().isOfType<number>() // ❌
      * schemaBad.build() // TypeError: property "build" does not exist on type "never"
+     *
+     * const result = ajvValidateRequest.body(req, schemaBad) // result will have `unknown` type
      * ```
      */
     isOfType<ExpectedType>(): ExactMatch<ExpectedType, OUT> extends true ? this : never;
@@ -86,6 +88,7 @@ export declare class JsonSchemaStringBuilder<IN extends string | undefined = str
     pattern(pattern: string, opt?: JsonBuilderRuleOpt): this;
     minLength(minLength: number): this;
     maxLength(maxLength: number): this;
+    length(exactLength: number): this;
     length(minLength: number, maxLength: number): this;
     email(opt?: Partial<JsonSchemaStringEmailOptions>): this;
     trim(): this;
@@ -234,6 +237,7 @@ export declare class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyB
     constructor(itemsSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>);
     minLength(minItems: number): this;
     maxLength(maxItems: number): this;
+    length(exactLength: number): this;
     length(minItems: number, maxItems: number): this;
     exactLength(length: number): this;
     unique(): this;

package/dist/validation/ajv/jsonSchemaBuilder.js

@@ -26,8 +26,6 @@ export const j = {
         },
         stringMap(schema) {
             const builtSchema = schema.build();
-            _assert(!builtSchema?.optionalField, 'In a StringMap schema the value cannot be `undefined`, because `undefined` is not a valid JSON Schema value.');
-            builtSchema.optionalField = undefined;
             return new JsonSchemaObjectBuilder({}, {
                 hasIsOfTypeCheck: false,
                 patternProperties: {
@@ -111,7 +109,9 @@ export class JsonSchemaTerminal {
      * Same as if it would be JSON.stringified.
      */
     build() {
-        return _sortObject(JSON.parse(JSON.stringify(this.schema)), JSON_SCHEMA_ORDER);
+        const jsonSchema = _sortObject(JSON.parse(JSON.stringify(this.schema)), JSON_SCHEMA_ORDER);
+        delete jsonSchema.optionalField;
+        return jsonSchema;
     }
     clone() {
         return new JsonSchemaAnyBuilder(_deepCopy(this.schema));
@@ -140,6 +140,8 @@ export class JsonSchemaAnyBuilder extends JsonSchemaTerminal {
      *
      * const schemaBad = j.string().isOfType<number>() // ❌
      * schemaBad.build() // TypeError: property "build" does not exist on type "never"
+     *
+     * const result = ajvValidateRequest.body(req, schemaBad) // result will have `unknown` type
      * ```
      */
     isOfType() {
@@ -248,9 +250,9 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
         _objectAssign(this.schema, { maxLength });
         return this;
     }
-    length(minLength, maxLength) {
-        _objectAssign(this.schema, { minLength, maxLength });
-        return this;
+    length(minLengthOrExactLength, maxLength) {
+        const maxLengthActual = maxLength ?? minLengthOrExactLength;
+        return this.minLength(minLengthOrExactLength).maxLength(maxLengthActual);
     }
     email(opt) {
         const defaultOptions = { checkTLD: true };
@@ -533,13 +535,11 @@ export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
         const properties = {};
         const required = [];
         for (const [key, builder] of Object.entries(props)) {
-            const schema = builder.build();
-            if (!schema.optionalField) {
+            const isOptional = builder.getSchema().optionalField;
+            if (!isOptional) {
                 required.push(key);
             }
-            else {
-                schema.optionalField = undefined;
-            }
+            const schema = builder.build();
             properties[key] = schema;
         }
         this.schema.properties = properties;
@@ -595,13 +595,11 @@ export class JsonSchemaObjectInferringBuilder extends JsonSchemaAnyBuilder {
         const properties = {};
         const required = [];
         for (const [key, builder] of Object.entries(props)) {
-            const schema = builder.build();
-            if (!schema.optionalField) {
+            const isOptional = builder.getSchema().optionalField;
+            if (!isOptional) {
                 required.push(key);
             }
-            else {
-                schema.optionalField = undefined;
-            }
+            const schema = builder.build();
             properties[key] = schema;
         }
         this.schema.properties = properties;
@@ -649,8 +647,9 @@ export class JsonSchemaArrayBuilder extends JsonSchemaAnyBuilder {
         _objectAssign(this.schema, { maxItems });
         return this;
     }
-    length(minItems, maxItems) {
-        return this.minLength(minItems).maxLength(maxItems);
+    length(minItemsOrExact, maxItems) {
+        const maxItemsActual = maxItems ?? minItemsOrExact;
+        return this.minLength(minItemsOrExact).maxLength(maxItemsActual);
     }
     exactLength(length) {
         return this.minLength(length).maxLength(length);

package/package.json

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

package/src/validation/ajv/ajvSchema.ts

@@ -73,6 +73,7 @@ export class AjvSchema<IN = unknown, OUT = IN> {
     let jsonSchema: JsonSchema<IN, OUT>
 
     if (AjvSchema.isJsonSchemaBuilder(schema)) {
+      // oxlint-disable typescript-eslint(no-unnecessary-type-assertion)
       jsonSchema = (schema as JsonSchemaTerminal<IN, OUT, any>).build()
       AjvSchema.requireValidJsonSchema(jsonSchema)
     } else {

package/src/validation/ajv/getAjv.ts

@@ -1,7 +1,7 @@
 import { _lazyValue } from '@naturalcycles/js-lib'
 import { Set2 } from '@naturalcycles/js-lib/object'
 import { _substringAfterLast } from '@naturalcycles/js-lib/string'
-import { _, Ajv, type Options, type ValidateFunction } from 'ajv'
+import { Ajv, type Options, type ValidateFunction } from 'ajv'
 import { validTLDs } from '../tlds.js'
 import type { JsonSchemaIsoDateOptions, JsonSchemaStringEmailOptions } from './jsonSchemaBuilder.js'
 
@@ -77,33 +77,42 @@ export function createAjv(opt?: Options): Ajv {
     modifying: true,
     schemaType: 'object',
     errors: true,
-    code(ctx) {
-      const { gen, data, schema, it } = ctx
-      const { parentData, parentDataProperty } = it
+    validate: function validate(
+      transform: { trim?: true; toLowerCase?: true; toUpperCase?: true; truncate?: number },
+      data: string,
+      _schema,
+      ctx,
+    ) {
+      if (!data) return true
 
-      if (schema.trim) {
-        gen.assign(_`${data}`, _`${data}.trim()`)
+      let transformedData = data
+
+      if (transform.trim) {
+        transformedData = transformedData.trim()
       }
 
-      if (schema.toLowerCase) {
-        gen.assign(_`${data}`, _`${data}.toLowerCase()`)
+      if (transform.toLowerCase) {
+        transformedData = transformedData.toLocaleLowerCase()
       }
 
-      if (schema.toUpperCase) {
-        gen.assign(_`${data}`, _`${data}.toUpperCase()`)
+      if (transform.toUpperCase) {
+        transformedData = transformedData.toLocaleUpperCase()
       }
 
-      if (typeof schema.truncate === 'number' && schema.truncate >= 0) {
-        gen.assign(_`${data}`, _`${data}.slice(0, ${schema.truncate})`)
+      if (typeof transform.truncate === 'number' && transform.truncate >= 0) {
+        transformedData = transformedData.slice(0, transform.truncate)
 
-        if (schema.trim) {
-          gen.assign(_`${data}`, _`${data}.trim()`)
+        if (transform.trim) {
+          transformedData = transformedData.trim()
         }
       }
 
-      gen.if(_`${parentData} !== undefined`, () => {
-        gen.assign(_`${parentData}[${parentDataProperty}]`, data)
-      })
+      // Explicit check for `undefined` because parentDataProperty can be `0` when it comes to arrays.
+      if (ctx?.parentData && typeof ctx.parentDataProperty !== 'undefined') {
+        ctx.parentData[ctx.parentDataProperty] = transformedData
+      }
+
+      return true
     },
   })
 
@@ -413,7 +422,7 @@ export function createAjv(opt?: Options): Ajv {
       if (!optionalValues.includes(data)) return true
 
       if (ctx?.parentData && ctx.parentDataProperty) {
-        ctx.parentData[ctx.parentDataProperty] = undefined
+        delete ctx.parentData[ctx.parentDataProperty]
       }
 
       return true

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -70,11 +70,6 @@ export const j = {
       schema: S,
     ): JsonSchemaObjectBuilder<StringMap<SchemaIn<S>>, StringMap<SchemaOut<S>>> {
       const builtSchema = schema.build()
-      _assert(
-        !builtSchema?.optionalField,
-        'In a StringMap schema the value cannot be `undefined`, because `undefined` is not a valid JSON Schema value.',
-      )
-      builtSchema.optionalField = undefined
 
       return new JsonSchemaObjectBuilder<StringMap<SchemaIn<S>>, StringMap<SchemaOut<S>>>(
         {},
@@ -193,7 +188,14 @@ export class JsonSchemaTerminal<IN, OUT, Opt> {
    * Same as if it would be JSON.stringified.
    */
   build(): JsonSchema<IN, OUT> {
-    return _sortObject(JSON.parse(JSON.stringify(this.schema)), JSON_SCHEMA_ORDER)
+    const jsonSchema = _sortObject(
+      JSON.parse(JSON.stringify(this.schema)),
+      JSON_SCHEMA_ORDER,
+    ) as JsonSchema<IN, OUT>
+
+    delete jsonSchema.optionalField
+
+    return jsonSchema
   }
 
   clone(): JsonSchemaAnyBuilder<IN, OUT, Opt> {
@@ -226,6 +228,8 @@ export class JsonSchemaAnyBuilder<IN, OUT, Opt> extends JsonSchemaTerminal<IN, O
    *
    * const schemaBad = j.string().isOfType<number>() // ❌
    * schemaBad.build() // TypeError: property "build" does not exist on type "never"
+   *
+   * const result = ajvValidateRequest.body(req, schemaBad) // result will have `unknown` type
    * ```
    */
   isOfType<ExpectedType>(): ExactMatch<ExpectedType, OUT> extends true ? this : never {
@@ -364,9 +368,11 @@ export class JsonSchemaStringBuilder<
     return this
   }
 
-  length(minLength: number, maxLength: number): this {
-    _objectAssign(this.schema, { minLength, maxLength })
-    return this
+  length(exactLength: number): this
+  length(minLength: number, maxLength: number): this
+  length(minLengthOrExactLength: number, maxLength?: number): this {
+    const maxLengthActual = maxLength ?? minLengthOrExactLength
+    return this.minLength(minLengthOrExactLength).maxLength(maxLengthActual)
   }
 
   email(opt?: Partial<JsonSchemaStringEmailOptions>): this {
@@ -753,12 +759,12 @@ export class JsonSchemaObjectBuilder<
     const required: string[] = []
 
     for (const [key, builder] of Object.entries(props)) {
-      const schema = builder.build()
-      if (!schema.optionalField) {
+      const isOptional = (builder as JsonSchemaTerminal<any, any, any>).getSchema().optionalField
+      if (!isOptional) {
         required.push(key)
-      } else {
-        schema.optionalField = undefined
       }
+
+      const schema = builder.build()
       properties[key] = schema
     }
 
@@ -868,12 +874,12 @@ export class JsonSchemaObjectInferringBuilder<
     const required: string[] = []
 
     for (const [key, builder] of Object.entries(props)) {
-      const schema = builder.build()
-      if (!schema.optionalField) {
+      const isOptional = (builder as JsonSchemaTerminal<any, any, any>).getSchema().optionalField
+      if (!isOptional) {
         required.push(key)
-      } else {
-        schema.optionalField = undefined
       }
+
+      const schema = builder.build()
       properties[key] = schema
     }
 
@@ -952,8 +958,11 @@ export class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<I
     return this
   }
 
-  length(minItems: number, maxItems: number): this {
-    return this.minLength(minItems).maxLength(maxItems)
+  length(exactLength: number): this
+  length(minItems: number, maxItems: number): this
+  length(minItemsOrExact: number, maxItems?: number): this {
+    const maxItemsActual = maxItems ?? minItemsOrExact
+    return this.minLength(minItemsOrExact).maxLength(maxItemsActual)
   }
 
   exactLength(length: number): this {