@naturalcycles/nodejs-lib 15.61.0 → 15.62.0

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

@@ -235,11 +235,32 @@ 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 a type to be passed in as a generic, and this type should be the expected final type.
+     *
+     * ```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>(barSchema)
+     * ```
+     */
+    concat(other: any): never;
+    concat<FINAL extends AnyObject>(other: JsonSchemaObjectBuilder<any, any, any>): JsonSchemaObjectBuilder<FINAL, FINAL, false>;
     /**
      * 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;
 }
@@ -396,10 +417,10 @@ declare function withEnumKeys<const T extends readonly (string | number)[] | Str
 } : {
     [P in K]: SchemaOut<S>;
 }, false>;
-type Expand<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-type ExactMatch<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+type Expand<T> = {
+    [K in keyof T]: T[K];
+};
+type ExactMatch<A, B> = (<T>() => T extends Expand<A> ? 1 : 2) extends <T>() => T extends Expand<B> ? 1 : 2 ? (<T>() => T extends Expand<B> ? 1 : 2) extends <T>() => T extends Expand<A> ? 1 : 2 ? true : false : false;
 type BuilderOutUnion<B extends readonly JsonSchemaAnyBuilder<any, any, any>[]> = {
     [K in keyof B]: B[K] extends JsonSchemaAnyBuilder<any, infer O, any> ? O : never;
 }[number];

package/dist/validation/ajv/jsonSchemaBuilder.js

@@ -586,9 +586,18 @@ export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
         return this.cloneAndUpdateSchema({ additionalProperties: true });
     }
     extend(props) {
-        const clone = this.cloneAndUpdateSchema(_deepCopy(this.schema));
+        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.0",
+  "version": "15.62.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@types/js-yaml": "^4",

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -828,18 +828,49 @@ export class JsonSchemaObjectBuilder<
     return this.cloneAndUpdateSchema({ additionalProperties: true })
   }
 
-  extend<IN2 extends AnyObject>(
-    props: AnyObject,
-  ): JsonSchemaObjectBuilder<IN & IN2, OUT & IN2, Opt> {
-    const clone = this.cloneAndUpdateSchema(_deepCopy(this.schema)) 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 a type to be passed in as a generic, and this type should be the expected final type.
+   *
+   * ```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>(barSchema)
+   * ```
+   */
+  concat(other: any): never
+  concat<FINAL extends AnyObject>(
+    other: JsonSchemaObjectBuilder<any, any, any>,
+  ): JsonSchemaObjectBuilder<FINAL, FINAL, false>
+  concat(other: any): any {
+    const clone = this.clone()
+    mergeJsonSchemaObjects(clone.schema as any, other.schema)
     return clone
   }
 
@@ -963,6 +994,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
@@ -1311,10 +1347,14 @@ function withEnumKeys<
   >(props, { hasIsOfTypeCheck: false })
 }
 
-type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
+type Expand<T> = { [K in keyof T]: T[K] }
 
 type ExactMatch<A, B> =
-  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false
+  (<T>() => T extends Expand<A> ? 1 : 2) extends <T>() => T extends Expand<B> ? 1 : 2
+    ? (<T>() => T extends Expand<B> ? 1 : 2) extends <T>() => T extends Expand<A> ? 1 : 2
+      ? true
+      : false
+    : false
 
 type BuilderOutUnion<B extends readonly JsonSchemaAnyBuilder<any, any, any>[]> = {
   [K in keyof B]: B[K] extends JsonSchemaAnyBuilder<any, infer O, any> ? O : never