graphql-jit 0.8.9 → 0.9.0

package/dist/esm/non-null.js

@@ -0,0 +1,199 @@
+import { isListType, isNonNullType, isObjectType, isAbstractType } from "graphql";
+import merge from "lodash.merge";
+import { collectFields, collectSubfields, resolveFieldDef } from "./ast.js";
+import { getOperationRootType } from "./compat.js";
+/**
+ *
+ * @param {CompilationContext} compilationContext
+ * @returns {(data: any, errors: GraphQLError[]) => {data: any; errors: GraphQLError[]}}
+ */
+export function createNullTrimmer(compilationContext) {
+    return trimData(parseQueryNullables(compilationContext));
+}
+/**
+ * Trims a data response according to the field errors in non null fields.
+ *
+ * Errors are filtered to ensure a single field error per field.
+ *
+ * @param {QueryMetadata} nullable Description of the query and their nullability
+ * @returns {(data: any, errors: GraphQLError[]) => {data: any; errors: GraphQLError[]}}
+ * the trimmed data and a filtered list of errors.
+ */
+function trimData(nullable) {
+    return (data, errors) => {
+        const finalErrors = [];
+        const processedErrors = new Set();
+        for (const error of errors) {
+            if (!error.path) {
+                // should never happen, it is a bug if it does
+                throw new Error("no path available for tree trimming");
+            }
+            if (processedErrors.has(error.path.join("."))) {
+                // there can be multiple field errors in some scenario
+                // there is no need to continue processing and it should not be part of the final response
+                continue;
+            }
+            const ancestors = findNullableAncestor(nullable, error.path);
+            // The top level field is always nullable
+            // http://facebook.github.io/graphql/June2018/#sec-Errors-and-Non-Nullability
+            //
+            // There is no mention if the following errors need to be present in the response.
+            // For now we assume this is not needed.
+            if (ancestors.length === 0) {
+                data = null;
+                finalErrors.push(error);
+                break;
+            }
+            removeBranch(data, ancestors);
+            processedErrors.add(error.path.join("."));
+            finalErrors.push(error);
+        }
+        return { data, errors: finalErrors };
+    };
+}
+/**
+ * Removes a branch out of the response data by mutating the original object.
+ *
+ * @param tree response data
+ * @param {Array<number | string>} branch array with the path that should be trimmed
+ */
+function removeBranch(tree, branch) {
+    for (let i = 0; i < branch.length - 1; ++i) {
+        // if ancestor has already been removed, there's nothing to do
+        if (tree[branch[i]] === null) {
+            return;
+        }
+        tree = tree[branch[i]];
+    }
+    const toNull = branch[branch.length - 1];
+    tree[toNull] = null;
+}
+/**
+ * Name of the child used in array to contain the description.
+ *
+ * Only used for list to contain the child description.
+ */
+const ARRAY_CHILD_NAME = "index";
+/**
+ *
+ * @param {QueryMetadata} nullable Description of the query and their nullability
+ * @param {ReadonlyArray<string | number>} paths path of the error location
+ * @returns {Array<string | number>} path of the branch to be made null
+ */
+function findNullableAncestor(nullable, paths) {
+    let lastNullable = 0;
+    for (let i = 0; i < paths.length; ++i) {
+        const path = paths[i];
+        const child = nullable.children[typeof path === "string" ? path : ARRAY_CHILD_NAME];
+        if (!child) {
+            // Stopping the search since we reached a leaf node,
+            // the loop should be on its final iteration
+            break;
+        }
+        if (child.isNullable) {
+            lastNullable = i + 1;
+        }
+        nullable = child;
+    }
+    return paths.slice(0, lastNullable);
+}
+/**
+ * Produce a description of the query regarding its nullability.
+ *
+ * Leaf nodes are not present in this representation since they are not
+ * interesting for removing branches of the response tree.
+ *
+ * The structure is recursive like the query.
+ * @param {CompilationContext} compilationContext Execution content
+ * @returns {QueryMetadata} description of the query
+ */
+function parseQueryNullables(compilationContext) {
+    const type = getOperationRootType(compilationContext.schema, compilationContext.operation);
+    const fields = collectFields(compilationContext, type, compilationContext.operation.selectionSet, Object.create(null), Object.create(null));
+    const properties = Object.create(null);
+    for (const responseName of Object.keys(fields)) {
+        const fieldType = resolveFieldDef(compilationContext, type, fields[responseName]);
+        if (!fieldType) {
+            // if field does not exist, it should be ignored for compatibility concerns.
+            // Usually, validation would stop it before getting here but this could be an old query
+            continue;
+        }
+        const property = transformNode(compilationContext, fields[responseName], fieldType.type);
+        if (property != null) {
+            properties[responseName] = property;
+        }
+    }
+    return {
+        isNullable: true,
+        children: properties
+    };
+}
+/**
+ * Processes a single node to produce a description of itself and its children.
+ *
+ * Leaf nodes are ignore and removed from the description
+ * @param {CompilationContext} compilationContext
+ * @param {FieldNode[]} fieldNodes list of fields
+ * @param {GraphQLType} type Current type being processed.
+ * @returns {QueryMetadata | null} null if node is a leaf, otherwise a description of the node and its children.
+ */
+function transformNode(compilationContext, fieldNodes, type) {
+    if (isNonNullType(type)) {
+        const nullable = transformNode(compilationContext, fieldNodes, type.ofType);
+        if (nullable != null) {
+            nullable.isNullable = false;
+            return nullable;
+        }
+        return null;
+    }
+    if (isObjectType(type)) {
+        const subfields = collectSubfields(compilationContext, type, fieldNodes);
+        const properties = Object.create(null);
+        for (const responseName of Object.keys(subfields)) {
+            const fieldType = resolveFieldDef(compilationContext, type, subfields[responseName]);
+            if (!fieldType) {
+                // if field does not exist, it should be ignored for compatibility concerns.
+                // Usually, validation would stop it before getting here but this could be an old query
+                continue;
+            }
+            const property = transformNode(compilationContext, subfields[responseName], fieldType.type);
+            if (property != null) {
+                properties[responseName] = property;
+            }
+        }
+        return {
+            isNullable: true,
+            children: properties
+        };
+    }
+    if (isListType(type)) {
+        const child = transformNode(compilationContext, fieldNodes, type.ofType);
+        if (child != null) {
+            return {
+                isNullable: true,
+                children: { [ARRAY_CHILD_NAME]: child }
+            };
+        }
+        return {
+            isNullable: true,
+            children: {}
+        };
+    }
+    if (isAbstractType(type)) {
+        return compilationContext.schema.getPossibleTypes(type).reduce((res, t) => {
+            const property = transformNode(compilationContext, fieldNodes, t);
+            if (property != null) {
+                // We do a deep merge because children can have subset of properties
+                // TODO: Possible bug: two object with different nullability on objects.
+                res.children = merge(res.children, property.children);
+            }
+            return res;
+        }, {
+            isNullable: true,
+            children: {}
+        });
+    }
+    // Scalars and enum are ignored since they are leaf values
+    return null;
+}
+//# sourceMappingURL=non-null.js.map

