@naturalcycles/nodejs-lib 15.140.0 → 15.141.0

package/dist/validation/ajv/getAjv.js

@@ -2,7 +2,7 @@ import { _isBetween, _lazyValue, _round } from '@naturalcycles/js-lib';
 import { _assert } from '@naturalcycles/js-lib/error';
 import { _deepCopy, _mapObject, Set2 } from '@naturalcycles/js-lib/object';
 import { _substringAfterLast } from '@naturalcycles/js-lib/string';
-import { Ajv2020 } from 'ajv/dist/2020.js';
+import { _, Ajv2020, str } from 'ajv/dist/2020.js';
 import { validTLDs } from '../tlds.js';
 import { jFormats } from './jsonSchemaBuilder.util.js';
 // oxlint-disable unicorn/prefer-code-point
@@ -265,130 +265,70 @@ export function createAjv(opt) {
             return true;
         },
     });
+    // The date/time keywords are `code` keywords, which Ajv inlines into the compiled validator.
+    // A `validate` keyword is a function call with a context object, whose instancePath Ajv builds
+    // on every call (escaping the key of every map entry), even for valid data.
     ajv.addKeyword({
         keyword: 'IsoDate',
         type: 'string',
-        modifying: false,
-        errors: true,
         schemaType: 'object',
-        validate: function validate(opt, data, _schema, ctx) {
-            const hasOptions = Object.keys(opt).length > 0;
-            const isValid = isIsoDateValid(data);
-            if (!isValid) {
-                ;
-                validate.errors = [
-                    {
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is an invalid IsoDate`,
-                    },
-                ];
-                return false;
-            }
-            if (!hasOptions)
-                return true;
-            const { before, sameOrBefore, after, sameOrAfter } = opt;
-            const errors = [];
-            if (before) {
-                const isParamValid = isIsoDateValid(before);
-                const isRuleValid = isParamValid && before > data;
-                if (!isRuleValid) {
-                    errors.push({
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is not before ${before}`,
-                    });
-                }
-            }
-            if (sameOrBefore) {
-                const isParamValid = isIsoDateValid(sameOrBefore);
-                const isRuleValid = isParamValid && sameOrBefore >= data;
-                if (!isRuleValid) {
-                    errors.push({
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is not the same or before ${sameOrBefore}`,
-                    });
-                }
-            }
-            if (after) {
-                const isParamValid = isIsoDateValid(after);
-                const isRuleValid = isParamValid && after < data;
-                if (!isRuleValid) {
-                    errors.push({
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is not after ${after}`,
-                    });
-                }
-            }
-            if (sameOrAfter) {
-                const isParamValid = isIsoDateValid(sameOrAfter);
-                const isRuleValid = isParamValid && sameOrAfter <= data;
-                if (!isRuleValid) {
-                    errors.push({
-                        instancePath: ctx?.instancePath ?? '',
-                        message: `is not the same or after ${sameOrAfter}`,
-                    });
+        error: {
+            message: ({ params }) => params['rule']
+                ? str `is not ${isoDateRuleLabels[params['rule']]} ${params['limit']}`
+                : str `is an invalid IsoDate`,
+            params: ({ params }) => (params['rule'] ? _ `{${params['rule']}: ${params['limit']}}` : _ `{}`),
+        },
+        code(cxt) {
+            const { gen, data } = cxt;
+            const opt = cxt.schema;
+            const isValid = gen.scopeValue('func', { ref: isIsoDateValid });
+            gen.if(_ `!${isValid}(${data})`, () => cxt.error(), () => {
+                for (const rule of isoDateRules) {
+                    const limit = opt[rule];
+                    if (!limit)
+                        continue;
+                    const params = { rule, limit };
+                    if (!isIsoDateValid(limit)) {
+                        // An invalid limit rejects every date
+                        cxt.error(false, params);
+                        continue;
+                    }
+                    gen.if(isoDateRuleFails(rule, data, limit), () => cxt.error(false, params));
                 }
-            }
-            if (errors.length === 0)
-                return true;
-            validate.errors = errors;
-            return false;
+            });
         },
     });
     ajv.addKeyword({
         keyword: 'IsoDateTime',
         type: 'string',
-        modifying: false,
-        errors: true,
         schemaType: 'boolean',
-        validate: function validate(_opt, data, _schema, ctx) {
-            const isValid = isIsoDateTimeValid(data);
-            if (isValid)
-                return true;
-            validate.errors = [
-                {
-                    instancePath: ctx?.instancePath ?? '',
-                    message: `is an invalid IsoDateTime`,
-                },
-            ];
-            return false;
+        error: { message: 'is an invalid IsoDateTime' },
+        code(cxt) {
+            const isValid = cxt.gen.scopeValue('func', { ref: isIsoDateTimeValid });
+            cxt.fail(_ `!${isValid}(${cxt.data})`);
         },
     });
     ajv.addKeyword({
         keyword: 'IsoMonth',
         type: 'string',
-        modifying: false,
-        errors: true,
         schemaType: 'object',
-        validate: function validate(_opt, data, _schema, ctx) {
-            const isValid = isIsoMonthValid(data);
-            if (isValid)
-                return true;
-            validate.errors = [
-                {
-                    instancePath: ctx?.instancePath ?? '',
-                    message: `is an invalid IsoMonth`,
-                },
-            ];
-            return false;
+        error: { message: 'is an invalid IsoMonth' },
+        code(cxt) {
+            const isValid = cxt.gen.scopeValue('func', { ref: isIsoMonthValid });
+            cxt.fail(_ `!${isValid}(${cxt.data})`);
         },
     });
     ajv.addKeyword({
         keyword: 'UtcOffset',
         type: 'string',
-        modifying: false,
-        errors: true,
         schemaType: 'object',
-        validate: function validate(opt, data, _schema, ctx) {
-            const isValid = data === 'Z' ? opt.allowZ : data !== '' && isIsoTimezoneValid(data);
-            if (isValid)
-                return true;
-            validate.errors = [
-                {
-                    instancePath: ctx?.instancePath ?? '',
-                    message: `is an invalid UtcOffset`,
-                },
-            ];
-            return false;
+        error: { message: 'is an invalid UtcOffset' },
+        code(cxt) {
+            const opt = cxt.schema;
+            const isValid = cxt.gen.scopeValue('func', {
+                ref: opt.allowZ ? isUtcOffsetOrZValid : isUtcOffsetValid,
+            });
+            cxt.fail(_ `!${isValid}(${cxt.data})`);
         },
     });
     // Annotation only (the values are validated by `enum`), registered so strict mode doesn't reject it
@@ -425,35 +365,62 @@ export function createAjv(opt) {
             return true;
         },
     });
+    // Strips the keys that don't match the key schema; the values are validated by `additionalProperties`.
+    // The key schema is inlined per key with error reporting off, and the error count is reset after
+    // a mismatch, so a stripped key never surfaces as an error. Keys listed in `properties` are skipped.
     ajv.addKeyword({
         keyword: 'keySchema',
         type: 'object',
-        modifying: true,
-        errors: false,
         schemaType: 'object',
-        compile(innerSchema, _parentSchema, _it) {
-            const isValidKeyFn = ajv.compile(innerSchema);
-            function validate(data, _ctx) {
-                if (typeof data !== 'object' || data === null)
-                    return true;
-                for (const key of Object.keys(data)) {
-                    if (!isValidKeyFn(key)) {
-                        delete data[key];
-                    }
+        trackErrors: true,
+        code(cxt) {
+            const { gen, data, parentSchema } = cxt;
+            const propertyNames = Object.keys(parentSchema['properties'] || {});
+            const valid = gen.name('valid');
+            gen.forIn('key', data, key => {
+                const checkKey = () => {
+                    cxt.subschema({
+                        keyword: 'keySchema',
+                        data: key,
+                        dataTypes: ['string'],
+                        compositeRule: true,
+                        createErrors: false,
+                        allErrors: false,
+                    }, valid);
+                    gen.if(_ `!${valid}`, () => {
+                        cxt.reset();
+                        gen.code(_ `delete ${data}[${key}]`);
+                    });
+                };
+                if (!propertyNames.length)
+                    return checkKey();
+                let isNotProperty = _ `${key} !== ${propertyNames[0]}`;
+                for (const name of propertyNames.slice(1)) {
+                    isNotProperty = _ `${isNotProperty} && ${key} !== ${name}`;
                 }
-                return true;
-            }
-            return validate;
+                gen.if(isNotProperty, checkKey);
+            });
         },
     });
-    // Validates that the value is undefined. Used in record/stringMap with optional value schemas
-    // to allow undefined values in patternProperties via anyOf.
+    // Validates the inner schema only when the value is defined. Used for the optional values of
+    // `stringMap`/`record`, whose `additionalProperties` loop visits the keys with undefined values too.
+    ajv.addKeyword({
+        keyword: 'ifDefined',
+        schemaType: ['object', 'boolean'],
+        code(cxt) {
+            const { gen, data } = cxt;
+            gen.if(_ `${data} !== undefined`, () => {
+                cxt.subschema({ keyword: 'ifDefined' }, gen.name('valid'));
+            });
+        },
+    });
+    // Validates that the value is undefined. Superseded by `ifDefined`, kept for raw JSON schemas.
     ajv.addKeyword({
         keyword: 'isUndefined',
-        modifying: false,
-        errors: false,
         schemaType: 'boolean',
-        validate: (_schema, data) => data === undefined,
+        code(cxt) {
+            cxt.fail(_ `${cxt.data} !== undefined`);
+        },
     });
     // This is added because Ajv validates the `min/maxProperties` before validating the properties.
     // So, in case of `minProperties(1)` and `{ foo: 'bar' }` Ajv will let it pass, even
@@ -660,6 +627,25 @@ export function createAjv(opt) {
     });
     return ajv;
 }
+const isoDateRules = ['before', 'sameOrBefore', 'after', 'sameOrAfter'];
+const isoDateRuleLabels = {
+    before: 'before',
+    sameOrBefore: 'the same or before',
+    after: 'after',
+    sameOrAfter: 'the same or after',
+};
+/**
+ * IsoDate strings compare chronologically as plain strings.
+ */
+function isoDateRuleFails(rule, data, limit) {
+    if (rule === 'before')
+        return _ `${data} >= ${limit}`;
+    if (rule === 'sameOrBefore')
+        return _ `${data} > ${limit}`;
+    if (rule === 'after')
+        return _ `${data} <= ${limit}`;
+    return _ `${data} < ${limit}`;
+}
 const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 const DASH_CODE = '-'.charCodeAt(0);
 const ZERO_CODE = '0'.charCodeAt(0);
@@ -788,6 +774,12 @@ function isIsoTimezoneValid(s) {
         return false; // min is -12:00
     return true;
 }
+function isUtcOffsetValid(s) {
+    return s !== 'Z' && s !== '' && isIsoTimezoneValid(s);
+}
+function isUtcOffsetOrZValid(s) {
+    return s === 'Z' || (s !== '' && isIsoTimezoneValid(s));
+}
 /**
  * This is a performance optimized correct validation
  * for ISO month formatted as "YYYY-MM".

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

@@ -307,6 +307,7 @@ export declare class JIsoDate<Opt extends boolean = false> extends JBuilder<IsoD
     after(date: string): this;
     sameOrAfter(date: string): this;
     between(fromDate: string, toDate: string, incl: Inclusiveness): this;
+    private addRules;
 }
 export interface JsonSchemaIsoDateOptions {
     before?: string;
@@ -387,6 +388,10 @@ export declare class JObject<OUT extends AnyObject, Opt extends boolean = false>
 }
 interface JObjectOpts {
     hasIsOfTypeCheck?: false;
+    /**
+     * Schema for every property not listed in `properties`, e.g the values of a string map.
+     */
+    additionalProperties?: JsonSchema<any>;
     patternProperties?: StringMap<JsonSchema<any>>;
     keySchema?: JsonSchema;
 }
@@ -574,7 +579,7 @@ export interface JsonSchema<OUT = unknown> {
     };
     patternProperties?: StringMap<JsonSchema<any>>;
     required?: string[];
-    additionalProperties?: boolean;
+    additionalProperties?: boolean | JsonSchema<any>;
     minProperties?: number;
     maxProperties?: number;
     default?: OUT;
@@ -626,6 +631,10 @@ export interface JsonSchema<OUT = unknown> {
     errorMessages?: StringMap<string>;
     optionalValues?: (string | number | boolean | null)[];
     keySchema?: JsonSchema;
+    /**
+     * Validates the value against the given schema only when it's defined.
+     */
+    ifDefined?: JsonSchema;
     isUndefined?: true;
     minProperties2?: number;
     exclusiveProperties?: (readonly string[])[];

package/dist/validation/ajv/jSchema.js

@@ -38,13 +38,13 @@ export const j = {
             const isValueOptional = schema.getSchema().optionalField;
             const builtSchema = schema.build();
             const finalValueSchema = isValueOptional
-                ? { anyOf: [{ isUndefined: true }, builtSchema] }
+                ? { ifDefined: builtSchema }
                 : builtSchema;
+            // `additionalProperties` instead of `patternProperties: { '^.+$': ... }`, which made Ajv
+            // regex-test every key twice (once more for `additionalProperties: false`)
             return new JObject({}, {
                 hasIsOfTypeCheck: false,
-                patternProperties: {
-                    '^.+$': finalValueSchema,
-                },
+                additionalProperties: finalValueSchema,
             });
         },
         /**
@@ -695,26 +695,25 @@ export class JIsoDate extends JBuilder {
         });
     }
     before(date) {
-        return this.cloneAndUpdateSchema({ IsoDate: { before: date } });
+        return this.addRules({ before: date });
     }
     sameOrBefore(date) {
-        return this.cloneAndUpdateSchema({ IsoDate: { sameOrBefore: date } });
+        return this.addRules({ sameOrBefore: date });
     }
     after(date) {
-        return this.cloneAndUpdateSchema({ IsoDate: { after: date } });
+        return this.addRules({ after: date });
     }
     sameOrAfter(date) {
-        return this.cloneAndUpdateSchema({ IsoDate: { sameOrAfter: date } });
+        return this.addRules({ sameOrAfter: date });
     }
     between(fromDate, toDate, incl) {
-        let schemaPatch = {};
         if (incl === '[)') {
-            schemaPatch = { IsoDate: { sameOrAfter: fromDate, before: toDate } };
-        }
-        else if (incl === '[]') {
-            schemaPatch = { IsoDate: { sameOrAfter: fromDate, sameOrBefore: toDate } };
+            return this.addRules({ sameOrAfter: fromDate, before: toDate });
         }
-        return this.cloneAndUpdateSchema(schemaPatch);
+        return this.addRules({ sameOrAfter: fromDate, sameOrBefore: toDate });
+    }
+    addRules(rules) {
+        return this.cloneAndUpdateSchema({ IsoDate: { ...this.schema.IsoDate, ...rules } });
     }
 }
 export class JNumber extends JBuilder {
@@ -832,7 +831,7 @@ export class JObject extends JBuilder {
             type: 'object',
             properties: {},
             required: [],
-            additionalProperties: false,
+            additionalProperties: opt?.additionalProperties ?? false,
             hasIsOfTypeCheck: opt?.hasIsOfTypeCheck ?? true,
             patternProperties: opt?.patternProperties ?? undefined,
             keySchema: opt?.keySchema ?? undefined,
@@ -844,6 +843,9 @@ export class JObject extends JBuilder {
      * When set, the validation will not strip away properties that are not specified explicitly in the schema.
      */
     allowAdditionalProperties() {
+        // A string map already accepts every property, validated by its value schema
+        if (typeof this.schema.additionalProperties === 'object')
+            return this.clone();
         return this.cloneAndUpdateSchema({ additionalProperties: true });
     }
     extend(props) {
@@ -1024,16 +1026,13 @@ function record(keySchema, valueSchema) {
     // Check if value schema is optional before build() strips the optionalField flag
     const isValueOptional = valueSchema.getSchema().optionalField;
     const valueJsonSchema = valueSchema.build();
-    // When value schema is optional, wrap in anyOf to allow undefined values
     const finalValueSchema = isValueOptional
-        ? { anyOf: [{ isUndefined: true }, valueJsonSchema] }
+        ? { ifDefined: valueJsonSchema }
         : valueJsonSchema;
     return new JObject([], {
         hasIsOfTypeCheck: false,
         keySchema: keyJsonSchema,
-        patternProperties: {
-            ['^.*$']: finalValueSchema,
-        },
+        additionalProperties: finalValueSchema,
     });
 }
 function withRegexKeys(keyRegex, schema) {

package/dist/validation/ajv/jsonSchemaBuilder.util.js

@@ -53,16 +53,20 @@ export function mergeJsonSchemaObjects(schema1, schema2) {
         s1.properties[k] = v;
     });
     // Merge `patternProperties`
-    Object.entries(s2.patternProperties || {}).forEach(([k, v]) => {
-        s1.patternProperties[k] = v;
-    });
+    if (s2.patternProperties) {
+        s1.patternProperties = { ...s1.patternProperties, ...s2.patternProperties };
+    }
     s1.propertyNames = s2.propertyNames || s1.propertyNames;
+    s1.keySchema = s2.keySchema || s1.keySchema;
     s1.minProperties = s2.minProperties ?? s1.minProperties;
     s1.maxProperties = s2.maxProperties ?? s1.maxProperties;
     // Merge `required`
     s1.required.push(...s2.required);
     s1.required = _uniq(s1.required).sort();
-    // `additionalProperties` remains the same
+    // `additionalProperties` remains the same, unless s2 is a string map (schema-valued)
+    if (typeof s2.additionalProperties === 'object') {
+        s1.additionalProperties = s2.additionalProperties;
+    }
     return _filterNullishValues(s1, { mutate: true });
 }
 export function isEveryItemString(arr) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.140.0",
+  "version": "15.141.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@standard-schema/spec": "^1",
@@ -14,7 +14,7 @@
     "yaml": "^2"
   },
   "devDependencies": {
-    "@naturalcycles/dev-lib": "20.71.0",
+    "@naturalcycles/dev-lib": "0.0.0",
     "typescript": "^7"
   },
   "exports": {

package/src/validation/ajv/getAjv.ts

@@ -3,15 +3,14 @@ import { _assert } from '@naturalcycles/js-lib/error'
 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 type { Options, ValidateFunction } from 'ajv/dist/2020.js'
-import { Ajv2020 } from 'ajv/dist/2020.js'
+import type { Code, KeywordCxt, Options, ValidateFunction } from 'ajv/dist/2020.js'
+import { _, Ajv2020, str } from 'ajv/dist/2020.js'
 import { validTLDs } from '../tlds.js'
 import type {
   CustomConverterFn,
   CustomValidatorFn,
   JSchema,
   JsonSchemaIsoDateOptions,
-  JsonSchemaIsoMonthOptions,
   JsonSchemaStringEmailOptions,
   JsonSchemaUtcOffsetOptions,
 } from './jSchema.js'
@@ -310,140 +309,79 @@ export function createAjv(opt?: Options): Ajv2020 {
     },
   })
 
