@graphql-hive/gateway-runtime
Version:
644 lines (635 loc) • 252 kB
JavaScript
import { isOriginalGraphQLError, getInstrumented as getInstrumented$1 } from '@envelop/core';
export { withState } from '@envelop/core';
import { useDisableIntrospection } from '@envelop/disable-introspection';
import { useGenericAuth } from '@envelop/generic-auth';
import { createSchemaFetcher, createSupergraphSDLFetcher } from '@graphql-hive/core';
import { Logger, LegacyLogger } from '@graphql-hive/logger';
export * from '@graphql-hive/logger';
import { millisecondsToStr, getOnSubgraphExecute, 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 { isUrl, readFileOrUrl, defaultImportFn, getHeadersObj, isDisposable, dispose, getInContextSDK, pathExists } from '@graphql-mesh/utils';
import { batchDelegateToSchema } from '@graphql-tools/batch-delegate';
import { getTypeInfo, EMPTY_OBJECT, delegateToSchema, defaultMergedResolver } from '@graphql-tools/delegate';
import { defaultPrintFn as defaultPrintFn$1 } from '@graphql-tools/executor-common';
import { getDirectiveExtensions, memoize1, isValidPath, pathToArray, memoize3, getDirective, 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 { useCookies } from '@whatwg-node/server-plugin-cookies';
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 { DEFAULT_UPLINKS, fetchSupergraphSdlFromManagedFederation } from '@graphql-tools/federation';
import { context } from '@opentelemetry/api';
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 { requestIdByRequest, loggerForRequest } from '@graphql-hive/logger/request';
import { defaultPrintFn } from '@graphql-mesh/transport-common';
import { abortSignalAny } from '@graphql-hive/signal';
import { getInstrumented } from '@envelop/instrumentation';
import { path, fs } from '@graphql-mesh/cross-helpers';
function createLoggerFromLogging(logging) {
if (logging == null || typeof logging === "boolean") {
return new Logger({ level: logging === false ? false : "info" });
}
if (typeof logging === "string") {
return new Logger({ level: logging });
}
return logging;
}
function getEnvStr(key, opts = {}) {
const globalThat = opts.globalThis ?? globalThis;
let variable = globalThat.process?.env?.[key] || // @ts-expect-error can exist in wrangler and maybe other runtimes
globalThat.env?.[key] || // @ts-expect-error can exist in deno
globalThat.Deno?.env?.get(key) || // @ts-expect-error could be
globalThat[key];
if (variable != null) {
variable += "";
} else {
variable = void 0;
}
return variable?.trim();
}
function getEnvBool(key, opts = {}) {
return strToBool(getEnvStr(key, opts));
}
function getNodeEnv(opts = {}) {
return getEnvStr("NODE_ENV", opts);
}
function strToBool(str) {
return ["1", "t", "true", "y", "yes", "on", "enabled"].includes(
(str || "").toLowerCase()
);
}
function isDebug() {
return getEnvBool("DEBUG");
}
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);
}
});
}
function urlMatches(url, specUrl) {
{
return url === specUrl;
}
}
function normalizeDirectiveName(directiveName) {
if (directiveName.startsWith("@")) {
return directiveName.slice(1);
}
return directiveName;
}
function getDirectiveNameForFederationDirective({
schema,
directiveName,
specUrl
}) {
const directivesOnSchemaDef = getDirectiveExtensions(schema, schema);
const normalizedDirectiveName = normalizeDirectiveName(directiveName);
if (directivesOnSchemaDef?.["link"]) {
const linkDirectives = directivesOnSchemaDef["link"];
for (const linkDirective of linkDirectives) {
if (urlMatches(linkDirective.url, specUrl)) {
const imports = linkDirective.import;
if (imports) {
for (const importDirective of imports) {
if (typeof importDirective === "string") {
const normalizedImportDirective = normalizeDirectiveName(importDirective);
if (normalizedImportDirective === normalizedDirectiveName) {
return normalizedImportDirective;
}
} else {
const normalizedImportDirective = normalizeDirectiveName(
importDirective.name
);
if (normalizedImportDirective === normalizedDirectiveName) {
const normalizedAlias = normalizeDirectiveName(
importDirective.as
);
return normalizedAlias;
}
}
}
}
}
}
}
return normalizedDirectiveName;
}
function createOpenTelemetryAPI() {
let delegate = {
// In case no OpenTelemetry plugin is registered, we just rely on standard context management
getActiveContext: () => context.active(),
// undefined to indicate the OpenTelemetry is either not setup or not initialized yet.
tracer: void 0,
getHttpContext: () => void 0,
getExecutionRequestContext: () => void 0,
getOperationContext: () => void 0
};
let register = (plugin) => {
delegate = plugin;
register = void 0;
};
return {
get tracer() {
return delegate.tracer;
},
getActiveContext: (...args) => delegate.getActiveContext(...args),
getHttpContext: (...args) => delegate.getHttpContext(...args),
getOperationContext: (...args) => delegate.getOperationContext(...args),
getExecutionRequestContext: (...args) => delegate.getExecutionRequestContext(...args),
register
};
}
const defaultLoadedPlacePrefix = "GraphOS Managed Federation";
function decideMaxRetries({
graphosOpts,
pollingInterval,
minDelaySeconds,
uplinks,
initialSchemaExists
}) {
let maxRetries = graphosOpts.maxRetries || Math.max(3, uplinks.length);
if (initialSchemaExists && pollingInterval && pollingInterval <= minDelaySeconds * 1e3) {
maxRetries = 1;
}
return maxRetries;
}
function createGraphOSFetcher({
graphosOpts,
configContext,
pollingInterval
}) {
let lastSeenId;
let lastSupergraphSdl;
let nextFetchTime;
const uplinksParam = graphosOpts.upLink || getEnvStr("APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT");
const uplinks = uplinksParam?.split(",").map((uplink) => uplink.trim()) || DEFAULT_UPLINKS;
const log = configContext.log.child("[apolloGraphOSSupergraphFetcher] ");
log.info({ uplinks }, "Using uplinks");
let supergraphLoadedPlace = defaultLoadedPlacePrefix;
if (graphosOpts.graphRef) {
supergraphLoadedPlace += ` <br>${graphosOpts.graphRef}`;
}
let minDelaySeconds = 10;
const uplinksToUse = [];
return {
supergraphLoadedPlace,
unifiedGraphFetcher(transportContext) {
const maxRetries = decideMaxRetries({
graphosOpts,
pollingInterval,
minDelaySeconds,
uplinks,
initialSchemaExists: !!lastSupergraphSdl
});
let retries = maxRetries;
function fetchSupergraphWithDelay() {
if (nextFetchTime) {
const currentTime = Date.now();
if (nextFetchTime >= currentTime) {
const delay = nextFetchTime - currentTime;
log.info(
`Fetching supergraph with delay ${millisecondsToStr(delay)}`
);
nextFetchTime = 0;
return delayInMs(delay).then(fetchSupergraph);
}
}
return fetchSupergraph();
}
function fetchSupergraph() {
if (uplinksToUse.length === 0) {
uplinksToUse.push(...uplinks);
}
retries--;
const uplinkToUse = uplinksToUse.pop();
const attemptMetadata = {
uplink: uplinkToUse || "none"
};
if (maxRetries > 1) {
attemptMetadata["attempt"] = `${maxRetries - retries}/${maxRetries}`;
}
const attemptLogger = log.child(attemptMetadata);
attemptLogger.debug("Fetching supergraph");
return handleMaybePromise(
() => 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);
}
}
}),
(result) => {
if (result.minDelaySeconds) {
minDelaySeconds = result.minDelaySeconds;
attemptLogger.debug(`Setting min delay to ${minDelaySeconds}s`);
}
nextFetchTime = Date.now() + minDelaySeconds * 1e3;
if ("error" in result && result.error) {
attemptLogger.error(result.error.code, result.error.message);
}
if ("id" in result) {
if (lastSeenId === result.id) {
attemptLogger.debug("Supergraph is unchanged");
return lastSupergraphSdl;
}
lastSeenId = result.id;
}
if ("supergraphSdl" in result && result.supergraphSdl) {
attemptLogger.debug(
`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 from '${uplinkToUse}': [${JSON.stringify(result)}]`
);
}
return lastSupergraphSdl;
},
(err) => {
nextFetchTime = Date.now() + minDelaySeconds * 1e3;
if (retries > 0) {
attemptLogger.error(err);
return fetchSupergraphWithDelay();
}
if (lastSupergraphSdl) {
attemptLogger.error(err);
return lastSupergraphSdl;
}
if (err?.name === "TimeoutError") {
throw new Error(`HTTP request to '${uplinkToUse}' timed out`);
}
throw err;
}
);
}
return fetchSupergraphWithDelay();
}
};
}
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,
logger: LegacyLogger.from(configContext.log)
},
getSubgraphSchema: getSchema,
transportExecutorStack,
transports: config.transports,
instrumentation
});
return function proxyExecutor(executionRequest) {
return onSubgraphExecute(subgraphName, executionRequest);
};
}
function useHiveConsole({
enabled,
token,
...options
}) {
const agent = {
name: "hive-gateway",
logger: LegacyLogger.from(options.log),
...options.agent
};
let usage = void 0;
if (options.usage && typeof options.usage === "object") {
usage = {
...options.usage,
clientInfo: typeof options.usage.clientInfo === "object" ? () => (
// @ts-expect-error clientInfo will be an object
options.usage.clientInfo
) : options.usage.clientInfo
};
} else {
usage = options.usage;
}
if (enabled && !token) {
throw new Error("Hive plugin is enabled but the token is not provided");
}
return useHive({
debug: isDebug(),
...options,
enabled: !!enabled,
token,
agent,
usage
});
}
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 useHiveConsole({
log: configContext.log.child("[useHiveConsole] "),
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;
}
}
const plugin = useApolloUsageReport({
agentVersion: `hive-gateway@${globalThis.__VERSION__}`,
...config.reporting
});
return plugin;
}
return {};
}
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: LegacyLogger.from(configContext.log),
allowUnknownExtensions: true,
importFn: defaultImportFn
});
}
return unifiedGraphSchema;
}
const iconBase64 = "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