@omnigraph/json-schema
Version:
This package generates GraphQL Schema from JSON Schema and sample JSON request and responses. You can define your root field endpoints like below in your GraphQL Config for example;
248 lines (247 loc) • 12.5 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.addExecutionDirectivesToComposer = void 0;
const graphql_1 = require("graphql");
const graphql_compose_1 = require("graphql-compose");
const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
const utils_1 = require("@graphql-tools/utils");
const directives_js_1 = require("./directives.js");
const utils_js_1 = require("./utils.js");
const responseMetadataType = new graphql_1.GraphQLObjectType({
name: 'ResponseMetadata',
fields: {
url: { type: graphql_1.GraphQLString },
method: { type: graphql_1.GraphQLString },
status: { type: graphql_1.GraphQLInt },
statusText: { type: graphql_1.GraphQLString },
headers: { type: graphql_compose_1.GraphQLJSON },
body: { type: graphql_compose_1.GraphQLJSON },
},
});
function addExecutionDirectivesToComposer(subgraphName, { schemaComposer, logger, operations, operationHeaders, endpoint, queryParams, queryStringOptions, handlerName, }) {
logger.debug(`Attaching execution directives to the schema`);
for (const operationConfig of operations) {
const { httpMethod, rootTypeName, fieldName } = (0, utils_js_1.getOperationMetadata)(operationConfig);
const rootTypeComposer = schemaComposer[rootTypeName];
const field = rootTypeComposer.getField(fieldName);
if ((0, utils_js_1.isPubSubOperationConfig)(operationConfig)) {
field.description =
operationConfig.description || `PubSub Topic: ${operationConfig.pubsubTopic}`;
field.directives = field.directives || [];
schemaComposer.addDirective(directives_js_1.PubSubOperationDirective);
field.directives.push({
name: 'pubsubOperation',
args: {
subgraph: subgraphName,
pubsubTopic: operationConfig.pubsubTopic,
},
});
}
else if (operationConfig.path) {
if (cross_helpers_1.process.env.DEBUG === '1' || cross_helpers_1.process.env.DEBUG === 'fieldDetails') {
field.description = `
>**Method**: \`${operationConfig.method}\`
>**Base URL**: \`${endpoint}\`
>**Path**: \`${operationConfig.path}\`
${operationConfig.description || ''}
`;
}
else {
field.description = operationConfig.description;
}
field.directives = field.directives || [];
schemaComposer.addDirective(directives_js_1.HTTPOperationDirective);
field.directives.push({
name: 'httpOperation',
args: JSON.parse(JSON.stringify({
subgraph: subgraphName,
path: operationConfig.path,
operationSpecificHeaders: operationConfig.headers,
httpMethod,
isBinary: 'binary' in operationConfig ? operationConfig.binary : undefined,
requestBaseBody: 'requestBaseBody' in operationConfig ? operationConfig.requestBaseBody : undefined,
queryParamArgMap: operationConfig.queryParamArgMap,
queryStringOptionsByParam: operationConfig.queryStringOptionsByParam,
jsonApiFields: operationConfig.jsonApiFields,
})),
});
const handleLinkMap = (linkMap, typeTC) => {
for (const linkName in linkMap) {
typeTC.addFields({
[linkName]: () => {
const linkObj = linkMap[linkName];
field.directives = field.directives || [];
let linkResolverMapDirective = field.directives.find(d => d.name === 'linkResolver');
if (!linkResolverMapDirective) {
schemaComposer.addDirective(directives_js_1.LinkResolverDirective);
linkResolverMapDirective = {
name: 'linkResolver',
args: {
subgraph: subgraphName,
linkResolverMap: {},
},
};
field.directives.push(linkResolverMapDirective);
}
const linkResolverFieldMap = linkResolverMapDirective.args.linkResolverMap;
let targetField;
let fieldTypeName;
try {
targetField = schemaComposer.Query.getField(linkObj.fieldName);
fieldTypeName = 'Query';
}
catch {
try {
targetField = schemaComposer.Mutation.getField(linkObj.fieldName);
fieldTypeName = 'Mutation';
}
catch { }
}
if (!targetField) {
logger.debug(`Field ${linkObj.fieldName} not found in ${subgraphName} for link ${linkName}`);
}
linkResolverFieldMap[linkName] = {
linkObjArgs: linkObj.args,
targetTypeName: fieldTypeName,
targetFieldName: linkObj.fieldName,
};
schemaComposer.addDirective(directives_js_1.LinkDirective);
return {
...targetField,
directives: [
{
name: 'link',
args: {
subgraph: subgraphName,
defaultRootType: rootTypeName,
defaultField: operationConfig.field,
},
},
],
args: linkObj.args ? {} : targetField.args,
description: linkObj.description || targetField.description,
};
},
});
}
};
if ('links' in operationConfig) {
const typeTC = schemaComposer.getOTC(field.type.getTypeName());
handleLinkMap(operationConfig.links, typeTC);
}
if ('exposeResponseMetadata' in operationConfig && operationConfig.exposeResponseMetadata) {
const typeTC = schemaComposer.getOTC(field.type.getTypeName());
schemaComposer.addDirective(directives_js_1.ResponseMetadataDirective);
typeTC.addFields({
_response: {
type: responseMetadataType,
directives: [
{
name: 'responseMetadata',
args: {
subgraph: subgraphName,
},
},
],
},
});
}
if ('responseByStatusCode' in operationConfig) {
const unionOrSingleTC = schemaComposer.getAnyTC((0, graphql_1.getNamedType)(field.type.getType()));
const types = 'getTypes' in unionOrSingleTC ? unionOrSingleTC.getTypes() : [unionOrSingleTC];
const statusCodeOneOfIndexMap = {};
const directives = unionOrSingleTC.getDirectives();
for (const directive of directives) {
if (directive.name === 'statusCodeOneOfIndex') {
statusCodeOneOfIndexMap[directive.args?.statusCode] = directive.args
?.oneOfIndex;
}
}
for (const statusCode in operationConfig.responseByStatusCode) {
const responseConfig = operationConfig.responseByStatusCode[statusCode];
if (responseConfig.links || responseConfig.exposeResponseMetadata) {
const typeTCThunked = types[statusCodeOneOfIndexMap[statusCode] || 0];
const originalName = typeTCThunked.getTypeName();
let typeTC = schemaComposer.getAnyTC(originalName);
if (!('addFieldArgs' in typeTC)) {
schemaComposer.addDirective(directives_js_1.ResolveRootDirective);
typeTC = schemaComposer.createObjectTC({
name: `${operationConfig.field}_${statusCode}_response`,
fields: {
[originalName]: {
type: typeTC,
directives: [
{
name: 'resolveRoot',
args: {
subgraph: subgraphName,
},
},
],
},
},
});
// If it is a scalar or enum type, it cannot be a union type, so we can set it directly
types[0] = typeTC;
field.type = typeTC;
}
if (responseConfig.exposeResponseMetadata) {
schemaComposer.addDirective(directives_js_1.ResponseMetadataDirective);
typeTC.addFields({
_response: {
type: responseMetadataType,
directives: [
{
name: 'responseMetadata',
args: {
subgraph: subgraphName,
},
},
],
},
});
}
if (responseConfig.links) {
handleLinkMap(responseConfig.links, typeTC);
}
}
}
}
}
}
logger.debug(`Building the executable schema.`);
if (schemaComposer.Query.getFieldNames().length === 0) {
schemaComposer.Query.addFields({
dummy: {
type: 'String',
resolve: () => 'dummy',
},
});
}
schemaComposer.addDirective(directives_js_1.TransportDirective);
let schema = schemaComposer.buildSchema();
const schemaExtensions = (schema.extensions = schema.extensions || {});
schemaExtensions.directives = schemaExtensions.directives || {};
schemaExtensions.directives.transport = {
subgraph: subgraphName,
kind: handlerName,
location: endpoint,
headers: operationHeaders,
queryParams,
queryStringOptions,
};
// Fix orphaned interfaces
schema = (0, utils_1.mapSchema)(schema, {
[utils_1.MapperKind.TYPE]: type => {
if ((0, graphql_1.isInterfaceType)(type)) {
const { objects, interfaces } = schema.getImplementations(type);
if (objects.length === 0 && interfaces.length === 0) {
return new graphql_1.GraphQLObjectType(type.toConfig());
}
}
return type;
},
});
return schema;
}
exports.addExecutionDirectivesToComposer = addExecutionDirectivesToComposer;