@graphql-mesh/fusion-composition 0.7.7 → 0.7.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/cjs/transforms/rename.js +114 -73
  2. package/esm/transforms/rename.js +114 -73
  3. package/package.json +1 -1
package/cjs/transforms/rename.js CHANGED
@@ -116,100 +116,141 @@ function createRenameTransform(opts) {
116
116
  };
117
117
  }
118
118
  const fieldRenameMap = new Map();
119
- if (fieldRenamers.length || argRenamers.length) {
120
- schemaMapper[utils_1.MapperKind.FIELD] = (field, fieldName, typeName, schema) => {
121
- let newFieldName = fieldName;
122
- if (fieldRenamers.length) {
123
- const type = schema.getType(typeName);
124
- for (const renamer of fieldRenamers) {
125
- newFieldName =
119
+ schemaMapper[utils_1.MapperKind.FIELD] = (field, fieldName, typeName, schema) => {
120
+ let newFieldName = fieldName;
121
+ if (fieldRenamers.length) {
122
+ const type = schema.getType(typeName);
123
+ for (const renamer of fieldRenamers) {
124
+ newFieldName =
125
+ renamer({
126
+ typeName,
127
+ fieldName: newFieldName,
128
+ type,
129
+ field,
130
+ subgraphConfig,
131
+ }) || newFieldName;
132
+ }
133
+ let typeFieldRenameMap = fieldRenameMap.get(typeName);
134
+ if (!typeFieldRenameMap) {
135
+ typeFieldRenameMap = new Map();
136
+ fieldRenameMap.set(typeName, typeFieldRenameMap);
137
+ }
138
+ typeFieldRenameMap.set(fieldName, newFieldName);
139
+ }
140
+ const fieldDirectives = (0, utils_1.getDirectiveExtensions)(field, schema);
141
+ if (fieldDirectives.resolveTo) {
142
+ fieldDirectives.resolveTo = fieldDirectives.resolveTo.map(resolveTo => ({
143
+ ...resolveTo,
144
+ sourceTypeName: (resolveTo.sourceTypeName && typeRenameMap.get(resolveTo.sourceTypeName)) ||
145
+ resolveTo.sourceTypeName,
146
+ sourceFieldName: (resolveTo.sourceFieldName &&
147
+ fieldRenameMap.get(resolveTo.sourceTypeName)?.get(resolveTo.sourceFieldName)) ||
148
+ resolveTo.sourceFieldName,
149
+ }));
150
+ const fieldExtensions = (field.extensions ||= {});
151
+ fieldExtensions.directives = fieldDirectives;
152
+ }
153
+ if (argRenamers.length && 'args' in field && field.args) {
154
+ const newArgs = {};
155
+ for (const argName in field.args) {
156
+ let newArgName = argName;
157
+ for (const renamer of argRenamers) {
158
+ newArgName =
126
159
  renamer({
127
160
  typeName,
128
- fieldName: newFieldName,
129
- type,
130
- field,
161
+ fieldName,
162
+ argName: newArgName,
131
163
  subgraphConfig,
132
- }) || newFieldName;
164
+ }) || newArgName;
133
165
  }
134
- let typeFieldRenameMap = fieldRenameMap.get(typeName);
135
- if (!typeFieldRenameMap) {
136
- typeFieldRenameMap = new Map();
137
- fieldRenameMap.set(typeName, typeFieldRenameMap);
138
- }
139
- typeFieldRenameMap.set(fieldName, newFieldName);
166
+ newArgs[newArgName] = field.args[argName];
140
167
  }
141
- if (argRenamers.length && 'args' in field && field.args) {
142
- const newArgs = {};
143
- for (const argName in field.args) {
144
- let newArgName = argName;
145
- for (const renamer of argRenamers) {
146
- newArgName =
147
- renamer({
148
- typeName,
149
- fieldName,
150
- argName: newArgName,
151
- subgraphConfig,
152
- }) || newArgName;
153
- }
154
- newArgs[newArgName] = field.args[argName];
155
- }
156
- return [
157
- newFieldName,
158
- {
159
- ...field,
160
- args: newArgs,
161
- },
162
- ];
163
- }
164
- const fieldDirectives = (0, utils_1.getDirectiveExtensions)(field, schema);
165
- if (fieldDirectives.resolveTo) {
166
- fieldDirectives.resolveTo = fieldDirectives.resolveTo.map(resolveTo => ({
167
- ...resolveTo,
168
- sourceTypeName: (resolveTo.sourceTypeName && typeRenameMap.get(resolveTo.sourceTypeName)) ||
169
- resolveTo.sourceTypeName,
170
- sourceFieldName: (resolveTo.sourceFieldName &&
171
- fieldRenameMap.get(resolveTo.sourceTypeName)?.get(resolveTo.sourceFieldName)) ||
172
- resolveTo.sourceFieldName,
173
- }));
174
- const fieldExtensions = (field.extensions ||= {});
175
- fieldExtensions.directives = fieldDirectives;
176
- }
177
- return [newFieldName, field];
178
- };
179
- }
168
+ return [
169
+ newFieldName,
170
+ {
171
+ ...field,
172
+ args: newArgs,
173
+ },
174
+ ];
175
+ }
176
+ return [newFieldName, field];
177
+ };
180
178
  return (0, utils_1.mapSchema)(schema, schemaMapper);
181
179
  };
182
180
  }
183
181
  function createRenameTypeTransform(renameFn, kind = utils_1.MapperKind.TYPE) {
184
182
  return function renameTypeTransform(schema, subgraphConfig) {
185
183
  const rootTypes = (0, utils_1.getRootTypes)(schema);
184
+ const renamedTypeMap = new Map();
186
185
  return (0, utils_1.mapSchema)(schema, {
187
- [kind]: (type) => (0, graphql_1.isSpecifiedScalarType)(type) || rootTypes.has(type)
188
- ? type
189
- : new (Object.getPrototypeOf(type).constructor)({
186
+ [kind]: type => {
187
+ if ((0, graphql_1.isSpecifiedScalarType)(type) || rootTypes.has(type)) {
188
+ return type;
189
+ }
190
+ const newName = renameFn({
191
+ typeName: type.name,
192
+ type,
193
+ subgraphConfig,
194
+ }) || type.name;
195
+ if (type.name === newName) {
196
+ return type;
197
+ }
198
+ renamedTypeMap.set(type.name, newName);
199
+ return new (Object.getPrototypeOf(type).constructor)({
190
200
  ...type.toConfig(),
191
- name: renameFn({
192
- typeName: type.name,
193
- type,
194
- subgraphConfig,
195
- }) || type.name,
196
- }),
201
+ name: newName,
202
+ });
203
+ },
204
+ [utils_1.MapperKind.FIELD](field) {
205
+ const fieldDirectives = (0, utils_1.getDirectiveExtensions)(field, schema);
206
+ if (fieldDirectives?.resolveTo) {
207
+ fieldDirectives.resolveTo = fieldDirectives.resolveTo.map(resolveTo => ({
208
+ ...resolveTo,
209
+ sourceTypeName: renamedTypeMap.get(resolveTo.sourceTypeName) || resolveTo.sourceTypeName,
210
+ }));
211
+ }
212
+ const fieldExtensions = (field.extensions ||= {});
213
+ fieldExtensions.directives = fieldDirectives;
214
+ return field;
215
+ },
197
216
  });
198
217
  };
199
218
  }
200
219
  function createRenameFieldTransform(renameFn, kind = utils_1.MapperKind.FIELD) {
201
220
  return function renameFieldTransform(schema, subgraphConfig) {
202
- return (0, utils_1.mapSchema)(schema, {
203
- [kind]: (field, fieldName, typeName) => [
204
- renameFn({
221
+ const fieldRenameMap = new Map();
222
+ const mapper = {
223
+ [kind]: (field, fieldName, typeName) => {
224
+ const type = schema.getType(typeName);
225
+ const newFieldName = renameFn({
205
226
  typeName,
206
227
  fieldName,
207
- type: schema.getType(typeName),
228
+ type,
208
229
  field,
209
230
  subgraphConfig,
210
- }) || fieldName,
211
- field,
212
- ],
213
- });
231
+ }) || fieldName;
232
+ let typeFieldRenameMap = fieldRenameMap.get(typeName);
233
+ if (!typeFieldRenameMap) {
234
+ typeFieldRenameMap = new Map();
235
+ fieldRenameMap.set(typeName, typeFieldRenameMap);
236
+ }
237
+ typeFieldRenameMap.set(fieldName, newFieldName);
238
+ return [newFieldName, resolveToUpdater(field, schema)];
239
+ },
240
+ };
241
+ function resolveToUpdater(field, schema) {
242
+ const fieldDirectives = (0, utils_1.getDirectiveExtensions)(field, schema);
243
+ if (fieldDirectives?.resolveTo) {
244
+ fieldDirectives.resolveTo = fieldDirectives.resolveTo.map(resolveTo => ({
245
+ ...resolveTo,
246
+ sourceFieldName: fieldRenameMap.get(resolveTo.sourceTypeName)?.get(resolveTo.sourceFieldName) ||
247
+ resolveTo.sourceFieldName,
248
+ }));
249
+ }
250
+ const fieldExtensions = (field.extensions ||= {});
251
+ fieldExtensions.directives = fieldDirectives;
252
+ return field;
253
+ }
254
+ return (0, utils_1.mapSchema)(schema, mapper);
214
255
  };
215
256
  }
