@graphql-hive/gateway-runtime
Version:
1,404 lines (1,382 loc) • 93.5 kB
JavaScript
import { useDisableIntrospection } from '@envelop/disable-introspection';
import { useGenericAuth } from '@envelop/generic-auth';
import { createSchemaFetcher, createSupergraphSDLFetcher } from '@graphql-hive/core';
import { getOnSubgraphExecute, subgraphNameByExecutionRequest, UnifiedGraphManager, restoreExtraDirectives, getTransportEntryMapUsingFusionAndFederationDirectives, getStitchingDirectivesTransformerForSubschema, handleFederationSubschema, handleResolveToDirectives } from '@graphql-mesh/fusion-runtime';
export { getExecutorForUnifiedGraph, getSdkRequesterForUnifiedGraph } from '@graphql-mesh/fusion-runtime';
import { useHmacUpstreamSignature } from '@graphql-mesh/hmac-upstream-signature';
export * from '@graphql-mesh/hmac-upstream-signature';
import useMeshResponseCache from '@graphql-mesh/plugin-response-cache';
import { DefaultLogger, LogLevel, isUrl, readFileOrUrl, defaultImportFn, requestIdByRequest, getHeadersObj, wrapFetchWithHooks, isDisposable, dispose, getInContextSDK, pathExists } from '@graphql-mesh/utils';
export { DefaultLogger, LogLevel } from '@graphql-mesh/utils';
import { batchDelegateToSchema } from '@graphql-tools/batch-delegate';
import { getTypeInfo, EMPTY_OBJECT, delegateToSchema } from '@graphql-tools/delegate';
import { defaultPrintFn as defaultPrintFn$1 } from '@graphql-tools/executor-common';
import { memoize1, isValidPath, pathToArray, memoize3, getDirective, getDirectiveExtensions, createGraphQLError, isAsyncIterable, mapAsyncIterator, createDeferred, isPromise, isDocumentNode, asArray, printSchemaWithDirectives, parseSelectionSet, mergeDeep } from '@graphql-tools/utils';
import { wrapSchema, schemaFromExecutor } from '@graphql-tools/wrap';
import { useCSRFPrevention } from '@graphql-yoga/plugin-csrf-prevention';
import { useDeferStream } from '@graphql-yoga/plugin-defer-stream';
import { usePersistedOperations } from '@graphql-yoga/plugin-persisted-operations';
import { AsyncDisposableStack } from '@whatwg-node/disposablestack';
export * from '@whatwg-node/disposablestack';
import { handleMaybePromise, iterateAsync } from '@whatwg-node/promise-helpers';
import { print, visit, visitWithTypeInfo, getArgumentValues, getNamedType, isIntrospectionType, isListType, isCompositeType, getOperationAST, isSchema, parse, buildASTSchema, buildSchema } from 'graphql';
import { isAsyncIterable as isAsyncIterable$1, useReadinessCheck, useExecutionCancellation, createYoga, chain, mergeSchemas } from 'graphql-yoga';
import { process as process$1, path, fs } from '@graphql-mesh/cross-helpers';
import { DEFAULT_UPLINKS, fetchSupergraphSdlFromManagedFederation } from '@graphql-tools/federation';
import { JSONLogger } from '@graphql-hive/logger-json';
export { JSONLogger } from '@graphql-hive/logger-json';
import { useApolloUsageReport } from '@graphql-yoga/plugin-apollo-usage-report';
import { useHive } from '@graphql-hive/yoga';
import { useContentEncoding as useContentEncoding$1 } from '@whatwg-node/server';
import { defaultPrintFn } from '@graphql-mesh/transport-common';
import { isOriginalGraphQLError } from '@envelop/core';
function checkIfDataSatisfiesSelectionSet(selectionSet, data) {
if (Array.isArray(data)) {
return data.every(
(item) => checkIfDataSatisfiesSelectionSet(selectionSet, item)
);
}
for (const selection of selectionSet.selections) {
if (selection.kind === "Field") {
const field = selection;
const responseKey = field.alias?.value || field.name.value;
if (data[responseKey] != null) {
if (field.selectionSet) {
if (!checkIfDataSatisfiesSelectionSet(
field.selectionSet,
data[field.name.value]
)) {
return false;
}
}
} else {
return false;
}
} else if (selection.kind === "InlineFragment") {
const inlineFragment = selection;
if (!checkIfDataSatisfiesSelectionSet(inlineFragment.selectionSet, data)) {
return false;
}
}
}
return true;
}
const defaultQueryText = (
/* GraphQL */
`
# Welcome to GraphiQL
# GraphiQL is an in-browser tool for writing, validating,
# and testing GraphQL queries.
#
# Type queries into this side of the screen, and you will
# see intelligent typeaheads aware of the current GraphQL
# type schema and live syntax and validation errors
# highlighted within the text.
#
# GraphQL queries typically start with a "{" character.
# Lines that start with a # are ignored.
#
# An example GraphQL query might look like:
#
# {
# field(arg: "value") {
# subField
# }
# }
#
`
);
function delayInMs(ms, signal) {
return new Promise((resolve, reject) => {
globalThis.setTimeout(resolve, ms);
});
}
const getExecuteFnFromExecutor = memoize1(
function getExecuteFnFromExecutor2(executor) {
return function executeFn(args) {
return executor({
document: args.document,
variables: args.variableValues,
operationName: args.operationName ?? void 0,
rootValue: args.rootValue,
context: args.contextValue,
signal: args.signal
});
};
}
);
function wrapCacheWithHooks({
cache,
onCacheGet,
onCacheSet,
onCacheDelete
}) {
return new Proxy(cache, {
get(target, prop, receiver) {
switch (prop) {
case "get": {
if (onCacheGet.length === 0) {
break;
}
return function cacheGet(key) {
const onCacheGetResults = [];
return handleMaybePromise(
() => iterateAsync(
onCacheGet,
(onCacheGet2) => onCacheGet2({
key,
cache
}),
onCacheGetResults
),
() => handleMaybePromise(
() => target.get(key),
(value) => value == null ? handleMaybePromise(
() => iterateAsync(
onCacheGetResults,
(onCacheGetResult) => onCacheGetResult?.onCacheMiss?.()
),
() => value
) : handleMaybePromise(
() => iterateAsync(
onCacheGetResults,
(onCacheGetResult) => onCacheGetResult?.onCacheHit?.({ value })
),
() => value
),
(error) => handleMaybePromise(
() => iterateAsync(
onCacheGetResults,
(onCacheGetResult) => onCacheGetResult?.onCacheGetError?.({ error })
),
() => {
throw error;
}
)
)
);
};
}
case "set": {
if (onCacheSet.length === 0) {
break;
}
return function cacheSet(key, value, opts) {
const onCacheSetResults = [];
return handleMaybePromise(
() => iterateAsync(
onCacheSet,
(onCacheSet2) => onCacheSet2({
key,
value,
ttl: opts?.ttl,
cache
}),
onCacheSetResults
),
() => handleMaybePromise(
() => target.set(key, value, opts),
(result) => handleMaybePromise(
() => iterateAsync(
onCacheSetResults,
(onCacheSetResult) => onCacheSetResult?.onCacheSetDone?.()
),
() => result
),
(err) => handleMaybePromise(
() => iterateAsync(
onCacheSetResults,
(onCacheSetResult) => onCacheSetResult?.onCacheSetError?.({ error: err })
),
() => {
throw err;
}
)
)
);
};
}
case "delete": {
if (onCacheDelete.length === 0) {
break;
}
return function cacheDelete(key) {
const onCacheDeleteResults = [];
return handleMaybePromise(
() => iterateAsync(
onCacheDelete,
(onCacheDelete2) => onCacheDelete2({
key,
cache
})
),
() => handleMaybePromise(
() => target.delete(key),
(result) => handleMaybePromise(
() => iterateAsync(
onCacheDeleteResults,
(onCacheDeleteResult) => onCacheDeleteResult?.onCacheDeleteDone?.()
),
() => result
)
),
(err) => handleMaybePromise(
() => iterateAsync(
onCacheDeleteResults,
(onCacheDeleteResult) => onCacheDeleteResult?.onCacheDeleteError?.({ error: err })
),
() => {
throw err;
}
)
);
};
}
}
return Reflect.get(target, prop, receiver);
}
});
}
const defaultLoadedPlacePrefix = "GraphOS Managed Federation";
function createGraphOSFetcher({
graphosOpts,
configContext
}) {
let lastSeenId;
let lastSupergraphSdl;
let nextFetchTime;
const uplinksParam = graphosOpts.upLink || process$1.env["APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT"];
const uplinks = uplinksParam?.split(",").map((uplink) => uplink.trim()) || DEFAULT_UPLINKS;
const graphosLogger = configContext.logger.child({ source: "GraphOS" });
graphosLogger.info("Using Managed Federation with uplinks: ", ...uplinks);
const maxRetries = graphosOpts.maxRetries || Math.max(3, uplinks.length);
let supergraphLoadedPlace = defaultLoadedPlacePrefix;
if (graphosOpts.graphRef) {
supergraphLoadedPlace += ` <br>${graphosOpts.graphRef}`;
}
return {
supergraphLoadedPlace,
unifiedGraphFetcher(transportContext) {
const uplinksToUse = [];
let retries = maxRetries;
function fetchSupergraphWithDelay() {
if (nextFetchTime) {
const currentTime = Date.now();
if (nextFetchTime >= currentTime) {
const delay = nextFetchTime - currentTime;
graphosLogger.info(`Fetching supergraph with delay: ${delay}ms`);
nextFetchTime = 0;
return delayInMs(delay).then(fetchSupergraph);
}
}
return fetchSupergraph();
}
function fetchSupergraph() {
if (uplinksToUse.length === 0) {
uplinksToUse.push(...uplinks);
}
retries--;
const uplinkToUse = uplinksToUse.pop();
const attemptLogger = graphosLogger.child({
attempt: maxRetries - retries,
uplink: uplinkToUse || "none"
});
attemptLogger.debug(`Fetching supergraph`);
return fetchSupergraphSdlFromManagedFederation({
graphRef: graphosOpts.graphRef,
apiKey: graphosOpts.apiKey,
upLink: uplinkToUse,
lastSeenId,
fetch: transportContext.fetch || configContext.fetch,
loggerByMessageLevel: {
ERROR(message) {
attemptLogger.error(message);
},
INFO(message) {
attemptLogger.info(message);
},
WARN(message) {
attemptLogger.warn(message);
}
}
}).then(
(result) => {
if (result.minDelaySeconds) {
attemptLogger.debug(
`Setting min delay to ${result.minDelaySeconds}s`
);
nextFetchTime = Date.now() + result.minDelaySeconds * 1e3;
}
if ("error" in result) {
attemptLogger.error(result.error.code, result.error.message);
}
if ("id" in result) {
if (lastSeenId === result.id) {
return lastSupergraphSdl;
}
lastSeenId = result.id;
}
if ("supergraphSdl" in result) {
attemptLogger.info(
`Fetched the new supergraph ${lastSeenId ? `with id ${lastSeenId}` : ""}`
);
lastSupergraphSdl = result.supergraphSdl;
}
if (!lastSupergraphSdl) {
if (retries > 0) {
return fetchSupergraphWithDelay();
}
throw new Error("Failed to fetch supergraph SDL");
}
return lastSupergraphSdl;
},
(err) => {
attemptLogger.error(err);
if (retries > 0) {
return fetchSupergraphWithDelay();
}
return lastSupergraphSdl;
}
);
}
return fetchSupergraphWithDelay();
}
};
}
function getDefaultLogger(opts) {
const logFormat = process$1.env["LOG_FORMAT"] || globalThis.LOG_FORMAT;
if (logFormat) {
if (logFormat.toLowerCase() === "json") {
return new JSONLogger(opts);
} else if (logFormat.toLowerCase() === "pretty") {
return new DefaultLogger(opts?.name, opts?.level);
}
}
const nodeEnv = process$1.env["NODE_ENV"] || globalThis.NODE_ENV;
if (nodeEnv === "production") {
return new JSONLogger(opts);
}
return new DefaultLogger(opts?.name, opts?.level);
}
function handleLoggingConfig(loggingConfig, existingLogger) {
if (typeof loggingConfig === "object") {
return loggingConfig;
}
if (typeof loggingConfig === "boolean") {
if (!loggingConfig) {
if (existingLogger && "logLevel" in existingLogger) {
existingLogger.logLevel = LogLevel.silent;
return existingLogger;
}
return getDefaultLogger({
name: existingLogger?.name,
level: LogLevel.silent
});
}
}
if (typeof loggingConfig === "number") {
if (existingLogger && "logLevel" in existingLogger) {
existingLogger.logLevel = loggingConfig;
return existingLogger;
}
return getDefaultLogger({
name: existingLogger?.name,
level: loggingConfig
});
}
if (typeof loggingConfig === "string") {
if (existingLogger && "logLevel" in existingLogger) {
existingLogger.logLevel = LogLevel[loggingConfig];
return existingLogger;
}
return getDefaultLogger({
name: existingLogger?.name,
level: LogLevel[loggingConfig]
});
}
return existingLogger || getDefaultLogger();
}
function getProxyExecutor({
config,
configContext,
getSchema,
onSubgraphExecuteHooks,
transportExecutorStack,
instrumentation
}) {
const fakeTransportEntryMap = {};
let subgraphName = "upstream";
const onSubgraphExecute = getOnSubgraphExecute({
onSubgraphExecuteHooks,
transportEntryMap: new Proxy(fakeTransportEntryMap, {
get(fakeTransportEntryMap2, subgraphNameProp) {
if (!fakeTransportEntryMap2[subgraphNameProp]) {
subgraphName = subgraphNameProp;
fakeTransportEntryMap2[subgraphNameProp] = {
kind: "http",
subgraph: subgraphName.toString(),
location: config.proxy?.endpoint,
headers: config.proxy?.headers,
options: config.proxy
};
}
return fakeTransportEntryMap2[subgraphNameProp];
}
}),
transportContext: configContext,
getSubgraphSchema: getSchema,
transportExecutorStack,
transports: config.transports,
instrumentation
});
return function proxyExecutor(executionRequest) {
return onSubgraphExecute(subgraphName, executionRequest);
};
}
function useHiveConsole(options) {
const agent = {
name: "graphql-hive-gateway",
logger: options.logger,
...options.agent
};
return useHive({
debug: ["1", "y", "yes", "t", "true"].includes(
String(process$1.env["DEBUG"])
),
...options,
agent
});
}
function getReportingPlugin(config, configContext) {
if (config.reporting?.type === "hive") {
const { target, ...reporting } = config.reporting;
let usage = reporting.usage;
if (usage === false) ; else {
usage = {
target,
...typeof usage === "object" ? { ...usage } : {}
};
}
return {
name: "Hive",
plugin: useHiveConsole({
logger: configContext.logger.child({ reporting: "Hive" }),
enabled: true,
...reporting,
...usage ? { usage } : {},
...config.persistedDocuments && "type" in config.persistedDocuments && config.persistedDocuments?.type === "hive" ? {
experimental__persistedDocuments: {
cdn: {
endpoint: config.persistedDocuments.endpoint,
accessToken: config.persistedDocuments.token
},
allowArbitraryDocuments: !!config.persistedDocuments.allowArbitraryDocuments
}
} : {}
})
};
} else if (config.reporting?.type === "graphos" || !config.reporting && "supergraph" in config && typeof config.supergraph === "object" && "type" in config.supergraph && config.supergraph.type === "graphos") {
if ("supergraph" in config && typeof config.supergraph === "object" && "type" in config.supergraph && config.supergraph.type === "graphos") {
if (!config.reporting) {
config.reporting = {
type: "graphos",
apiKey: config.supergraph.apiKey,
graphRef: config.supergraph.graphRef
};
} else {
config.reporting.apiKey ||= config.supergraph.apiKey;
config.reporting.graphRef ||= config.supergraph.graphRef;
}
}
return {
name: "GraphOS",
// @ts-expect-error - TODO: Fix types
plugin: useApolloUsageReport({
agentVersion: `hive-gateway@${globalThis.__VERSION__}`,
...config.reporting
})
};
}
return {
plugin: {}
};
}
function handleUnifiedGraphConfig(config, configContext) {
return handleMaybePromise(
() => typeof config === "function" ? config(configContext) : config,
(schema) => handleUnifiedGraphSchema(schema, configContext)
);
}
function handleUnifiedGraphSchema(unifiedGraphSchema, configContext) {
if (typeof unifiedGraphSchema === "string" && (isValidPath(unifiedGraphSchema) || isUrl(unifiedGraphSchema))) {
return readFileOrUrl(unifiedGraphSchema, {
fetch: configContext.fetch,
cwd: configContext.cwd,
logger: configContext.logger,
allowUnknownExtensions: true,
importFn: defaultImportFn
});
}
return unifiedGraphSchema;
}
var landingPageHtml = "<!doctype html><html lang=en><head><meta charset=utf-8><title>Welcome to __PRODUCT_NAME__</title><link rel=icon href=https://the-guild.dev/favicon.ico><style>body,html{padding:0;margin:0;height:100%;font-family:Inter,-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Oxygen,Ubuntu,Cantarell,'Fira Sans','Droid Sans','Helvetica Neue',sans-serif;color:#fff;background-color:#000}main>section.hero{display:flex;height:50vh;justify-content:center;align-items:center;flex-direction:column}.logo{display:flex;align-items:center}.buttons{margin-top:24px}h1{font-size:80px}h2{color:#888;max-width:50%;margin-top:0;text-align:center}a{color:#fff;text-decoration:none;margin-left:10px;margin-right:10px;font-weight:700;transition:color .3s ease;padding:4px;overflow:visible}a.graphiql:hover{color:rgba(255,0,255,.7)}a.docs:hover{color:rgba(28,200,238,.7)}a.tutorial:hover{color:rgba(125,85,245,.7)}svg{margin-right:24px}.supergraph-information>*{margin-left:auto;margin-right:auto;text-align:center;max-width:50%}.not-what-your-looking-for{margin-top:5vh}.not-what-your-looking-for>*{margin-left:auto;margin-right:auto}.not-what-your-looking-for>p{text-align:center}.not-what-your-looking-for>h2{color:#464646}.not-what-your-looking-for>p{max-width:600px;line-height:1.3em}.not-what-your-looking-for>pre{max-width:300px}</style></head><body id=body><main><section class=hero><div class=logo><div>__PRODUCT_LOGO__</div><h1>__PRODUCT_NAME__</h1></div><h2>__PRODUCT_DESCRIPTION__</h2><div class=buttons><a href=__PRODUCT_LINK__ class=docs>Read the Docs</a> <a href=__GRAPHIQL_LINK__ class=graphiql>Visit GraphiQL</a></div></section>__SUBGRAPH_HTML__<section class=not-what-your-looking-for><h2>Not the page you are looking for? \u{1F440}</h2><p>This page is shown be default whenever a 404 is hit.<br>You can disable this by behavior via the <code>landingPage</code> option.</p><pre>\n <code>\n// gateway.config.ts\n\nimport { defineConfig } from '__PRODUCT_PACKAGE_NAME__';\n\nexport const gatewayConfig = defineConfig({\n landingPage: false,\n});\n </code>\n </pre><p>If you expected this page to be the GraphQL route, you need to configure Hive Gateway. Currently, the GraphQL route is configured to be on <code>__GRAPHIQL_LINK__</code>.</p><pre>\n <code>\n// gateway.config.ts\n\nimport { defineConfig } from '__PRODUCT_PACKAGE_NAME__';\n\nexport const gatewayConfig = defineConfig({\n graphqlEndpoint: '__REQUEST_PATH__',\n});\n </code>\n </pre></section></main></body></html>";
function useCacheDebug(opts) {
return {
onCacheGet({ key }) {
return {
onCacheGetError({ error }) {
const cacheGetErrorLogger = opts.logger.child("cache-get-error");
cacheGetErrorLogger.error({ key, error });
},
onCacheHit({ value }) {
const cacheHitLogger = opts.logger.child("cache-hit");
cacheHitLogger.debug({ key, value });
},
onCacheMiss() {
const cacheMissLogger = opts.logger.child("cache-miss");
cacheMissLogger.debug({ key });
}
};
},
onCacheSet({ key, value, ttl }) {
return {
onCacheSetError({ error }) {
const cacheSetErrorLogger = opts.logger.child("cache-set-error");
cacheSetErrorLogger.error({ key, value, ttl, error });
},
onCacheSetDone() {
const cacheSetDoneLogger = opts.logger.child("cache-set-done");
cacheSetDoneLogger.debug({ key, value, ttl });
}
};
},
onCacheDelete({ key }) {
return {
onCacheDeleteError({ error }) {
const cacheDeleteErrorLogger = opts.logger.child("cache-delete-error");
cacheDeleteErrorLogger.error({ key, error });
},
onCacheDeleteDone() {
const cacheDeleteDoneLogger = opts.logger.child("cache-delete-done");
cacheDeleteDoneLogger.debug({ key });
}
};
}
};
}
function useContentEncoding({
subgraphs
} = {}) {
if (!subgraphs?.length) {
return useContentEncoding$1();
}
const compressionAlgorithm = "gzip";
let fetchAPI;
const execReqWithContentEncoding = /* @__PURE__ */ new WeakSet();
return {
onYogaInit({ yoga }) {
fetchAPI = yoga.fetchAPI;
},
onPluginInit({ addPlugin }) {
addPlugin(
// @ts-expect-error - Plugin types do not match
useContentEncoding$1()
);
},
onSubgraphExecute({ subgraphName, executionRequest }) {
if (subgraphs.includes(subgraphName) || subgraphs.includes("*")) {
execReqWithContentEncoding.add(executionRequest);
}
},
onFetch({ executionRequest, options, setOptions }) {
if (options.body && !options.headers?.["Content-Encoding"] && executionRequest && execReqWithContentEncoding.has(executionRequest) && fetchAPI.CompressionStream) {
const compressionStream = new fetchAPI.CompressionStream(
compressionAlgorithm
);
let bodyStream;
if (options.body instanceof fetchAPI.ReadableStream) {
bodyStream = options.body;
} else {
bodyStream = new fetchAPI.Response(options.body).body;
}
setOptions({
...options,
headers: {
"Accept-Encoding": "gzip, deflate",
...options.headers,
"Content-Encoding": compressionAlgorithm
},
body: bodyStream.pipeThrough(compressionStream)
});
}
}
};
}
function useCustomAgent(agentFactory) {
return {
onFetch(payload) {
const agent = agentFactory(payload);
if (agent != null) {
payload.setOptions({
...payload.options,
// @ts-expect-error - `agent` is there
agent
});
}
}
};
}
function useDelegationPlanDebug(opts) {
let fetchAPI;
const stageExecuteLogById = /* @__PURE__ */ new WeakMap();
return {
onYogaInit({ yoga }) {
fetchAPI = yoga.fetchAPI;
},
onDelegationPlan({
typeName,
variables,
fragments,
fieldNodes,
info,
logger = opts.logger
}) {
const planId = fetchAPI.crypto.randomUUID();
const planLogger = logger.child({ planId, typeName });
const delegationPlanStartLogger = planLogger.child(
"delegation-plan-start"
);
delegationPlanStartLogger.debug(() => {
const logObj = {};
if (variables && Object.keys(variables).length) {
logObj["variables"] = variables;
}
if (fragments && Object.keys(fragments).length) {
logObj["fragments"] = Object.fromEntries(
Object.entries(fragments).map(([name, fragment]) => [
name,
print(fragment)
])
);
}
if (fieldNodes && fieldNodes.length) {
logObj["fieldNodes"] = fieldNodes.map(
(fieldNode) => print(fieldNode)
);
}
if (info?.path) {
logObj["path"] = pathToArray(info.path).join(" | ");
}
return logObj;
});
return ({ delegationPlan }) => {
const delegationPlanDoneLogger = logger.child("delegation-plan-done");
delegationPlanDoneLogger.debug(
() => delegationPlan.map((plan) => {
const planObj = {};
for (const [subschema, selectionSet] of plan) {
if (subschema.name) {
planObj[subschema.name] = print(selectionSet);
}
}
return planObj;
})
);
};
},
onDelegationStageExecute({
object,
info,
context,
subgraph,
selectionSet,
key,
typeName,
logger = opts.logger
}) {
let contextLog = stageExecuteLogById.get(context);
if (!contextLog) {
contextLog = /* @__PURE__ */ new Set();
stageExecuteLogById.set(context, contextLog);
}
const log = {
key: JSON.stringify(key),
object: JSON.stringify(object),
selectionSet: print(selectionSet)
};
const logStr = JSON.stringify(log);
if (contextLog.has(logStr)) {
return;
}
contextLog.add(logStr);
const logMeta = {
stageId: fetchAPI.crypto.randomUUID(),
subgraph,
typeName
};
const delegationStageLogger = logger.child(logMeta);
delegationStageLogger.debug("delegation-plan-start", () => {
return {
...log,
path: pathToArray(info.path).join(" | ")
};
});
return ({ result }) => {
const delegationStageExecuteDoneLogger = logger.child(
"delegation-stage-execute-done"
);
delegationStageExecuteDoneLogger.debug(() => result);
};
}
};
}
function getDepthOfListType(type) {
let depth = 0;
while (isListType(type)) {
depth++;
type = type.ofType;
}
return depth;
}
function createCalculateCost({
listSize,
operationTypeCost,
typeCost,
fieldCost
}) {
return memoize3(function calculateCost(schema, document, variables) {
let cost = 0;
const factorQueue = [];
function timesFactor(c) {
for (const f of factorQueue) {
c *= f;
}
return c;
}
const fieldFactorMap = /* @__PURE__ */ new Map();
const typeInfo = getTypeInfo(schema);
visit(
document,
visitWithTypeInfo(typeInfo, {
OperationTypeDefinition(node) {
cost += operationTypeCost(node.operation) || 0;
},
Field: {
enter(node) {
let currentFieldCost = 0;
const field = typeInfo.getFieldDef();
if (field) {
const fieldAnnotations = getDirectiveExtensions(field, schema);
const factoryResult = fieldCost?.(node, typeInfo);
if (factoryResult) {
currentFieldCost += factoryResult;
} else if (fieldAnnotations?.cost) {
for (const costAnnotation of fieldAnnotations.cost) {
if (costAnnotation?.weight) {
const weight = Number(costAnnotation.weight);
if (weight && !isNaN(weight)) {
currentFieldCost += weight;
}
}
}
}
const returnType = typeInfo.getType();
let factor = 1;
const sizedFieldFactor = fieldFactorMap.get(node.name.value);
if (sizedFieldFactor) {
factor = sizedFieldFactor;
fieldFactorMap.delete(field.name);
} else if (fieldAnnotations?.listSize) {
for (const listSizeAnnotation of fieldAnnotations.listSize) {
if (listSizeAnnotation) {
if ("slicingArguments" in listSizeAnnotation) {
const slicingArguments = listSizeAnnotation.slicingArguments;
const argValues = getArgumentValues(
field,
node,
variables
);
let factorSet = false;
let slicingArgumentFactor = 1;
for (const slicingArgument of slicingArguments) {
const value = argValues[slicingArgument];
const numValue = Number(value);
if (numValue && !isNaN(numValue)) {
slicingArgumentFactor = Math.max(
slicingArgumentFactor,
numValue
);
if (factorSet && listSizeAnnotation.requireOneSlicingArgument !== false) {
throw createGraphQLError(
`Only one slicing argument is allowed on field "${field.name}"; found multiple slicing arguments "${slicingArguments.join(", ")}"`,
{
extensions: {
code: "COST_QUERY_PARSE_FAILURE"
}
}
);
}
factorSet = true;
}
}
if (listSizeAnnotation.sizedFields?.length) {
for (const sizedField of listSizeAnnotation.sizedFields) {
fieldFactorMap.set(sizedField, slicingArgumentFactor);
}
} else {
factor = slicingArgumentFactor;
}
} else if ("assumedSize" in listSizeAnnotation) {
const assumedSizeVal = listSizeAnnotation.assumedSize;
const numValue = Number(assumedSizeVal);
if (numValue && !isNaN(numValue)) {
factor = numValue;
}
}
}
}
} else if (listSize && returnType) {
const depth = getDepthOfListType(returnType);
if (depth > 0) {
factor = listSize * depth;
}
}
factorQueue.push(factor);
if (returnType) {
const namedReturnType = getNamedType(returnType);
if (isIntrospectionType(namedReturnType)) {
return;
}
const namedReturnTypeAnnotations = getDirectiveExtensions(
namedReturnType,
schema
);
if (namedReturnTypeAnnotations.cost) {
for (const costAnnotation of namedReturnTypeAnnotations.cost) {
if (costAnnotation?.weight) {
const weight = Number(costAnnotation?.weight);
if (weight && !isNaN(weight)) {
currentFieldCost += weight;
}
}
}
} else {
currentFieldCost += typeCost(namedReturnType);
}
}
if (currentFieldCost) {
cost += timesFactor(currentFieldCost);
}
}
},
leave() {
factorQueue.pop();
}
},
Directive() {
const directive = typeInfo.getDirective();
if (directive) {
const directiveCostAnnotations = getDirective(
schema,
directive,
"cost"
);
if (directiveCostAnnotations) {
for (const costAnnotation of directiveCostAnnotations) {
if (costAnnotation["weight"]) {
const weight = Number(costAnnotation["weight"]);
if (weight && !isNaN(weight)) {
cost += timesFactor(weight);
}
}
}
}
}
},
Argument() {
const argument = typeInfo.getArgument();
if (argument) {
const argumentCostAnnotations = getDirective(
schema,
argument,
"cost"
);
if (argumentCostAnnotations) {
for (const costAnnotation of argumentCostAnnotations) {
if (costAnnotation["weight"]) {
const weight = Number(costAnnotation["weight"]);
if (weight && !isNaN(weight)) {
cost += timesFactor(weight);
}
}
}
}
}
}
})
);
return cost;
});
}
function useDemandControl({
listSize = 0,
maxCost,
includeExtensionMetadata = process$1.env.NODE_ENV === "development",
operationTypeCost = (operationType) => operationType === "mutation" ? 10 : 0,
fieldCost,
typeCost = (type) => isCompositeType(type) ? 1 : 0
}) {
const calculateCost = createCalculateCost({
listSize,
operationTypeCost,
fieldCost,
typeCost
});
const costByContextMap = /* @__PURE__ */ new WeakMap();
return {
onSubgraphExecute({ subgraph, executionRequest, logger }) {
const demandControlLogger = logger?.child("demand-control");
let costByContext = executionRequest.context ? costByContextMap.get(executionRequest.context) || 0 : 0;
const operationCost = calculateCost(
subgraph,
executionRequest.document,
executionRequest.variables || EMPTY_OBJECT
);
costByContext += operationCost;
if (executionRequest.context) {
costByContextMap.set(executionRequest.context, costByContext);
}
demandControlLogger?.debug({
operationCost,
totalCost: costByContext
});
if (maxCost != null && costByContext > maxCost) {
throw createGraphQLError(
`Operation estimated cost ${costByContext} exceeded configured maximum ${maxCost}`,
{
extensions: {
code: "COST_ESTIMATED_TOO_EXPENSIVE",
cost: {
estimated: costByContext,
max: maxCost
}
}
}
);
}
},
onExecutionResult({ result, setResult, context }) {
if (includeExtensionMetadata) {
const costByContext = costByContextMap.get(context);
if (costByContext) {
if (isAsyncIterable(result)) {
setResult(
mapAsyncIterator(result, (value) => ({
...value,
extensions: {
...value.extensions || {},
cost: {
estimated: costByContext,
max: maxCost
}
}
}))
);
} else {
setResult({
...result || {},
extensions: {
...result?.extensions || {},
cost: {
estimated: costByContext,
max: maxCost
}
}
});
}
}
}
}
};
}
function useFetchDebug(opts) {
let fetchAPI;
return {
onYogaInit({ yoga }) {
fetchAPI = yoga.fetchAPI;
},
onFetch({ url, options, logger = opts.logger }) {
const fetchId = fetchAPI.crypto.randomUUID();
const fetchLogger = logger.child({
fetchId
});
const httpFetchRequestLogger = fetchLogger.child("http-fetch-request");
httpFetchRequestLogger.debug(() => ({
url,
...options || {},
body: options?.body,
headers: options?.headers,
signal: options?.signal?.aborted ? options?.signal?.reason : false
}));
const start = performance.now();
return function onFetchDone({ response }) {
const httpFetchResponseLogger = fetchLogger.child(
"http-fetch-response"
);
httpFetchResponseLogger.debug(() => ({
status: response.status,
headers: Object.fromEntries(response.headers.entries()),
duration: performance.now() - start
}));
};
}
};
}
function usePropagateHeaders(opts) {
const resHeadersByRequest = /* @__PURE__ */ new WeakMap();
return {
onFetch({ executionRequest, context, options, setOptions }) {
const request = context?.request || executionRequest?.context?.request;
if (request) {
const subgraphName = executionRequest && subgraphNameByExecutionRequest.get(executionRequest);
return handleMaybePromise(
() => handleMaybePromise(
() => opts.fromClientToSubgraphs?.({
request,
subgraphName
}),
(headers) => setOptions({
...options,
// @ts-expect-error TODO: headers can contain null and undefined values. the types are incorrect
headers: {
...headers,
...options.headers
}
})
),
() => {
if (opts.fromSubgraphsToClient) {
return function onFetchDone({ response }) {
return handleMaybePromise(
() => opts.fromSubgraphsToClient?.({
response,
subgraphName
}),
(headers) => {
if (headers && request) {
let existingHeaders = resHeadersByRequest.get(request);
if (!existingHeaders) {
existingHeaders = {};
resHeadersByRequest.set(request, existingHeaders);
}
for (const key in headers) {
const value = headers[key];
if (value) {
const headerAsArray = Array.isArray(value) ? value : [value];
if (existingHeaders[key]) {
existingHeaders[key].push(...headerAsArray);
} else {
existingHeaders[key] = headerAsArray;
}
}
}
}
}
);
};
}
}
);
}
},
onResponse({ response, request }) {
const headers = resHeadersByRequest.get(request);
if (headers) {
for (const key in headers) {
const value = headers[key];
if (value) {
for (const v of value) {
response.headers.append(key, v);
}
}
}
}
}
};
}
function useRequestId() {
return {
onRequest({ request, fetchAPI }) {
const requestId = request.headers.get("x-request-id") || fetchAPI.crypto.randomUUID();
requestIdByRequest.set(request, requestId);
},
onContextBuilding({ context }) {
if (context?.request) {
const requestId = requestIdByRequest.get(context.request);
if (requestId && context.logger) {
context.logger = context.logger.child({ requestId });
}
}
},
onFetch({ context, options, setOptions }) {
if (context?.request) {
const requestId = requestIdByRequest.get(context.request);
if (requestId) {
setOptions({
...options || {},
headers: {
...options.headers || {},
"x-request-id": requestId
}
});
}
}
},
onResponse({ request, response }) {
const requestId = requestIdByRequest.get(request);
if (requestId) {
response.headers.set("x-request-id", requestId);
}
}
};
}
function useRetryOnSchemaReload() {
const execHandlerByContext = /* @__PURE__ */ new WeakMap();
return {
onParams({ request, params, context, paramsHandler }) {
execHandlerByContext.set(
context,
() => paramsHandler({
request,
params,
context
})
);
},
onExecute({ args }) {
const operation = getOperationAST(args.document, args.operationName);
if (operation?.operation !== "query") {
execHandlerByContext.delete(args.contextValue);
}
},
onExecutionResult({ context, result, setResult }) {
const execHandler = execHandlerByContext.get(context);
if (execHandler && !isAsyncIterable$1(result) && result?.errors?.some((e) => e.extensions?.["code"] === "SCHEMA_RELOAD")) {
if (execHandler) {
return handleMaybePromise(
execHandler,
(newResult) => setResult(newResult)
);
}
}
}
};
}
function useSubgraphExecuteDebug(opts) {
let fetchAPI;
return {
onYogaInit({ yoga }) {
fetchAPI = yoga.fetchAPI;
},
onSubgraphExecute({ executionRequest, logger = opts.logger }) {
const subgraphExecuteHookLogger = logger.child({
subgraphExecuteId: fetchAPI.crypto.randomUUID()
});
const subgraphExecuteStartLogger = subgraphExecuteHookLogger.child(
"subgraph-execute-start"
);
subgraphExecuteStartLogger.debug(() => {
const logData = {};
if (executionRequest.document) {
logData["query"] = defaultPrintFn(executionRequest.document);
}
if (executionRequest.variables && Object.keys(executionRequest.variables).length) {
logData["variables"] = executionRequest.variables;
}
return logData;
});
const start = performance.now();
return function onSubgraphExecuteDone({ result }) {
const subgraphExecuteEndLogger = subgraphExecuteHookLogger.child(
"subgraph-execute-end"
);
if (isAsyncIterable$1(result)) {
return {
onNext({ result: result2 }) {
const subgraphExecuteNextLogger = subgraphExecuteHookLogger.child(
"subgraph-execute-next"
);
subgraphExecuteNextLogger.debug(result2);
},
onEnd() {
subgraphExecuteEndLogger.debug(() => ({
duration: performance.now() - start
}));
}
};
}
subgraphExecuteEndLogger.debug(result);
return void 0;
};
}
};
}
function useUpstreamCancel() {
return {
onFetch({ context, options, executionRequest, info }) {
const signals = [];
if (context?.request?.signal) {
signals.push(context.request.signal);
}
const execRequestSignal = executionRequest?.signal || executionRequest?.info?.signal;
if (execRequestSignal) {
signals.push(execRequestSignal);
}
const signalInInfo = info?.signal;
if (signalInInfo) {
signals.push(signalInInfo);
}
if (options.signal) {
signals.push(options.signal);
}
options.signal = AbortSignal.any(signals);
},
onSubgraphExecute({ executionRequest }) {
const signals = [];
if (executionRequest.info?.signal) {
signals.push(executionRequest.info.signal);
}
if (executionRequest.context?.request?.signal) {
signals.push(executionRequest.context.request.signal);
}
if (executionRequest.signal) {
signals.push(executionRequest.signal);
}
executionRequest.signal = AbortSignal.any(signals);
}
};
}
function useUpstreamRetry(opts) {
const timeouts = /* @__PURE__ */ new Set();
const retryOptions = typeof opts === "function" ? opts : () => opts;
const executionRequestResponseMap = /* @__PURE__ */ new WeakMap();
return {
onSubgraphExecute({
subgraphName,
executionRequest,
executor,
setExecutor
}) {
const optsForReq = retryOptions({ subgraphName, executionRequest });
if (optsForReq) {
const {
maxRetries,
retryDelay = 1e3,
retryDelayFactor = 1.25,
shouldRetry = ({ response, executionResult }) => {
if (response) {
if (response.status >= 500 || response.status === 429 || response.headers.get("Retry-After")) {
return true;
}
}
if (!executionResult || !isAsyncIterable(executionResult) && executionResult.errors?.length && executionResult.errors.some((e) => !isOriginalGraphQLError(e))) {
return true;
}
return false;
}
} = optsForReq;
if (maxRetries > 0) {
setExecutor(function(executionRequest2) {
let attemptsLeft = maxRetries + 1;
let executionResult;
let currRetryDelay = retryDelay;
function retry() {
try {
if (attemptsLeft <= 0) {
return executionResult;
}
const requestTime = Date.now();
attemptsLeft--;
return handleMaybePromise(
() => executor(executionRequest2),
(currRes) => {
executionResult = currRes;
let retryAfterSecondsFromHeader;
const response = executionRequestResponseMap.get(executionRequest2);
executionRequestResponseMap.delete(executionRequest2);
const retryAfterHeader = response?.headers.get("Retry-After");
if (retryAfterHeader) {
retryAfterSecondsFromHeader = parseInt(retryAfterHeader) * 1e3;
if (isNaN(retryAfterSecondsFromHeader)) {
const dateTime = new Date(retryAfterHeader).getTime();
if (!isNaN(dateTime)) {
retryAfterSecondsFromHeader = dateTime - requestTime;
}
}
}
currRetryDelay = retryAfterSecondsFromHeader || currRetryDelay * retryDelayFactor;
if (shouldRetry({
executionRequest: executionRequest2,
executionResult,
response
})) {
return new Promise((resolve) => {
const timeout = setTimeout(() => {
timeouts.delete(timeout);
resolve(retry());
}, currRetryDelay);
timeouts.add(timeout);
});
}
return executionResult;
},
(e) => {
if (attemptsLeft <= 0) {
throw e;
}
return retry();
}
);
} catch (e) {
if (attemptsLeft <= 0) {
throw e;
}
return retry();
}
}
return retry();
});
}
}
},
onFetch({ executionRequest }) {
if (executionRequest) {
return function onFetchDone({ response }) {
executionRequestResponseMap.set(executionRequest, response);
};
}
return void 0;
},
onDispose() {
for (const timeout of timeouts) {
clearTimeout(timeout);
timeouts.delete(timeout);
}
}
};
}
function useUpstreamTimeout(opts) {
const timeoutFactory = typeof opts === "function" ? opts : () => opts;
const timeoutSignalsByExecutionRequest = /* @__PURE__ */ new WeakMap();
const errorExtensionsByExecRequest = /* @__PURE__ */ new WeakMap();
return {
onSubgraphExecute({
subgraphName,
executionRequest,
executor,
setExecutor
}) {
const timeout = timeoutFactory({ subgraphName, executionRequest });
if (timeout) {
setExecutor(function timeoutExecutor(executionRequest2) {
let timeoutSignal = timeoutSignalsByExecution