/** * This will create an execution path from the list of objects * * @param objects the path objects * * @return a new execution path */ public static ExecutionPath fromList(List<?> objects) { assertNotNull(objects); ExecutionPath path = ExecutionPath.rootPath(); for (Object object : objects) { if (object instanceof Number) { path = path.segment(((Number) object).intValue()); } else { path = path.segment(String.valueOf(object)); } } return path; }
public ExecutionPath sibling(String siblingField) { Assert.assertTrue(!ROOT_PATH.equals(this), "You MUST not call this with the root path"); return new ExecutionPath(this.parent, new StringPathSegment(siblingField)); }
/** * This method will only put one error per field path. * * @param error the error to add * @param fieldPath the field path to put it under */ public void addError(GraphQLError error, ExecutionPath fieldPath) { // // see http://facebook.github.io/graphql/#sec-Errors-and-Non-Nullability about how per // field errors should be handled - ie only once per field if its already there for nullability // but unclear if its not that error path // for (GraphQLError graphQLError : errors) { List<Object> path = graphQLError.getPath(); if (path != null) { if (fieldPath.equals(ExecutionPath.fromList(path))) { return; } } } this.errors.add(error); }
MergedField currentField = fields.getSubField(fieldName); ExecutionPath fieldPath = parameters.getPath().segment(mkNameForPath(currentField)); ExecutionStrategyParameters newParameters = parameters .transform(builder -> builder.field(currentField).path(fieldPath).parent(parameters));
/** * Parses an execution path from the provided path string in the format /segment1/segment2[index]/segmentN * * @param pathString the path string * * @return a parsed execution path */ public static ExecutionPath parse(String pathString) { pathString = pathString == null ? "" : pathString; pathString = pathString.trim(); StringTokenizer st = new StringTokenizer(pathString, "/[]", true); ExecutionPath path = ExecutionPath.rootPath(); while (st.hasMoreTokens()) { String token = st.nextToken(); if ("/".equals(token)) { assertTrue(st.hasMoreTokens(), mkErrMsg(), pathString); path = path.segment(st.nextToken()); } else if ("[".equals(token)) { assertTrue(st.countTokens() >= 2, mkErrMsg(), pathString); path = path.segment(Integer.parseInt(st.nextToken())); String closingBrace = st.nextToken(); assertTrue(closingBrace.equals("]"), mkErrMsg(), pathString); } else { throw new AssertException(format(mkErrMsg(), pathString)); } } return path; }
FieldAndArgError(String message, Field field, ExecutionPath path) { this.message = message; this.locations = field == null ? null : Collections.singletonList(field.getSourceLocation()); this.path = path == null ? null : path.toList(); }
ExecutionPath path = ExecutionPath.rootPath(); ExecutionStepInfo executionStepInfo = newExecutionStepInfo().type(operationRootType).path(path).build(); NonNullableFieldValidator nonNullableFieldValidator = new NonNullableFieldValidator(executionContext, executionStepInfo);
public InstrumentationContext<Object> beginFieldFetch(InstrumentationFieldFetchParameters parameters) { CallStack callStack = parameters.getInstrumentationState(); ExecutionPath path = parameters.getEnvironment().getExecutionStepInfo().getPath(); int level = path.getLevel(); return new InstrumentationContext<Object>() { @Override public void onDispatched(CompletableFuture result) { boolean dispatchNeeded; synchronized (callStack) { callStack.increaseFetchCount(level); dispatchNeeded = dispatchIfNeeded(callStack, level); } if (dispatchNeeded) { dispatch(); } } @Override public void onCompleted(Object result, Throwable t) { } }; }
private ExecutionPath() { parent = null; segment = null; pathList = toListImpl(); }
/** * Takes the current path and adds a new segment to it, returning a new path * * @param segment the int path segment to add * * @return a new path containing that segment */ public ExecutionPath segment(int segment) { return new ExecutionPath(this, new IntPathSegment(segment)); }
public ExecutionPath getPathWithoutListEnd() { if (ROOT_PATH.equals(this)) { return ROOT_PATH; } if (segment instanceof StringPathSegment) { return this; } return parent; }
private ExecutionStrategyParameters firstFieldOfSubscriptionSelection(ExecutionStrategyParameters parameters) { MergedSelectionSet fields = parameters.getFields(); MergedField firstField = fields.getSubField(fields.getKeys().get(0)); ExecutionPath fieldPath = parameters.getPath().segment(mkNameForPath(firstField.getSingleField())); return parameters.transform(builder -> builder.field(firstField).path(fieldPath)); }
/** * Parses an execution path from the provided path string in the format /segment1/segment2[index]/segmentN * * @param pathString the path string * * @return a parsed execution path */ public static ExecutionPath parse(String pathString) { pathString = pathString == null ? "" : pathString; pathString = pathString.trim(); StringTokenizer st = new StringTokenizer(pathString, "/[]", true); ExecutionPath path = ExecutionPath.rootPath(); while (st.hasMoreTokens()) { String token = st.nextToken(); if ("/".equals(token)) { assertTrue(st.hasMoreTokens(), mkErrMsg(), pathString); path = path.segment(st.nextToken()); } else if ("[".equals(token)) { assertTrue(st.countTokens() >= 2, mkErrMsg(), pathString); path = path.segment(Integer.parseInt(st.nextToken())); String closingBrace = st.nextToken(); assertTrue(closingBrace.equals("]"), mkErrMsg(), pathString); } else { throw new AssertException(format(mkErrMsg(), pathString)); } } return path; }
/** * Creating absolute paths follows the following logic: * Relative path is null -> Absolute path null * Relative path is empty -> Absolute paths is path up to the field. * Relative path is not empty -> Absolute paths [base Path, relative Path] * * * @return List of paths from the root. */ private List<Object> createAbsolutePath(ExecutionPath executionPath, GraphQLError relativeError) { return Optional.ofNullable(relativeError.getPath()) .map(originalPath -> { List<Object> path = new ArrayList<>(); path.addAll(executionPath.toList()); path.addAll(relativeError.getPath()); return path; }) .map(Collections::unmodifiableList) .orElse(null); }
.build(); MergedSelectionSet mergedSelectionSet = fieldCollector.collectFields(collectorParameters, operationDefinition.getSelectionSet()); ExecutionStepInfo executionInfo = newExecutionStepInfo().type(operationRootType).path(ExecutionPath.rootPath()).build();
DeferredFieldInstrumentationContext beginDeferredField(InstrumentationDeferredFieldParameters parameters) { CallStack callStack = parameters.getInstrumentationState(); int level = parameters.getExecutionStrategyParameters().getPath().getLevel(); synchronized (callStack) { callStack.clearAndMarkCurrentLevelAsReady(level); } return new DeferredFieldInstrumentationContext() { @Override public void onDispatched(CompletableFuture<ExecutionResult> result) { } @Override public void onCompleted(ExecutionResult result, Throwable t) { } @Override public void onFieldValueInfo(FieldValueInfo fieldValueInfo) { boolean dispatchNeeded; synchronized (callStack) { dispatchNeeded = handleOnFieldValuesInfo(Collections.singletonList(fieldValueInfo), callStack, level); } if (dispatchNeeded) { dispatch(); } } }; }
private ExecutionPath(ExecutionPath parent, PathSegment segment) { this.parent = assertNotNull(parent, "Must provide a parent path"); this.segment = assertNotNull(segment, "Must provide a sub path"); pathList = toListImpl(); }
/** * Takes the current path and adds a new segment to it, returning a new path * * @param segment the string path segment to add * * @return a new path containing that segment */ public ExecutionPath segment(String segment) { return new ExecutionPath(this, new StringPathSegment(segment)); }