@naturalcycles/nodejs-lib 15.58.0 → 15.60.0

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

@@ -39,9 +39,9 @@ export declare class AjvSchema<IN = unknown, OUT = IN> {
      *
      * Returned object is always the same object (`===`) that was passed, so it is returned just for convenience.
      */
-    validate(input: IN, opt?: AjvValidationOptions): OUT;
-    isValid(input: IN, opt?: AjvValidationOptions): boolean;
-    getValidationResult(input: IN, opt?: AjvValidationOptions): ValidationFunctionResult<OUT, AjvValidationError>;
+    validate(input: IN, opt?: AjvValidationOptions<IN>): OUT;
+    isValid(input: IN, opt?: AjvValidationOptions<IN>): boolean;
+    getValidationResult(input: IN, opt?: AjvValidationOptions<IN>): ValidationFunctionResult<OUT, AjvValidationError>;
     getValidationFunction(): ValidationFunction<IN, OUT, AjvValidationError>;
     static isSchemaWithCachedAjvSchema<Base, IN, OUT>(schema: Base): schema is WithCachedAjvSchema<Base, IN, OUT>;
     static cacheAjvSchema<Base extends AnyObject, IN, OUT>(schema: Base, ajvSchema: AjvSchema<IN, OUT>): WithCachedAjvSchema<Base, IN, OUT>;
@@ -54,7 +54,7 @@ export declare const HIDDEN_AJV_SCHEMA: unique symbol;
 export type WithCachedAjvSchema<Base, IN, OUT> = Base & {
     [HIDDEN_AJV_SCHEMA]: AjvSchema<IN, OUT>;
 };
-export interface AjvValidationOptions {
+export interface AjvValidationOptions<IN> {
     /**
      * Defaults to true,
      * because that's how AJV works by default,
@@ -73,6 +73,16 @@ export interface AjvValidationOptions {
     mutateInput?: boolean;
     inputName?: string;
     inputId?: string;
+    /**
+     * Function that returns "original input".
+     * What is original input?
+     * It's an input in its original non-mutated form.
+     * Why is it needed?
+     * Because we mutates the Input here. And after its been mutated - we no longer
+     * can include it "how it was" in an error message. So, for that reason we'll use
+     * `getOriginalInput()`, if it's provided.
+     */
+    getOriginalInput?: () => IN;
 }
 export interface AjvSchemaCfg {
     /**

package/dist/validation/ajv/ajvSchema.js

@@ -108,7 +108,7 @@ export class AjvSchema {
         const item = opt.mutateInput !== false || typeof input !== 'object'
             ? input // mutate
             : _deepCopy(input); // not mutate
-        const valid = fn(item); // mutates item
+        const valid = fn(item); // mutates item, but not input
         _typeCast(item);
         if (valid)
             return [null, item];
@@ -122,7 +122,8 @@ export class AjvSchema {
         });
         // Note: if we mutated the input already, e.g stripped unknown properties,
         // the error message Input would contain already mutated object print, such as Input: {}
-        const inputStringified = _inspect(input, { maxLen: 4000 });
+        // Unless `getOriginalInput` function is provided - then it will be used to preserve the Input pureness.
+        const inputStringified = _inspect(opt.getOriginalInput?.() || input, { maxLen: 4000 });
         message = [message, 'Input: ' + inputStringified].join(separator);
         const err = new AjvValidationError(message, _filterNullishValues({
             errors,

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

@@ -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;

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,10 @@ 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();
     }
     /**
      * Validates the string format to be JWT.
@@ -385,29 +382,26 @@ 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 JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
@@ -435,31 +429,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 +572,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 +592,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 +628,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 +657,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 +670,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 +681,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.58.0",
+  "version": "15.60.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@types/js-yaml": "^4",

package/src/validation/ajv/ajvSchema.ts

@@ -120,13 +120,13 @@ export class AjvSchema<IN = unknown, OUT = IN> {
    *
    * Returned object is always the same object (`===`) that was passed, so it is returned just for convenience.
    */
-  validate(input: IN, opt: AjvValidationOptions = {}): OUT {
+  validate(input: IN, opt: AjvValidationOptions<IN> = {}): OUT {
     const [err, output] = this.getValidationResult(input, opt)
     if (err) throw err
     return output
   }
 
-  isValid(input: IN, opt?: AjvValidationOptions): boolean {
+  isValid(input: IN, opt?: AjvValidationOptions<IN>): boolean {
     // todo: we can make it both fast and non-mutating by using Ajv
     // with "removeAdditional" and "useDefaults" disabled.
     const [err] = this.getValidationResult(input, opt)
@@ -135,7 +135,7 @@ export class AjvSchema<IN = unknown, OUT = IN> {
 
   getValidationResult(
     input: IN,
-    opt: AjvValidationOptions = {},
+    opt: AjvValidationOptions<IN> = {},
   ): ValidationFunctionResult<OUT, AjvValidationError> {
     const fn = this.getAJVValidateFunction()
 
@@ -144,7 +144,7 @@ export class AjvSchema<IN = unknown, OUT = IN> {
         ? input // mutate
         : _deepCopy(input) // not mutate
 
-    const valid = fn(item) // mutates item
+    const valid = fn(item) // mutates item, but not input
     _typeCast<OUT>(item)
     if (valid) return [null, item]
 
@@ -165,7 +165,8 @@ export class AjvSchema<IN = unknown, OUT = IN> {
 
     // Note: if we mutated the input already, e.g stripped unknown properties,
     // the error message Input would contain already mutated object print, such as Input: {}
-    const inputStringified = _inspect(input, { maxLen: 4000 })
+    // Unless `getOriginalInput` function is provided - then it will be used to preserve the Input pureness.
+    const inputStringified = _inspect(opt.getOriginalInput?.() || input, { maxLen: 4000 })
     message = [message, 'Input: ' + inputStringified].join(separator)
 
     const err = new AjvValidationError(
@@ -245,7 +246,7 @@ export type WithCachedAjvSchema<Base, IN, OUT> = Base & {
   [HIDDEN_AJV_SCHEMA]: AjvSchema<IN, OUT>
 }
 
-export interface AjvValidationOptions {
+export interface AjvValidationOptions<IN> {
   /**
    * Defaults to true,
    * because that's how AJV works by default,
@@ -264,6 +265,16 @@ export interface AjvValidationOptions {
   mutateInput?: boolean
   inputName?: string
   inputId?: string
+  /**
+   * Function that returns "original input".
+   * What is original input?
+   * It's an input in its original non-mutated form.
+   * Why is it needed?
+   * Because we mutates the Input here. And after its been mutated - we no longer
+   * can include it "how it was" in an error message. So, for that reason we'll use
+   * `getOriginalInput()`, if it's provided.
+   */
+  getOriginalInput?: () => IN
 }
 
 export interface AjvSchemaCfg {

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -232,8 +232,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 +249,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 +276,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 +385,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 +408,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 +446,11 @@ 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>()
   }
 
   /**
@@ -537,33 +535,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)
   }
 }
 
@@ -591,6 +587,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 +610,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 +618,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 +803,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 +836,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 +920,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 +977,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 +996,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 +1013,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 })
   }
 }