@graphql-mesh/serve-runtime
Version:
778 lines (776 loc) • 35.9 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.createGatewayRuntime = createGatewayRuntime;
const tslib_1 = require("tslib");
const graphql_1 = require("graphql");
const graphql_yoga_1 = require("graphql-yoga");
const disable_introspection_1 = require("@envelop/disable-introspection");
const generic_auth_1 = require("@envelop/generic-auth");
const core_1 = require("@graphql-hive/core");
const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
const fusion_runtime_1 = require("@graphql-mesh/fusion-runtime");
const hmac_upstream_signature_1 = require("@graphql-mesh/hmac-upstream-signature");
const plugin_hive_1 = tslib_1.__importDefault(require("@graphql-mesh/plugin-hive"));
const plugin_response_cache_1 = tslib_1.__importDefault(require("@graphql-mesh/plugin-response-cache"));
const utils_1 = require("@graphql-mesh/utils");
const batch_delegate_1 = require("@graphql-tools/batch-delegate");
const delegate_1 = require("@graphql-tools/delegate");
const federation_1 = require("@graphql-tools/federation");
const utils_2 = require("@graphql-tools/utils");
const wrap_1 = require("@graphql-tools/wrap");
const plugin_csrf_prevention_1 = require("@graphql-yoga/plugin-csrf-prevention");
const plugin_defer_stream_1 = require("@graphql-yoga/plugin-defer-stream");
const plugin_persisted_operations_1 = require("@graphql-yoga/plugin-persisted-operations");
const disposablestack_1 = require("@whatwg-node/disposablestack");
const getProxyExecutor_js_1 = require("./getProxyExecutor.js");
const getReportingPlugin_js_1 = require("./getReportingPlugin.js");
const handleUnifiedGraphConfig_js_1 = require("./handleUnifiedGraphConfig.js");
const landing_page_html_js_1 = tslib_1.__importDefault(require("./landing-page-html.js"));
const useChangingSchema_js_1 = require("./plugins/useChangingSchema.js");
const useCompleteSubscriptionsOnDispose_js_1 = require("./plugins/useCompleteSubscriptionsOnDispose.js");
const useCompleteSubscriptionsOnSchemaChange_js_1 = require("./plugins/useCompleteSubscriptionsOnSchemaChange.js");
const useContentEncoding_js_1 = require("./plugins/useContentEncoding.js");
const useCustomAgent_js_1 = require("./plugins/useCustomAgent.js");
const useFetchDebug_js_1 = require("./plugins/useFetchDebug.js");
const usePropagateHeaders_js_1 = require("./plugins/usePropagateHeaders.js");
const useRequestId_js_1 = require("./plugins/useRequestId.js");
const useSubgraphExecuteDebug_js_1 = require("./plugins/useSubgraphExecuteDebug.js");
const useUpstreamCancel_js_1 = require("./plugins/useUpstreamCancel.js");
const useWebhooks_js_1 = require("./plugins/useWebhooks.js");
const productLogo_js_1 = require("./productLogo.js");
const utils_js_1 = require("./utils.js");
function createGatewayRuntime(config) {
let fetchAPI = config.fetchAPI;
let logger;
if (config.logging == null) {
logger = new utils_1.DefaultLogger();
}
else if (typeof config.logging === 'boolean') {
logger = config.logging ? new utils_1.DefaultLogger() : new utils_1.DefaultLogger('', utils_1.LogLevel.silent);
}
if (typeof config.logging === 'number') {
logger = new utils_1.DefaultLogger(undefined, config.logging);
}
else if (typeof config.logging === 'object') {
logger = config.logging;
}
const onFetchHooks = [];
const wrappedFetchFn = (0, utils_1.wrapFetchWithHooks)(onFetchHooks);
const configContext = {
fetch: wrappedFetchFn,
logger,
cwd: 'cwd' in config ? config.cwd : cross_helpers_1.process.cwd?.(),
cache: 'cache' in config ? config.cache : undefined,
pubsub: 'pubsub' in config ? config.pubsub : undefined,
};
let unifiedGraphPlugin;
const readinessCheckEndpoint = config.readinessCheckEndpoint || '/readiness';
const onSubgraphExecuteHooks = [];
// TODO: Will be deleted after v0
const onDelegateHooks = [];
let unifiedGraph;
let schemaInvalidator;
let getSchema = () => unifiedGraph;
let setSchema = schema => {
unifiedGraph = schema;
};
let contextBuilder;
let readinessChecker;
const { name: reportingTarget, plugin: registryPlugin } = (0, getReportingPlugin_js_1.getReportingPlugin)(config, configContext);
let persistedDocumentsPlugin = {};
if (config.reporting?.type !== 'hive' &&
config.persistedDocuments &&
'type' in config.persistedDocuments &&
config.persistedDocuments?.type === 'hive') {
persistedDocumentsPlugin = (0, plugin_hive_1.default)({
...configContext,
logger: configContext.logger.child('Hive'),
experimental__persistedDocuments: {
cdn: {
endpoint: config.persistedDocuments.endpoint,
accessToken: config.persistedDocuments.token,
},
allowArbitraryDocuments: config.persistedDocuments.allowArbitraryDocuments,
},
});
}
else if (config.persistedDocuments && 'getPersistedOperation' in config.persistedDocuments) {
persistedDocumentsPlugin = (0, plugin_persisted_operations_1.usePersistedOperations)({
...configContext,
...config.persistedDocuments,
});
}
let subgraphInformationHTMLRenderer = () => '';
const disposableStack = new disposablestack_1.AsyncDisposableStack();
if ('proxy' in config) {
const proxyExecutor = (0, getProxyExecutor_js_1.getProxyExecutor)({
config,
configContext,
getSchema() {
return unifiedGraph;
},
onSubgraphExecuteHooks,
disposableStack,
});
function createExecuteFnFromExecutor(executor) {
return function executeFn(args) {
return executor({
document: args.document,
variables: args.variableValues,
operationName: args.operationName,
rootValue: args.rootValue,
context: args.contextValue,
});
};
}
const executeFn = createExecuteFnFromExecutor(proxyExecutor);
let currentTimeout;
const pollingInterval = config.pollingInterval;
function continuePolling() {
if (currentTimeout) {
clearTimeout(currentTimeout);
}
if (pollingInterval) {
currentTimeout = setTimeout(schemaFetcher, pollingInterval);
}
}
function pausePolling() {
if (currentTimeout) {
clearTimeout(currentTimeout);
}
}
let lastFetchedSdl;
let initialFetch$;
let schemaFetcher;
if (config.schema && typeof config.schema === 'object' && 'type' in config.schema) {
// hive cdn
const { endpoint, key } = config.schema;
const fetcher = (0, core_1.createSchemaFetcher)({
endpoint,
key,
logger: configContext.logger.child('Hive CDN'),
});
schemaFetcher = function fetchSchemaFromCDN() {
pausePolling();
initialFetch$ = (0, utils_1.mapMaybePromise)(fetcher(), ({ sdl }) => {
if (lastFetchedSdl == null || lastFetchedSdl !== sdl) {
unifiedGraph = (0, graphql_1.buildSchema)(sdl, {
assumeValid: true,
assumeValidSDL: true,
});
setSchema(unifiedGraph);
}
continuePolling();
return true;
});
return initialFetch$;
};
}
else if (config.schema) {
// local or remote
if (!isDynamicUnifiedGraphSchema(config.schema)) {
// no polling for static schemas
delete config.pollingInterval;
}
schemaFetcher = function fetchSchema() {
pausePolling();
initialFetch$ = (0, utils_1.mapMaybePromise)((0, handleUnifiedGraphConfig_js_1.handleUnifiedGraphConfig)(
// @ts-expect-error TODO: what's up with type narrowing
config.schema, configContext), schema => {
setSchema(schema);
continuePolling();
return true;
});
return initialFetch$;
};
}
else {
// introspect endpoint
schemaFetcher = function fetchSchemaWithExecutor() {
pausePolling();
return (0, utils_1.mapMaybePromise)((0, wrap_1.schemaFromExecutor)(proxyExecutor, configContext, {
assumeValid: true,
}), schema => {
unifiedGraph = schema;
setSchema(schema);
continuePolling();
return true;
}, err => {
configContext.logger.warn(`Failed to introspect schema`, err);
return true;
});
};
}
getSchema = () => {
if (unifiedGraph != null) {
return unifiedGraph;
}
if (initialFetch$ != null) {
return (0, utils_1.mapMaybePromise)(initialFetch$, () => unifiedGraph);
}
if (!initialFetch$) {
return (0, utils_1.mapMaybePromise)(schemaFetcher(), () => unifiedGraph);
}
};
disposableStack.defer(pausePolling);
const shouldSkipValidation = 'skipValidation' in config ? config.skipValidation : false;
const executorPlugin = {
onExecute({ setExecuteFn }) {
setExecuteFn(executeFn);
},
onSubscribe({ setSubscribeFn }) {
setSubscribeFn(executeFn);
},
onValidate({ params, setResult }) {
if (shouldSkipValidation || !params.schema) {
setResult([]);
}
},
};
unifiedGraphPlugin = executorPlugin;
readinessChecker = () => {
const res$ = proxyExecutor({
document: (0, graphql_1.parse)(`query ReadinessCheck { __typename }`),
});
return (0, utils_1.mapMaybePromise)(res$, res => !(0, graphql_yoga_1.isAsyncIterable)(res) && !!res.data?.__typename);
};
schemaInvalidator = () => {
unifiedGraph = undefined;
initialFetch$ = schemaFetcher();
};
subgraphInformationHTMLRenderer = () => {
const endpoint = config.proxy.endpoint;
const htmlParts = [];
htmlParts.push(`<section class="supergraph-information">`);
htmlParts.push(`<h3>Proxy: <a href="${endpoint}">${endpoint}</a></h3>`);
if (config.schema) {
if (typeof config.schema === 'object' && 'type' in config.schema) {
htmlParts.push(`<p><strong>Source: </strong> <i>${config.schema.type === 'hive' ? 'Hive' : 'Unknown'} CDN</i></p>`);
}
else if ((0, utils_2.isValidPath)(config.schema) || (0, utils_1.isUrl)(String(config.schema))) {
htmlParts.push(`<p><strong>Source: </strong> <i>${config.schema}</i></p>`);
}
else {
htmlParts.push(`<p><strong>Source: </strong> <i>GraphQL schema in config</i></p>`);
}
}
if (reportingTarget) {
htmlParts.push(`<p><strong>Usage Reporting: </strong> <i>${reportingTarget}</i></p>`);
}
htmlParts.push(`</section>`);
return htmlParts.join('');
};
}
else if ('subgraph' in config) {
const subgraphInConfig = config.subgraph;
let getSubschemaConfig$;
let subschemaConfig;
function getSubschemaConfig() {
if (getSubschemaConfig$) {
return getSubschemaConfig$;
}
return (0, utils_1.mapMaybePromise)((0, handleUnifiedGraphConfig_js_1.handleUnifiedGraphConfig)(subgraphInConfig, configContext), newUnifiedGraph => {
unifiedGraph = newUnifiedGraph;
unifiedGraph = (0, fusion_runtime_1.restoreExtraDirectives)(unifiedGraph);
subschemaConfig = {
name: (0, utils_2.getDirectiveExtensions)(unifiedGraph)?.transport?.[0]?.subgraph,
schema: unifiedGraph,
};
const transportEntryMap = {};
const additionalTypeDefs = [];
const additionalResolvers = [];
const stitchingDirectivesTransformer = (0, fusion_runtime_1.getStitchingDirectivesTransformerForSubschema)();
const onSubgraphExecute = (0, fusion_runtime_1.getOnSubgraphExecute)({
onSubgraphExecuteHooks,
transports: config.transports,
transportContext: configContext,
transportEntryMap,
getSubgraphSchema() {
return unifiedGraph;
},
transportExecutorStack: disposableStack,
});
subschemaConfig = (0, fusion_runtime_1.handleFederationSubschema)({
subschemaConfig,
transportEntryMap,
additionalTypeDefs,
stitchingDirectivesTransformer,
onSubgraphExecute,
});
// TODO: Find better alternative later
unifiedGraph = (0, wrap_1.wrapSchema)(subschemaConfig);
unifiedGraph = (0, graphql_yoga_1.mergeSchemas)({
assumeValid: true,
assumeValidSDL: true,
schemas: [unifiedGraph],
typeDefs: [
(0, graphql_1.parse)(/* GraphQL */ `
type Query {
_entities(representations: [_Any!]!): [_Entity]!
_service: _Service!
}
scalar _Any
union _Entity = ${Object.keys(subschemaConfig.merge || {}).join(' | ')}
type _Service {
sdl: String
}
`),
],
resolvers: {
Query: {
_entities(_root, args, context, info) {
if (Array.isArray(args.representations)) {
return args.representations.map(representation => {
const typeName = representation.__typename;
const mergeConfig = subschemaConfig.merge[typeName];
const entryPoints = mergeConfig?.entryPoints || [mergeConfig];
const satisfiedEntryPoint = entryPoints.find(entryPoint => {
if (entryPoint.selectionSet) {
const selectionSet = (0, utils_2.parseSelectionSet)(entryPoint.selectionSet, {
noLocation: true,
});
return (0, utils_js_1.checkIfDataSatisfiesSelectionSet)(selectionSet, representation);
}
return true;
});
if (satisfiedEntryPoint) {
if (satisfiedEntryPoint.key) {
return (0, utils_1.mapMaybePromise)((0, batch_delegate_1.batchDelegateToSchema)({
schema: subschemaConfig,
fieldName: satisfiedEntryPoint.fieldName,
key: satisfiedEntryPoint.key(representation),
argsFromKeys: satisfiedEntryPoint.argsFromKeys,
valuesFromResults: satisfiedEntryPoint.valuesFromResults,
context,
info,
}), res => (0, utils_2.mergeDeep)([representation, res]));
}
if (satisfiedEntryPoint.args) {
return (0, utils_1.mapMaybePromise)((0, delegate_1.delegateToSchema)({
schema: subschemaConfig,
fieldName: satisfiedEntryPoint.fieldName,
args: satisfiedEntryPoint.args(representation),
context,
info,
}), res => (0, utils_2.mergeDeep)([representation, res]));
}
}
return representation;
});
}
return [];
},
_service() {
return {
sdl() {
return (0, handleUnifiedGraphConfig_js_1.getUnifiedGraphSDL)(newUnifiedGraph);
},
};
},
},
},
});
return true;
});
}
getSchema = () => (0, utils_1.mapMaybePromise)(getSubschemaConfig(), () => unifiedGraph);
} /** 'supergraph' in config */
else {
let unifiedGraphFetcher;
let supergraphLoadedPlace;
if (typeof config.supergraph === 'object' && 'type' in config.supergraph) {
if (config.supergraph.type === 'hive') {
// hive cdn
const { endpoint, key } = config.supergraph;
supergraphLoadedPlace = 'Hive CDN <br>' + endpoint;
const fetcher = (0, core_1.createSupergraphSDLFetcher)({
endpoint,
key,
logger: configContext.logger.child('Hive CDN'),
});
unifiedGraphFetcher = () => fetcher().then(({ supergraphSdl }) => supergraphSdl);
}
else if (config.supergraph.type === 'graphos') {
const opts = config.supergraph;
supergraphLoadedPlace = 'GraphOS Managed Federation <br>' + opts.graphRef || '';
let lastSeenId;
let lastSupergraphSdl;
let minDelayMS = config.pollingInterval || 0;
unifiedGraphFetcher = () => (0, utils_1.mapMaybePromise)((0, federation_1.fetchSupergraphSdlFromManagedFederation)({
graphRef: opts.graphRef,
apiKey: opts.apiKey,
upLink: opts.upLink,
lastSeenId,
// @ts-expect-error TODO: what's up with type narrowing
fetch: configContext.fetch,
loggerByMessageLevel: {
ERROR(message) {
configContext.logger.child('GraphOS').error(message);
},
INFO(message) {
configContext.logger.child('GraphOS').info(message);
},
WARN(message) {
configContext.logger.child('GraphOS').warn(message);
},
},
}), async (result) => {
if (minDelayMS) {
await new Promise(resolve => setTimeout(resolve, minDelayMS));
}
if (result.minDelaySeconds && result.minDelaySeconds > minDelayMS) {
minDelayMS = result.minDelaySeconds;
}
if ('error' in result) {
configContext.logger.child('GraphOS').error(result.error.message);
return lastSupergraphSdl;
}
if ('id' in result) {
lastSeenId = result.id;
}
if ('supergraphSdl' in result) {
lastSupergraphSdl = result.supergraphSdl;
return result.supergraphSdl;
}
if (lastSupergraphSdl) {
throw new Error('Failed to fetch supergraph SDL');
}
return lastSupergraphSdl;
});
}
else {
configContext.logger.error(`Unknown supergraph configuration: `, config.supergraph);
}
}
else {
// local or remote
if (!isDynamicUnifiedGraphSchema(config.supergraph)) {
// no polling for static schemas
delete config.pollingInterval;
}
unifiedGraphFetcher = () => (0, handleUnifiedGraphConfig_js_1.handleUnifiedGraphConfig)(
// @ts-expect-error TODO: what's up with type narrowing
config.supergraph, configContext);
if (typeof config.supergraph === 'function') {
const fnName = config.supergraph.name || '';
supergraphLoadedPlace = `a custom loader ${fnName}`;
}
else if (typeof config.supergraph === 'string') {
supergraphLoadedPlace = config.supergraph;
}
}
const unifiedGraphManager = new fusion_runtime_1.UnifiedGraphManager({
getUnifiedGraph: unifiedGraphFetcher,
onSchemaChange(unifiedGraph) {
setSchema(unifiedGraph);
},
transports: config.transports,
transportEntryAdditions: config.transportEntries,
pollingInterval: config.pollingInterval,
additionalResolvers: config.additionalResolvers,
transportContext: configContext,
onDelegateHooks,
onSubgraphExecuteHooks,
});
getSchema = () => unifiedGraphManager.getUnifiedGraph();
readinessChecker = () => (0, utils_1.mapMaybePromise)(unifiedGraphManager.getUnifiedGraph(), schema => {
if (!schema) {
logger.debug(`Readiness check failed: Supergraph cannot be loaded`);
return false;
}
logger.debug(`Readiness check passed: Supergraph loaded`);
return true;
}, err => {
logger.debug(`Readiness check failed due to errors on loading supergraph:\n${err.stack || err.message}`);
logger.error(err);
return false;
});
schemaInvalidator = () => unifiedGraphManager.invalidateUnifiedGraph();
contextBuilder = base => unifiedGraphManager.getContext(base);
disposableStack.use(unifiedGraphManager);
subgraphInformationHTMLRenderer = async () => {
const htmlParts = [];
let loaded = false;
let loadError;
let transportEntryMap;
try {
transportEntryMap = await unifiedGraphManager.getTransportEntryMap();
loaded = true;
}
catch (e) {
loaded = false;
loadError = e;
}
if (loaded) {
htmlParts.push(`<h3>Supergraph Status: Loaded ✅</h3>`);
if (supergraphLoadedPlace) {
htmlParts.push(`<p><strong>Source: </strong> <i>${supergraphLoadedPlace}</i></p>`);
if (reportingTarget) {
htmlParts.push(`<p><strong>Usage Reporting: </strong> <i>${reportingTarget}</i></p>`);
}
}
htmlParts.push(`<table>`);
htmlParts.push(`<tr><th>Subgraph</th><th>Transport</th><th>Location</th></tr>`);
for (const subgraphName in transportEntryMap) {
const transportEntry = transportEntryMap[subgraphName];
htmlParts.push(`<tr>`);
htmlParts.push(`<td>${subgraphName}</td>`);
htmlParts.push(`<td>${transportEntry.kind}</td>`);
htmlParts.push(`<td><a href="${transportEntry.location}">${transportEntry.location}</a></td>`);
htmlParts.push(`</tr>`);
}
htmlParts.push(`</table>`);
}
else if (loadError) {
htmlParts.push(`<h3>Status: Failed ❌</h3>`);
if (supergraphLoadedPlace) {
htmlParts.push(`<p><strong>Source: </strong> <i>${supergraphLoadedPlace}</i></p>`);
}
htmlParts.push(`<h3>Error:</h3>`);
htmlParts.push(`<pre>${loadError.stack}</pre>`);
}
else {
htmlParts.push(`<h3>Status: Unknown</h3>`);
if (supergraphLoadedPlace) {
htmlParts.push(`<p><strong>Source: </strong> <i>${supergraphLoadedPlace}</i></p>`);
}
}
return `<section class="supergraph-information">${htmlParts.join('')}</section>`;
};
}
const readinessCheckPlugin = (0, graphql_yoga_1.useReadinessCheck)({
endpoint: readinessCheckEndpoint,
// @ts-expect-error PromiseLike is not compatible with Promise
check: readinessChecker,
});
const defaultGatewayPlugin = {
onFetch({ setFetchFn }) {
setFetchFn(fetchAPI.fetch);
},
onPluginInit({ plugins }) {
onFetchHooks.splice(0, onFetchHooks.length);
onSubgraphExecuteHooks.splice(0, onSubgraphExecuteHooks.length);
onDelegateHooks.splice(0, onDelegateHooks.length);
for (const plugin of plugins) {
if (plugin.onFetch) {
onFetchHooks.push(plugin.onFetch);
}
if (plugin.onSubgraphExecute) {
onSubgraphExecuteHooks.push(plugin.onSubgraphExecute);
}
// @ts-expect-error For backward compatibility
if (plugin.onDelegate) {
// @ts-expect-error For backward compatibility
onDelegateHooks.push(plugin.onDelegate);
}
if ((0, utils_1.isDisposable)(plugin)) {
disposableStack.use(plugin);
}
}
},
};
const productName = config.productName || 'GraphQL Mesh';
const productDescription = config.productDescription || 'Federated architecture for any API service';
const productPackageName = config.productPackageName || '@graphql-mesh/serve-cli';
const productLogo = config.productLogo || productLogo_js_1.defaultProductLogo;
const productLink = config.productLink || 'https://the-guild.dev/graphql/mesh';
let graphiqlOptionsOrFactory;
if (config.graphiql == null || config.graphiql === true) {
graphiqlOptionsOrFactory = {
title: productName,
defaultQuery: utils_js_1.defaultQueryText,
};
}
else if (config.graphiql === false) {
graphiqlOptionsOrFactory = false;
}
else if (typeof config.graphiql === 'object') {
graphiqlOptionsOrFactory = {
title: productName,
defaultQuery: utils_js_1.defaultQueryText,
...config.graphiql,
};
}
else if (typeof config.graphiql === 'function') {
const userGraphiqlFactory = config.graphiql;
// @ts-expect-error PromiseLike is not compatible with Promise
graphiqlOptionsOrFactory = function graphiqlOptionsFactoryForMesh(...args) {
const options = userGraphiqlFactory(...args);
return (0, utils_1.mapMaybePromise)(options, resolvedOpts => {
if (resolvedOpts === false) {
return false;
}
if (resolvedOpts === true) {
return {
title: productName,
defaultQuery: utils_js_1.defaultQueryText,
};
}
return {
title: productName,
defaultQuery: utils_js_1.defaultQueryText,
...resolvedOpts,
};
});
};
}
let landingPageRenderer;
if (config.landingPage == null || config.landingPage === true) {
landingPageRenderer = async function gatewayLandingPageRenderer(opts) {
const subgraphHtml = await subgraphInformationHTMLRenderer();
return new opts.fetchAPI.Response(landing_page_html_js_1.default
.replace(/__GRAPHIQL_LINK__/g, opts.graphqlEndpoint)
.replace(/__REQUEST_PATH__/g, opts.url.pathname)
.replace(/__SUBGRAPH_HTML__/g, subgraphHtml)
.replaceAll(/__PRODUCT_NAME__/g, productName)
.replaceAll(/__PRODUCT_DESCRIPTION__/g, productDescription)
.replaceAll(/__PRODUCT_PACKAGE_NAME__/g, productPackageName)
.replace(/__PRODUCT_LINK__/, productLink)
.replace(/__PRODUCT_LOGO__/g, productLogo), {
status: 200,
statusText: 'OK',
headers: {
'Content-Type': 'text/html',
},
});
};
}
else if (typeof config.landingPage === 'function') {
landingPageRenderer = config.landingPage;
}
else if (config.landingPage === false) {
landingPageRenderer = false;
}
const basePlugins = [
defaultGatewayPlugin,
unifiedGraphPlugin,
readinessCheckPlugin,
registryPlugin,
persistedDocumentsPlugin,
(0, useChangingSchema_js_1.useChangingSchema)(getSchema, _setSchema => {
setSchema = _setSchema;
}),
(0, useCompleteSubscriptionsOnDispose_js_1.useCompleteSubscriptionsOnDispose)(disposableStack),
(0, useCompleteSubscriptionsOnSchemaChange_js_1.useCompleteSubscriptionsOnSchemaChange)(),
(0, useRequestId_js_1.useRequestId)(),
(0, useSubgraphExecuteDebug_js_1.useSubgraphExecuteDebug)(configContext),
(0, useFetchDebug_js_1.useFetchDebug)(configContext),
];
const extraPlugins = [];
if (config.webhooks) {
extraPlugins.push((0, useWebhooks_js_1.useWebhooks)(configContext));
}
if (config.responseCaching) {
extraPlugins.push(
// @ts-expect-error TODO: what's up with type narrowing
(0, plugin_response_cache_1.default)({
...configContext,
...config.responseCaching,
}));
}
if (config.contentEncoding) {
extraPlugins.push((0, useContentEncoding_js_1.useContentEncoding)(typeof config.contentEncoding === 'object' ? config.contentEncoding : {}));
}
if (config.deferStream) {
extraPlugins.push((0, plugin_defer_stream_1.useDeferStream)());
}
if (config.executionCancellation) {
extraPlugins.push((0, graphql_yoga_1.useExecutionCancellation)());
}
if (config.upstreamCancellation) {
extraPlugins.push((0, useUpstreamCancel_js_1.useUpstreamCancel)());
}
if (config.disableIntrospection) {
extraPlugins.push((0, disable_introspection_1.useDisableIntrospection)(typeof config.disableIntrospection === 'object' ? config.disableIntrospection : {}));
}
if (config.csrfPrevention) {
extraPlugins.push((0, plugin_csrf_prevention_1.useCSRFPrevention)(typeof config.csrfPrevention === 'object' ? config.csrfPrevention : {}));
}
if (config.customAgent) {
extraPlugins.push((0, useCustomAgent_js_1.useCustomAgent)(config.customAgent));
}
if (config.genericAuth) {
extraPlugins.push((0, generic_auth_1.useGenericAuth)(config.genericAuth));
}
if (config.hmacSignature) {
extraPlugins.push((0, hmac_upstream_signature_1.useHmacUpstreamSignature)(config.hmacSignature));
}
if (config.propagateHeaders) {
extraPlugins.push((0, usePropagateHeaders_js_1.usePropagateHeaders)(config.propagateHeaders));
}
const yoga = (0, graphql_yoga_1.createYoga)({
fetchAPI: config.fetchAPI,
logging: logger,
plugins: [...basePlugins, ...(config.plugins?.(configContext) || []), ...extraPlugins],
// @ts-expect-error PromiseLike is not compatible with Promise
context({ request, params, ...rest }) {
// TODO: I dont like this cast, but it's necessary
const { req, connectionParams } = rest;
let headers = // Maybe Node-like environment
req?.headers
? (0, utils_1.getHeadersObj)(req.headers)
: // Fetch environment
request?.headers
? (0, utils_1.getHeadersObj)(request.headers)
: // Unknown environment
{};
if (connectionParams) {
headers = { ...headers, ...connectionParams };
}
const baseContext = {
...configContext,
request,
params,
headers,
connectionParams: headers,
};
if (contextBuilder) {
return contextBuilder(baseContext);
}
return baseContext;
},
cors: config.cors,
graphiql: graphiqlOptionsOrFactory,
batching: config.batching,
graphqlEndpoint: config.graphqlEndpoint,
maskedErrors: config.maskedErrors,
healthCheckEndpoint: config.healthCheckEndpoint || '/healthcheck',
landingPage: landingPageRenderer,
});
fetchAPI ||= yoga.fetchAPI;
Object.defineProperties(yoga, {
invalidateUnifiedGraph: {
value: schemaInvalidator,
configurable: true,
},
getSchema: {
value: getSchema,
configurable: true,
},
});
return (0, utils_1.makeAsyncDisposable)(yoga, () => disposableStack.disposeAsync());
}
function isDynamicUnifiedGraphSchema(schema) {
if ((0, graphql_1.isSchema)(schema)) {
// schema object
return false;
}
if ((0, utils_2.isDocumentNode)(schema)) {
// document node that could be a schema
return false;
}
if (typeof schema === 'string') {
if ((0, utils_2.isValidPath)(schema) && !(0, utils_1.isUrl)(String(schema))) {
// local path
return false;
}
try {
// sdl
(0, graphql_1.parse)(schema);
return false;
}
catch { }
}
// likely a dynamic schema that can be polled
return true;
}