feat: allow reusing resolvers

README.md

@@ -82,7 +82,21 @@ Builds a logical conjunction (AND) of multiple [JSON schemas](https://json-schem
 
 #### resolvers
 
-A list of default resolvers that __merge-json-schema__ uses to merge JSON schemas. You can override the default resolvers by passing a list of custom resolvers in the `options` argument of `mergeSchemas`. See [keywordResolver](#keywordresolver-keyword-values-mergedschema-parentschemas-options).
+A list of default resolvers that __merge-json-schema__ uses to merge JSON schemas. You can override the default resolvers by passing resolver functions against the keywords in the `options` argument of `mergeSchemas`. You may either pass in your own custom resolver functions or utilize the ones exposed via the `resolvers` object from the library. See [keywordResolver](#keywordresolver-keyword-values-mergedschema-parentschemas-options).
+
+__Example:__ Overriding the default resolver(intersection) with a union function for the `enum` keyword. 
+
+```javascript
+const schemaMerger = require('@fastify/merge-json-schemas');
+const mergedSchema = schemaMerger.mergeSchemas(
+    schemas,
+    {
+      resolvers: {
+        enum: schemaMerger.resolvers.arraysUnion
+      },
+    }
+);
+```
 
 #### defaultResolver
 

index.js

@@ -353,4 +353,4 @@ function mergeSchemas (schemas, options = {}) {
   return _mergeSchemas(schemas, options)
 }
 
-module.exports = { mergeSchemas, keywordsResolvers, defaultResolver, ...errors }
+module.exports = { mergeSchemas, keywordsResolvers, defaultResolver, resolvers, ...errors }

test/exports.test.js

@@ -0,0 +1,22 @@
+const { resolvers } = require('../index')
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+
+test('Exported resolvers: should export all expected resolvers', () => {
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'arraysIntersection'))
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'hybridArraysIntersection'))
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'arraysUnion'))
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'minNumber'))
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'maxNumber'))
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'commonMultiple'))
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'allEqual'))
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'booleanAnd'))
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'booleanOr'))
+  assert(Object.prototype.hasOwnProperty.call(resolvers, 'skip'))
+})
+
+test('Exported resolvers: should ensure each resolver is a function', () => {
+  Object.values(resolvers).forEach((resolver) => {
+    assert.strictEqual(typeof resolver, 'function')
+  })
+})

types/index.d.ts

@@ -59,3 +59,15 @@ export function mergeSchemas (schemas: any[], options?: MergeOptions): any
 
 export const keywordsResolvers: KeywordResolvers
 export const defaultResolver: KeywordResolver
+export const resolvers: {
+  arraysIntersection: KeywordResolver;
+  hybridArraysIntersection: KeywordResolver;
+  arraysUnion: KeywordResolver;
+  minNumber: KeywordResolver;
+  maxNumber: KeywordResolver;
+  commonMultiple: KeywordResolver;
+  allEqual: KeywordResolver;
+  booleanAnd: KeywordResolver;
+  booleanOr: KeywordResolver;
+  skip: KeywordResolver;
+}

types/index.test-d.ts

@@ -1,4 +1,4 @@
-import { mergeSchemas, MergeOptions } from '..'
+import { mergeSchemas, MergeOptions, resolvers, KeywordResolver } from '..'
 import { expectType } from 'tsd'
 
 {
@@ -50,3 +50,14 @@ import { expectType } from 'tsd'
 
   mergeSchemas([schema1, schema2], mergeOptions)
 }
+
+expectType<KeywordResolver>(resolvers.arraysIntersection)
+expectType<KeywordResolver>(resolvers.hybridArraysIntersection)
+expectType<KeywordResolver>(resolvers.arraysUnion)
+expectType<KeywordResolver>(resolvers.minNumber)
+expectType<KeywordResolver>(resolvers.maxNumber)
+expectType<KeywordResolver>(resolvers.commonMultiple)
+expectType<KeywordResolver>(resolvers.allEqual)
+expectType<KeywordResolver>(resolvers.booleanAnd)
+expectType<KeywordResolver>(resolvers.booleanOr)
+expectType<KeywordResolver>(resolvers.skip)