Socket
Socket
Sign inDemoInstall

graphql

Package Overview
Dependencies
Maintainers
9
Versions
258
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

graphql - npm Package Compare versions

Comparing version 17.0.0-alpha.5 to 17.0.0-alpha.5.canary.pr.4153.4ff43175428332c954563050819fcb612e19ca41

execution/buildExecutionPlan.d.ts
execution/buildExecutionPlan.js
execution/buildExecutionPlan.mjs
execution/DeferredFragments.d.ts
execution/DeferredFragments.js
execution/DeferredFragments.mjs

17

execution/collectFields.d.ts
import type { ObjMap } from '../jsutils/ObjMap.js';
import type { Path } from '../jsutils/Path.js';
import type {

@@ -12,2 +13,3 @@ FieldNode,

parentDeferUsage: DeferUsage | undefined;
depth: number;
}

@@ -19,3 +21,5 @@ export interface FieldDetails {

export type FieldGroup = ReadonlyArray<FieldDetails>;
export type GroupedFieldSet = ReadonlyMap<string, FieldGroup>;
export type GroupedFieldSet = ReadonlyMap<string, FieldGroup> & {
encounteredDefer?: boolean;
};
/**

@@ -38,6 +42,3 @@ * Given a selectionSet, collects all of the fields and returns them.

operation: OperationDefinitionNode,
): {
groupedFieldSet: GroupedFieldSet;
newDeferUsages: ReadonlyArray<DeferUsage>;
};
): GroupedFieldSet;
/**

@@ -62,5 +63,3 @@ * Given an array of field nodes, collects all of the subfields of the passed

fieldGroup: FieldGroup,
): {
groupedFieldSet: GroupedFieldSet;
newDeferUsages: ReadonlyArray<DeferUsage>;
};
path: Path,
): GroupedFieldSet;

57

execution/collectFields.js

@@ -6,2 +6,3 @@ 'use strict';

const invariant_js_1 = require('../jsutils/invariant.js');
const Path_js_1 = require('../jsutils/Path.js');
const ast_js_1 = require('../language/ast.js');

@@ -30,3 +31,2 @@ const kinds_js_1 = require('../language/kinds.js');

const groupedFieldSet = new AccumulatorMap_js_1.AccumulatorMap();
const newDeferUsages = [];
const context = {

@@ -39,10 +39,9 @@ schema,

visitedFragmentNames: new Set(),
encounteredDefer: false,
};
collectFieldsImpl(
context,
operation.selectionSet,
groupedFieldSet,
newDeferUsages,
);
return { groupedFieldSet, newDeferUsages };
collectFieldsImpl(context, operation.selectionSet, groupedFieldSet);
if (context.encounteredDefer) {
groupedFieldSet.encounteredDefer = true;
}
return groupedFieldSet;
}

@@ -68,2 +67,3 @@ exports.collectFields = collectFields;

fieldGroup,
path,
) {

@@ -77,7 +77,7 @@ const context = {

visitedFragmentNames: new Set(),
encounteredDefer: false,
};
const subGroupedFieldSet = new AccumulatorMap_js_1.AccumulatorMap();
const newDeferUsages = [];
for (const fieldDetail of fieldGroup) {
const node = fieldDetail.node;
const { node, deferUsage } = fieldDetail;
if (node.selectionSet) {

@@ -88,11 +88,11 @@ collectFieldsImpl(

subGroupedFieldSet,
newDeferUsages,
fieldDetail.deferUsage,
path,
deferUsage,
);
}
}
return {
groupedFieldSet: subGroupedFieldSet,
newDeferUsages,
};
if (context.encounteredDefer) {
subGroupedFieldSet.encounteredDefer = true;
}
return subGroupedFieldSet;
}

@@ -104,3 +104,3 @@ exports.collectSubfields = collectSubfields;

groupedFieldSet,
newDeferUsages,
path,
deferUsage,

@@ -139,2 +139,3 @@ ) {

selection,
path,
deferUsage,

@@ -147,7 +148,7 @@ );

groupedFieldSet,
newDeferUsages,
path,
deferUsage,
);
} else {
newDeferUsages.push(newDeferUsage);
context.encounteredDefer = true;
collectFieldsImpl(

@@ -157,3 +158,3 @@ context,

groupedFieldSet,
newDeferUsages,
path,
newDeferUsage,

@@ -170,2 +171,3 @@ );

selection,
path,
deferUsage,

@@ -193,7 +195,7 @@ );

groupedFieldSet,
newDeferUsages,
path,
deferUsage,
);
} else {
newDeferUsages.push(newDeferUsage);
context.encounteredDefer = true;
collectFieldsImpl(

@@ -203,3 +205,3 @@ context,

groupedFieldSet,
newDeferUsages,
path,
newDeferUsage,

@@ -218,3 +220,9 @@ );

*/
function getDeferUsage(operation, variableValues, node, parentDeferUsage) {
function getDeferUsage(
operation,
variableValues,
node,
path,
parentDeferUsage,
) {
const defer = (0, values_js_1.getDirectiveValues)(

@@ -239,2 +247,3 @@ directives_js_1.GraphQLDeferDirective,

parentDeferUsage,
depth: (0, Path_js_1.pathToArray)(path).length,
};

@@ -241,0 +250,0 @@ }

1

execution/execute.d.ts

@@ -65,2 +65,3 @@ import type { Maybe } from '../jsutils/Maybe.js';

errors: Array<GraphQLError> | undefined;
encounteredDefer: boolean;
cancellableStreams: Set<CancellableStreamRecord> | undefined;

@@ -67,0 +68,0 @@ }

66

execution/IncrementalGraph.d.ts

@@ -0,8 +1,12 @@

import type { Path } from '../jsutils/Path.js';
import type { DeferUsage } from './collectFields.js';
import type {
DeferredFragmentRecord,
DeliveryGroup,
} from './DeferredFragments.js';
import type {
IncrementalDataRecord,
IncrementalDataRecordResult,
ReconcilableDeferredGroupedFieldSetResult,
StreamRecord,
SubsequentResultRecord,
SuccessfulExecutionGroup,
} from './types.js';

@@ -13,38 +17,46 @@ /**

export declare class IncrementalGraph {
private _pending;
private _deferredFragmentNodes;
private _newPending;
private _newIncrementalDataRecords;
private _rootNodes;
private _deferredFragmentFactory;
private _completedQueue;
private _nextQueue;
constructor();
addIncrementalDataRecords(
getNewRootNodes(
incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>,
): ReadonlyArray<DeliveryGroup>;
addCompletedSuccessfulExecutionGroup(
successfulExecutionGroup: SuccessfulExecutionGroup,
): void;
addCompletedReconcilableDeferredGroupedFieldSet(
reconcilableResult: ReconcilableDeferredGroupedFieldSetResult,
): void;
getNewPending(): ReadonlyArray<SubsequentResultRecord>;
completedIncrementalData(): {
[Symbol.asyncIterator](): any;
next: () => Promise<IteratorResult<Iterable<IncrementalDataRecordResult>>>;
return: () => Promise<
IteratorResult<Iterable<IncrementalDataRecordResult>>
>;
};
getDeepestDeferredFragmentAtRoot(
initialDeferUsage: DeferUsage,
deferUsages: ReadonlySet<DeferUsage>,
path: Path | undefined,
): DeferredFragmentRecord;
currentCompletedBatch(): Generator<IncrementalDataRecordResult>;
nextCompletedBatch(): Promise<
Iterable<IncrementalDataRecordResult> | undefined
>;
abort(): void;
hasNext(): boolean;
completeDeferredFragment(
deferredFragmentRecord: DeferredFragmentRecord,
): Array<ReconcilableDeferredGroupedFieldSetResult> | undefined;
deferUsage: DeferUsage,
path: Path | undefined,
):
| {
deferredFragmentRecord: DeferredFragmentRecord;
newRootNodes: ReadonlyArray<DeliveryGroup>;
successfulExecutionGroups: ReadonlyArray<SuccessfulExecutionGroup>;
}
| undefined;
removeDeferredFragment(
deferredFragmentRecord: DeferredFragmentRecord,
): boolean;
deferUsage: DeferUsage,
path: Path | undefined,
): DeferredFragmentRecord | undefined;
removeStream(streamRecord: StreamRecord): void;
private _removePending;
private _addDeferredGroupedFieldSetRecord;
private _addStreamRecord;
private _addDeferredFragmentNode;
private _addIncrementalDataRecords;
private _promoteNonEmptyToRoot;
private _completesRootNode;
private _addDeferredFragment;
private _onExecutionGroup;
private _onStreamItems;
private _yieldCurrentCompletedIncrementalData;
private _enqueue;
}

393

execution/IncrementalGraph.js

@@ -5,11 +5,7 @@ 'use strict';

const BoxedPromiseOrValue_js_1 = require('../jsutils/BoxedPromiseOrValue.js');
const invariant_js_1 = require('../jsutils/invariant.js');
const isPromise_js_1 = require('../jsutils/isPromise.js');
const promiseWithResolvers_js_1 = require('../jsutils/promiseWithResolvers.js');
const DeferredFragments_js_1 = require('./DeferredFragments.js');
const types_js_1 = require('./types.js');
function isDeferredFragmentNode(node) {
return node !== undefined;
}
function isStreamNode(record) {
return 'streamItemQueue' in record;
}
/**

@@ -20,216 +16,243 @@ * @internal

constructor() {
this._pending = new Set();
this._deferredFragmentNodes = new Map();
this._newIncrementalDataRecords = new Set();
this._newPending = new Set();
this._deferredFragmentFactory =
new DeferredFragments_js_1.DeferredFragmentFactory();
this._rootNodes = new Set();
this._completedQueue = [];
this._nextQueue = [];
}
addIncrementalDataRecords(incrementalDataRecords) {
for (const incrementalDataRecord of incrementalDataRecords) {
if (
(0, types_js_1.isDeferredGroupedFieldSetRecord)(incrementalDataRecord)
) {
this._addDeferredGroupedFieldSetRecord(incrementalDataRecord);
} else {
this._addStreamRecord(incrementalDataRecord);
}
}
getNewRootNodes(incrementalDataRecords) {
const initialResultChildren = new Set();
this._addIncrementalDataRecords(
incrementalDataRecords,
undefined,
initialResultChildren,
);
return this._promoteNonEmptyToRoot(initialResultChildren);
}
addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult) {
const deferredFragmentNodes =
reconcilableResult.deferredGroupedFieldSetRecord.deferredFragmentRecords
.map((deferredFragmentRecord) =>
this._deferredFragmentNodes.get(deferredFragmentRecord),
)
.filter(isDeferredFragmentNode);
for (const deferredFragmentNode of deferredFragmentNodes) {
deferredFragmentNode.deferredGroupedFieldSetRecords.delete(
reconcilableResult.deferredGroupedFieldSetRecord,
addCompletedSuccessfulExecutionGroup(successfulExecutionGroup) {
const { pendingExecutionGroup, incrementalDataRecords } =
successfulExecutionGroup;
const { deferUsages, path } = pendingExecutionGroup;
const deferredFragmentRecords = [];
for (const deferUsage of deferUsages) {
const deferredFragmentRecord = this._deferredFragmentFactory.get(
deferUsage,
path,
);
deferredFragmentNode.reconcilableResults.add(reconcilableResult);
deferredFragmentRecords.push(deferredFragmentRecord);
const { pendingExecutionGroups, successfulExecutionGroups } =
deferredFragmentRecord;
pendingExecutionGroups.delete(pendingExecutionGroup);
successfulExecutionGroups.add(successfulExecutionGroup);
}
if (incrementalDataRecords !== undefined) {
this._addIncrementalDataRecords(
incrementalDataRecords,
deferredFragmentRecords,
);
}
}
getNewPending() {
const newPending = [];
for (const node of this._newPending) {
if (isStreamNode(node)) {
this._pending.add(node);
newPending.push(node);
this._newIncrementalDataRecords.add(node);
} else if (node.deferredGroupedFieldSetRecords.size > 0) {
for (const deferredGroupedFieldSetNode of node.deferredGroupedFieldSetRecords) {
this._newIncrementalDataRecords.add(deferredGroupedFieldSetNode);
}
this._pending.add(node);
newPending.push(node.deferredFragmentRecord);
} else {
for (const child of node.children) {
this._newPending.add(child);
}
getDeepestDeferredFragmentAtRoot(initialDeferUsage, deferUsages, path) {
let bestDeferUsage = initialDeferUsage;
let maxDepth = initialDeferUsage.depth;
for (const deferUsage of deferUsages) {
if (deferUsage === initialDeferUsage) {
continue;
}
const depth = deferUsage.depth;
if (depth > maxDepth) {
maxDepth = depth;
bestDeferUsage = deferUsage;
}
}
this._newPending.clear();
for (const incrementalDataRecord of this._newIncrementalDataRecords) {
if (isStreamNode(incrementalDataRecord)) {
// eslint-disable-next-line @typescript-eslint/no-floating-promises
this._onStreamItems(
incrementalDataRecord,
incrementalDataRecord.streamItemQueue,
);
} else {
const deferredGroupedFieldSetResult = incrementalDataRecord.result;
const result =
deferredGroupedFieldSetResult instanceof
BoxedPromiseOrValue_js_1.BoxedPromiseOrValue
? deferredGroupedFieldSetResult.value
: deferredGroupedFieldSetResult().value;
if ((0, isPromise_js_1.isPromise)(result)) {
// eslint-disable-next-line @typescript-eslint/no-floating-promises
result.then((resolved) => this._enqueue(resolved));
} else {
this._enqueue(result);
}
return this._deferredFragmentFactory.get(bestDeferUsage, path);
}
*currentCompletedBatch() {
let completed;
while ((completed = this._completedQueue.shift()) !== undefined) {
yield completed;
}
if (this._rootNodes.size === 0) {
for (const resolve of this._nextQueue) {
resolve(undefined);
}
}
this._newIncrementalDataRecords.clear();
return newPending;
}
completedIncrementalData() {
return {
[Symbol.asyncIterator]() {
return this;
},
next: () => {
const firstResult = this._completedQueue.shift();
if (firstResult !== undefined) {
return Promise.resolve({
value: this._yieldCurrentCompletedIncrementalData(firstResult),
done: false,
});
}
const { promise, resolve } = (0,
promiseWithResolvers_js_1.promiseWithResolvers)();
this._nextQueue.push(resolve);
return promise;
},
return: () => {
for (const resolve of this._nextQueue) {
resolve({ value: undefined, done: true });
}
return Promise.resolve({ value: undefined, done: true });
},
};
nextCompletedBatch() {
const { promise, resolve } = (0,
promiseWithResolvers_js_1.promiseWithResolvers)();
this._nextQueue.push(resolve);
return promise;
}
abort() {
for (const resolve of this._nextQueue) {
resolve(undefined);
}
}
hasNext() {
return this._pending.size > 0;
return this._rootNodes.size > 0;
}
completeDeferredFragment(deferredFragmentRecord) {
const deferredFragmentNode = this._deferredFragmentNodes.get(
deferredFragmentRecord,
completeDeferredFragment(deferUsage, path) {
const deferredFragmentRecord = this._deferredFragmentFactory.get(
deferUsage,
path,
);
// TODO: add test case?
/* c8 ignore next 3 */
if (deferredFragmentNode === undefined) {
return undefined;
}
if (deferredFragmentNode.deferredGroupedFieldSetRecords.size > 0) {
if (
!this._rootNodes.has(deferredFragmentRecord) ||
deferredFragmentRecord.pendingExecutionGroups.size > 0
) {
return;
}
const reconcilableResults = Array.from(
deferredFragmentNode.reconcilableResults,
const successfulExecutionGroups = Array.from(
deferredFragmentRecord.successfulExecutionGroups,
);
for (const reconcilableResult of reconcilableResults) {
for (const otherDeferredFragmentRecord of reconcilableResult
.deferredGroupedFieldSetRecord.deferredFragmentRecords) {
const otherDeferredFragmentNode = this._deferredFragmentNodes.get(
otherDeferredFragmentRecord,
this._rootNodes.delete(deferredFragmentRecord);
for (const successfulExecutionGroup of successfulExecutionGroups) {
const { deferUsages, path: resultPath } =
successfulExecutionGroup.pendingExecutionGroup;
for (const otherDeferUsage of deferUsages) {
const otherDeferredFragmentRecord = this._deferredFragmentFactory.get(
otherDeferUsage,
resultPath,
);
if (otherDeferredFragmentNode === undefined) {
continue;
}
otherDeferredFragmentNode.reconcilableResults.delete(
reconcilableResult,
otherDeferredFragmentRecord.successfulExecutionGroups.delete(
successfulExecutionGroup,
);
}
}
this._removePending(deferredFragmentNode);
for (const child of deferredFragmentNode.children) {
this._newPending.add(child);
}
return reconcilableResults;
const newRootNodes = this._promoteNonEmptyToRoot(
deferredFragmentRecord.children,
);
return { deferredFragmentRecord, newRootNodes, successfulExecutionGroups };
}
removeDeferredFragment(deferredFragmentRecord) {
const deferredFragmentNode = this._deferredFragmentNodes.get(
deferredFragmentRecord,
removeDeferredFragment(deferUsage, path) {
const deferredFragmentRecord = this._deferredFragmentFactory.get(
deferUsage,
path,
);
if (deferredFragmentNode === undefined) {
return false;
if (!this._rootNodes.has(deferredFragmentRecord)) {
return;
}
this._removePending(deferredFragmentNode);
this._deferredFragmentNodes.delete(deferredFragmentRecord);
// TODO: add test case for an erroring deferred fragment with child defers
/* c8 ignore next 3 */
for (const child of deferredFragmentNode.children) {
this.removeDeferredFragment(child.deferredFragmentRecord);
}
return true;
this._rootNodes.delete(deferredFragmentRecord);
return deferredFragmentRecord;
}
removeStream(streamRecord) {
this._removePending(streamRecord);
this._rootNodes.delete(streamRecord);
}
_removePending(subsequentResultNode) {
this._pending.delete(subsequentResultNode);
if (this._pending.size === 0) {
for (const resolve of this._nextQueue) {
resolve({ value: undefined, done: true });
_addIncrementalDataRecords(
incrementalDataRecords,
parents,
initialResultChildren,
) {
for (const incrementalDataRecord of incrementalDataRecords) {
if ((0, types_js_1.isPendingExecutionGroup)(incrementalDataRecord)) {
const { deferUsages, path } = incrementalDataRecord;
for (const deferUsage of deferUsages) {
const deferredFragmentRecord = this._deferredFragmentFactory.get(
deferUsage,
path,
);
this._addDeferredFragment(
deferredFragmentRecord,
initialResultChildren,
);
deferredFragmentRecord.pendingExecutionGroups.add(
incrementalDataRecord,
);
}
if (this._completesRootNode(incrementalDataRecord)) {
this._onExecutionGroup(incrementalDataRecord);
}
} else if (parents === undefined) {
initialResultChildren !== undefined ||
(0, invariant_js_1.invariant)(false);
initialResultChildren.add(incrementalDataRecord);
} else {
for (const parent of parents) {
this._addDeferredFragment(parent, initialResultChildren);
parent.children.add(incrementalDataRecord);
}
}
}
}
_addDeferredGroupedFieldSetRecord(deferredGroupedFieldSetRecord) {
for (const deferredFragmentRecord of deferredGroupedFieldSetRecord.deferredFragmentRecords) {
const deferredFragmentNode = this._addDeferredFragmentNode(
deferredFragmentRecord,
_promoteNonEmptyToRoot(maybeEmptyNewRootNodes) {
const newRootNodes = [];
for (const node of maybeEmptyNewRootNodes) {
if ((0, DeferredFragments_js_1.isDeferredFragmentRecord)(node)) {
if (node.pendingExecutionGroups.size > 0) {
for (const pendingExecutionGroup of node.pendingExecutionGroups) {
if (!this._completesRootNode(pendingExecutionGroup)) {
this._onExecutionGroup(pendingExecutionGroup);
}
}
this._rootNodes.add(node);
newRootNodes.push(node);
continue;
}
for (const child of node.children) {
maybeEmptyNewRootNodes.add(child);
}
} else {
this._rootNodes.add(node);
newRootNodes.push(node);
// eslint-disable-next-line @typescript-eslint/no-floating-promises
this._onStreamItems(node);
}
}
return newRootNodes;
}
_completesRootNode(pendingExecutionGroup) {
const { deferUsages, path } = pendingExecutionGroup;
for (const deferUsage of deferUsages) {
const deferredFragmentRecord = this._deferredFragmentFactory.get(
deferUsage,
path,
);
if (this._pending.has(deferredFragmentNode)) {
this._newIncrementalDataRecords.add(deferredGroupedFieldSetRecord);
if (this._rootNodes.has(deferredFragmentRecord)) {
return true;
}
deferredFragmentNode.deferredGroupedFieldSetRecords.add(
deferredGroupedFieldSetRecord,
);
}
return false;
}
_addStreamRecord(streamRecord) {
this._newPending.add(streamRecord);
}
_addDeferredFragmentNode(deferredFragmentRecord) {
let deferredFragmentNode = this._deferredFragmentNodes.get(
deferredFragmentRecord,
);
if (deferredFragmentNode !== undefined) {
return deferredFragmentNode;
_addDeferredFragment(deferredFragmentRecord, initialResultChildren) {
if (this._rootNodes.has(deferredFragmentRecord)) {
return;
}
deferredFragmentNode = {
deferredFragmentRecord,
deferredGroupedFieldSetRecords: new Set(),
reconcilableResults: new Set(),
children: [],
};
this._deferredFragmentNodes.set(
deferredFragmentRecord,
deferredFragmentNode,
const parentDeferUsage = deferredFragmentRecord.parentDeferUsage;
if (parentDeferUsage === undefined) {
initialResultChildren !== undefined ||
(0, invariant_js_1.invariant)(false);
initialResultChildren.add(deferredFragmentRecord);
return;
}
const parent = this._deferredFragmentFactory.get(
parentDeferUsage,
deferredFragmentRecord.path,
);
const parent = deferredFragmentRecord.parent;
if (parent === undefined) {
this._newPending.add(deferredFragmentNode);
return deferredFragmentNode;
parent.children.add(deferredFragmentRecord);
this._addDeferredFragment(parent, initialResultChildren);
}
_onExecutionGroup(pendingExecutionGroup) {
let completedExecutionGroup = pendingExecutionGroup.result;
if (
!(
completedExecutionGroup instanceof
BoxedPromiseOrValue_js_1.BoxedPromiseOrValue
)
) {
completedExecutionGroup = completedExecutionGroup();
}
const parentNode = this._addDeferredFragmentNode(parent);
parentNode.children.push(deferredFragmentNode);
return deferredFragmentNode;
const value = completedExecutionGroup.value;
if ((0, isPromise_js_1.isPromise)(value)) {
// eslint-disable-next-line @typescript-eslint/no-floating-promises
value.then((resolved) => this._enqueue(resolved));
} else {
this._enqueue(value);
}
}
async _onStreamItems(streamRecord, streamItemQueue) {
async _onStreamItems(streamRecord) {
let items = [];
let errors = [];
let incrementalDataRecords = [];
const streamItemQueue = streamRecord.streamItemQueue;
let streamItemRecord;

@@ -290,21 +313,11 @@ while ((streamItemRecord = streamItemQueue.shift()) !== undefined) {

}
*_yieldCurrentCompletedIncrementalData(first) {
yield first;
let completed;
while ((completed = this._completedQueue.shift()) !== undefined) {
yield completed;
}
}
_enqueue(completed) {
this._completedQueue.push(completed);
const next = this._nextQueue.shift();
if (next !== undefined) {
next({
value: this._yieldCurrentCompletedIncrementalData(completed),
done: false,
});
if (next === undefined) {
return;
}
this._completedQueue.push(completed);
next(this.currentCompletedBatch());
}
}
exports.IncrementalGraph = IncrementalGraph;

171

execution/IncrementalPublisher.js

@@ -35,5 +35,6 @@ 'use strict';

buildResponse(data, errors, incrementalDataRecords) {
this._incrementalGraph.addIncrementalDataRecords(incrementalDataRecords);
const newPending = this._incrementalGraph.getNewPending();
const pending = this._pendingSourcesToResults(newPending);
const newRootNodes = this._incrementalGraph.getNewRootNodes(
incrementalDataRecords,
);
const pending = this._toPendingResults(newRootNodes);
const initialResult =

@@ -48,13 +49,13 @@ errors === undefined

}
_pendingSourcesToResults(newPending) {
_toPendingResults(newRootNodes) {
const pendingResults = [];
for (const pendingSource of newPending) {
for (const node of newRootNodes) {
const id = String(this._getNextId());
pendingSource.id = id;
node.id = id;
const pendingResult = {
id,
path: (0, Path_js_1.pathToArray)(pendingSource.path),
path: (0, Path_js_1.pathToArray)(node.path),
};
if (pendingSource.label !== undefined) {
pendingResult.label = pendingSource.label;
if (node.label !== undefined) {
pendingResult.label = node.label;
}

@@ -80,10 +81,5 @@ pendingResults.push(pendingResult);

};
const completedIncrementalData =
this._incrementalGraph.completedIncrementalData();
// use the raw iterator rather than 'for await ... of' so as not to trigger the
// '.return()' method on the iterator when exiting the loop with the next value
const asyncIterator = completedIncrementalData[Symbol.asyncIterator]();
let iteration = await asyncIterator.next();
while (!iteration.done) {
for (const completedResult of iteration.value) {
let batch = this._incrementalGraph.currentCompletedBatch();
do {
for (const completedResult of batch) {
this._handleCompletedIncrementalData(completedResult, context);

@@ -95,3 +91,2 @@ }

if (!hasNext) {
// eslint-disable-next-line require-atomic-updates
isDone = true;

@@ -113,4 +108,4 @@ }

// eslint-disable-next-line no-await-in-loop
iteration = await asyncIterator.next();
}
batch = await this._incrementalGraph.nextCompletedBatch();
} while (batch !== undefined);
await this._returnAsyncIteratorsIgnoringErrors();

@@ -121,2 +116,3 @@ return { value: undefined, done: true };

isDone = true;
this._incrementalGraph.abort();
await this._returnAsyncIterators();

@@ -127,2 +123,3 @@ return { value: undefined, done: true };

isDone = true;
this._incrementalGraph.abort();
await this._returnAsyncIterators();

@@ -141,37 +138,23 @@ return Promise.reject(error);

_handleCompletedIncrementalData(completedIncrementalData, context) {
if (
(0, types_js_1.isDeferredGroupedFieldSetResult)(completedIncrementalData)
) {
this._handleCompletedDeferredGroupedFieldSet(
completedIncrementalData,
context,
);
if ((0, types_js_1.isCompletedExecutionGroup)(completedIncrementalData)) {
this._handleCompletedExecutionGroup(completedIncrementalData, context);
} else {
this._handleCompletedStreamItems(completedIncrementalData, context);
}
const newPending = this._incrementalGraph.getNewPending();
context.pending.push(...this._pendingSourcesToResults(newPending));
}
_handleCompletedDeferredGroupedFieldSet(
deferredGroupedFieldSetResult,
context,
) {
if (
(0, types_js_1.isNonReconcilableDeferredGroupedFieldSetResult)(
deferredGroupedFieldSetResult,
)
) {
for (const deferredFragmentRecord of deferredGroupedFieldSetResult
.deferredGroupedFieldSetRecord.deferredFragmentRecords) {
const id = deferredFragmentRecord.id;
if (
!this._incrementalGraph.removeDeferredFragment(deferredFragmentRecord)
) {
_handleCompletedExecutionGroup(completedExecutionGroup, context) {
const { deferUsages, path } = completedExecutionGroup.pendingExecutionGroup;
if ((0, types_js_1.isFailedExecutionGroup)(completedExecutionGroup)) {
for (const deferUsage of deferUsages) {
const deferredFragmentRecord =
this._incrementalGraph.removeDeferredFragment(deferUsage, path);
if (deferredFragmentRecord === undefined) {
// This can occur if multiple deferred grouped field sets error for a fragment.
continue;
}
const id = deferredFragmentRecord.id;
id !== undefined || (0, invariant_js_1.invariant)(false);
context.completed.push({
id,
errors: deferredGroupedFieldSetResult.errors,
errors: completedExecutionGroup.errors,
});

@@ -181,31 +164,39 @@ }

}
this._incrementalGraph.addCompletedReconcilableDeferredGroupedFieldSet(
deferredGroupedFieldSetResult,
this._incrementalGraph.addCompletedSuccessfulExecutionGroup(
completedExecutionGroup,
);
const incrementalDataRecords =
deferredGroupedFieldSetResult.incrementalDataRecords;
if (incrementalDataRecords !== undefined) {
this._incrementalGraph.addIncrementalDataRecords(incrementalDataRecords);
}
for (const deferredFragmentRecord of deferredGroupedFieldSetResult
.deferredGroupedFieldSetRecord.deferredFragmentRecords) {
const reconcilableResults =
this._incrementalGraph.completeDeferredFragment(deferredFragmentRecord);
if (reconcilableResults === undefined) {
for (const deferUsage of deferUsages) {
const completion = this._incrementalGraph.completeDeferredFragment(
deferUsage,
path,
);
if (completion === undefined) {
continue;
}
const id = deferredFragmentRecord.id;
id !== undefined || (0, invariant_js_1.invariant)(false);
const incremental = context.incremental;
for (const reconcilableResult of reconcilableResults) {
const { bestId, subPath } = this._getBestIdAndSubPath(
id,
deferredFragmentRecord,
reconcilableResult,
);
const {
deferredFragmentRecord,
newRootNodes,
successfulExecutionGroups,
} = completion;
context.pending.push(...this._toPendingResults(newRootNodes));
for (const successfulExecutionGroup of successfulExecutionGroups) {
const { deferUsages: resultDeferUsages, path: resultPath } =
successfulExecutionGroup.pendingExecutionGroup;
const bestDeferredFragmentRecord =
this._incrementalGraph.getDeepestDeferredFragmentAtRoot(
deferUsage,
resultDeferUsages,
resultPath,
);
const bestId = bestDeferredFragmentRecord.id;
bestId !== undefined || (0, invariant_js_1.invariant)(false);
const incrementalEntry = {
...reconcilableResult.result,
...successfulExecutionGroup.result,
id: bestId,
};
if (subPath !== undefined) {
const subPath = (0, Path_js_1.pathToArray)(resultPath).slice(
(0, Path_js_1.pathToArray)(bestDeferredFragmentRecord.path).length,
);
if (subPath.length > 0) {
incrementalEntry.subPath = subPath;

@@ -215,2 +206,4 @@ }

}
const id = deferredFragmentRecord.id;
id !== undefined || (0, invariant_js_1.invariant)(false);
context.completed.push({ id });

@@ -252,46 +245,12 @@ }

context.incremental.push(incrementalEntry);
if (streamItemsResult.incrementalDataRecords !== undefined) {
this._incrementalGraph.addIncrementalDataRecords(
streamItemsResult.incrementalDataRecords,
const incrementalDataRecords = streamItemsResult.incrementalDataRecords;
if (incrementalDataRecords !== undefined) {
const newRootNodes = this._incrementalGraph.getNewRootNodes(
incrementalDataRecords,
);
context.pending.push(...this._toPendingResults(newRootNodes));
}
}
}
_getBestIdAndSubPath(
initialId,
initialDeferredFragmentRecord,
deferredGroupedFieldSetResult,
) {
let maxLength = (0, Path_js_1.pathToArray)(
initialDeferredFragmentRecord.path,
).length;
let bestId = initialId;
for (const deferredFragmentRecord of deferredGroupedFieldSetResult
.deferredGroupedFieldSetRecord.deferredFragmentRecords) {
if (deferredFragmentRecord === initialDeferredFragmentRecord) {
continue;
}
const id = deferredFragmentRecord.id;
// TODO: add test case for when an fragment has not been released, but might be processed for the shortest path.
/* c8 ignore next 3 */
if (id === undefined) {
continue;
}
const fragmentPath = (0, Path_js_1.pathToArray)(
deferredFragmentRecord.path,
);
const length = fragmentPath.length;
if (length > maxLength) {
maxLength = length;
bestId = id;
}
}
const subPath = deferredGroupedFieldSetResult.path.slice(maxLength);
return {
bestId,
subPath: subPath.length > 0 ? subPath : undefined,
};
}
async _returnAsyncIterators() {
await this._incrementalGraph.completedIncrementalData().return();
const cancellableStreams = this._context.cancellableStreams;

@@ -298,0 +257,0 @@ if (cancellableStreams === undefined) {

67

execution/types.d.ts

@@ -8,2 +8,3 @@ import type { BoxedPromiseOrValue } from '../jsutils/BoxedPromiseOrValue.js';

} from '../error/GraphQLError.js';
import type { DeferUsage } from './collectFields.js';
/**

@@ -83,3 +84,3 @@ * The result of GraphQL execution.

}
interface BareDeferredGroupedFieldSetResult<TData = ObjMap<unknown>> {
interface ExecutionGroupResult<TData = ObjMap<unknown>> {
errors?: ReadonlyArray<GraphQLError>;

@@ -91,3 +92,3 @@ data: TData;

TExtensions = ObjMap<unknown>,
> extends BareDeferredGroupedFieldSetResult<TData> {
> extends ExecutionGroupResult<TData> {
id: string;

@@ -107,3 +108,3 @@ subPath?: ReadonlyArray<string | number>;

}
interface BareStreamItemsResult<TData = ReadonlyArray<unknown>> {
interface StreamItemsRecordResult<TData = ReadonlyArray<unknown>> {
errors?: ReadonlyArray<GraphQLError>;

@@ -115,3 +116,3 @@ items: TData;

TExtensions = ObjMap<unknown>,
> extends BareStreamItemsResult<TData> {
> extends StreamItemsRecordResult<TData> {
id: string;

@@ -154,20 +155,20 @@ subPath?: ReadonlyArray<string | number>;

}
export declare function isDeferredGroupedFieldSetRecord(
export declare function isPendingExecutionGroup(
incrementalDataRecord: IncrementalDataRecord,
): incrementalDataRecord is DeferredGroupedFieldSetRecord;
export type DeferredGroupedFieldSetResult =
| ReconcilableDeferredGroupedFieldSetResult
| NonReconcilableDeferredGroupedFieldSetResult;
export declare function isDeferredGroupedFieldSetResult(
subsequentResult: DeferredGroupedFieldSetResult | StreamItemsResult,
): subsequentResult is DeferredGroupedFieldSetResult;
export interface ReconcilableDeferredGroupedFieldSetResult {
deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
): incrementalDataRecord is PendingExecutionGroup;
export type CompletedExecutionGroup =
| SuccessfulExecutionGroup
| FailedExecutionGroup;
export declare function isCompletedExecutionGroup(
incrementalDataRecordResult: IncrementalDataRecordResult,
): incrementalDataRecordResult is CompletedExecutionGroup;
export interface SuccessfulExecutionGroup {
pendingExecutionGroup: PendingExecutionGroup;
path: Array<string | number>;
result: BareDeferredGroupedFieldSetResult;
result: ExecutionGroupResult;
incrementalDataRecords: ReadonlyArray<IncrementalDataRecord> | undefined;
errors?: never;
}
interface NonReconcilableDeferredGroupedFieldSetResult {
deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
interface FailedExecutionGroup {
pendingExecutionGroup: PendingExecutionGroup;
path: Array<string | number>;

@@ -177,18 +178,12 @@ errors: ReadonlyArray<GraphQLError>;

}
export declare function isNonReconcilableDeferredGroupedFieldSetResult(
deferredGroupedFieldSetResult: DeferredGroupedFieldSetResult,
): deferredGroupedFieldSetResult is NonReconcilableDeferredGroupedFieldSetResult;
export declare function isFailedExecutionGroup(
completedExecutionGroup: CompletedExecutionGroup,
): completedExecutionGroup is FailedExecutionGroup;
type ThunkIncrementalResult<T> =
| BoxedPromiseOrValue<T>
| (() => BoxedPromiseOrValue<T>);
export interface DeferredGroupedFieldSetRecord {
deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>;
result: ThunkIncrementalResult<DeferredGroupedFieldSetResult>;
}
export type SubsequentResultRecord = DeferredFragmentRecord | StreamRecord;
export interface DeferredFragmentRecord {
export interface PendingExecutionGroup {
deferUsages: ReadonlySet<DeferUsage>;
path: Path | undefined;
label: string | undefined;
id?: string | undefined;
parent: DeferredFragmentRecord | undefined;
result: ThunkIncrementalResult<CompletedExecutionGroup>;
}

@@ -209,5 +204,5 @@ export interface StreamItemResult {

streamRecord: StreamRecord;
result?: BareStreamItemsResult | undefined;
errors?: ReadonlyArray<GraphQLError>;
result?: StreamItemsRecordResult;
incrementalDataRecords?: ReadonlyArray<IncrementalDataRecord> | undefined;
errors?: ReadonlyArray<GraphQLError> | undefined;
}

@@ -218,10 +213,8 @@ export interface CancellableStreamRecord extends StreamRecord {

export declare function isCancellableStreamRecord(
subsequentResultRecord: SubsequentResultRecord,
): subsequentResultRecord is CancellableStreamRecord;
export type IncrementalDataRecord =
| DeferredGroupedFieldSetRecord
| StreamRecord;
streamRecord: StreamRecord,
): streamRecord is CancellableStreamRecord;
export type IncrementalDataRecord = PendingExecutionGroup | StreamRecord;
export type IncrementalDataRecordResult =
| DeferredGroupedFieldSetResult
| CompletedExecutionGroup
| StreamItemsResult;
export {};

31

execution/types.js
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
exports.isCancellableStreamRecord =
exports.isNonReconcilableDeferredGroupedFieldSetResult =
exports.isDeferredGroupedFieldSetResult =
exports.isDeferredGroupedFieldSetRecord =
exports.isFailedExecutionGroup =
exports.isCompletedExecutionGroup =
exports.isPendingExecutionGroup =
void 0;
function isDeferredGroupedFieldSetRecord(incrementalDataRecord) {
return 'deferredFragmentRecords' in incrementalDataRecord;
function isPendingExecutionGroup(incrementalDataRecord) {
return 'deferUsages' in incrementalDataRecord;
}
exports.isDeferredGroupedFieldSetRecord = isDeferredGroupedFieldSetRecord;
function isDeferredGroupedFieldSetResult(subsequentResult) {
return 'deferredGroupedFieldSetRecord' in subsequentResult;
exports.isPendingExecutionGroup = isPendingExecutionGroup;
function isCompletedExecutionGroup(incrementalDataRecordResult) {
return 'pendingExecutionGroup' in incrementalDataRecordResult;
}
exports.isDeferredGroupedFieldSetResult = isDeferredGroupedFieldSetResult;
function isNonReconcilableDeferredGroupedFieldSetResult(
deferredGroupedFieldSetResult,
) {
return deferredGroupedFieldSetResult.errors !== undefined;
exports.isCompletedExecutionGroup = isCompletedExecutionGroup;
function isFailedExecutionGroup(completedExecutionGroup) {
return completedExecutionGroup.errors !== undefined;
}
exports.isNonReconcilableDeferredGroupedFieldSetResult =
isNonReconcilableDeferredGroupedFieldSetResult;
function isCancellableStreamRecord(subsequentResultRecord) {
return 'earlyReturn' in subsequentResultRecord;
exports.isFailedExecutionGroup = isFailedExecutionGroup;
function isCancellableStreamRecord(streamRecord) {
return 'earlyReturn' in streamRecord;
}
exports.isCancellableStreamRecord = isCancellableStreamRecord;

7

jsutils/memoize3.d.ts
/**
* Memoizes the provided three-argument function.
* Memoizes the provided three-argument or more function based on the first three arguments.
*/

@@ -8,3 +8,6 @@ export declare function memoize3<

A3 extends object,
V extends Array<any>,
R,
>(fn: (a1: A1, a2: A2, a3: A3) => R): (a1: A1, a2: A2, a3: A3) => R;
>(
fn: (a1: A1, a2: A2, a3: A3, ...rest: V) => R,
): (a1: A1, a2: A2, a3: A3, ...rest: V) => R;

6

jsutils/memoize3.js

@@ -5,7 +5,7 @@ 'use strict';

/**
* Memoizes the provided three-argument function.
* Memoizes the provided three-argument or more function based on the first three arguments.
*/
function memoize3(fn) {
let cache0;
return function memoized(a1, a2, a3) {
return function memoized(a1, a2, a3, ...rest) {
if (cache0 === undefined) {

@@ -26,3 +26,3 @@ cache0 = new WeakMap();

if (fnResult === undefined) {
fnResult = fn(a1, a2, a3);
fnResult = fn(a1, a2, a3, ...rest);
cache2.set(a3, fnResult);

@@ -29,0 +29,0 @@ }

9

package.json
{
"name": "graphql",
"version": "17.0.0-alpha.5",
"version": "17.0.0-alpha.5.canary.pr.4153.4ff43175428332c954563050819fcb612e19ca41",
"description": "A Query Language and Runtime which can target any service.",

@@ -35,6 +35,7 @@ "license": "MIT",

"publishConfig": {
"tag": "alpha"
"tag": "canary-pr-4153"
},
"main": "index",
"module": "index.mjs"
}
"module": "index.mjs",
"deprecated": "You are using canary version build from https://github.com/graphql/graphql-js/pull/4153, no gurantees provided so please use your own discretion."
}

7

type/validate.js

@@ -122,3 +122,8 @@ 'use strict';

validateName(context, directive);
// TODO: Ensure proper locations.
if (directive.locations.length === 0) {
context.reportError(
`Directive @${directive.name} must include 1 or more locations.`,
directive.astNode,
);
}
// Ensure the arguments are valid.

@@ -125,0 +130,0 @@ for (const arg of directive.args) {

2

utilities/getIntrospectionQuery.d.ts

@@ -33,3 +33,3 @@ import type { Maybe } from '../jsutils/Maybe.js';

*/
inputObjectOneOf?: boolean;
oneOf?: boolean;
}

@@ -36,0 +36,0 @@ /**

6

utilities/getIntrospectionQuery.js

@@ -15,3 +15,3 @@ 'use strict';

inputValueDeprecation: false,
inputObjectOneOf: false,
oneOf: false,
...options,

@@ -32,3 +32,3 @@ };

}
const inputObjectOneOf = optionsWithDefault.inputObjectOneOf ? 'isOneOf' : '';
const oneOf = optionsWithDefault.oneOf ? 'isOneOf' : '';
return `

@@ -61,3 +61,3 @@ query IntrospectionQuery {

${specifiedByUrl}
${inputObjectOneOf}
${oneOf}
fields(includeDeprecated: true) {

@@ -64,0 +64,0 @@ name

2

utilities/introspectionFromSchema.js

@@ -23,3 +23,3 @@ 'use strict';

inputValueDeprecation: true,
inputObjectOneOf: true,
oneOf: true,
...options,

@@ -26,0 +26,0 @@ };

2

validation/rules/SingleFieldSubscriptionsRule.js

@@ -34,3 +34,3 @@ 'use strict';

}
const { groupedFieldSet } = (0, collectFields_js_1.collectFields)(
const groupedFieldSet = (0, collectFields_js_1.collectFields)(
schema,

@@ -37,0 +37,0 @@ fragments,

execution/buildFieldPlan.d.ts
execution/buildFieldPlan.js
execution/buildFieldPlan.mjs
execution/collectFields.mjs

Sorry, the diff of this file is not supported yet

execution/execute.js

Sorry, the diff of this file is too big to display

execution/execute.mjs

Sorry, the diff of this file is not supported yet

execution/IncrementalGraph.mjs

Sorry, the diff of this file is not supported yet

execution/IncrementalPublisher.mjs

Sorry, the diff of this file is not supported yet

execution/types.mjs

Sorry, the diff of this file is not supported yet

jsutils/memoize3.mjs

Sorry, the diff of this file is not supported yet

type/validate.mjs

Sorry, the diff of this file is not supported yet

utilities/getIntrospectionQuery.mjs

Sorry, the diff of this file is not supported yet

utilities/introspectionFromSchema.mjs

Sorry, the diff of this file is not supported yet

validation/rules/SingleFieldSubscriptionsRule.mjs

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc