@naturalcycles/nodejs-lib 15.59.0 → 15.60.0

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.59.0",
+  "version": "15.60.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@types/js-yaml": "^4",

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 })
   }
 }