@naturalcycles/nodejs-lib 15.61.1 → 15.62.1

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

@@ -235,11 +235,34 @@ export declare class JsonSchemaObjectBuilder<IN extends AnyObject, OUT extends A
      * When set, the validation will not strip away properties that are not specified explicitly in the schema.
      */
     allowAdditionalProperties(): this;
-    extend<IN2 extends AnyObject>(props: AnyObject): JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, Opt>;
+    extend(props: AnyObject): never;
+    extend<IN2 extends AnyObject>(props: {
+        [K in keyof Required<IN2>]-?: JsonSchemaAnyBuilder<any, IN2[K], any>;
+    }): JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, false>;
+    /**
+     * Concatenates another schema to the current schema.
+     *
+     * It expects 2 types to be passed in as a generic:
+     * 1) the expected final type,
+     * 2) the type of the passed in schema.
+     *
+     * ```ts
+     *  interface Foo { foo: string }
+     *  const fooSchema = j.object<Foo>({ foo: j.string() })
+     *
+     *  interface Bar { bar: number }
+     *  const barSchema = j.object<Bar>({ bar: j.number() })
+     *
+     *  interface Shu { foo: string, bar: number }
+     *  const shuSchema = fooSchema.concat<Shu, Bar>(barSchema)
+     * ```
+     */
+    concat(other: any): never;
+    concat<NEW_TYPE extends AnyObject, OUT2 extends AnyObject>(other: JsonSchemaObjectBuilder<any, OUT2, any>): ExactMatch<NEW_TYPE, OUT & OUT2> extends true ? JsonSchemaObjectBuilder<NEW_TYPE, NEW_TYPE, false> : never;
     /**
      * Extends the current schema with `id`, `created` and `updated` according to NC DB conventions.
      */
-    dbEntity(): JsonSchemaObjectBuilder<any, any, Opt>;
+    dbEntity(): never;
     minProperties(minProperties: number): this;
     maxProperties(maxProperties: number): this;
 }

package/dist/validation/ajv/jsonSchemaBuilder.js

@@ -589,6 +589,15 @@ export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
         const clone = this.clone();
         const incomingSchemaBuilder = new JsonSchemaObjectBuilder(props);
         mergeJsonSchemaObjects(clone.schema, incomingSchemaBuilder.schema);
+        // The incoming object is type-safe because `extend<Foo>()` expects a passed in type that matches the passed in props,
+        // but maybe the current schema was created differently, so that's what decides the typecheckedness.
+        const hasIsOfTypeCheck = this.schema.hasIsOfTypeCheck;
+        _objectAssign(clone.schema, { hasIsOfTypeCheck });
+        return clone;
+    }
+    concat(other) {
+        const clone = this.clone();
+        mergeJsonSchemaObjects(clone.schema, other.schema);
         return clone;
     }
     /**
@@ -646,6 +655,10 @@ export class JsonSchemaObjectInferringBuilder extends JsonSchemaAnyBuilder {
         _objectAssign(newBuilder.schema, _deepCopy(this.schema));
         const incomingSchemaBuilder = new JsonSchemaObjectInferringBuilder(props);
         mergeJsonSchemaObjects(newBuilder.schema, incomingSchemaBuilder.schema);
+        // This extend function is not type-safe as it is inferring,
+        // so even if the base schema was already type-checked,
+        // the new schema loses that quality.
+        _objectAssign(newBuilder.schema, { hasIsOfTypeCheck: false });
         return newBuilder;
     }
     /**

package/package.json

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

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -828,14 +828,53 @@ export class JsonSchemaObjectBuilder<
     return this.cloneAndUpdateSchema({ additionalProperties: true })
   }
 
-  extend<IN2 extends AnyObject>(
-    props: AnyObject,
-  ): JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, Opt> {
-    const clone = this.clone() as JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, Opt>
+  extend(props: AnyObject): never
+  extend<IN2 extends AnyObject>(props: {
+    [K in keyof Required<IN2>]-?: JsonSchemaAnyBuilder<any, IN2[K], any>
+  }): JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, false>
+  extend<IN2 extends AnyObject>(props: {
+    [key in keyof IN2]: JsonSchemaAnyBuilder<any, IN2[key], any>
+  }): JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, false> {
+    const clone = this.clone()
 
     const incomingSchemaBuilder = new JsonSchemaObjectBuilder<IN2, IN2, false>(props)
     mergeJsonSchemaObjects(clone.schema as any, incomingSchemaBuilder.schema as any)
 
+    // The incoming object is type-safe because `extend<Foo>()` expects a passed in type that matches the passed in props,
+    // but maybe the current schema was created differently, so that's what decides the typecheckedness.
+    const hasIsOfTypeCheck = this.schema.hasIsOfTypeCheck
+    _objectAssign(clone.schema, { hasIsOfTypeCheck })
+
+    return clone as unknown as JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, false>
+  }
+
+  /**
+   * Concatenates another schema to the current schema.
+   *
+   * It expects 2 types to be passed in as a generic:
+   * 1) the expected final type,
+   * 2) the type of the passed in schema.
+   *
+   * ```ts
+   *  interface Foo { foo: string }
+   *  const fooSchema = j.object<Foo>({ foo: j.string() })
+   *
+   *  interface Bar { bar: number }
+   *  const barSchema = j.object<Bar>({ bar: j.number() })
+   *
+   *  interface Shu { foo: string, bar: number }
+   *  const shuSchema = fooSchema.concat<Shu, Bar>(barSchema)
+   * ```
+   */
+  concat(other: any): never
+  concat<NEW_TYPE extends AnyObject, OUT2 extends AnyObject>(
+    other: JsonSchemaObjectBuilder<any, OUT2, any>,
+  ): ExactMatch<NEW_TYPE, OUT & OUT2> extends true
+    ? JsonSchemaObjectBuilder<NEW_TYPE, NEW_TYPE, false>
+    : never
+  concat(other: any): any {
+    const clone = this.clone()
+    mergeJsonSchemaObjects(clone.schema as any, other.schema)
     return clone
   }
 
@@ -959,6 +998,11 @@ export class JsonSchemaObjectInferringBuilder<
     const incomingSchemaBuilder = new JsonSchemaObjectInferringBuilder<NEW_PROPS, false>(props)
     mergeJsonSchemaObjects(newBuilder.schema as any, incomingSchemaBuilder.schema as any)
 
+    // This extend function is not type-safe as it is inferring,
+    // so even if the base schema was already type-checked,
+    // the new schema loses that quality.
+    _objectAssign(newBuilder.schema, { hasIsOfTypeCheck: false })
+
     return newBuilder as JsonSchemaObjectInferringBuilder<
       {
         [K in keyof PROPS | keyof NEW_PROPS]: K extends keyof NEW_PROPS