package/esm/transforms/rename.js CHANGED
@@ -110,100 +110,141 @@ export function createRenameTransform(opts) {
110
110
  };
111
111
  }
112
112
  const fieldRenameMap = new Map();
113
- if (fieldRenamers.length || argRenamers.length) {
114
- schemaMapper[MapperKind.FIELD] = (field, fieldName, typeName, schema) => {
115
- let newFieldName = fieldName;
116
- if (fieldRenamers.length) {
117
- const type = schema.getType(typeName);
118
- for (const renamer of fieldRenamers) {
119
- newFieldName =
113
+ schemaMapper[MapperKind.FIELD] = (field, fieldName, typeName, schema) => {
114
+ let newFieldName = fieldName;
115
+ if (fieldRenamers.length) {
116
+ const type = schema.getType(typeName);
117
+ for (const renamer of fieldRenamers) {
118
+ newFieldName =
119
+ renamer({
120
+ typeName,
121
+ fieldName: newFieldName,
122
+ type,
123
+ field,
124
+ subgraphConfig,
125
+ }) || newFieldName;
126
+ }
127
+ let typeFieldRenameMap = fieldRenameMap.get(typeName);
128
+ if (!typeFieldRenameMap) {
129
+ typeFieldRenameMap = new Map();
130
+ fieldRenameMap.set(typeName, typeFieldRenameMap);
131
+ }
132
+ typeFieldRenameMap.set(fieldName, newFieldName);
133
+ }
134
+ const fieldDirectives = getDirectiveExtensions(field, schema);
135
+ if (fieldDirectives.resolveTo) {
136
+ fieldDirectives.resolveTo = fieldDirectives.resolveTo.map(resolveTo => ({
137
+ ...resolveTo,
138
+ sourceTypeName: (resolveTo.sourceTypeName && typeRenameMap.get(resolveTo.sourceTypeName)) ||
139
+ resolveTo.sourceTypeName,
140
+ sourceFieldName: (resolveTo.sourceFieldName &&
141
+ fieldRenameMap.get(resolveTo.sourceTypeName)?.get(resolveTo.sourceFieldName)) ||
142
+ resolveTo.sourceFieldName,
143
+ }));
144
+ const fieldExtensions = (field.extensions ||= {});
145
+ fieldExtensions.directives = fieldDirectives;
146
+ }
147
+ if (argRenamers.length && 'args' in field && field.args) {
148
+ const newArgs = {};
149
+ for (const argName in field.args) {
150
+ let newArgName = argName;
151
+ for (const renamer of argRenamers) {
152
+ newArgName =
120
153
  renamer({
121
154
  typeName,
122
- fieldName: newFieldName,
123
- type,
124
- field,
155
+ fieldName,
156
+ argName: newArgName,
125
157
  subgraphConfig,
126
- }) || newFieldName;
158
+ }) || newArgName;
127
159
  }
128
- let typeFieldRenameMap = fieldRenameMap.get(typeName);
129
- if (!typeFieldRenameMap) {
130
- typeFieldRenameMap = new Map();
131
- fieldRenameMap.set(typeName, typeFieldRenameMap);
132
- }
133
- typeFieldRenameMap.set(fieldName, newFieldName);
160
+ newArgs[newArgName] = field.args[argName];
134
161
  }
135
- if (argRenamers.length && 'args' in field && field.args) {
136
- const newArgs = {};
137
- for (const argName in field.args) {
138
- let newArgName = argName;
139
- for (const renamer of argRenamers) {
140
- newArgName =
141
- renamer({
142
- typeName,
143
- fieldName,
144
- argName: newArgName,
145
- subgraphConfig,
146
- }) || newArgName;
147
- }
148
- newArgs[newArgName] = field.args[argName];
149
- }
150
- return [
151
- newFieldName,
152
- {
153
- ...field,
154
- args: newArgs,
155
- },
156
- ];
157
- }
158
- const fieldDirectives = getDirectiveExtensions(field, schema);
159
- if (fieldDirectives.resolveTo) {
160
- fieldDirectives.resolveTo = fieldDirectives.resolveTo.map(resolveTo => ({
161
- ...resolveTo,
162
- sourceTypeName: (resolveTo.sourceTypeName && typeRenameMap.get(resolveTo.sourceTypeName)) ||
163
- resolveTo.sourceTypeName,
164
- sourceFieldName: (resolveTo.sourceFieldName &&
165
- fieldRenameMap.get(resolveTo.sourceTypeName)?.get(resolveTo.sourceFieldName)) ||
166
- resolveTo.sourceFieldName,
167
- }));
168
- const fieldExtensions = (field.extensions ||= {});
169
- fieldExtensions.directives = fieldDirectives;
170
- }
171
- return [newFieldName, field];
172
- };
173
- }
162
+ return [
163
+ newFieldName,
164
+ {
165
+ ...field,
166
+ args: newArgs,
167
+ },
168
+ ];
169
+ }
170
+ return [newFieldName, field];
171
+ };
174
172
  return mapSchema(schema, schemaMapper);