package/dist/esm/non-null.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-null.js","sourceRoot":"","sources":["../../src/non-null.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type ExecutionResult,\n  type FieldNode,\n  type GraphQLError,\n  type GraphQLType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n  isAbstractType\n} from \"graphql\";\nimport merge from \"lodash.merge\";\nimport { collectFields, collectSubfields, resolveFieldDef } from \"./ast.js\";\nimport { getOperationRootType } from \"./compat.js\";\nimport { type CompilationContext } from \"./execution.js\";\n\ninterface QueryMetadata {\n  isNullable: boolean;\n  children: { [key: string]: QueryMetadata };\n}\n\nexport type NullTrimmer = (data: any, errors: GraphQLError[]) => any;\n\n/**\n *\n * @param {CompilationContext} compilationContext\n * @returns {(data: any, errors: GraphQLError[]) => {data: any; errors: GraphQLError[]}}\n */\nexport function createNullTrimmer(\n  compilationContext: CompilationContext\n): NullTrimmer {\n  return trimData(parseQueryNullables(compilationContext));\n}\n\n/**\n * Trims a data response according to the field errors in non null fields.\n *\n * Errors are filtered to ensure a single field error per field.\n *\n * @param {QueryMetadata} nullable Description of the query and their nullability\n * @returns {(data: any, errors: GraphQLError[]) => {data: any; errors: GraphQLError[]}}\n * the trimmed data and a filtered list of errors.\n */\nfunction trimData(nullable: QueryMetadata): NullTrimmer {\n  return (data: any, errors: GraphQLError[]): ExecutionResult => {\n    const finalErrors = [];\n    const processedErrors = new Set<string>();\n    for (const error of errors) {\n      if (!error.path) {\n        // should never happen, it is a bug if it does\n        throw new Error(\"no path available for tree trimming\");\n      }\n      if (processedErrors.has(error.path.join(\".\"))) {\n        // there can be multiple field errors in some scenario\n        // there is no need to continue processing and it should not be part of the final response\n        continue;\n      }\n      const ancestors = findNullableAncestor(nullable, error.path);\n      // The top level field is always nullable\n      // http://facebook.github.io/graphql/June2018/#sec-Errors-and-Non-Nullability\n      //\n      // There is no mention if the following errors need to be present in the response.\n      // For now we assume this is not needed.\n      if (ancestors.length === 0) {\n        data = null;\n        finalErrors.push(error);\n        break;\n      }\n      removeBranch(data, ancestors);\n      processedErrors.add(error.path.join(\".\"));\n      finalErrors.push(error);\n    }\n    return { data, errors: finalErrors };\n  };\n}\n\n/**\n * Removes a branch out of the response data by mutating the original object.\n *\n * @param tree response data\n * @param {Array<number | string>} branch array with the path that should be trimmed\n */\nfunction removeBranch(tree: any, branch: Array<number | string>): void {\n  for (let i = 0; i < branch.length - 1; ++i) {\n    // if ancestor has already been removed, there's nothing to do\n    if (tree[branch[i]] === null) {\n      return;\n    }\n    tree = tree[branch[i]];\n  }\n  const toNull = branch[branch.length - 1];\n  tree[toNull] = null;\n}\n\n/**\n * Name of the child used in array to contain the description.\n *\n * Only used for list to contain the child description.\n */\nconst ARRAY_CHILD_NAME = \"index\";\n\n/**\n *\n * @param {QueryMetadata} nullable Description of the query and their nullability\n * @param {ReadonlyArray<string | number>} paths path of the error location\n * @returns {Array<string | number>} path of the branch to be made null\n */\nfunction findNullableAncestor(\n  nullable: QueryMetadata,\n  paths: ReadonlyArray<string | number>\n): Array<string | number> {\n  let lastNullable = 0;\n  for (let i = 0; i < paths.length; ++i) {\n    const path = paths[i];\n    const child =\n      nullable.children[typeof path === \"string\" ? path : ARRAY_CHILD_NAME];\n    if (!child) {\n      // Stopping the search since we reached a leaf node,\n      // the loop should be on its final iteration\n      break;\n    }\n    if (child.isNullable) {\n      lastNullable = i + 1;\n    }\n    nullable = child;\n  }\n  return paths.slice(0, lastNullable);\n}\n\n/**\n * Produce a description of the query regarding its nullability.\n *\n * Leaf nodes are not present in this representation since they are not\n * interesting for removing branches of the response tree.\n *\n * The structure is recursive like the query.\n * @param {CompilationContext} compilationContext Execution content\n * @returns {QueryMetadata} description of the query\n */\nfunction parseQueryNullables(\n  compilationContext: CompilationContext\n): QueryMetadata {\n  const type = getOperationRootType(\n    compilationContext.schema,\n    compilationContext.operation\n  );\n  const fields = collectFields(\n    compilationContext,\n    type,\n    compilationContext.operation.selectionSet,\n    Object.create(null),\n    Object.create(null)\n  );\n  const properties = Object.create(null);\n  for (const responseName of Object.keys(fields)) {\n    const fieldType = resolveFieldDef(\n      compilationContext,\n      type,\n      fields[responseName]\n    );\n    if (!fieldType) {\n      // if field does not exist, it should be ignored for compatibility concerns.\n      // Usually, validation would stop it before getting here but this could be an old query\n      continue;\n    }\n    const property = transformNode(\n      compilationContext,\n      fields[responseName],\n      fieldType.type\n    );\n    if (property != null) {\n      properties[responseName] = property;\n    }\n  }\n  return {\n    isNullable: true,\n    children: properties\n  };\n}\n\n/**\n * Processes a single node to produce a description of itself and its children.\n *\n * Leaf nodes are ignore and removed from the description\n * @param {CompilationContext} compilationContext\n * @param {FieldNode[]} fieldNodes list of fields\n * @param {GraphQLType} type Current type being processed.\n * @returns {QueryMetadata | null} null if node is a leaf, otherwise a description of the node and its children.\n */\nfunction transformNode(\n  compilationContext: CompilationContext,\n  fieldNodes: FieldNode[],\n  type: GraphQLType\n): QueryMetadata | null {\n  if (isNonNullType(type)) {\n    const nullable = transformNode(compilationContext, fieldNodes, type.ofType);\n    if (nullable != null) {\n      nullable.isNullable = false;\n      return nullable;\n    }\n    return null;\n  }\n  if (isObjectType(type)) {\n    const subfields = collectSubfields(compilationContext, type, fieldNodes);\n    const properties = Object.create(null);\n    for (const responseName of Object.keys(subfields)) {\n      const fieldType = resolveFieldDef(\n        compilationContext,\n        type,\n        subfields[responseName]\n      );\n      if (!fieldType) {\n        // if field does not exist, it should be ignored for compatibility concerns.\n        // Usually, validation would stop it before getting here but this could be an old query\n        continue;\n      }\n      const property = transformNode(\n        compilationContext,\n        subfields[responseName],\n        fieldType.type\n      );\n      if (property != null) {\n        properties[responseName] = property;\n      }\n    }\n    return {\n      isNullable: true,\n      children: properties\n    };\n  }\n  if (isListType(type)) {\n    const child = transformNode(compilationContext, fieldNodes, type.ofType);\n    if (child != null) {\n      return {\n        isNullable: true,\n        children: { [ARRAY_CHILD_NAME]: child }\n      };\n    }\n\n    return {\n      isNullable: true,\n      children: {}\n    };\n  }\n  if (isAbstractType(type)) {\n    return compilationContext.schema.getPossibleTypes(type).reduce(\n      (res, t) => {\n        const property = transformNode(compilationContext, fieldNodes, t);\n        if (property != null) {\n          // We do a deep merge because children can have subset of properties\n          // TODO: Possible bug: two object with different nullability on objects.\n          res.children = merge(res.children, property.children);\n        }\n        return res;\n      },\n      {\n        isNullable: true,\n        children: {}\n      }\n    );\n  }\n\n  // Scalars and enum are ignored since they are leaf values\n  return null;\n}\n"]}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/{resolve-info.d.mts → esm/resolve-info.d.ts}

