@naturalcycles/nodejs-lib 15.59.0 → 15.61.0

package/dist/validation/ajv/getAjv.js

@@ -1,4 +1,4 @@
-import { _lazyValue } from '@naturalcycles/js-lib';
+import { _isBetween, _lazyValue } from '@naturalcycles/js-lib';
 import { Set2 } from '@naturalcycles/js-lib/object';
 import { _substringAfterLast } from '@naturalcycles/js-lib/string';
 import { Ajv } from 'ajv';
@@ -349,6 +349,25 @@ export function createAjv(opt) {
             return false;
         },
     });
+    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;
+        },
+    });
     ajv.addKeyword({
         keyword: 'errorMessages',
         schemaType: 'object',
@@ -516,3 +535,21 @@ function isIsoTimezoneValid(s) {
         return false; // min is -12:00
     return true;
 }
+/**
+ * This is a performance optimized correct validation
+ * for ISO month formatted as "YYYY-MM".
+ */
+function isIsoMonthValid(s) {
+    // must be exactly "YYYY-MM"
+    if (s.length !== 7)
+        return false;
+    if (s.charCodeAt(4) !== DASH_CODE)
+        return false;
+    // fast parse numbers without substrings/Number()
+    const year = (s.charCodeAt(0) - ZERO_CODE) * 1000 +
+        (s.charCodeAt(1) - ZERO_CODE) * 100 +
+        (s.charCodeAt(2) - ZERO_CODE) * 10 +
+        (s.charCodeAt(3) - ZERO_CODE);
+    const month = (s.charCodeAt(5) - ZERO_CODE) * 10 + (s.charCodeAt(6) - ZERO_CODE);
+    return _isBetween(year, 1900, 2500, '[]') && _isBetween(month, 1, 12, '[]');
+}

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

@@ -1,5 +1,5 @@
 import type { Set2 } from '@naturalcycles/js-lib/object';
-import { type AnyObject, type BaseDBEntity, type IANATimezone, type Inclusiveness, type IsoDate, type IsoDateTime, type NumberEnum, type StringEnum, type StringMap, type UnixTimestamp, type UnixTimestampMillis } from '@naturalcycles/js-lib/types';
+import { type AnyObject, type BaseDBEntity, type IANATimezone, type Inclusiveness, type IsoDate, type IsoDateTime, type IsoMonth, 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>;
@@ -62,12 +62,14 @@ export declare class JsonSchemaTerminal<IN, OUT, Opt> {
      * Same as if it would be JSON.stringified.
      */
     build(): JsonSchema<IN, OUT>;
-    clone(): JsonSchemaAnyBuilder<IN, OUT, Opt>;
+    clone(): this;
+    cloneAndUpdateSchema(schema: Partial<JsonSchema>): this;
     /**
      * @experimental
      */
     in: IN;
     out: OUT;
+    opt: Opt;
 }
 export declare class JsonSchemaAnyBuilder<IN, OUT, Opt> extends JsonSchemaTerminal<IN, OUT, Opt> {
     protected setErrorMessage(ruleName: string, errorMessage: string | undefined): void;
@@ -137,6 +139,7 @@ export declare class JsonSchemaStringBuilder<IN extends string | undefined = str
      */
     isoDate(): JsonSchemaIsoDateBuilder;
     isoDateTime(): JsonSchemaStringBuilder<IsoDateTime | IN, IsoDateTime, Opt>;
+    isoMonth(): JsonSchemaIsoMonthBuilder;
     /**
      * Validates the string format to be JWT.
      * Expects the JWT to be signed!
@@ -177,6 +180,11 @@ export interface JsonSchemaIsoDateOptions {
     after?: string;
     sameOrAfter?: string;
 }
+export declare class JsonSchemaIsoMonthBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<string | IsoDate, IsoMonth, Opt> {
+    constructor();
+}
+export interface JsonSchemaIsoMonthOptions {
+}
 export declare class JsonSchemaNumberBuilder<IN extends number | undefined = number, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
     constructor();
     /**
@@ -341,6 +349,7 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
     Buffer?: true;
     IsoDate?: JsonSchemaIsoDateOptions;
     IsoDateTime?: true;
+    IsoMonth?: JsonSchemaIsoMonthOptions;
     instanceof?: string | string[];
     transform?: {
         trim?: true;

package/dist/validation/ajv/jsonSchemaBuilder.js

@@ -147,13 +147,21 @@ export class JsonSchemaTerminal {
         return jsonSchema;
     }
     clone() {
-        return new JsonSchemaAnyBuilder(_deepCopy(this.schema));
+        const cloned = Object.create(Object.getPrototypeOf(this));
+        cloned.schema = _deepCopy(this.schema);
+        return cloned;
+    }
+    cloneAndUpdateSchema(schema) {
+        const clone = this.clone();
+        _objectAssign(clone.schema, schema);
+        return clone;
     }
     /**
      * @experimental
      */
     in;
     out;
+    opt;
 }
 export class JsonSchemaAnyBuilder extends JsonSchemaTerminal {
     setErrorMessage(ruleName, errorMessage) {
@@ -178,48 +186,38 @@ export class JsonSchemaAnyBuilder extends JsonSchemaTerminal {
      * ```
      */
     isOfType() {
-        _objectAssign(this.schema, { hasIsOfTypeCheck: true });
-        return this;
+        return this.cloneAndUpdateSchema({ hasIsOfTypeCheck: true });
     }
     $schema($schema) {
-        _objectAssign(this.schema, { $schema });
-        return this;
+        return this.cloneAndUpdateSchema({ $schema });
     }
     $schemaDraft7() {
-        this.$schema('http://json-schema.org/draft-07/schema#');
-        return this;
+        return this.$schema('http://json-schema.org/draft-07/schema#');
     }
     $id($id) {
-        _objectAssign(this.schema, { $id });
-        return this;
+        return this.cloneAndUpdateSchema({ $id });
     }
     title(title) {
-        _objectAssign(this.schema, { title });
-        return this;
+        return this.cloneAndUpdateSchema({ title });
     }
     description(description) {
-        _objectAssign(this.schema, { description });
-        return this;
+        return this.cloneAndUpdateSchema({ description });
     }
     deprecated(deprecated = true) {
-        _objectAssign(this.schema, { deprecated });
-        return this;
+        return this.cloneAndUpdateSchema({ deprecated });
     }
     type(type) {
-        _objectAssign(this.schema, { type });
-        return this;
+        return this.cloneAndUpdateSchema({ type });
     }
     default(v) {
-        _objectAssign(this.schema, { default: v });
-        return this;
+        return this.cloneAndUpdateSchema({ default: v });
     }
     instanceof(of) {
-        _objectAssign(this.schema, { type: 'object', instanceof: of });
-        return this;
+        return this.cloneAndUpdateSchema({ type: 'object', instanceof: of });
     }
     optional() {
-        this.schema.optionalField = true;
-        return this;
+        const clone = this.cloneAndUpdateSchema({ optionalField: true });
+        return clone;
     }
     nullable() {
         return new JsonSchemaAnyBuilder({
@@ -268,20 +266,18 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
         return this.pattern(pattern.source, opt);
     }
     pattern(pattern, opt) {
+        const clone = this.cloneAndUpdateSchema({ pattern });
         if (opt?.name)
-            this.setErrorMessage('pattern', `is not a valid ${opt.name}`);
+            clone.setErrorMessage('pattern', `is not a valid ${opt.name}`);
         if (opt?.msg)
-            this.setErrorMessage('pattern', opt.msg);
-        _objectAssign(this.schema, { pattern });
-        return this;
+            clone.setErrorMessage('pattern', opt.msg);
+        return clone;
     }
     minLength(minLength) {
-        _objectAssign(this.schema, { minLength });
-        return this;
+        return this.cloneAndUpdateSchema({ minLength });
     }
     maxLength(maxLength) {
-        _objectAssign(this.schema, { maxLength });
-        return this;
+        return this.cloneAndUpdateSchema({ maxLength });
     }
     length(minLengthOrExactLength, maxLength) {
         const maxLengthActual = maxLength ?? minLengthOrExactLength;
@@ -289,24 +285,27 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
     }
     email(opt) {
         const defaultOptions = { checkTLD: true };
-        _objectAssign(this.schema, { email: { ...defaultOptions, ...opt } });
-        return this.trim().toLowerCase();
+        return this.cloneAndUpdateSchema({ email: { ...defaultOptions, ...opt } })
+            .trim()
+            .toLowerCase();
     }
     trim() {
-        _objectAssign(this.schema, { transform: { ...this.schema.transform, trim: true } });
-        return this;
+        return this.cloneAndUpdateSchema({ transform: { ...this.schema.transform, trim: true } });
     }
     toLowerCase() {
-        _objectAssign(this.schema, { transform: { ...this.schema.transform, toLowerCase: true } });
-        return this;
+        return this.cloneAndUpdateSchema({
+            transform: { ...this.schema.transform, toLowerCase: true },
+        });
     }
     toUpperCase() {
-        _objectAssign(this.schema, { transform: { ...this.schema.transform, toUpperCase: true } });
-        return this;
+        return this.cloneAndUpdateSchema({
+            transform: { ...this.schema.transform, toUpperCase: true },
+        });
     }
     truncate(toLength) {
-        _objectAssign(this.schema, { transform: { ...this.schema.transform, truncate: toLength } });
-        return this;
+        return this.cloneAndUpdateSchema({
+            transform: { ...this.schema.transform, truncate: toLength },
+        });
     }
     branded() {
         return this;
@@ -318,12 +317,13 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
      * because this call effectively starts a new schema chain.
      */
     isoDate() {
-        _objectAssign(this.schema, { IsoDate: {} });
         return new JsonSchemaIsoDateBuilder();
     }
     isoDateTime() {
-        _objectAssign(this.schema, { IsoDateTime: true });
-        return this.branded();
+        return this.cloneAndUpdateSchema({ IsoDateTime: true }).branded();
+    }
+    isoMonth() {
+        return new JsonSchemaIsoMonthBuilder();
     }
     /**
      * Validates the string format to be JWT.
@@ -385,29 +385,34 @@ export class JsonSchemaIsoDateBuilder extends JsonSchemaAnyBuilder {
         });
     }
     before(date) {
-        _objectAssign(this.schema.IsoDate, { before: date });
-        return this;
+        return this.cloneAndUpdateSchema({ IsoDate: { before: date } });
     }
     sameOrBefore(date) {
-        _objectAssign(this.schema.IsoDate, { sameOrBefore: date });
-        return this;
+        return this.cloneAndUpdateSchema({ IsoDate: { sameOrBefore: date } });
     }
     after(date) {
-        _objectAssign(this.schema.IsoDate, { after: date });
-        return this;
+        return this.cloneAndUpdateSchema({ IsoDate: { after: date } });
     }
     sameOrAfter(date) {
-        _objectAssign(this.schema.IsoDate, { sameOrAfter: date });
-        return this;
+        return this.cloneAndUpdateSchema({ IsoDate: { sameOrAfter: date } });
     }
     between(fromDate, toDate, incl) {
+        let schemaPatch = {};
         if (incl === '[)') {
-            _objectAssign(this.schema.IsoDate, { sameOrAfter: fromDate, before: toDate });
+            schemaPatch = { IsoDate: { sameOrAfter: fromDate, before: toDate } };
         }
         else if (incl === '[]') {
-            _objectAssign(this.schema.IsoDate, { sameOrAfter: fromDate, sameOrBefore: toDate });
+            schemaPatch = { IsoDate: { sameOrAfter: fromDate, sameOrBefore: toDate } };
         }
-        return this;
+        return this.cloneAndUpdateSchema(schemaPatch);
+    }
+}
+export class JsonSchemaIsoMonthBuilder extends JsonSchemaAnyBuilder {
+    constructor() {
+        super({
+            type: 'string',
+            IsoMonth: {},
+        });
     }
 }
 export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
@@ -435,31 +440,25 @@ export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
         return newBuilder;
     }
     integer() {
-        _objectAssign(this.schema, { type: 'integer' });
-        return this;
+        return this.cloneAndUpdateSchema({ type: 'integer' });
     }
     branded() {
         return this;
     }
     multipleOf(multipleOf) {
-        _objectAssign(this.schema, { multipleOf });
-        return this;
+        return this.cloneAndUpdateSchema({ multipleOf });
     }
     min(minimum) {
-        _objectAssign(this.schema, { minimum });
-        return this;
+        return this.cloneAndUpdateSchema({ minimum });
     }
     exclusiveMin(exclusiveMinimum) {
-        _objectAssign(this.schema, { exclusiveMinimum });
-        return this;
+        return this.cloneAndUpdateSchema({ exclusiveMinimum });
     }
     max(maximum) {
-        _objectAssign(this.schema, { maximum });
-        return this;
+        return this.cloneAndUpdateSchema({ maximum });
     }
     exclusiveMax(exclusiveMaximum) {
-        _objectAssign(this.schema, { exclusiveMaximum });
-        return this;
+        return this.cloneAndUpdateSchema({ exclusiveMaximum });
     }
     lessThan(value) {
         return this.exclusiveMax(value);
@@ -584,15 +583,13 @@ export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
      * When set, the validation will not strip away properties that are not specified explicitly in the schema.
      */
     allowAdditionalProperties() {
-        _objectAssign(this.schema, { additionalProperties: true });
-        return this;
+        return this.cloneAndUpdateSchema({ additionalProperties: true });
     }
     extend(props) {
-        const newBuilder = new JsonSchemaObjectBuilder();
-        _objectAssign(newBuilder.schema, _deepCopy(this.schema));
+        const clone = this.cloneAndUpdateSchema(_deepCopy(this.schema));
         const incomingSchemaBuilder = new JsonSchemaObjectBuilder(props);
-        mergeJsonSchemaObjects(newBuilder.schema, incomingSchemaBuilder.schema);
-        return newBuilder;
+        mergeJsonSchemaObjects(clone.schema, incomingSchemaBuilder.schema);
+        return clone;
     }
     /**
      * Extends the current schema with `id`, `created` and `updated` according to NC DB conventions.
@@ -606,12 +603,10 @@ export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
         });
     }
     minProperties(minProperties) {
-        Object.assign(this.schema, { minProperties });
-        return this;
+        return this.cloneAndUpdateSchema({ minProperties });
     }
     maxProperties(maxProperties) {
-        Object.assign(this.schema, { maxProperties });
-        return this;
+        return this.cloneAndUpdateSchema({ maxProperties });
     }
 }
 export class JsonSchemaObjectInferringBuilder extends JsonSchemaAnyBuilder {
@@ -644,8 +639,7 @@ export class JsonSchemaObjectInferringBuilder extends JsonSchemaAnyBuilder {
      * When set, the validation will not strip away properties that are not specified explicitly in the schema.
      */
     allowAdditionalProperties() {
-        _objectAssign(this.schema, { additionalProperties: true });
-        return this;
+        return this.cloneAndUpdateSchema({ additionalProperties: true });
     }
     extend(props) {
         const newBuilder = new JsonSchemaObjectInferringBuilder();
@@ -674,12 +668,10 @@ export class JsonSchemaArrayBuilder extends JsonSchemaAnyBuilder {
         });
     }
     minLength(minItems) {
-        _objectAssign(this.schema, { minItems });
-        return this;
+        return this.cloneAndUpdateSchema({ minItems });
     }
     maxLength(maxItems) {
-        _objectAssign(this.schema, { maxItems });
-        return this;
+        return this.cloneAndUpdateSchema({ maxItems });
     }
     length(minItemsOrExact, maxItems) {
         const maxItemsActual = maxItems ?? minItemsOrExact;
@@ -689,8 +681,7 @@ export class JsonSchemaArrayBuilder extends JsonSchemaAnyBuilder {
         return this.minLength(length).maxLength(length);
     }
     unique() {
-        _objectAssign(this.schema, { uniqueItems: true });
-        return this;
+        return this.cloneAndUpdateSchema({ uniqueItems: true });
     }
 }
 export class JsonSchemaSet2Builder extends JsonSchemaAnyBuilder {
@@ -701,12 +692,10 @@ export class JsonSchemaSet2Builder extends JsonSchemaAnyBuilder {
         });
     }
     min(minItems) {
-        _objectAssign(this.schema, { minItems });
-        return this;
+        return this.cloneAndUpdateSchema({ minItems });
     }
     max(maxItems) {
-        _objectAssign(this.schema, { maxItems });
-        return this;
+        return this.cloneAndUpdateSchema({ maxItems });
     }
 }
 export class JsonSchemaBufferBuilder extends JsonSchemaAnyBuilder {

package/package.json

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

package/src/validation/ajv/getAjv.ts

@@ -1,10 +1,14 @@
-import { _lazyValue } from '@naturalcycles/js-lib'
+import { _isBetween, _lazyValue } from '@naturalcycles/js-lib'
 import { Set2 } from '@naturalcycles/js-lib/object'
 import { _substringAfterLast } from '@naturalcycles/js-lib/string'
 import type { AnyObject } from '@naturalcycles/js-lib/types'
 import { Ajv, type Options, type ValidateFunction } from 'ajv'
 import { validTLDs } from '../tlds.js'
-import type { JsonSchemaIsoDateOptions, JsonSchemaStringEmailOptions } from './jsonSchemaBuilder.js'
+import type {
+  JsonSchemaIsoDateOptions,
+  JsonSchemaIsoMonthOptions,
+  JsonSchemaStringEmailOptions,
+} from './jsonSchemaBuilder.js'
 
 /* eslint-disable @typescript-eslint/prefer-string-starts-ends-with */
 // oxlint-disable unicorn/prefer-code-point
@@ -383,7 +387,7 @@ export function createAjv(opt?: Options): Ajv {
     modifying: false,
     errors: true,
     schemaType: 'boolean',
-    validate: function validate(_opt: true, data: string, _schema, ctx) {
+    validate: function validate(_opt: JsonSchemaIsoMonthOptions, data: string, _schema, ctx) {
       const isValid = isIsoDateTimeValid(data)
       if (isValid) return true
       ;(validate as any).errors = [
@@ -396,6 +400,25 @@ export function createAjv(opt?: Options): Ajv {
     },
   })
 
+  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
+    },
+  })
+
   ajv.addKeyword({
     keyword: 'errorMessages',
     schemaType: 'object',
@@ -577,3 +600,24 @@ function isIsoTimezoneValid(s: string): boolean {
 
   return true
 }
+
+/**
+ * This is a performance optimized correct validation
+ * for ISO month formatted as "YYYY-MM".
+ */
+function isIsoMonthValid(s: string): boolean {
+  // must be exactly "YYYY-MM"
+  if (s.length !== 7) return false
+  if (s.charCodeAt(4) !== DASH_CODE) return false
+
+  // fast parse numbers without substrings/Number()
+  const year =
+    (s.charCodeAt(0) - ZERO_CODE) * 1000 +
+    (s.charCodeAt(1) - ZERO_CODE) * 100 +
+    (s.charCodeAt(2) - ZERO_CODE) * 10 +
+    (s.charCodeAt(3) - ZERO_CODE)
+
+  const month = (s.charCodeAt(5) - ZERO_CODE) * 10 + (s.charCodeAt(6) - ZERO_CODE)
+
+  return _isBetween(year, 1900, 2500, '[]') && _isBetween(month, 1, 12, '[]')
+}

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -19,6 +19,7 @@ import {
   type Inclusiveness,
   type IsoDate,
   type IsoDateTime,
+  type IsoMonth,
   JWT_REGEX,
   type NumberEnum,
   type StringEnum,
@@ -232,8 +233,16 @@ export class JsonSchemaTerminal<IN, OUT, Opt> {
     return jsonSchema
   }
 
-  clone(): JsonSchemaAnyBuilder<IN, OUT, Opt> {
-    return new JsonSchemaAnyBuilder<IN, OUT, Opt>(_deepCopy(this.schema))
+  clone(): this {
+    const cloned = Object.create(Object.getPrototypeOf(this))
+    cloned.schema = _deepCopy(this.schema)
+    return cloned
+  }
+
+  cloneAndUpdateSchema(schema: Partial<JsonSchema>): this {
+    const clone = this.clone()
+    _objectAssign(clone.schema, schema)
+    return clone
   }
 
   /**
@@ -241,6 +250,7 @@ export class JsonSchemaTerminal<IN, OUT, Opt> {
    */
   in!: IN
   out!: OUT
+  opt!: Opt
 }
 
 export class JsonSchemaAnyBuilder<IN, OUT, Opt> extends JsonSchemaTerminal<IN, OUT, Opt> {
@@ -267,58 +277,48 @@ export class JsonSchemaAnyBuilder<IN, OUT, Opt> extends JsonSchemaTerminal<IN, O
    * ```
    */
   isOfType<ExpectedType>(): ExactMatch<ExpectedType, OUT> extends true ? this : never {
-    _objectAssign(this.schema, { hasIsOfTypeCheck: true })
-    return this as any
+    return this.cloneAndUpdateSchema({ hasIsOfTypeCheck: true }) as any
   }
 
   $schema($schema: string): this {
-    _objectAssign(this.schema, { $schema })
-    return this
+    return this.cloneAndUpdateSchema({ $schema })
   }
 
   $schemaDraft7(): this {
-    this.$schema('http://json-schema.org/draft-07/schema#')
-    return this
+    return this.$schema('http://json-schema.org/draft-07/schema#')
   }
 
   $id($id: string): this {
-    _objectAssign(this.schema, { $id })
-    return this
+    return this.cloneAndUpdateSchema({ $id })
   }
 
   title(title: string): this {
-    _objectAssign(this.schema, { title })
-    return this
+    return this.cloneAndUpdateSchema({ title })
   }
 
   description(description: string): this {
-    _objectAssign(this.schema, { description })
-    return this
+    return this.cloneAndUpdateSchema({ description })
   }
 
   deprecated(deprecated = true): this {
-    _objectAssign(this.schema, { deprecated })
-    return this
+    return this.cloneAndUpdateSchema({ deprecated })
   }
 
   type(type: string): this {
-    _objectAssign(this.schema, { type })
-    return this
+    return this.cloneAndUpdateSchema({ type })
   }
 
   default(v: any): this {
-    _objectAssign(this.schema, { default: v })
-    return this
+    return this.cloneAndUpdateSchema({ default: v })
   }
 
   instanceof(of: string): this {
-    _objectAssign(this.schema, { type: 'object', instanceof: of })
-    return this
+    return this.cloneAndUpdateSchema({ type: 'object', instanceof: of })
   }
 
   optional(): JsonSchemaAnyBuilder<IN | undefined, OUT | undefined, true> {
-    this.schema.optionalField = true
-    return this as unknown as JsonSchemaAnyBuilder<IN | undefined, OUT | undefined, true>
+    const clone = this.cloneAndUpdateSchema({ optionalField: true })
+    return clone as unknown as JsonSchemaAnyBuilder<IN | undefined, OUT | undefined, true>
   }
 
   nullable(): JsonSchemaAnyBuilder<IN | null, OUT | null, Opt> {
@@ -386,20 +386,18 @@ export class JsonSchemaStringBuilder<
   }
 
   pattern(pattern: string, opt?: JsonBuilderRuleOpt): this {
-    if (opt?.name) this.setErrorMessage('pattern', `is not a valid ${opt.name}`)
-    if (opt?.msg) this.setErrorMessage('pattern', opt.msg)
-    _objectAssign(this.schema, { pattern })
-    return this
+    const clone = this.cloneAndUpdateSchema({ pattern })
+    if (opt?.name) clone.setErrorMessage('pattern', `is not a valid ${opt.name}`)
+    if (opt?.msg) clone.setErrorMessage('pattern', opt.msg)
+    return clone
   }
 
   minLength(minLength: number): this {
-    _objectAssign(this.schema, { minLength })
-    return this
+    return this.cloneAndUpdateSchema({ minLength })
   }
 
   maxLength(maxLength: number): this {
-    _objectAssign(this.schema, { maxLength })
-    return this
+    return this.cloneAndUpdateSchema({ maxLength })
   }
 
   length(exactLength: number): this
@@ -411,28 +409,31 @@ export class JsonSchemaStringBuilder<
 
   email(opt?: Partial<JsonSchemaStringEmailOptions>): this {
     const defaultOptions: JsonSchemaStringEmailOptions = { checkTLD: true }
-    _objectAssign(this.schema, { email: { ...defaultOptions, ...opt } })
-    return this.trim().toLowerCase()
+    return this.cloneAndUpdateSchema({ email: { ...defaultOptions, ...opt } })
+      .trim()
+      .toLowerCase()
   }
 
   trim(): this {
-    _objectAssign(this.schema, { transform: { ...this.schema.transform, trim: true } })
-    return this
+    return this.cloneAndUpdateSchema({ transform: { ...this.schema.transform, trim: true } })
   }
 
   toLowerCase(): this {
-    _objectAssign(this.schema, { transform: { ...this.schema.transform, toLowerCase: true } })
-    return this
+    return this.cloneAndUpdateSchema({
+      transform: { ...this.schema.transform, toLowerCase: true },
+    })
   }
 
   toUpperCase(): this {
-    _objectAssign(this.schema, { transform: { ...this.schema.transform, toUpperCase: true } })
-    return this
+    return this.cloneAndUpdateSchema({
+      transform: { ...this.schema.transform, toUpperCase: true },
+    })
   }
 
   truncate(toLength: number): this {
-    _objectAssign(this.schema, { transform: { ...this.schema.transform, truncate: toLength } })
-    return this
+    return this.cloneAndUpdateSchema({
+      transform: { ...this.schema.transform, truncate: toLength },
+    })
   }
 
   branded<B extends string>(): JsonSchemaStringBuilder<B, B, Opt> {
@@ -446,13 +447,15 @@ export class JsonSchemaStringBuilder<
    * because this call effectively starts a new schema chain.
    */
   isoDate(): JsonSchemaIsoDateBuilder {
-    _objectAssign(this.schema, { IsoDate: {} })
     return new JsonSchemaIsoDateBuilder()
   }
 
   isoDateTime(): JsonSchemaStringBuilder<IsoDateTime | IN, IsoDateTime, Opt> {
-    _objectAssign(this.schema, { IsoDateTime: true })
-    return this.branded<IsoDateTime>()
+    return this.cloneAndUpdateSchema({ IsoDateTime: true }).branded<IsoDateTime>()
+  }
+
+  isoMonth(): JsonSchemaIsoMonthBuilder {
+    return new JsonSchemaIsoMonthBuilder()
   }
 
   /**
@@ -537,33 +540,31 @@ export class JsonSchemaIsoDateBuilder<Opt extends boolean = false> extends JsonS
   }
 
   before(date: string): this {
-    _objectAssign(this.schema.IsoDate!, { before: date })
-    return this
+    return this.cloneAndUpdateSchema({ IsoDate: { before: date } })
   }
 
   sameOrBefore(date: string): this {
-    _objectAssign(this.schema.IsoDate!, { sameOrBefore: date })
-    return this
+    return this.cloneAndUpdateSchema({ IsoDate: { sameOrBefore: date } })
   }
 
   after(date: string): this {
-    _objectAssign(this.schema.IsoDate!, { after: date })
-    return this
+    return this.cloneAndUpdateSchema({ IsoDate: { after: date } })
   }
 
   sameOrAfter(date: string): this {
-    _objectAssign(this.schema.IsoDate!, { sameOrAfter: date })
-    return this
+    return this.cloneAndUpdateSchema({ IsoDate: { sameOrAfter: date } })
   }
 
   between(fromDate: string, toDate: string, incl: Inclusiveness): this {
+    let schemaPatch: Partial<JsonSchema> = {}
+
     if (incl === '[)') {
-      _objectAssign(this.schema.IsoDate!, { sameOrAfter: fromDate, before: toDate })
+      schemaPatch = { IsoDate: { sameOrAfter: fromDate, before: toDate } }
     } else if (incl === '[]') {
-      _objectAssign(this.schema.IsoDate!, { sameOrAfter: fromDate, sameOrBefore: toDate })
+      schemaPatch = { IsoDate: { sameOrAfter: fromDate, sameOrBefore: toDate } }
     }
 
-    return this
+    return this.cloneAndUpdateSchema(schemaPatch)
   }
 }
 
@@ -574,6 +575,21 @@ export interface JsonSchemaIsoDateOptions {
   sameOrAfter?: string
 }
 
+export class JsonSchemaIsoMonthBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<
+  string | IsoDate,
+  IsoMonth,
+  Opt
+> {
+  constructor() {
+    super({
+      type: 'string',
+      IsoMonth: {},
+    })
+  }
+}
+
+export interface JsonSchemaIsoMonthOptions {}
+
 export class JsonSchemaNumberBuilder<
   IN extends number | undefined = number,
   OUT = IN,
@@ -591,6 +607,7 @@ export class JsonSchemaNumberBuilder<
    * This `optionalValues` feature only works when the current schema is nested in an object or array schema,
    * due to how mutability works in Ajv.
    */
+
   override optional(
     optionalValues?: number[],
   ): JsonSchemaNumberBuilder<IN | undefined, OUT | undefined, true> {
@@ -613,8 +630,7 @@ export class JsonSchemaNumberBuilder<
   }
 
   integer(): this {
-    _objectAssign(this.schema, { type: 'integer' })
-    return this
+    return this.cloneAndUpdateSchema({ type: 'integer' })
   }
 
   branded<B extends number>(): JsonSchemaNumberBuilder<B, B, Opt> {
@@ -622,28 +638,23 @@ export class JsonSchemaNumberBuilder<
   }
 
   multipleOf(multipleOf: number): this {
-    _objectAssign(this.schema, { multipleOf })
-    return this
+    return this.cloneAndUpdateSchema({ multipleOf })
   }
 
   min(minimum: number): this {
-    _objectAssign(this.schema, { minimum })
-    return this
+    return this.cloneAndUpdateSchema({ minimum })
   }
 
   exclusiveMin(exclusiveMinimum: number): this {
-    _objectAssign(this.schema, { exclusiveMinimum })
-    return this
+    return this.cloneAndUpdateSchema({ exclusiveMinimum })
   }
 
   max(maximum: number): this {
-    _objectAssign(this.schema, { maximum })
-    return this
+    return this.cloneAndUpdateSchema({ maximum })
   }
 
   exclusiveMax(exclusiveMaximum: number): this {
-    _objectAssign(this.schema, { exclusiveMaximum })
-    return this
+    return this.cloneAndUpdateSchema({ exclusiveMaximum })
   }
 
   lessThan(value: number): this {
@@ -812,21 +823,24 @@ export class JsonSchemaObjectBuilder<
   /**
    * When set, the validation will not strip away properties that are not specified explicitly in the schema.
    */
+
   allowAdditionalProperties(): this {
-    _objectAssign(this.schema, { additionalProperties: true })
-    return this
+    return this.cloneAndUpdateSchema({ additionalProperties: true })
   }
 
   extend<IN2 extends AnyObject>(
     props: AnyObject,
   ): JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, Opt> {
-    const newBuilder = new JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, Opt>()
-    _objectAssign(newBuilder.schema, _deepCopy(this.schema))
+    const clone = this.cloneAndUpdateSchema(_deepCopy(this.schema)) as JsonSchemaObjectBuilder<
+      IN & IN2,
+      OUT & IN2,
+      Opt
+    >
 
     const incomingSchemaBuilder = new JsonSchemaObjectBuilder<IN2, IN2, false>(props)
-    mergeJsonSchemaObjects(newBuilder.schema as any, incomingSchemaBuilder.schema as any)
+    mergeJsonSchemaObjects(clone.schema as any, incomingSchemaBuilder.schema as any)
 
-    return newBuilder
+    return clone
   }
 
   /**
@@ -842,13 +856,11 @@ export class JsonSchemaObjectBuilder<
   }
 
   minProperties(minProperties: number): this {
-    Object.assign(this.schema, { minProperties })
-    return this
+    return this.cloneAndUpdateSchema({ minProperties })
   }
 
   maxProperties(maxProperties: number): this {
-    Object.assign(this.schema, { maxProperties })
-    return this
+    return this.cloneAndUpdateSchema({ maxProperties })
   }
 }
 
@@ -928,9 +940,9 @@ export class JsonSchemaObjectInferringBuilder<
   /**
    * When set, the validation will not strip away properties that are not specified explicitly in the schema.
    */
+
   allowAdditionalProperties(): this {
-    _objectAssign(this.schema, { additionalProperties: true })
-    return this
+    return this.cloneAndUpdateSchema({ additionalProperties: true })
   }
 
   extend<NEW_PROPS extends Record<string, JsonSchemaAnyBuilder<any, any, any>>>(
@@ -985,13 +997,11 @@ export class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<I
   }
 
   minLength(minItems: number): this {
-    _objectAssign(this.schema, { minItems })
-    return this
+    return this.cloneAndUpdateSchema({ minItems })
   }
 
   maxLength(maxItems: number): this {
-    _objectAssign(this.schema, { maxItems })
-    return this
+    return this.cloneAndUpdateSchema({ maxItems })
   }
 
   length(exactLength: number): this
@@ -1006,8 +1016,7 @@ export class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<I
   }
 
   unique(): this {
-    _objectAssign(this.schema, { uniqueItems: true })
-    return this
+    return this.cloneAndUpdateSchema({ uniqueItems: true })
   }
 }
 
@@ -1024,13 +1033,11 @@ export class JsonSchemaSet2Builder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<
   }
 
   min(minItems: number): this {
-    _objectAssign(this.schema, { minItems })
-    return this
+    return this.cloneAndUpdateSchema({ minItems })
   }
 
   max(maxItems: number): this {
-    _objectAssign(this.schema, { maxItems })
-    return this
+    return this.cloneAndUpdateSchema({ maxItems })
   }
 }
 
@@ -1139,6 +1146,7 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
   Buffer?: true
   IsoDate?: JsonSchemaIsoDateOptions
   IsoDateTime?: true
+  IsoMonth?: JsonSchemaIsoMonthOptions
   instanceof?: string | string[]
   transform?: { trim?: true; toLowerCase?: true; toUpperCase?: true; truncate?: number }
   errorMessages?: StringMap<string>