From 23323d1c842f0a46cb450af4c056726049ae4aba Mon Sep 17 00:00:00 2001 From: Simone Sanfratello Date: Tue, 12 Dec 2023 23:37:34 +0100 Subject: [PATCH 1/2] Add linking entity option on m2m --- README.md | 8 +- fixtures/artists-subgraph-with-entities.js | 2 +- fixtures/foods-subgraph.js | 70 ++++++ fixtures/movies-subgraph-with-entities.js | 2 +- fixtures/restaurants-subgraph.js | 112 +++++++++ fixtures/songs-subgraph-with-entities.js | 2 +- lib/composer.js | 223 +++--------------- lib/query-builder.js | 205 +++++++++++----- lib/results.js | 257 +++++++++++++++++++++ lib/utils.js | 94 +++++++- package.json | 1 + test/many-to-many.test.js | 91 ++++++++ 12 files changed, 811 insertions(+), 256 deletions(-) create mode 100644 fixtures/foods-subgraph.js create mode 100644 fixtures/restaurants-subgraph.js create mode 100644 lib/results.js create mode 100644 test/many-to-many.test.js diff --git a/README.md b/README.md index 5b79af4..6952645 100644 --- a/README.md +++ b/README.md @@ -173,6 +173,9 @@ main() - Arguments - `config` (object, optional) - A configuration object with the following schema. + - `defaultArgsAdapter` (function, optional) - The default `argsAdapter` function for the entities. + - `addEntitiesResolvers` (boolean, optional) - automatically add entities types and resolvers accordingly with configuration, see [composer entities section](#composer-entities). + - `logger` TODO - `subgraphs` (array, optional) - Array of subgraph configuration objects with the following schema. - `name` (string, optional) - A unique name to identify the subgraph; if missing the default one is `#${index}`, where index is the subgraph index in the array. - `server` (object, required) - Configuration object for communicating with the subgraph server with the following schema: @@ -195,11 +198,12 @@ main() - `resolver` (object, optional) - The resolver definition to query the foreing entity, same structure as `entity.resolver`. - `many` (array of objects, optional) - Describe a 1-to-many relation - the reverse of the foreign key. - `type` (string, required) - The entity type where the entity is a foreign key. - - `fkey` (string, required) - The foreign key field in the referred entity. + - `fkey` (string, optional) - The foreign key field in the referred entity. TODO Required but not on `link` - `as` (string, required) - When using `addEntitiesResolvers`, it defines the name of the relation as a field of the current one, as a list. - `pkey` (string, optional) - The primary key of the referred entity. - `subgraph` (string, optional) - The subgraph name of the referred entity, where the resolver is located; if missing is intended the self. - `resolver` (object, required) - The resolver definition to query the referred entity, same structure as `entity.resolver`. + - `link` TODO - `onSubgraphError` (function, optional) - Hook called when an error occurs getting schema from a subgraph. The default function will throw the error. The arguments are: - `error` (error) - The error. - `subgraph` (string) - The erroring subgraph name. @@ -221,8 +225,6 @@ main() - `queryTypeName` (string, optional) - The name of the `Query` type in the composed schema. **Default:** `'Query'`. - `mutationTypeName` (string, optional) - The name of the `Mutation` type in the composed schema. **Default:** `'Mutation'`. - `subscriptionTypeName` (string, optional) - The name of the `Subscription` type in the composed schema. **Default:** `'Subscription'`. - - `defaultArgsAdapter` (function, optional) - The default `argsAdapter` function for the entities. - - `addEntitiesResolvers` (boolean, optional) - automatically add entities types and resolvers accordingly with configuration, see [composer entities section](#composer-entities). - Returns - A `Promise` that resolves with a `Composer` instance. diff --git a/fixtures/artists-subgraph-with-entities.js b/fixtures/artists-subgraph-with-entities.js index fff7742..3a93a26 100644 --- a/fixtures/artists-subgraph-with-entities.js +++ b/fixtures/artists-subgraph-with-entities.js @@ -91,4 +91,4 @@ const entities = { } } -module.exports = { name: 'artists', schema, reset, resolvers, entities, data } +module.exports = { name: 'artists-subgraph', schema, reset, resolvers, entities, data } diff --git a/fixtures/foods-subgraph.js b/fixtures/foods-subgraph.js new file mode 100644 index 0000000..b857674 --- /dev/null +++ b/fixtures/foods-subgraph.js @@ -0,0 +1,70 @@ +'use strict' + +const schema = ` + input WhereConditionIn { + in: [ID!]! + } + + input FoodsWhereCondition { + id: WhereConditionIn + } + + type Food { + id: ID! + name: String + } + + type Query { + foods(where: FoodsWhereCondition): [Food] + } +` + +const data = { + foods: null +} + +function reset () { + data.foods = { + 50: { + id: 50, + name: 'Pizza margherita' + }, + 51: { + id: 51, + name: 'Pizza boscaiola' + }, + 52: { + id: 52, + name: 'Pizza capricciosa' + }, + 60: { + id: 60, + name: 'Spaghetti carbonara' + }, + 61: { + id: 61, + name: 'Tagliolini scoglio' + }, + 62: { + id: 62, + name: 'Pici cacio e pepe' + }, + 63: { + id: 63, + name: 'Grigliata mista' + } + } +} + +reset() + +const resolvers = { + Query: { + foods (_, { where }) { + return Object.values(data.foods) + .filter(a => where.id.in.includes(String(a.id))) + } + } +} + +module.exports = { name: 'foods-subgraph', schema, reset, resolvers, data } diff --git a/fixtures/movies-subgraph-with-entities.js b/fixtures/movies-subgraph-with-entities.js index 1348660..3e5926f 100644 --- a/fixtures/movies-subgraph-with-entities.js +++ b/fixtures/movies-subgraph-with-entities.js @@ -100,4 +100,4 @@ const entities = { } } -module.exports = { name: 'movies', schema, reset, resolvers, entities, data } +module.exports = { name: 'movies-subgraph', schema, reset, resolvers, entities, data } diff --git a/fixtures/restaurants-subgraph.js b/fixtures/restaurants-subgraph.js new file mode 100644 index 0000000..39527b1 --- /dev/null +++ b/fixtures/restaurants-subgraph.js @@ -0,0 +1,112 @@ +'use strict' + +const schema = ` + input WhereConditionIn { + in: [ID!]! + } + + input RestaurantsWhereCondition { + id: WhereConditionIn + } + + input RestaurantsFoodsWhereCondition { + restaurantId: WhereConditionIn + foodId: WhereConditionIn + } + + type Restaurant { + id: ID! + name: String + } + + type RestaurantsFoods { + restaurantId: ID! + foodId: ID! + } + + type Query { + restaurants(where: RestaurantsWhereCondition): [Restaurant] + restaurantsFoods(where: RestaurantsFoodsWhereCondition): [RestaurantsFoods] + } +` + +const data = { + restaurants: null +} + +function reset () { + data.restaurantsFoods = [ + { + restaurantId: 90, + foodId: 50 + }, + { + restaurantId: 90, + foodId: 51 + }, + { + restaurantId: 90, + foodId: 52 + }, + + { + restaurantId: 91, + foodId: 60 + }, + { + restaurantId: 91, + foodId: 61 + }, + { + restaurantId: 91, + foodId: 62 + }, + + { + restaurantId: 92, + foodId: 60 + }, + { + restaurantId: 92, + foodId: 63 + } + ] + + data.restaurants = { + 90: { + id: 90, + name: 'Pizzeria Napoletana' + }, + 91: { + id: 91, + name: 'Ristorante Stellato' + }, + 92: { + id: 92, + name: 'Trattoria da Gigi' + } + } +} + +reset() + +const resolvers = { + Query: { + restaurants (_, { where }) { + return Object.values(data.restaurants) + .filter(r => where.id.in.includes(String(r.id))) + }, + restaurantsFoods (_, { where }) { + if (where.restaurantId?.in) { + return data.restaurantsFoods + .filter(rf => where.restaurantId.in.includes(String(rf.restaurantId))) + } + if (where.foodId?.in) { + return data.restaurantsFoods + .filter(rf => where.foodId.in.includes(String(rf.foodId))) + } + } + } +} + +module.exports = { name: 'restaurants-subgraph', schema, reset, resolvers, data } diff --git a/fixtures/songs-subgraph-with-entities.js b/fixtures/songs-subgraph-with-entities.js index 6b35b5f..261e5f8 100644 --- a/fixtures/songs-subgraph-with-entities.js +++ b/fixtures/songs-subgraph-with-entities.js @@ -100,4 +100,4 @@ const entities = { } } -module.exports = { name: 'songs', schema, reset, resolvers, entities, data } +module.exports = { name: 'songs-subgraph', schema, reset, resolvers, entities, data } diff --git a/lib/composer.js b/lib/composer.js index 72c767a..a1cc182 100644 --- a/lib/composer.js +++ b/lib/composer.js @@ -10,7 +10,7 @@ const metaline = require('metaline') const { createEmptyObject, unwrapSchemaType } = require('./graphql-utils') const { fetchSubgraphSchema, makeGraphqlRequest } = require('./network') const { QueryBuilder } = require('./query-builder') -const { isObject, traverseResult, schemaTypeName, createDefaultArgsAdapter } = require('./utils') +const { schemaTypeName, createDefaultArgsAdapter, dummyLogger } = require('./utils') const { validateArray, validateFunction, @@ -18,6 +18,7 @@ const { validateString, validateResolver } = require('./validation') +const { mergeResults } = require('./results') class Composer { #queryTypeName @@ -29,6 +30,7 @@ class Composer { #types #directives #entities + #logger constructor (options = {}) { validateObject(options, 'options') @@ -40,12 +42,14 @@ class Composer { subgraphs = [], onSubgraphError = onError, subscriptions, - addEntitiesResolvers + addEntitiesResolvers, + logger = dummyLogger() } = options let defaultArgsAdapter = options.defaultArgsAdapter this.addEntitiesResolvers = !!addEntitiesResolvers + this.#logger = logger validateString(queryTypeName, 'queryTypeName') validateString(mutationTypeName, 'mutationTypeName') @@ -148,12 +152,28 @@ class Composer { for (let k = 0; k < many.length; ++k) { const m = many[k] - for (const p of ['type', 'fkey', 'as', 'pkey']) { + for (const p of ['type', 'as', 'pkey']) { validateString(m[p], `subgraphs[${subgraphName}].entities.${name}.many[${k}].${p}`) } - for (const p of ['subgraph']) { - if (!m[p]) { continue } - validateString(m[p], `subgraphs[${subgraphName}].entities.${name}.many[${k}].${p}`) + // TODO validate: fkey is not required for link + if (m.fkey) { + validateString(m.subgraph, `subgraphs[${subgraphName}].entities.${name}.many[${k}].fkey`) + } + + if (!m.subgraph) { + m.subgraph = subgraphName + } else { + validateString(m.subgraph, `subgraphs[${subgraphName}].entities.${name}.many[${k}].subgraph`) + } + + // TODO validate many.link + // type, pkey, fkey, resolver + if (m.link) { + if (!m.link.subgraph) { + m.link.subgraph = subgraphName + } else { + validateString(m.subgraph, `subgraphs[${subgraphName}].entities.${name}.many[${k}].subgraph`) + } } if (typeof m.resolver.argsAdapter === 'string') { @@ -473,6 +493,7 @@ class Composer { path: [fieldName], type: objType, fields: [], + subgraphs: this.#subgraphs, subgraph, resolverName: info.fieldName, root: true, @@ -527,6 +548,7 @@ class Composer { path: [fieldName], type: objType, fields: [], + subgraphs: this.#subgraphs, subgraph, resolverName: info.fieldName, root: true, @@ -559,10 +581,13 @@ class Composer { async #runQuery (ctx, query) { const text = query.buildQuery(ctx) - // TODO debug(' run subgraph query', query.subgraph.name, text) + + this.#logger.debug({ subgraph: query.subgraph.name, query: text }, 'run subgraph query') const data = await makeGraphqlRequest(text, query.subgraph.server) - // TODO debug(' result', data) + + this.#logger.debug({ query: text, data }, 'query result') mergeResults(query, ctx.result, data) + this.#logger.debug({ merged: ctx.result }, 'merged result') await this.#runFollowupQueries(ctx, query) } @@ -692,88 +717,6 @@ class Composer { } } -function mergeResults (query, partialResult, response) { - let { result, mergedPartial, mergedPartialParentNode } = selectResult(query, partialResult, response) - - if (mergedPartial === null) { - mergedPartialParentNode[query.path.at(-1)] = result - mergedPartial = result - } else if (Array.isArray(result) && result.length > 0) { - // TODO refactor this case, too many loops, split functions, memoize if possible - - const key = query.key - const parentKey = query.parentKey.field - const as = query.parentKey.as - const many = query.parentKey.many - - const resultIndex = new Map() - - // TODO get list from node result type? - const list = Array.isArray(result[0][key]) - - // TODO refactor as a matrix for every case - if (list) { - for (let i = 0; i < result.length; i++) { - for (let j = 0; j < result[i][key].length; j++) { - const s = resultIndex.get(result[i][key][j]) - if (s) { - resultIndex.set(result[i][key][j], s.concat(i)) - continue - } - resultIndex.set(result[i][key][j], [i]) - } - } - } else if (many) { - for (let i = 0; i < result.length; i++) { - const s = resultIndex.get(result[i][key]) - if (s) { - resultIndex.set(result[i][key], s.concat(i)) - continue - } - resultIndex.set(result[i][key], [i]) - } - } else { - for (let i = 0; i < result.length; i++) { - resultIndex.set(result[i][key], i) - } - } - - for (let i = 0; i < mergedPartial.length; i++) { - const merging = mergedPartial[i] - if (!merging) { continue } - - // no need to be recursive - if (Array.isArray(merging)) { - if (list || many) { - for (let j = 0; j < merging.length; j++) { - copyResults(result, resultIndex, merging[j], parentKey, as) - } - } else { - for (let j = 0; j < merging.length; j++) { - copyResult(result, resultIndex, merging[j], parentKey, as) - } - } - continue - } - - if (list || many) { - copyResults(result, resultIndex, merging, parentKey, as) - } else { - copyResult(result, resultIndex, merging, parentKey, as) - } - } - } else if (isObject(result)) { - // TODO copy object fn? - const fields = Object.keys(result) - for (let i = 0; i < fields.length; i++) { - mergedPartial[fields[i]] = result[fields[i]] - } - } else { - // no result - mergedPartialParentNode[query.path.at(-1)] = result - } -} - function createContext ({ fieldName, followups, result }) { return { path: [], @@ -782,106 +725,6 @@ function createContext ({ fieldName, followups, result }) { } } -function copyResult (result, resultIndex, to, key, as) { - if (Array.isArray(to)) { - for (const line of to) { - copyResult(result, resultIndex, line, key, as) - } - return - } - - const index = resultIndex.get(to[key]) - if (index === undefined) { - // TODO if not nullable set it to an empty object - return - } - if (as) { - if (!to[as]) { - to[as] = {} - } - to = to[as] - } - - // TODO copy object fn? - const fields = Object.keys(result[index]) - for (let i = 0; i < fields.length; i++) { - to[fields[i]] = result[index][fields[i]] - } -} - -function copyResults (result, resultIndex, to, key, as) { - let indexes - - if (Array.isArray(to)) { - for (const line of to) { - copyResults(result, resultIndex, line, key, as) - } - return - } - - // TODO refactor? - if (Array.isArray(to[key])) { - indexes = to[key].map(k => resultIndex.get(k)).flat() - } else { - indexes = resultIndex.get(to[key]) - } - - if (indexes === undefined) { - // TODO get if nullable from node result type - if (as && !to[as]) { - to[as] = [] - } - - return - } - if (as) { - if (!to[as]) { - to[as] = [] - } - to = to[as] - } - - for (let i = 0; i < indexes.length; i++) { - // TODO copy object fn? - const fields = Object.keys(result[indexes[i]]) - const r = {} - for (let j = 0; j < fields.length; j++) { - r[fields[j]] = result[indexes[i]][fields[j]] - } - to.push(r) - } -} - -function selectResult (query, partialResult, response) { - let result = response[query.resolverName] - let mergedPartial = partialResult - let mergedPartialParentNode = null - - for (let i = 0; i < query.path.length; ++i) { - const path = query.path[i] - mergedPartialParentNode = mergedPartial - mergedPartialParentNode[path] ??= null - - if (!mergedPartial && !mergedPartial[path]) { break } - - mergedPartial = traverseResult(mergedPartial, path) - } - - if (!query.root) { - if (Array.isArray(mergedPartial) && !Array.isArray(result)) { - result = [result] - } else if (!Array.isArray(mergedPartial) && Array.isArray(result) && result.length === 1) { - result = result[0] - } - } - - if (Array.isArray(result)) { - result = result.filter(r => !!r) - } - - return { result, mergedPartial, mergedPartialParentNode } -} - function addFieldToType (type, field, subgraph) { const { schemaNode: schemaType, fieldMap } = type const existingField = fieldMap.get(field.name) diff --git a/lib/query-builder.js b/lib/query-builder.js index bffd330..e1b2f7a 100644 --- a/lib/query-builder.js +++ b/lib/query-builder.js @@ -1,6 +1,6 @@ 'use strict' const { unwrapSchemaType, valueToArgumentString } = require('./graphql-utils') -const { toQueryArgs, keySelection, traverseResult, nodeTypeName, transitivePKey } = require('./utils') +const { toQueryArgs, keySelection, traverseResult, nodeTypeName, transitivePKey, linkingEntities, dummyLogger } = require('./utils') class QueryBuilder { constructor (options) { @@ -10,7 +10,9 @@ class QueryBuilder { this.path = options.path.slice() this.type = options.type this.fields = options.fields + this.logger = options.logger ?? dummyLogger() + this.subgraphs = options.subgraphs this.subgraph = options.subgraph this.resolverName = options.resolverName this.resolverArgsAdapter = options.argsAdapter @@ -181,7 +183,7 @@ class QueryBuilder { const bareType = unwrapSchemaType(schemaNode.type) const type = this.types.get(bareType.name) const { fieldMap } = type - const set = new Set() + const selectionFields = new Set() let keyFields for (let i = 0; i < length; ++i) { @@ -204,7 +206,7 @@ class QueryBuilder { value += ` ${this.buildSelectionSet(ctx, fragNode, schemaNode)}` } - set.add(value) + selectionFields.add(value) } } else { let value = selection.name.value @@ -221,7 +223,9 @@ class QueryBuilder { const parentKeys = this.getKeyFields(type) let followupSchema, followupNode - if (swap) { + // on swap: resolve current entity with its source resolver + // on parentKeys.many: m2m relation, querying linking entity + if (swap || parentKeys.many?.link) { followupSchema = selectionSchemaNode followupNode = selection } else { @@ -229,7 +233,7 @@ class QueryBuilder { followupNode = node } - followup = this.createFollowup(ctx, followupSchema, followupNode, this.subgraph, type, field, subgraph, swap) + followup = this.createFollowup(ctx, followupSchema, followupNode, this.subgraph, type, field, subgraph, swap, parentKeys.many) keyFields = collectKeys(keyFields, parentKeys) if (followup) { @@ -254,47 +258,66 @@ class QueryBuilder { } } - set.add(value) + selectionFields.add(value) } } ctx.path.pop() - // add entity pkey to selection, needed to match rows merging results + const selectedFields = this.buildSelectionFields(bareType, keyFields, selectionFields) + + if (selectedFields.length < 1) { + // TODO this is an error on configuration + return '' + } + + this.selectedFields = selectedFields.map(f => f.split(' ')[0]) + return `{ ${selectedFields.join(', ')} }` + } + + buildSelectionFields (type, keyFields, selectionFields) { + const selectionKeyFields = new Set() + // add entity keys to selection, needed to match rows merging results // no followups here if (!keyFields) { - const entity = this.subgraph.entities[bareType.name] + const entity = this.subgraph.entities[type.name] if (!entity) { // TODO onError: missing entity definition', typeName, 'in subgraph', this.subgraph.name) } else { - // TODO keys generator fn - // TODO collect entity keys on composer mergeSchema to avoid collecting them every time - // TODO lookup for entities to resolve, no need to add all the fkeys always - keyFields = { - pkey: entity.pkey, - fkeys: [ - ...(entity.fkeys || []), - ...(entity.many || []) - .map(m => ({ field: m.pkey, as: m.as })) - ] - } + keyFields = collectEntityKeys(entity) } } if (keyFields) { - set.add(keySelection(keyFields.pkey)) + keySelection(keyFields.pkey, selectionKeyFields) + for (let i = 0; i < keyFields.fkeys.length; ++i) { if (!keyFields.fkeys[i].field) { continue } - const keyFieldName = keySelection(keyFields.fkeys[i].field) - set.add(keyFieldName) + keySelection(keyFields.fkeys[i].field, selectionKeyFields) + } + + // resolving a linking entity + if (this.parentKey?.linking) { + // get keys for linking entity + for (let i = 0; i < keyFields.many.length; ++i) { + if (!keyFields.many[i].link) { continue } + keySelection(keyFields.many[i].link.pkey, selectionKeyFields) + keySelection(keyFields.many[i].link.fkey, selectionKeyFields) + } + } else { + // skip link entity keys, they have their own query + for (let i = 0; i < keyFields.many.length; ++i) { + if (keyFields.many[i].link) { continue } + keySelection(keyFields.many[i].pkey, selectionKeyFields) + } } } // TODO improve structure - const selectedFields = Array.from(set) - this.selectedFields = selectedFields.map(f => f.split(' ')[0]) - - return `{ ${selectedFields.join(', ')} }` + for (const s of selectionFields.values()) { + selectionKeyFields.add(s) + } + return Array.from(selectionKeyFields) } // TODO memoize by subgraph#entity @@ -303,26 +326,22 @@ class QueryBuilder { const entity = this.subgraph.entities[typeName] - if (!entity) { - const pkey = transitivePKey(typeName, this.subgraph.entities) - if (!pkey) { - // TODO onError - throw new Error(`Unable to resolve entity ${typeName} in subgraph ${this.subgraph.name}`) - } - return { - pkey, - fkeys: [] - } - } else { - return { - pkey: entity.pkey, - fkeys: [ - ...(entity.fkeys || []), - ...(entity.many || []) - .map(m => ({ field: m.pkey, as: m.as })) - ] - } + if (entity) { + return collectEntityKeys(entity) + } + + // look for transitive key + const pkey = transitivePKey(typeName, this.subgraph.entities) + + // look for 1-to-many or many-to-many relations and so keys + const many = linkingEntities(typeName, this.subgraph.entities) + + // at least should be a key to resolve the entity type + if (!pkey && !many) { + // TODO onError + throw new Error(`Unable to resolve entity ${typeName} in subgraph ${this.subgraph.name}`) } + return { pkey, fkeys: [], many: many ?? [] } } followupSubgraph (field) { @@ -340,9 +359,7 @@ class QueryBuilder { // in this way we save a roundtrip to a resolver on the current subgraph to resolve the entity // TODO use a Map on subgraph to avoid this loop - const entitySubgraph = entity.subgraphs.find(s => { - return s.name === subgraph.name - }) + const entitySubgraph = entity.subgraphs.find(s => s.name === subgraph.name) if (entitySubgraph.entities[fieldTypeName]?.resolver) { return { subgraph, swap: true } @@ -356,7 +373,8 @@ class QueryBuilder { return { subgraph: s, swap: true } } - createFollowup (ctx, schemaNode, node, parentSubgraph, parentType, field, subgraph, swap) { + // TODO refactor this function, too long + createFollowup (ctx, schemaNode, node, parentSubgraph, parentType, field, subgraph, swap, linkingEntitiesMany) { const parentTypeName = parentType.schemaNode.name let fieldTypeName = parentTypeName @@ -366,6 +384,10 @@ class QueryBuilder { fieldTypeName = nodeTypeName(field) } + if (!subgraph || !parentSubgraph) { + console.log('nnnn') + } + // TODO refactor: followupSubgraph can return both subgraph and entity and probably keys // TODO handle error if entity or subgraphs don't exists const parentEntity = parentSubgraph.entities[parentTypeName] @@ -378,16 +400,82 @@ class QueryBuilder { let resolverName = entity.resolver.name let key = entity.pkey + const many = linkingEntitiesMany?.[0] + // linking entities + if (many?.link) { + // TODO can a node have more linking entities? + if (this.parentKey?.linking) { + // resolve linked entity + parentKey = { field: many.link.fkey, as: many.as, many: false, linked: true } + // TODO use a Map on subgraph to avoid this loop + subgraph = this.subgraphs.find(s => s.name === many.subgraph) + const type = this.types.get(many.type) + + return { + swap, + path, + node, + schemaNode, + type, + resolverName: many.resolver.name, + argsAdapter: many.resolver.argsAdapter, + partialResults: many.resolver.partialResults, + key, + parentKey, + subgraph, + subgraphs: this.subgraphs, + info: this.info, + types: this.types, + entities: this.entities, + root: false, + fields: [field], + solved: false + } + } else { + // resolve linking entity + key = many.pkey + parentKey = { field: many.link.pkey, as: many.as, many: true, linking: true } + // TODO use a Map on subgraph to avoid this loop + subgraph = this.subgraphs.find(s => s.name === many.link.subgraph) + const type = this.types.get(many.link.type) + + return { + swap, + path, + node, + schemaNode, + type, + resolverName: many.link.resolver.name, + argsAdapter: many.link.resolver.argsAdapter, + partialResults: many.link.resolver.partialResults, + key, + parentKey, + subgraph, + subgraphs: this.subgraphs, + info: this.info, + types: this.types, + entities: this.entities, + root: false, + fields: [field], + solved: false + } + } + } + if (parentEntity?.many) { + // TODO support many folloups manyEntity = parentEntity.many.find(m => m.type === fieldTypeName) if (manyEntity) { // TODO createKey fn - // reverse the keys as the many relation is inverse + // pkey and fkey are switched as the many relation is inverse key = manyEntity.fkey parentKey = { field: manyEntity.pkey, as: manyEntity.as, many: true } argsAdapter = manyEntity.resolver.argsAdapter resolverName = manyEntity.resolver.name partialResults = manyEntity.resolver.partialResults + + // TODO use a Map on subgraph to avoid this loop + subgraph = this.subgraphs.find(s => s.name === manyEntity.subgraph) } } @@ -414,12 +502,13 @@ class QueryBuilder { resolverName, argsAdapter, partialResults, + key, + parentKey, subgraph, + subgraphs: this.subgraphs, info: this.info, types: this.types, entities: this.entities, - key, - parentKey, root: false, fields: [field], solved: false @@ -438,6 +527,17 @@ class QueryBuilder { } } +// TODO collect entity keys on composer mergeSchema to avoid collecting them every time +// TODO lookup for entities to resolve, no need to add all the fkeys always +// TODO memoize by subgraph +function collectEntityKeys (entity) { + return { + pkey: entity.pkey, + fkeys: [...(entity.fkeys || [])], + many: [...(entity.many || [])] + } +} + function collectKeys (keyFields, parentKeys) { if (!keyFields) { return parentKeys @@ -446,6 +546,7 @@ function collectKeys (keyFields, parentKeys) { // TODO if parentKeys.pkey != keyFields.pkey throw Error keyFields.fkeys = keyFields.fkeys.concat(parentKeys.fkeys) + keyFields.many = keyFields.many.concat(parentKeys.many) return keyFields } diff --git a/lib/results.js b/lib/results.js new file mode 100644 index 0000000..2069c1e --- /dev/null +++ b/lib/results.js @@ -0,0 +1,257 @@ +'use strict' + +const { copyObjectByKeys, traverseResult, isObject } = require('./utils') + +function selectResult (query, partialResult, response) { + let result = response[query.resolverName] + let mergedPartial = partialResult + let mergedPartialParentNode = null + + const path = query.parentKey?.linked + ? query.path.slice(0, -1) + : query.path + + for (let i = 0; i < path.length; ++i) { + const p = path[i] + mergedPartialParentNode = mergedPartial + mergedPartialParentNode[p] ??= null + + if (!mergedPartial && !mergedPartial[p]) { break } + + mergedPartial = traverseResult(mergedPartial, p) + } + + if (!query.root) { + if (Array.isArray(mergedPartial) && !Array.isArray(result)) { + result = [result] + } else if (!Array.isArray(mergedPartial) && Array.isArray(result) && result.length === 1) { + result = result[0] + } + } + + if (Array.isArray(result)) { + result = result.filter(r => !!r) + } + + return { result, mergedPartial, mergedPartialParentNode } +} + +function mergeResults (query, partialResult, response) { + const path = query.path + let { result, mergedPartial, mergedPartialParentNode } = selectResult(query, partialResult, response) + + if (mergedPartial === null) { + mergedPartialParentNode[path.at(-1)] = result + mergedPartial = result + } else if (Array.isArray(result) && result.length > 0) { + if (query.parentKey?.linking) { + mergeManyLinkingResults(query, result, mergedPartial) + return + } else if (query.parentKey?.linked) { + mergeManyLinkedResults(query, result, mergedPartial) + return + } + // TODO cover other cases to avoid the following loop with many switches + + const key = query.key + const parentKey = query.parentKey.field + const as = query.parentKey.as + const many = query.parentKey.many + + const { list, resultIndex } = index(result, key, many) + + for (let i = 0; i < mergedPartial.length; i++) { + const merging = mergedPartial[i] + if (!merging) { continue } + + // no need to be recursive + if (Array.isArray(merging)) { + if (list || many) { + for (let j = 0; j < merging.length; j++) { + copyResults(result, resultIndex, merging[j], parentKey, as) + } + } else { + for (let j = 0; j < merging.length; j++) { + copyResult(result, resultIndex, merging[j], parentKey, as) + } + } + continue + } + + if (list || many) { + copyResults(result, resultIndex, merging, parentKey, as) + } else { + copyResult(result, resultIndex, merging, parentKey, as) + } + } + } else if (isObject(result)) { + copyObjectByKeys(mergedPartial, result) + } else { + // no result + mergedPartialParentNode[query.path.at(-1)] = result + } +} + +/** + * index result by key + */ +function index (result, key, many) { + // TODO get list from node result type? + const list = Array.isArray(result[0][key]) + const resultIndex = new Map() + // TODO refactor as a matrix for every case + if (list) { + for (let i = 0; i < result.length; i++) { + for (let j = 0; j < result[i][key].length; j++) { + const s = resultIndex.get(result[i][key][j]) + if (s) { + resultIndex.set(result[i][key][j], s.concat(i)) + continue + } + resultIndex.set(result[i][key][j], [i]) + } + } + } else if (many) { + for (let i = 0; i < result.length; i++) { + const s = resultIndex.get(result[i][key]) + if (s) { + resultIndex.set(result[i][key], s.concat(i)) + continue + } + resultIndex.set(result[i][key], [i]) + } + } else { + for (let i = 0; i < result.length; i++) { + resultIndex.set(result[i][key], i) + } + } + return { list, resultIndex } +} + +/** + * merge many to many relation + */ +function mergeManyLinkingResults (query, result, mergedPartial) { + const key = query.key + const parentKey = query.parentKey.field + const as = query.parentKey.as + const many = query.parentKey.many // true + const { resultIndex } = index(result, parentKey, many) + + for (let i = 0; i < mergedPartial.length; i++) { + const merging = mergedPartial[i] + if (!merging) { continue } + + // no need to be recursive + if (Array.isArray(merging)) { + for (let j = 0; j < merging.length; j++) { + copyResults(result, resultIndex, merging[j], key, as) + } + continue + } + copyResults(result, resultIndex, merging, key, as) + } +} + +function mergeManyLinkedResults (query, result, mergedPartial) { + const key = query.key + const parentKey = query.parentKey.field + const as = query.parentKey.as + const many = query.parentKey.many // false + const { list, resultIndex } = index(result, key, many) + + for (let i = 0; i < mergedPartial.length; i++) { + const merging = mergedPartial[i][as] + if (!merging) { continue } + + // no need to be recursive + if (Array.isArray(merging)) { + if (list) { + for (let j = 0; j < merging.length; j++) { + copyResults(result, resultIndex, merging[j], parentKey, as) + } + } else { + for (let j = 0; j < merging.length; j++) { + copyResult(result, resultIndex, merging[j], parentKey) + } + } + continue + } + + if (list || many) { + copyResults(result, resultIndex, merging, parentKey, as) + } else { + copyResult(result, resultIndex, merging, parentKey, as) + } + } +} + +function copyResult (result, resultIndex, to, key, as) { + if (Array.isArray(to)) { + for (const line of to) { + copyResult(result, resultIndex, line, key, as) + } + return + } + + const index = resultIndex.get(to[key]) + if (index === undefined) { + // TODO if not nullable set it to an empty object + return + } + if (as) { + if (!to[as]) { + to[as] = {} + } + to = to[as] + } + + // TODO copy object fn? + const fields = Object.keys(result[index]) + for (let i = 0; i < fields.length; i++) { + to[fields[i]] = result[index][fields[i]] + } +} + +function copyResults (result, resultIndex, to, key, as) { + let indexes + + if (Array.isArray(to)) { + for (const line of to) { + copyResults(result, resultIndex, line, key, as) + } + return + } + + // TODO refactor? + if (Array.isArray(to[key])) { + indexes = to[key].map(k => resultIndex.get(k)).flat() + } else { + indexes = resultIndex.get(to[key]) + } + + if (indexes === undefined) { + // TODO get if nullable from node result type + if (as && !to[as]) { + to[as] = [] + } + + return + } + if (as) { + if (!to[as]) { + to[as] = [] + } + to = to[as] + } + + for (let i = 0; i < indexes.length; i++) { + const r = {} + copyObjectByKeys(r, result[indexes[i]]) + to.push(r) + } +} + +module.exports = { + mergeResults +} diff --git a/lib/utils.js b/lib/utils.js index b247c50..9ae2e04 100644 --- a/lib/utils.js +++ b/lib/utils.js @@ -1,5 +1,11 @@ 'use strict' +const pino = require('pino') + +function dummyLogger () { + return pino({ level: 'silent' }) +} + function createDefaultArgsAdapter (entityName, pkey) { return function argsAdapter (partialResults) { return { [pkey + 's']: partialResults.map(r => r[pkey]) } @@ -10,6 +16,13 @@ function isObject (obj) { return obj !== null && typeof obj === 'object' } +function copyObjectByKeys (to, src) { + const keys = Object.keys(src) + for (let i = 0; i < keys.length; i++) { + to[keys[i]] = src[keys[i]] + } +} + // TODO filter same values function toQueryArgs (v, root = true) { if (v === undefined || v === null) { return '' } @@ -44,26 +57,79 @@ function toQueryArgs (v, root = true) { return typeof v === 'string' ? `"${v}"` : v.toString() } -function keySelection (path) { - if (path.indexOf('.') === -1) { return path } +/** + * add to "set" the key portion of path, if any + * @param {string?} path + * @param {Set} set + */ +function keySelection (path, set) { + if (!path) { return } + if (path.indexOf('.') === -1) { set.add(path) } - return path.split('.').pop() + const key = path.split('.').pop() + if (!key) { return } + set.add(key) } /** - * get pkey from fkeys of entities in the subgraph - * TODO update to support composite pkey + * Get pkey from fkeys of entities in the subgraph + * it happens when the entity doesn't have a field to identify the fk, + * but the key is nested in a type. + * Example: + * + * type Book { id: ID, title: String, author: Writer } + * type Writer { id: ID, name: String } + * + * fkeys: [{ pkey: 'author.id', type: 'Writer' }] */ -function transitivePKey (type, subgraphEntities) { +function transitivePKey (typeName, subgraphEntities) { for (const entity of Object.values(subgraphEntities)) { for (const fkey of entity?.fkeys) { - if (fkey.type === type) { + if (fkey.type === typeName) { return fkey.pkey } } } } +/** + * Get fkeys to resolve mamy-2-many relations with a linking entity, + * Example: + * + * type Food { id: ID, name: String } + * type Restaurants { id: ID, name: String } + * type RestaurantsFoods { foodId: ID, restaurantId: ID } + * + * to have + * extend type Restaurants { foods: [Food] } + * + * entities: { Restaurant: { + * ... + * many: [{ + * type: 'Food', as: 'foods', pkey: 'id', + * link: { + * entity: 'RestaurantsFoods', + * pkey: 'foodId', + * fkey: 'restaurantId', + * resolver: { name: 'restaurantsFoods' } + * } + * }] + * } } + * and viceversa for Food.restaurants + * + * TODO memoize + */ +function linkingEntities (typeName, subgraphEntities) { + let many = [] + + // TODO optimize this loop + for (const entity of Object.values(subgraphEntities)) { + many = many.concat(entity?.many.filter(many => many.type === typeName && many.link)) + } + + return many.length > 0 ? many : undefined +} + function traverseResult (result, path) { if (Array.isArray(result)) { result = result.map(r => { @@ -85,4 +151,16 @@ function nodeTypeName (node) { return node.schemaNode.type.name || node.schemaNode.type.ofType.name || node.schemaNode.type.ofType.ofType.name } -module.exports = { createDefaultArgsAdapter, isObject, keySelection, transitivePKey, traverseResult, toQueryArgs, schemaTypeName, nodeTypeName } +module.exports = { + dummyLogger, + createDefaultArgsAdapter, + isObject, + copyObjectByKeys, + keySelection, + transitivePKey, + linkingEntities, + traverseResult, + toQueryArgs, + schemaTypeName, + nodeTypeName +} diff --git a/package.json b/package.json index 090bec6..84f088d 100644 --- a/package.json +++ b/package.json @@ -16,6 +16,7 @@ "graphql": "^16.8.1", "mercurius": "^13.2.2", "metaline": "^1.1.0", + "pino": "^8.16.2", "undici": "^6.0.0" }, "devDependencies": { diff --git a/test/many-to-many.test.js b/test/many-to-many.test.js new file mode 100644 index 0000000..dec4b98 --- /dev/null +++ b/test/many-to-many.test.js @@ -0,0 +1,91 @@ +'use strict' + +const assert = require('node:assert/strict') +const { test } = require('node:test') +const pino = require('pino') +const { graphqlRequest, buildComposer } = require('./helper') + +test('should handle many-to-many relation linked by an intermediary entity', async (t) => { + const requests = [ + { + query: '{ restaurants (where: { id: { in: [90, 91] } }) { name, foods { name } } }', + expected: { restaurants: [{ name: 'Pizzeria Napoletana', foods: [{ name: 'Pizza margherita' }, { name: 'Pizza boscaiola' }, { name: 'Pizza capricciosa' }] }, { name: 'Ristorante Stellato', foods: [{ name: 'Spaghetti carbonara' }, { name: 'Tagliolini scoglio' }, { name: 'Pici cacio e pepe' }] }] } + } + // TODO reverse, nested, nested x n + ] + + const composerOptions = { + defaultArgsAdapter: (partialResults) => { + return { where: { id: { in: partialResults.map(r => r.id) } } } + }, + addEntitiesResolvers: true, + logger: pino({ level: 'debug' }), + entities: { + 'restaurants-subgraph': { + Restaurant: { + resolver: { name: 'restaurants' }, + pkey: 'id', + many: [ + { + type: 'Food', + as: 'foods', + pkey: 'id', + link: { + type: 'RestaurantsFoods', + pkey: 'restaurantId', + fkey: 'foodId', + resolver: { + name: 'restaurantsFoods', + argsAdapter: (restaurantIds) => { + return { where: { restaurantId: { in: restaurantIds } } } + }, + partialResults: (restaurants) => { + return restaurants.map(r => r.id) + } + } + }, + subgraph: 'foods-subgraph', + resolver: { + name: 'foods', + argsAdapter: (foodIds) => { + return { where: { id: { in: foodIds } } } + }, + partialResults: (restaurantFoods) => { + return restaurantFoods.map(r => r.foodId) + } + } + } + ] + } + }, + 'foods-subgraph': { + Food: { + resolver: { name: 'foods' }, + pkey: 'id' + // many: [ + // { + // type: 'Restaurant', + // as: 'restaurants' + // // TODO ... + // } + // ] + } + } + } + } + + const { service } = await buildComposer(t, ['restaurants-subgraph', 'foods-subgraph'], composerOptions) + + await service.listen() + + for (const request of requests) { + const response = await graphqlRequest(service, request.query, request.variables) + + console.log(JSON.stringify(response)) + + assert.deepStrictEqual(response, request.expected, 'should get expected result from composer service,' + + '\nquery: ' + request.query + + '\nexpected' + JSON.stringify(request.expected, null, 2) + + '\nresponse' + JSON.stringify(response, null, 2)) + } +}) From d533b243d1fef6dbe4f16a464735afc2b700f3de Mon Sep 17 00:00:00 2001 From: Simone Sanfratello Date: Thu, 14 Dec 2023 16:45:52 +0100 Subject: [PATCH 2/2] wip --- fixtures/restaurants-subgraph.js | 8 ++-- lib/composer.js | 12 +++--- lib/query-builder.js | 55 ++++++++++++++------------ test/many-to-many.test.js | 66 ++++++++++++++++++++++++-------- 4 files changed, 92 insertions(+), 49 deletions(-) diff --git a/fixtures/restaurants-subgraph.js b/fixtures/restaurants-subgraph.js index 39527b1..1e07f8c 100644 --- a/fixtures/restaurants-subgraph.js +++ b/fixtures/restaurants-subgraph.js @@ -16,7 +16,7 @@ const schema = ` type Restaurant { id: ID! - name: String + businessName: String } type RestaurantsFoods { @@ -75,15 +75,15 @@ function reset () { data.restaurants = { 90: { id: 90, - name: 'Pizzeria Napoletana' + businessName: 'Pizzeria Napoletana' }, 91: { id: 91, - name: 'Ristorante Stellato' + businessName: 'Ristorante Stellato' }, 92: { id: 92, - name: 'Trattoria da Gigi' + businessName: 'Trattoria da Gigi' } } } diff --git a/lib/composer.js b/lib/composer.js index a1cc182..a0744c7 100644 --- a/lib/composer.js +++ b/lib/composer.js @@ -485,13 +485,13 @@ class Composer { const schemaNode = type.fields.find((f) => { return f.name === node.name.value }) - const bareType = unwrapSchemaType(schemaNode.type) - const objType = this.#types.get(bareType.name) + const schemaNodeType = unwrapSchemaType(schemaNode.type) + const schemaNodeTypeName = this.#types.get(schemaNodeType.name) const query = new QueryBuilder({ node, schemaNode, path: [fieldName], - type: objType, + type: schemaNodeTypeName, fields: [], subgraphs: this.#subgraphs, subgraph, @@ -500,7 +500,8 @@ class Composer { info, argsAdapter: null, types: this.#types, - entities: this.#entities + entities: this.#entities, + logger: this.#logger }) await this.#runQuery(ctx, query) return ctx.result[fieldName] @@ -555,7 +556,8 @@ class Composer { info, argsAdapter: null, types: this.#types, - entities: this.#entities + entities: this.#entities, + logger: this.#logger }) const text = query.buildQuery(ctx) topic = await client.createSubscription(text, {}, async (data) => { diff --git a/lib/query-builder.js b/lib/query-builder.js index e1b2f7a..4b82403 100644 --- a/lib/query-builder.js +++ b/lib/query-builder.js @@ -48,13 +48,14 @@ class QueryBuilder { // avoid to pass back and forth path between context and folloups // keep the "result path" synced with "result" since it's needed to merge results and get partial results // then work with a subpart/branch of ctx.result and then for followups + // possible solution: inject a node to the schemaNode if (this.swap) { ctx.path = this.path.slice() } else { ctx.path = this.path.slice(0, -1) } - const selectionSet = this.buildSelectionSet(ctx, this.node, this.schemaNode) + const selectionSet = this.buildSelectionSet(ctx, this.node, this.schemaNode, true) const computedArgs = this.buildArguments(this.node) const query = `${this.operation} { ${this.resolverName}${computedArgs} ${selectionSet} }` @@ -170,7 +171,7 @@ class QueryBuilder { return this.buildNodeArgs(node) } - buildSelectionSet (ctx, node, schemaNode) { + buildSelectionSet (ctx, node, schemaNode, main) { const selections = node.selectionSet?.selections const length = selections?.length ?? 0 @@ -180,8 +181,8 @@ class QueryBuilder { ctx.path.push(node.name.value) - const bareType = unwrapSchemaType(schemaNode.type) - const type = this.types.get(bareType.name) + const schemaNodeType = unwrapSchemaType(schemaNode.type) + const type = this.types.get(schemaNodeType.name) const { fieldMap } = type const selectionFields = new Set() let keyFields @@ -209,13 +210,17 @@ class QueryBuilder { selectionFields.add(value) } } else { - let value = selection.name.value - const field = fieldMap.get(value) + let fieldName = selection.name.value + const field = fieldMap.get(fieldName) const selectionSchemaNode = field?.schemaNode // Some nodes won't have a schema representation. For example, __typename. if (selectionSchemaNode) { - if (!field.subgraphs.has(this.subgraph)) { + console.log({ type: schemaNodeType.name, fieldName, subgraph: field.subgraphs.has(this.subgraph) }, 'buildSelectionSet > selectionSchemaNode') + + // followup if field is not on this subgraph or is resolving a swap entity (fkey or many relation) + if (!field.subgraphs.has(this.subgraph) || + (main && this.swap && schemaNodeType.name !== this.type.schemaNode.name)) { const { index, subgraph, swap } = this.followupIndex(field, ctx.path) let followup = ctx.followups.get(index) @@ -225,7 +230,7 @@ class QueryBuilder { let followupSchema, followupNode // on swap: resolve current entity with its source resolver // on parentKeys.many: m2m relation, querying linking entity - if (swap || parentKeys.many?.link) { + if (swap) { followupSchema = selectionSchemaNode followupNode = selection } else { @@ -234,7 +239,6 @@ class QueryBuilder { } followup = this.createFollowup(ctx, followupSchema, followupNode, this.subgraph, type, field, subgraph, swap, parentKeys.many) - keyFields = collectKeys(keyFields, parentKeys) if (followup) { ctx.followups.set(index, followup) @@ -250,21 +254,21 @@ class QueryBuilder { } if (selection.arguments.length > 0) { - value += this.buildArguments(selection) + fieldName += this.buildArguments(selection) } if (selection.selectionSet) { - value += ` ${this.buildSelectionSet(ctx, selection, selectionSchemaNode)}` + fieldName += ` ${this.buildSelectionSet(ctx, selection, selectionSchemaNode)}` } } - selectionFields.add(value) + selectionFields.add(fieldName) } } ctx.path.pop() - const selectedFields = this.buildSelectionFields(bareType, keyFields, selectionFields) + const selectedFields = this.selectFields(schemaNodeType, keyFields, selectionFields) if (selectedFields.length < 1) { // TODO this is an error on configuration @@ -275,13 +279,14 @@ class QueryBuilder { return `{ ${selectedFields.join(', ')} }` } - buildSelectionFields (type, keyFields, selectionFields) { + selectFields (type, keyFields, selectionFields) { const selectionKeyFields = new Set() // add entity keys to selection, needed to match rows merging results // no followups here if (!keyFields) { const entity = this.subgraph.entities[type.name] if (!entity) { + console.log('aaaaaaaaaaaa') // TODO onError: missing entity definition', typeName, 'in subgraph', this.subgraph.name) } else { keyFields = collectEntityKeys(entity) @@ -289,7 +294,9 @@ class QueryBuilder { } if (keyFields) { - keySelection(keyFields.pkey, selectionKeyFields) + if (!this.swap) { + keySelection(keyFields.pkey, selectionKeyFields) + } for (let i = 0; i < keyFields.fkeys.length; ++i) { if (!keyFields.fkeys[i].field) { continue } @@ -314,8 +321,8 @@ class QueryBuilder { } // TODO improve structure - for (const s of selectionFields.values()) { - selectionKeyFields.add(s) + for (const fieldName of selectionFields.values()) { + selectionKeyFields.add(fieldName) } return Array.from(selectionKeyFields) } @@ -374,6 +381,7 @@ class QueryBuilder { } // TODO refactor this function, too long + // TODO memoize partially createFollowup (ctx, schemaNode, node, parentSubgraph, parentType, field, subgraph, swap, linkingEntitiesMany) { const parentTypeName = parentType.schemaNode.name let fieldTypeName = parentTypeName @@ -384,10 +392,6 @@ class QueryBuilder { fieldTypeName = nodeTypeName(field) } - if (!subgraph || !parentSubgraph) { - console.log('nnnn') - } - // TODO refactor: followupSubgraph can return both subgraph and entity and probably keys // TODO handle error if entity or subgraphs don't exists const parentEntity = parentSubgraph.entities[parentTypeName] @@ -400,12 +404,12 @@ class QueryBuilder { let resolverName = entity.resolver.name let key = entity.pkey + // TODO can a node have more linking entities? const many = linkingEntitiesMany?.[0] // linking entities if (many?.link) { - // TODO can a node have more linking entities? if (this.parentKey?.linking) { - // resolve linked entity + // resolve linked entity - followup of linking parentKey = { field: many.link.fkey, as: many.as, many: false, linked: true } // TODO use a Map on subgraph to avoid this loop subgraph = this.subgraphs.find(s => s.name === many.subgraph) @@ -424,6 +428,7 @@ class QueryBuilder { parentKey, subgraph, subgraphs: this.subgraphs, + logger: this.logger, info: this.info, types: this.types, entities: this.entities, @@ -432,7 +437,7 @@ class QueryBuilder { solved: false } } else { - // resolve linking entity + // resolve linking entity - first followup of many.link option key = many.pkey parentKey = { field: many.link.pkey, as: many.as, many: true, linking: true } // TODO use a Map on subgraph to avoid this loop @@ -452,6 +457,7 @@ class QueryBuilder { parentKey, subgraph, subgraphs: this.subgraphs, + logger: this.logger, info: this.info, types: this.types, entities: this.entities, @@ -506,6 +512,7 @@ class QueryBuilder { parentKey, subgraph, subgraphs: this.subgraphs, + logger: this.logger, info: this.info, types: this.types, entities: this.entities, diff --git a/test/many-to-many.test.js b/test/many-to-many.test.js index dec4b98..771f643 100644 --- a/test/many-to-many.test.js +++ b/test/many-to-many.test.js @@ -6,14 +6,6 @@ const pino = require('pino') const { graphqlRequest, buildComposer } = require('./helper') test('should handle many-to-many relation linked by an intermediary entity', async (t) => { - const requests = [ - { - query: '{ restaurants (where: { id: { in: [90, 91] } }) { name, foods { name } } }', - expected: { restaurants: [{ name: 'Pizzeria Napoletana', foods: [{ name: 'Pizza margherita' }, { name: 'Pizza boscaiola' }, { name: 'Pizza capricciosa' }] }, { name: 'Ristorante Stellato', foods: [{ name: 'Spaghetti carbonara' }, { name: 'Tagliolini scoglio' }, { name: 'Pici cacio e pepe' }] }] } - } - // TODO reverse, nested, nested x n - ] - const composerOptions = { defaultArgsAdapter: (partialResults) => { return { where: { id: { in: partialResults.map(r => r.id) } } } @@ -61,19 +53,61 @@ test('should handle many-to-many relation linked by an intermediary entity', asy 'foods-subgraph': { Food: { resolver: { name: 'foods' }, - pkey: 'id' - // many: [ - // { - // type: 'Restaurant', - // as: 'restaurants' - // // TODO ... - // } - // ] + pkey: 'id', + many: [ + { + type: 'Restaurant', + as: 'restaurants', + pkey: 'id', + link: { + type: 'RestaurantsFoods', + pkey: 'foodId', + fkey: 'restaurantId', + subgraph: 'restaurants-subgraph', + resolver: { + name: 'restaurantsFoods', + argsAdapter: (foodIds) => { + return { where: { foodId: { in: foodIds } } } + }, + partialResults: (foods) => { + return foods.map(r => r.id) + } + } + }, + subgraph: 'restaurants-subgraph', + resolver: { + name: 'restaurants', + argsAdapter: (restaurantIds) => { + return { where: { id: { in: restaurantIds } } } + }, + partialResults: (restaurantFoods) => { + return restaurantFoods.map(r => r.restaurantId) + } + } + } + ] } } } } + const requests = [ + // { + // query: '{ restaurants (where: { id: { in: [90, 91] } }) { businessName, foods { name } } }', + // expected: { + // restaurants: [ + // { businessName: 'Pizzeria Napoletana', foods: [{ name: 'Pizza margherita' }, { name: 'Pizza boscaiola' }, { name: 'Pizza capricciosa' }] }, + // { businessName: 'Ristorante Stellato', foods: [{ name: 'Spaghetti carbonara' }, { name: 'Tagliolini scoglio' }, { name: 'Pici cacio e pepe' }] } + // ] + // } + // }, + { + query: '{ foods (where: { id: { in: [50, 60] } }) { name, restaurants { businessName } } }', + expected: { } + } + // TODO nested, nested x n + ] + const { service } = await buildComposer(t, ['restaurants-subgraph', 'foods-subgraph'], composerOptions) await service.listen()