@@ -1,7 +1,6 @@
-import { GraphQLResolveInfo, GraphQLObjectType, GraphQLOutputType, FieldNode } from 'graphql';
-
-type GraphQLJitResolveInfo<Enrichments> = GraphQLResolveInfo & Enrichments;
-interface ResolveInfoEnricherInput {
+import { type FieldNode, GraphQLObjectType, type GraphQLOutputType, type GraphQLResolveInfo } from "graphql";
+export type GraphQLJitResolveInfo<Enrichments> = GraphQLResolveInfo & Enrichments;
+export interface ResolveInfoEnricherInput {
     schema: GraphQLResolveInfo["schema"];
     fragments: GraphQLResolveInfo["fragments"];
     operation: GraphQLResolveInfo["operation"];
@@ -10,23 +9,23 @@ interface ResolveInfoEnricherInput {
     fieldName: string;
     fieldNodes: FieldNode[];
 }
-interface FieldExpansion {
+export interface FieldExpansion {
     [returnType: string]: TypeExpansion;
 }
 declare const LeafFieldSymbol: unique symbol;
-interface LeafField {
+export interface LeafField {
     [LeafFieldSymbol]: true;
 }
-interface TypeExpansion {
+export interface TypeExpansion {
     [fieldName: string]: FieldExpansion | LeafField;
 }
-declare function isLeafField(obj: LeafField | FieldExpansion): obj is LeafField;
+export declare function isLeafField(obj: LeafField | FieldExpansion): obj is LeafField;
 /**
  * Compute the GraphQLJitResolveInfo's `fieldExpansion` and return a function
  * that returns the computed resolveInfo. This thunk is registered in
  * context.dependencies for the field's resolveInfoName
  */
-declare function createResolveInfoThunk<T>({ schema, fragments, operation, parentType, fieldName, fieldType, fieldNodes }: {
+export declare function createResolveInfoThunk<T>({ schema, fragments, operation, parentType, fieldName, fieldType, fieldNodes }: {
     schema: GraphQLResolveInfo["schema"];
     fragments: GraphQLResolveInfo["fragments"];
     operation: GraphQLResolveInfo["operation"];
@@ -35,8 +34,7 @@ declare function createResolveInfoThunk<T>({ schema, fragments, operation, paren
     fieldName: string;
     fieldNodes: FieldNode[];
 }, enricher?: (inp: ResolveInfoEnricherInput) => T): any;
-declare function fieldExpansionEnricher(input: ResolveInfoEnricherInput): {
+export declare function fieldExpansionEnricher(input: ResolveInfoEnricherInput): {
     fieldExpansion: FieldExpansion;
 };
-
-export { type FieldExpansion, type GraphQLJitResolveInfo, type LeafField, type ResolveInfoEnricherInput, type TypeExpansion, createResolveInfoThunk, fieldExpansionEnricher, isLeafField };
+export {};

package/dist/esm/resolve-info.js

@@ -0,0 +1,224 @@
+import { genFn } from "./generate.js";
+import { doTypesOverlap, GraphQLError, isAbstractType, isCompositeType, isListType, isNonNullType, isObjectType, isUnionType, Kind } from "graphql";
+import memoize from "lodash.memoize";
+import mergeWith from "lodash.mergewith";
+import { memoize2, memoize4 } from "./memoize.js";
+const LeafFieldSymbol = Symbol("LeafFieldSymbol");
+function createLeafField(props) {
+    return {
+        [LeafFieldSymbol]: true,
+        ...props
+    };
+}
+export function isLeafField(obj) {
+    return (obj != null && Object.prototype.hasOwnProperty.call(obj, LeafFieldSymbol));
+}
+/**
+ * Compute the GraphQLJitResolveInfo's `fieldExpansion` and return a function
+ * that returns the computed resolveInfo. This thunk is registered in
+ * context.dependencies for the field's resolveInfoName
+ */
+export function createResolveInfoThunk({ schema, fragments, operation, parentType, fieldName, fieldType, fieldNodes }, enricher) {
+    let enrichedInfo = {};
+    if (typeof enricher === "function") {
+        enrichedInfo =
+            enricher({
+                fieldName,
+                fieldNodes,
+                returnType: fieldType,
+                parentType,
+                schema,
+                fragments,
+                operation
+            }) || {};
+        if (typeof enrichedInfo !== "object" || Array.isArray(enrichedInfo)) {
+            enrichedInfo = {};
+        }
+    }
+    const gen = genFn();
+    gen(`return function getGraphQLResolveInfo(rootValue, variableValues, path) {
+      return {
+          fieldName,
+          fieldNodes,
+          returnType: fieldType,
+          parentType,
+          path,
+          schema,
+          fragments,
+          rootValue,
+          operation,
+          variableValues,`);
+    Object.keys(enrichedInfo).forEach((key) => {
+        gen(`${key}: enrichedInfo["${key}"],\n`);
+    });
+    gen(`};};`);
+    // eslint-disable-next-line
+    return new Function("fieldName", "fieldNodes", "fieldType", "parentType", "schema", "fragments", "operation", "enrichedInfo", gen.toString()).call(null, fieldName, fieldNodes, fieldType, parentType, schema, fragments, operation, enrichedInfo);
+}
+export function fieldExpansionEnricher(input) {
+    const { schema, fragments, returnType, fieldNodes } = input;
+    const fieldExpansion = {};
+    for (const fieldNode of fieldNodes) {
+        deepMerge(fieldExpansion, memoizedExpandFieldNode(schema, fragments, fieldNode, returnType));
+    }
+    return {
+        fieldExpansion
+    };
+}
+const MEMOIZATION = true;
+const memoizedGetReturnType = MEMOIZATION
+    ? memoize2(getReturnType)
+    : getReturnType;
+const memoizedHasField = MEMOIZATION ? memoize2(hasField) : hasField;
+const memoizedResolveEndType = MEMOIZATION
+    ? memoize(resolveEndType)
+    : resolveEndType;
+const memoizedGetPossibleTypes = MEMOIZATION
+    ? memoize2(getPossibleTypes)
+    : getPossibleTypes;
+const memoizedExpandFieldNodeType = MEMOIZATION
+    ? memoize4(expandFieldNodeType)
+    : expandFieldNodeType;
+const memoizedExpandFieldNode = MEMOIZATION
+    ? memoize4(expandFieldNode)
+    : expandFieldNode;
+function expandFieldNode(schema, fragments, node, fieldType) {
+    if (node.selectionSet == null) {
+        return createLeafField({});
+    }
+    // there is a selectionSet which makes the fieldType a CompositeType
+    const typ = memoizedResolveEndType(fieldType);
+    const possibleTypes = memoizedGetPossibleTypes(schema, typ);
+    const fieldExpansion = {};
+    for (const possibleType of possibleTypes) {
+        if (!isUnionType(possibleType)) {
+            fieldExpansion[possibleType.name] = memoizedExpandFieldNodeType(schema, fragments, possibleType, node.selectionSet);
+        }
+    }
+    return fieldExpansion;
+}
+function expandFieldNodeType(schema, fragments, parentType, selectionSet) {
+    const typeExpansion = {};
+    for (const selection of selectionSet.selections) {
+        if (selection.kind === Kind.FIELD) {
+            if (!isUnionType(parentType) &&
+                memoizedHasField(parentType, selection.name.value)) {
+                typeExpansion[selection.name.value] = memoizedExpandFieldNode(schema, fragments, selection, memoizedGetReturnType(parentType, selection.name.value));
+            }
+        }
+        else {
+            const selectionSet = selection.kind === Kind.INLINE_FRAGMENT
+                ? selection.selectionSet
+                : fragments[selection.name.value].selectionSet;
+            const nextType = selection.kind === Kind.INLINE_FRAGMENT
+                ? selection.typeCondition
+                    ? schema.getType(selection.typeCondition.name.value)
+                    : parentType
+                : schema.getType(fragments[selection.name.value].typeCondition.name.value);
+            /**
+             * nextType (comes from query) is the type extracted from the fragment
+             * parentType (comes from schema) is the possibleType for which we are filling fields
+             *
+             * if the type from query (nextType) is the same as the type we are filling (parentType)
+             * or
+             * if the type from query (nextType) is an abstract type - this case is when we jump
+             * to a super type or sub type. Here we maintain the context (parentType) for which
+             * we are filling the fields. The super type / sub type will be filled in its own
+             * pass.
+             */
+            if (nextType === parentType || isAbstractType(nextType)) {
+                deepMerge(typeExpansion, memoizedExpandFieldNodeType(schema, fragments, parentType, selectionSet));
+            }
+        }
+    }
+    return typeExpansion;
+}
+/**
+ * Returns a list of Possible types that one can get to from the
+ * resolvedType. As an analogy, these are the same types that one
+ * can use in a fragment's typeCondition.
+ *
+ * Note: This is different from schema.getPossibleTypes() that this
+ * returns all possible types and not just the ones from the type definition.
+ *
+ * Example:
+ * interface Node {
+ *   id: ID!
+ * }
+ * type User implements Node {
+ *   id: ID!
+ *   name: String
+ * }
+ * type Article implements Node {
+ *   id: ID!
+ *   title: String
+ * }
+ * union Card = User | Article
+ *
+ * - schema.getPossibleTypes(Card) would give [User, Article]
+ * - This function getPossibleTypes(schema, Card) would give [User, Article, Node]
+ *
+ */
+function getPossibleTypes(schema, compositeType) {
+    if (isObjectType(compositeType)) {
+        return [compositeType];
+    }
+    const possibleTypes = [];
+    const types = schema.getTypeMap();
+    for (const typeName in types) {
+        if (Object.prototype.hasOwnProperty.call(types, typeName)) {
+            const typ = types[typeName];
+            if (isCompositeType(typ) && doTypesOverlap(schema, typ, compositeType)) {
+                possibleTypes.push(typ);
+            }
+        }
+    }
+    return possibleTypes;
+}
+/**
+ * Given an (Object|Interface)Type, and a fieldName, find the
+ * appropriate `end` return type for the field in the Composite Type.
+ *
+ * Note: The `end` return type is the type by unwrapping non-null types
+ * and list types. Check `resolveEndType`
+ */
+function getReturnType(parentType, fieldName) {
+    const fields = parentType.getFields();
+    if (!Object.prototype.hasOwnProperty.call(fields, fieldName)) {
+        throw new GraphQLError(`Field "${fieldName}" does not exist in "${parentType.name}"`);
+    }
+    const outputType = fields[fieldName].type;
+    return memoizedResolveEndType(outputType);
+}
+/**
+ * Resolve to the end type of the Output type unwrapping non-null types and lists
+ */
+function resolveEndType(typ) {
+    if (isListType(typ) || isNonNullType(typ)) {
+        return memoizedResolveEndType(typ.ofType);
+    }
+    return typ;
+}
+function hasField(typ, fieldName) {
+    return Object.prototype.hasOwnProperty.call(typ.getFields(), fieldName);
+}
+// This is because lodash does not support merging keys
+// which are symbols. We require them for leaf fields
+function deepMerge(obj, src) {
+    mergeWith(obj, src, (objValue, srcValue) => {
+        if (isLeafField(objValue)) {
+            if (isLeafField(srcValue)) {
+                return {
+                    ...objValue,
+                    ...srcValue
+                };
+            }
+            return objValue;
+        }
+        else if (isLeafField(srcValue)) {
+            return srcValue;
+        }
+        return undefined;
+    });
+}
+//# sourceMappingURL=resolve-info.js.map

package/dist/esm/resolve-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-info.js","sourceRoot":"","sources":["../../src/resolve-info.ts"],"names":[],"mappings":"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","sourcesContent":["import { genFn } from \"./generate.js\";\nimport {\n  doTypesOverlap,\n  type FieldNode,\n  type GraphQLCompositeType,\n  GraphQLError,\n  GraphQLInterfaceType,\n  type GraphQLNamedType,\n  GraphQLObjectType,\n  type GraphQLOutputType,\n  type GraphQLResolveInfo,\n  GraphQLSchema,\n  isAbstractType,\n  isCompositeType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n  isUnionType,\n  Kind,\n  type SelectionSetNode\n} from \"graphql\";\nimport memoize from \"lodash.memoize\";\nimport mergeWith from \"lodash.mergewith\";\nimport { memoize2, memoize4 } from \"./memoize.js\";\n\n// TODO(boopathi): Use negated types to express\n// Enrichments<T> = { [key in (string & not keyof GraphQLResolveInfo)]: T[key] }\n// in TypeScript 3.5\n// https://github.com/Microsoft/TypeScript/pull/29317\nexport type GraphQLJitResolveInfo<Enrichments> = GraphQLResolveInfo &\n  Enrichments;\n\nexport interface ResolveInfoEnricherInput {\n  schema: GraphQLResolveInfo[\"schema\"];\n  fragments: GraphQLResolveInfo[\"fragments\"];\n  operation: GraphQLResolveInfo[\"operation\"];\n  parentType: GraphQLObjectType;\n  returnType: GraphQLOutputType;\n  fieldName: string;\n  fieldNodes: FieldNode[];\n}\n\nexport interface FieldExpansion {\n  // The possible return types that the field can return\n  // It includes all the types in the Schema that intersect with the actual return type\n  [returnType: string]: TypeExpansion;\n}\n\nconst LeafFieldSymbol = Symbol(\"LeafFieldSymbol\");\n\nexport interface LeafField {\n  [LeafFieldSymbol]: true;\n}\n\nexport interface TypeExpansion {\n  // The fields that are requested in the Query for a particular type\n  // `true` indicates a leaf node\n  [fieldName: string]: FieldExpansion | LeafField;\n}\n\nfunction createLeafField<T extends object>(props: T): T & LeafField {\n  return {\n    [LeafFieldSymbol]: true,\n    ...props\n  };\n}\n\nexport function isLeafField(obj: LeafField | FieldExpansion): obj is LeafField {\n  return (\n    obj != null && Object.prototype.hasOwnProperty.call(obj, LeafFieldSymbol)\n  );\n}\n\n/**\n * Compute the GraphQLJitResolveInfo's `fieldExpansion` and return a function\n * that returns the computed resolveInfo. This thunk is registered in\n * context.dependencies for the field's resolveInfoName\n */\nexport function createResolveInfoThunk<T>(\n  {\n    schema,\n    fragments,\n    operation,\n    parentType,\n    fieldName,\n    fieldType,\n    fieldNodes\n  }: {\n    schema: GraphQLResolveInfo[\"schema\"];\n    fragments: GraphQLResolveInfo[\"fragments\"];\n    operation: GraphQLResolveInfo[\"operation\"];\n    parentType: GraphQLObjectType;\n    fieldType: GraphQLOutputType;\n    fieldName: string;\n    fieldNodes: FieldNode[];\n  },\n  enricher?: (inp: ResolveInfoEnricherInput) => T\n) {\n  let enrichedInfo = {};\n  if (typeof enricher === \"function\") {\n    enrichedInfo =\n      enricher({\n        fieldName,\n        fieldNodes,\n        returnType: fieldType,\n        parentType,\n        schema,\n        fragments,\n        operation\n      }) || {};\n    if (typeof enrichedInfo !== \"object\" || Array.isArray(enrichedInfo)) {\n      enrichedInfo = {};\n    }\n  }\n  const gen = genFn();\n  gen(`return function getGraphQLResolveInfo(rootValue, variableValues, path) {\n      return {\n          fieldName,\n          fieldNodes,\n          returnType: fieldType,\n          parentType,\n          path,\n          schema,\n          fragments,\n          rootValue,\n          operation,\n          variableValues,`);\n  Object.keys(enrichedInfo).forEach((key) => {\n    gen(`${key}: enrichedInfo[\"${key}\"],\\n`);\n  });\n  gen(`};};`);\n  // eslint-disable-next-line\n  return new Function(\n    \"fieldName\",\n    \"fieldNodes\",\n    \"fieldType\",\n    \"parentType\",\n    \"schema\",\n    \"fragments\",\n    \"operation\",\n    \"enrichedInfo\",\n    gen.toString()\n  ).call(\n    null,\n    fieldName,\n    fieldNodes,\n    fieldType,\n    parentType,\n    schema,\n    fragments,\n    operation,\n    enrichedInfo\n  );\n}\n\nexport function fieldExpansionEnricher(input: ResolveInfoEnricherInput) {\n  const { schema, fragments, returnType, fieldNodes } = input;\n  const fieldExpansion: FieldExpansion | LeafField = {};\n\n  for (const fieldNode of fieldNodes) {\n    deepMerge(\n      fieldExpansion,\n      memoizedExpandFieldNode(schema, fragments, fieldNode, returnType)\n    );\n  }\n\n  return {\n    fieldExpansion\n  };\n}\n\ntype FragmentsType = GraphQLResolveInfo[\"fragments\"];\ntype GraphQLNamedOutputType = GraphQLNamedType & GraphQLOutputType;\ntype GraphQLObjectLike = GraphQLInterfaceType | GraphQLObjectType;\n\nconst MEMOIZATION = true;\n\nconst memoizedGetReturnType = MEMOIZATION\n  ? memoize2(getReturnType)\n  : getReturnType;\nconst memoizedHasField = MEMOIZATION ? memoize2(hasField) : hasField;\nconst memoizedResolveEndType = MEMOIZATION\n  ? memoize(resolveEndType)\n  : resolveEndType;\nconst memoizedGetPossibleTypes = MEMOIZATION\n  ? memoize2(getPossibleTypes)\n  : getPossibleTypes;\nconst memoizedExpandFieldNodeType = MEMOIZATION\n  ? memoize4(expandFieldNodeType)\n  : expandFieldNodeType;\nconst memoizedExpandFieldNode = MEMOIZATION\n  ? memoize4(expandFieldNode)\n  : expandFieldNode;\n\nfunction expandFieldNode(\n  schema: GraphQLSchema,\n  fragments: FragmentsType,\n  node: FieldNode,\n  fieldType: GraphQLOutputType\n): FieldExpansion | LeafField {\n  if (node.selectionSet == null) {\n    return createLeafField({});\n  }\n\n  // there is a selectionSet which makes the fieldType a CompositeType\n  const typ = memoizedResolveEndType(fieldType) as GraphQLCompositeType;\n  const possibleTypes = memoizedGetPossibleTypes(schema, typ);\n\n  const fieldExpansion: FieldExpansion = {};\n  for (const possibleType of possibleTypes) {\n    if (!isUnionType(possibleType)) {\n      fieldExpansion[possibleType.name] = memoizedExpandFieldNodeType(\n        schema,\n        fragments,\n        possibleType,\n        node.selectionSet\n      );\n    }\n  }\n\n  return fieldExpansion;\n}\n\nfunction expandFieldNodeType(\n  schema: GraphQLSchema,\n  fragments: FragmentsType,\n  parentType: GraphQLCompositeType,\n  selectionSet: SelectionSetNode\n): TypeExpansion {\n  const typeExpansion: TypeExpansion = {};\n\n  for (const selection of selectionSet.selections) {\n    if (selection.kind === Kind.FIELD) {\n      if (\n        !isUnionType(parentType) &&\n        memoizedHasField(parentType, selection.name.value)\n      ) {\n        typeExpansion[selection.name.value] = memoizedExpandFieldNode(\n          schema,\n          fragments,\n          selection,\n          memoizedGetReturnType(parentType, selection.name.value)\n        );\n      }\n    } else {\n      const selectionSet =\n        selection.kind === Kind.INLINE_FRAGMENT\n          ? selection.selectionSet\n          : fragments[selection.name.value].selectionSet;\n\n      const nextType =\n        selection.kind === Kind.INLINE_FRAGMENT\n          ? selection.typeCondition\n            ? (schema.getType(\n                selection.typeCondition.name.value\n              ) as GraphQLCompositeType)\n            : parentType\n          : (schema.getType(\n              fragments[selection.name.value].typeCondition.name.value\n            ) as GraphQLCompositeType);\n\n      /**\n       * nextType (comes from query) is the type extracted from the fragment\n       * parentType (comes from schema) is the possibleType for which we are filling fields\n       *\n       * if the type from query (nextType) is the same as the type we are filling (parentType)\n       * or\n       * if the type from query (nextType) is an abstract type - this case is when we jump\n       * to a super type or sub type. Here we maintain the context (parentType) for which\n       * we are filling the fields. The super type / sub type will be filled in its own\n       * pass.\n       */\n      if (nextType === parentType || isAbstractType(nextType)) {\n        deepMerge(\n          typeExpansion,\n          memoizedExpandFieldNodeType(\n            schema,\n            fragments,\n            parentType,\n            selectionSet\n          )\n        );\n      }\n    }\n  }\n\n  return typeExpansion;\n}\n\n/**\n * Returns a list of Possible types that one can get to from the\n * resolvedType. As an analogy, these are the same types that one\n * can use in a fragment's typeCondition.\n *\n * Note: This is different from schema.getPossibleTypes() that this\n * returns all possible types and not just the ones from the type definition.\n *\n * Example:\n * interface Node {\n *   id: ID!\n * }\n * type User implements Node {\n *   id: ID!\n *   name: String\n * }\n * type Article implements Node {\n *   id: ID!\n *   title: String\n * }\n * union Card = User | Article\n *\n * - schema.getPossibleTypes(Card) would give [User, Article]\n * - This function getPossibleTypes(schema, Card) would give [User, Article, Node]\n *\n */\nfunction getPossibleTypes(\n  schema: GraphQLSchema,\n  compositeType: GraphQLCompositeType\n) {\n  if (isObjectType(compositeType)) {\n    return [compositeType];\n  }\n\n  const possibleTypes: GraphQLCompositeType[] = [];\n  const types = schema.getTypeMap();\n  for (const typeName in types) {\n    if (Object.prototype.hasOwnProperty.call(types, typeName)) {\n      const typ = types[typeName];\n      if (isCompositeType(typ) && doTypesOverlap(schema, typ, compositeType)) {\n        possibleTypes.push(typ);\n      }\n    }\n  }\n\n  return possibleTypes;\n}\n\n/**\n * Given an (Object|Interface)Type, and a fieldName, find the\n * appropriate `end` return type for the field in the Composite Type.\n *\n * Note: The `end` return type is the type by unwrapping non-null types\n * and list types. Check `resolveEndType`\n */\nfunction getReturnType(\n  parentType: GraphQLObjectLike,\n  fieldName: string\n): GraphQLNamedOutputType {\n  const fields = parentType.getFields();\n  if (!Object.prototype.hasOwnProperty.call(fields, fieldName)) {\n    throw new GraphQLError(\n      `Field \"${fieldName}\" does not exist in \"${parentType.name}\"`\n    );\n  }\n\n  const outputType = fields[fieldName].type;\n  return memoizedResolveEndType(outputType);\n}\n\n/**\n * Resolve to the end type of the Output type unwrapping non-null types and lists\n */\nfunction resolveEndType(typ: GraphQLOutputType): GraphQLNamedOutputType {\n  if (isListType(typ) || isNonNullType(typ)) {\n    return memoizedResolveEndType(typ.ofType);\n  }\n  return typ;\n}\n\nfunction hasField(typ: GraphQLObjectLike, fieldName: string) {\n  return Object.prototype.hasOwnProperty.call(typ.getFields(), fieldName);\n}\n\n// This is because lodash does not support merging keys\n// which are symbols. We require them for leaf fields\nfunction deepMerge<TObject, TSource>(obj: TObject, src: TSource) {\n  mergeWith(obj, src, (objValue, srcValue): LeafField | undefined => {\n    if (isLeafField(objValue)) {\n      if (isLeafField(srcValue)) {\n        return {\n          ...objValue,\n          ...srcValue\n        };\n      }\n\n      return objValue;\n    } else if (isLeafField(srcValue)) {\n      return srcValue;\n    }\n\n    return undefined;\n  });\n}\n"]}

package/dist/esm/runtime.d.ts

@@ -0,0 +1,14 @@
+import { type ExecutionContext } from "./execution.js";
+type Serializer = (c: ExecutionContext, v: any, onError: any, ...idx: number[]) => any;
+export declare const jitRuntime: {
+    isPromise(value: unknown): boolean;
+    checkNonNullLeaf(ctx: ExecutionContext, value: unknown, dest: any[], nullMsg: string, locs: any, path: any, capStack: boolean, serialize: Serializer, errHandler: any, ...parentIndexes: number[]): any;
+    checkNullableLeaf(ctx: ExecutionContext, value: unknown, dest: any[], locs: any, path: any, capStack: boolean, serialize: Serializer, errHandler: any, ...parentIndexes: number[]): any;
+    callResolver(ctx: ExecutionContext, call: () => unknown, onSuccess: (result: unknown) => void, onError: (err: unknown) => void): void;
+    handleResolverResult(ctx: ExecutionContext, value: unknown, onSuccess: (result: unknown) => void, onError: (err: unknown) => void): void;
+    handleListItemResult(ctx: ExecutionContext, item: unknown, onSuccess: (result: unknown) => void, onError: (err: unknown) => void): void;
+    finalizeResult(ctx: ExecutionContext): Promise<unknown> | undefined;
+    safeMap(ctx: ExecutionContext, iterable: Iterable<unknown> | string, cb: (context: ExecutionContext, a: unknown, index: number, resultArray: unknown[], ...idx: number[]) => void, ...idx: number[]): unknown[];
+};
+export type JitRuntime = typeof jitRuntime;
+export {};

package/dist/esm/runtime.js

@@ -0,0 +1,89 @@
+function resolvePromise(ctx, promise, onSuccess, onError) {
+    ++ctx.promiseCounter;
+    promise.then((result) => {
+        onSuccess(result);
+        --ctx.promiseCounter;
+        if (ctx.promiseCounter === 0)
+            ctx.resolve(ctx);
+    }, (err) => {
+        onError(err);
+        --ctx.promiseCounter;
+        if (ctx.promiseCounter === 0)
+            ctx.resolve(ctx);
+    });
+}
+export const jitRuntime = {
+    isPromise(value) {
+        return (value != null &&
+            typeof value === "object" &&
+            typeof value.then === "function");
+    },
+    checkNonNullLeaf(ctx, value, dest, nullMsg, locs, path, capStack, serialize, errHandler, ...parentIndexes) {
+        const GQLError = ctx.GraphQLError;
+        if (value == null) {
+            dest.push(new GQLError(nullMsg, locs, path, undefined, capStack));
+            return null;
+        }
+        if (value instanceof Error) {
+            dest.push(new GQLError(value.message ?? value, locs, path, value, capStack));
+            return null;
+        }
+        return serialize(ctx, value, errHandler, ...parentIndexes);
+    },
+    checkNullableLeaf(ctx, value, dest, locs, path, capStack, serialize, errHandler, ...parentIndexes) {
+        if (value == null)
+            return null;
+        const GQLError = ctx.GraphQLError;
+        if (value instanceof Error) {
+            dest.push(new GQLError(value.message ?? value, locs, path, value, capStack));
+            return null;
+        }
+        return serialize(ctx, value, errHandler, ...parentIndexes);
+    },
+    callResolver(ctx, call, onSuccess, onError) {
+        let value;
+        try {
+            value = call();
+        }
+        catch (err) {
+            onError(err);
+            onSuccess(null);
+            return;
+        }
+        this.handleResolverResult(ctx, value, onSuccess, onError);
+    },
+    handleResolverResult(ctx, value, onSuccess, onError) {
+        if (this.isPromise(value)) {
+            resolvePromise(ctx, value, onSuccess, onError);
+        }
+        else {
+            onSuccess(value);
+        }
+    },
+    handleListItemResult(ctx, item, onSuccess, onError) {
+        if (this.isPromise(item)) {
+            resolvePromise(ctx, item, onSuccess, onError);
+        }
+        else {
+            onSuccess(item);
+        }
+    },
+    finalizeResult(ctx) {
+        if (ctx.promiseCounter > 0) {
+            return new Promise((resolve) => {
+                ctx.resolve = resolve;
+            });
+        }
+        return undefined;
+    },
+    safeMap(ctx, iterable, cb, ...idx) {
+        let index = 0;
+        const result = [];
+        for (const a of iterable) {
+            cb(ctx, a, index, result, ...idx);
+            ++index;
+        }
+        return result;
+    }
+};
+//# sourceMappingURL=runtime.js.map