175
173
  };
176
174
  }
177
175
  export function createRenameTypeTransform(renameFn, kind = MapperKind.TYPE) {
178
176
  return function renameTypeTransform(schema, subgraphConfig) {
179
177
  const rootTypes = getRootTypes(schema);
178
+ const renamedTypeMap = new Map();
180
179
  return mapSchema(schema, {
181
- [kind]: (type) => isSpecifiedScalarType(type) || rootTypes.has(type)
182
- ? type
183
- : new (Object.getPrototypeOf(type).constructor)({
180
+ [kind]: type => {
181
+ if (isSpecifiedScalarType(type) || rootTypes.has(type)) {
182
+ return type;
183
+ }
184
+ const newName = renameFn({
185
+ typeName: type.name,
186
+ type,
187
+ subgraphConfig,
188
+ }) || type.name;
189
+ if (type.name === newName) {
190
+ return type;
191
+ }
192
+ renamedTypeMap.set(type.name, newName);
193
+ return new (Object.getPrototypeOf(type).constructor)({
184
194
  ...type.toConfig(),
185
- name: renameFn({
186
- typeName: type.name,
187
- type,
188
- subgraphConfig,
189
- }) || type.name,
190
- }),
195
+ name: newName,
196
+ });
197
+ },
198
+ [MapperKind.FIELD](field) {
199
+ const fieldDirectives = getDirectiveExtensions(field, schema);
200
+ if (fieldDirectives?.resolveTo) {
201
+ fieldDirectives.resolveTo = fieldDirectives.resolveTo.map(resolveTo => ({
202
+ ...resolveTo,
203
+ sourceTypeName: renamedTypeMap.get(resolveTo.sourceTypeName) || resolveTo.sourceTypeName,
204
+ }));
205
+ }
206
+ const fieldExtensions = (field.extensions ||= {});
207
+ fieldExtensions.directives = fieldDirectives;
208
+ return field;
209
+ },
191
210
  });
192
211
  };
193
212
  }
194
213
  export function createRenameFieldTransform(renameFn, kind = MapperKind.FIELD) {
195
214
  return function renameFieldTransform(schema, subgraphConfig) {
196
- return mapSchema(schema, {
197
- [kind]: (field, fieldName, typeName) => [
198
- renameFn({
215
+ const fieldRenameMap = new Map();
216
+ const mapper = {
217
+ [kind]: (field, fieldName, typeName) => {
218
+ const type = schema.getType(typeName);
219
+ const newFieldName = renameFn({
199
220
  typeName,
200
221
  fieldName,
201
- type: schema.getType(typeName),
222
+ type,
202
223
  field,
203
224
  subgraphConfig,
204
- }) || fieldName,
205
- field,
206
- ],
207
- });
225
+ }) || fieldName;
226
+ let typeFieldRenameMap = fieldRenameMap.get(typeName);
227
+ if (!typeFieldRenameMap) {
228
+ typeFieldRenameMap = new Map();
229
+ fieldRenameMap.set(typeName, typeFieldRenameMap);
230
+ }
231
+ typeFieldRenameMap.set(fieldName, newFieldName);
232
+ return [newFieldName, resolveToUpdater(field, schema)];
233
+ },
234
+ };
235
+ function resolveToUpdater(field, schema) {
236
+ const fieldDirectives = getDirectiveExtensions(field, schema);
237
+ if (fieldDirectives?.resolveTo) {
238
+ fieldDirectives.resolveTo = fieldDirectives.resolveTo.map(resolveTo => ({
239
+ ...resolveTo,
240
+ sourceFieldName: fieldRenameMap.get(resolveTo.sourceTypeName)?.get(resolveTo.sourceFieldName) ||
241
+ resolveTo.sourceFieldName,
242
+ }));
243
+ }
244
+ const fieldExtensions = (field.extensions ||= {});
245
+ fieldExtensions.directives = fieldDirectives;
246
+ return field;
247
+ }
248
+ return mapSchema(schema, mapper);
208
249
  };
209
250
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@graphql-mesh/fusion-composition",
3
- "version": "0.7.7",
3
+ "version": "0.7.8",
4
4
  "description": "Basic composition utility for Fusion spec",
5
5
  "sideEffects": false,
6
6
  "peerDependencies": {