+  // The date/time keywords are `code` keywords, which Ajv inlines into the compiled validator.
+  // A `validate` keyword is a function call with a context object, whose instancePath Ajv builds
+  // on every call (escaping the key of every map entry), even for valid data.
   ajv.addKeyword({
     keyword: 'IsoDate',
     type: 'string',
-    modifying: false,
-    errors: true,
     schemaType: 'object',
-    validate: function validate(opt: JsonSchemaIsoDateOptions, data: string, _schema, ctx) {
-      const hasOptions = Object.keys(opt).length > 0
-
-      const isValid = isIsoDateValid(data)
-      if (!isValid) {
-        ;(validate as any).errors = [
-          {
-            instancePath: ctx?.instancePath ?? '',
-            message: `is an invalid IsoDate`,
-          },
-        ]
-
-        return false
-      }
-
-      if (!hasOptions) return true
-
-      const { before, sameOrBefore, after, sameOrAfter } = opt
-      const errors: any[] = []
-
-      if (before) {
-        const isParamValid = isIsoDateValid(before)
-        const isRuleValid = isParamValid && before > data
-
-        if (!isRuleValid) {
-          errors.push({
-            instancePath: ctx?.instancePath ?? '',
-            message: `is not before ${before}`,
-          })
-        }
-      }
-
-      if (sameOrBefore) {
-        const isParamValid = isIsoDateValid(sameOrBefore)
-        const isRuleValid = isParamValid && sameOrBefore >= data
-
-        if (!isRuleValid) {
-          errors.push({
-            instancePath: ctx?.instancePath ?? '',
-            message: `is not the same or before ${sameOrBefore}`,
-          })
-        }
-      }
-
-      if (after) {
-        const isParamValid = isIsoDateValid(after)
-        const isRuleValid = isParamValid && after < data
-
-        if (!isRuleValid) {
-          errors.push({
-            instancePath: ctx?.instancePath ?? '',
-            message: `is not after ${after}`,
-          })
-        }
-      }
-
-      if (sameOrAfter) {
-        const isParamValid = isIsoDateValid(sameOrAfter)
-        const isRuleValid = isParamValid && sameOrAfter <= data
-
-        if (!isRuleValid) {
-          errors.push({
-            instancePath: ctx?.instancePath ?? '',
-            message: `is not the same or after ${sameOrAfter}`,
-          })
-        }
-      }
-
-      if (errors.length === 0) return true
-      ;(validate as any).errors = errors
-      return false
+    error: {
+      message: ({ params }) =>
+        params['rule']
+          ? str`is not ${isoDateRuleLabels[params['rule'] as IsoDateRule]} ${params['limit']}`
+          : str`is an invalid IsoDate`,
+      params: ({ params }) => (params['rule'] ? _`{${params['rule']}: ${params['limit']}}` : _`{}`),
+    },
+    code(cxt: KeywordCxt) {
+      const { gen, data } = cxt
+      const opt: JsonSchemaIsoDateOptions = cxt.schema
+      const isValid = gen.scopeValue('func', { ref: isIsoDateValid })
+
+      gen.if(
+        _`!${isValid}(${data})`,
+        () => cxt.error(),
+        () => {
+          for (const rule of isoDateRules) {
+            const limit = opt[rule]
+            if (!limit) continue
+
+            const params = { rule, limit }
+            if (!isIsoDateValid(limit)) {
+              // An invalid limit rejects every date
+              cxt.error(false, params)
+              continue
+            }
+            gen.if(isoDateRuleFails(rule, data, limit), () => cxt.error(false, params))
+          }
+        },
+      )
     },
   })
 
   ajv.addKeyword({
     keyword: 'IsoDateTime',
     type: 'string',
-    modifying: false,
-    errors: true,
     schemaType: 'boolean',
-    validate: function validate(_opt: JsonSchemaIsoMonthOptions, data: string, _schema, ctx) {
-      const isValid = isIsoDateTimeValid(data)
-      if (isValid) return true
-      ;(validate as any).errors = [
-        {
-          instancePath: ctx?.instancePath ?? '',
-          message: `is an invalid IsoDateTime`,
-        },
-      ]
-      return false
+    error: { message: 'is an invalid IsoDateTime' },
+    code(cxt: KeywordCxt) {
+      const isValid = cxt.gen.scopeValue('func', { ref: isIsoDateTimeValid })
+      cxt.fail(_`!${isValid}(${cxt.data})`)
     },
   })
 
   ajv.addKeyword({
     keyword: 'IsoMonth',
     type: 'string',
-    modifying: false,
-    errors: true,
     schemaType: 'object',
-    validate: function validate(_opt: true, data: string, _schema, ctx) {
-      const isValid = isIsoMonthValid(data)
-      if (isValid) return true
-      ;(validate as any).errors = [
-        {
-          instancePath: ctx?.instancePath ?? '',
-          message: `is an invalid IsoMonth`,
-        },
-      ]
-      return false
+    error: { message: 'is an invalid IsoMonth' },
+    code(cxt: KeywordCxt) {
+      const isValid = cxt.gen.scopeValue('func', { ref: isIsoMonthValid })
+      cxt.fail(_`!${isValid}(${cxt.data})`)
     },
   })
 
   ajv.addKeyword({
     keyword: 'UtcOffset',
     type: 'string',
-    modifying: false,
-    errors: true,
     schemaType: 'object',
-    validate: function validate(opt: JsonSchemaUtcOffsetOptions, data: string, _schema, ctx) {
-      const isValid = data === 'Z' ? opt.allowZ : data !== '' && isIsoTimezoneValid(data)
-      if (isValid) return true
-      ;(validate as any).errors = [
-        {
-          instancePath: ctx?.instancePath ?? '',
-          message: `is an invalid UtcOffset`,
-        },
-      ]
-      return false
+    error: { message: 'is an invalid UtcOffset' },
+    code(cxt: KeywordCxt) {
+      const opt: JsonSchemaUtcOffsetOptions = cxt.schema
+      const isValid = cxt.gen.scopeValue('func', {
+        ref: opt.allowZ ? isUtcOffsetOrZValid : isUtcOffsetValid,
+      })
+      cxt.fail(_`!${isValid}(${cxt.data})`)
     },
   })
 
@@ -496,39 +434,69 @@ export function createAjv(opt?: Options): Ajv2020 {
     },
   })
 
+  // Strips the keys that don't match the key schema; the values are validated by `additionalProperties`.
+  // The key schema is inlined per key with error reporting off, and the error count is reset after
+  // a mismatch, so a stripped key never surfaces as an error. Keys listed in `properties` are skipped.
   ajv.addKeyword({
     keyword: 'keySchema',
     type: 'object',
-    modifying: true,
-    errors: false,
     schemaType: 'object',
-    compile(innerSchema, _parentSchema, _it) {
-      const isValidKeyFn: ValidateFunction = ajv.compile(innerSchema)
+    trackErrors: true,
+    code(cxt: KeywordCxt) {
+      const { gen, data, parentSchema } = cxt
+      const propertyNames = Object.keys(parentSchema['properties'] || {})
+      const valid = gen.name('valid')
+
+      gen.forIn('key', data, key => {
+        const checkKey = (): void => {
+          cxt.subschema(
+            {
+              keyword: 'keySchema',
+              data: key,
+              dataTypes: ['string'],
+              compositeRule: true,
+              createErrors: false,
+              allErrors: false,
+            },
+            valid,
+          )
+          gen.if(_`!${valid}`, () => {
+            cxt.reset()
+            gen.code(_`delete ${data}[${key}]`)
+          })
+        }
 
-      function validate(data: AnyObject, _ctx: any): boolean {
-        if (typeof data !== 'object' || data === null) return true
+        if (!propertyNames.length) return checkKey()
 
-        for (const key of Object.keys(data)) {
-          if (!isValidKeyFn(key)) {
-            delete data[key]
-          }
+        let isNotProperty: Code = _`${key} !== ${propertyNames[0]}`
+        for (const name of propertyNames.slice(1)) {
+          isNotProperty = _`${isNotProperty} && ${key} !== ${name}`
         }
+        gen.if(isNotProperty, checkKey)
+      })
+    },
+  })
 
-        return true
-      }
-
-      return validate
+  // Validates the inner schema only when the value is defined. Used for the optional values of
+  // `stringMap`/`record`, whose `additionalProperties` loop visits the keys with undefined values too.
+  ajv.addKeyword({
+    keyword: 'ifDefined',
+    schemaType: ['object', 'boolean'],
+    code(cxt: KeywordCxt) {
+      const { gen, data } = cxt
+      gen.if(_`${data} !== undefined`, () => {
+        cxt.subschema({ keyword: 'ifDefined' }, gen.name('valid'))
+      })
     },
   })
 
-  // Validates that the value is undefined. Used in record/stringMap with optional value schemas
-  // to allow undefined values in patternProperties via anyOf.
+  // Validates that the value is undefined. Superseded by `ifDefined`, kept for raw JSON schemas.
   ajv.addKeyword({
     keyword: 'isUndefined',
-    modifying: false,
-    errors: false,
     schemaType: 'boolean',
-    validate: (_schema: boolean, data: unknown) => data === undefined,
+    code(cxt: KeywordCxt) {
+      cxt.fail(_`${cxt.data} !== undefined`)
+    },
   })
 
   // This is added because Ajv validates the `min/maxProperties` before validating the properties.
@@ -777,6 +745,27 @@ export function createAjv(opt?: Options): Ajv2020 {
   return ajv
 }
 
+type IsoDateRule = keyof JsonSchemaIsoDateOptions
+
+const isoDateRules: IsoDateRule[] = ['before', 'sameOrBefore', 'after', 'sameOrAfter']
+
+const isoDateRuleLabels: Record<IsoDateRule, string> = {
+  before: 'before',
+  sameOrBefore: 'the same or before',
+  after: 'after',
+  sameOrAfter: 'the same or after',
+}
+
+/**
+ * IsoDate strings compare chronologically as plain strings.
+ */
+function isoDateRuleFails(rule: IsoDateRule, data: Code, limit: string): Code {
+  if (rule === 'before') return _`${data} >= ${limit}`
+  if (rule === 'sameOrBefore') return _`${data} > ${limit}`
+  if (rule === 'after') return _`${data} <= ${limit}`
+  return _`${data} < ${limit}`
+}
+
 const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 
 const DASH_CODE = '-'.charCodeAt(0)
@@ -904,6 +893,14 @@ function isIsoTimezoneValid(s: string): boolean {
   return true
 }
 
+function isUtcOffsetValid(s: string): boolean {
+  return s !== 'Z' && s !== '' && isIsoTimezoneValid(s)
+}
+
+function isUtcOffsetOrZValid(s: string): boolean {
+  return s === 'Z' || (s !== '' && isIsoTimezoneValid(s))
+}
+
 /**
  * This is a performance optimized correct validation
  * for ISO month formatted as "YYYY-MM".

package/src/validation/ajv/jSchema.ts

@@ -89,16 +89,16 @@ export const j = {
       const isValueOptional = schema.getSchema().optionalField
       const builtSchema = schema.build()
       const finalValueSchema: JsonSchema = isValueOptional
-        ? { anyOf: [{ isUndefined: true }, builtSchema] }
+        ? { ifDefined: builtSchema }
         : builtSchema
 
+      // `additionalProperties` instead of `patternProperties: { '^.+$': ... }`, which made Ajv
+      // regex-test every key twice (once more for `additionalProperties: false`)
       return new JObject<StringMap<SchemaOut<S>>>(
         {},
         {
           hasIsOfTypeCheck: false,
-          patternProperties: {
-            '^.+$': finalValueSchema,
-          },
+          additionalProperties: finalValueSchema,
         },
       )
     },
@@ -917,31 +917,30 @@ export class JIsoDate<Opt extends boolean = false> extends JBuilder<IsoDate, Opt
   }
 
   before(date: string): this {
-    return this.cloneAndUpdateSchema({ IsoDate: { before: date } })
+    return this.addRules({ before: date })
   }
 
   sameOrBefore(date: string): this {
-    return this.cloneAndUpdateSchema({ IsoDate: { sameOrBefore: date } })
+    return this.addRules({ sameOrBefore: date })
   }
 
   after(date: string): this {
-    return this.cloneAndUpdateSchema({ IsoDate: { after: date } })
+    return this.addRules({ after: date })
   }
 
   sameOrAfter(date: string): this {
-    return this.cloneAndUpdateSchema({ IsoDate: { sameOrAfter: date } })
+    return this.addRules({ sameOrAfter: date })
   }
 
   between(fromDate: string, toDate: string, incl: Inclusiveness): this {
-    let schemaPatch: Partial<JsonSchema> = {}
-
     if (incl === '[)') {
-      schemaPatch = { IsoDate: { sameOrAfter: fromDate, before: toDate } }
-    } else if (incl === '[]') {
-      schemaPatch = { IsoDate: { sameOrAfter: fromDate, sameOrBefore: toDate } }
+      return this.addRules({ sameOrAfter: fromDate, before: toDate })
     }
+    return this.addRules({ sameOrAfter: fromDate, sameOrBefore: toDate })
+  }
 
-    return this.cloneAndUpdateSchema(schemaPatch)
+  private addRules(rules: JsonSchemaIsoDateOptions): this {
+    return this.cloneAndUpdateSchema({ IsoDate: { ...this.schema.IsoDate, ...rules } })
   }
 }
 
@@ -1108,7 +1107,7 @@ export class JObject<OUT extends AnyObject, Opt extends boolean = false> extends
       type: 'object',
       properties: {},
       required: [],
-      additionalProperties: false,
+      additionalProperties: opt?.additionalProperties ?? false,
       hasIsOfTypeCheck: opt?.hasIsOfTypeCheck ?? true,
       patternProperties: opt?.patternProperties ?? undefined,
       keySchema: opt?.keySchema ?? undefined,
@@ -1122,6 +1121,8 @@ export class JObject<OUT extends AnyObject, Opt extends boolean = false> extends
    */
 
   allowAdditionalProperties(): this {
+    // A string map already accepts every property, validated by its value schema
+    if (typeof this.schema.additionalProperties === 'object') return this.clone()
     return this.cloneAndUpdateSchema({ additionalProperties: true })
   }
 
@@ -1207,6 +1208,10 @@ export class JObject<OUT extends AnyObject, Opt extends boolean = false> extends
 
 interface JObjectOpts {
   hasIsOfTypeCheck?: false
+  /**
+   * Schema for every property not listed in `properties`, e.g the values of a string map.
+   */
+  additionalProperties?: JsonSchema<any>
   patternProperties?: StringMap<JsonSchema<any>>
   keySchema?: JsonSchema
 }
@@ -1477,17 +1482,14 @@ function record<
   const isValueOptional = (valueSchema as JSchema<any, any>).getSchema().optionalField
   const valueJsonSchema = valueSchema.build()
 
-  // When value schema is optional, wrap in anyOf to allow undefined values
   const finalValueSchema: JsonSchema = isValueOptional
-    ? { anyOf: [{ isUndefined: true }, valueJsonSchema] }
+    ? { ifDefined: valueJsonSchema }
     : valueJsonSchema
 
   return new JObject([], {
     hasIsOfTypeCheck: false,
     keySchema: keyJsonSchema,
-    patternProperties: {
-      ['^.*$']: finalValueSchema,
-    },
+    additionalProperties: finalValueSchema,
   }) as any
 }
 
@@ -2086,7 +2088,7 @@ export interface JsonSchema<OUT = unknown> {
   }
   patternProperties?: StringMap<JsonSchema<any>>
   required?: string[]
-  additionalProperties?: boolean
+  additionalProperties?: boolean | JsonSchema<any>
   minProperties?: number
   maxProperties?: number
 
@@ -2146,6 +2148,10 @@ export interface JsonSchema<OUT = unknown> {
   errorMessages?: StringMap<string>
   optionalValues?: (string | number | boolean | null)[]
   keySchema?: JsonSchema
+  /**
+   * Validates the value against the given schema only when it's defined.
+   */
+  ifDefined?: JsonSchema
   isUndefined?: true
   minProperties2?: number
   exclusiveProperties?: (readonly string[])[]

package/src/validation/ajv/jsonSchemaBuilder.util.ts

@@ -62,11 +62,12 @@ export function mergeJsonSchemaObjects<T1 extends AnyObject, T2 extends AnyObjec
   })
 
   // Merge `patternProperties`
-  Object.entries(s2.patternProperties || {}).forEach(([k, v]) => {
-    s1.patternProperties[k] = v
-  })
+  if (s2.patternProperties) {
+    s1.patternProperties = { ...s1.patternProperties, ...s2.patternProperties }
+  }
 
   s1.propertyNames = s2.propertyNames || s1.propertyNames
+  s1.keySchema = s2.keySchema || s1.keySchema
   s1.minProperties = s2.minProperties ?? s1.minProperties
   s1.maxProperties = s2.maxProperties ?? s1.maxProperties
 
@@ -74,7 +75,10 @@ export function mergeJsonSchemaObjects<T1 extends AnyObject, T2 extends AnyObjec
   s1.required.push(...s2.required)
   s1.required = _uniq(s1.required).sort()
 
-  // `additionalProperties` remains the same
+  // `additionalProperties` remains the same, unless s2 is a string map (schema-valued)
+  if (typeof s2.additionalProperties === 'object') {
+    s1.additionalProperties = s2.additionalProperties
+  }
 
   return _filterNullishValues(s1, { mutate: true })
 }