graphql-jit 0.8.9 → 0.9.0

package/README.md

@@ -123,6 +123,31 @@ Compiles the `document` AST, using an optional operationName and compiler option
   - `customSerializers` {Object as Map, default: {}} - Replace serializer functions for specific types. Can be used as a safer alternative
     for overly expensive serializers
   - `customJSONSerializer` {boolean, default: false} - Whether to produce also a JSON serializer function using `fast-json-stringify`. The default stringifier function is `JSON.stringify`
+  - `debug` {object, optional} - Publishes formatted generated executors as virtual JavaScript sources. This is intended for local development.
+    - `enabled` {boolean, required} - Enables all debug-only work. Set this to `false` to skip formatting and generated-source changes.
+    - `querySourceName` {string, optional} - A stable name for the generated query source, such as `graphql-jit://graphql-jit/my-service/GetProduct.query.js`.
+    - `variablesSourceName` {string, optional} - A stable name for the generated variable-coercion source, such as `graphql-jit://graphql-jit/my-service/GetProduct.variables.js`.
+    - `formatSourceCode` {(source: string) => string, optional} - A synchronous formatter that runs before compilation. e.g. `@prettier/sync`.
+
+### Debugging generated executors
+
+Start Node with `--inspect` and enable `debug` for the operation being investigated:
+
+```js
+const { format } = require("@prettier/sync");
+
+const compiledQuery = compileQuery(schema, document, "GetProduct", {
+  debug: {
+    enabled: true,
+    querySourceName: "graphql-jit://graphql-jit/shop/GetProduct.query.js",
+    variablesSourceName:
+      "graphql-jit://graphql-jit/shop/GetProduct.variables.js",
+    formatSourceCode: (source) => format(source, { parser: "babel" })
+  }
+});
+```
+
+The debugger exposes separate query and variable-coercion scripts. Set breakpoints directly in those generated JavaScript sources.
 
 #### compiledQuery.query(root: any, context: any, variables: Maybe<{ [key: string]: any }>)
 

package/dist/cjs/ast.d.ts

@@ -0,0 +1,89 @@
+import { type ArgumentNode, type ASTNode, type DirectiveNode, type FieldNode, type GraphQLArgument, GraphQLDirective, type GraphQLField, type GraphQLInputType, GraphQLObjectType, type SelectionSetNode, type SourceLocation, type ValueNode, type VariableNode } from "graphql";
+import { type CompilationContext } from "./execution.js";
+import { resolveFieldDef } from "./compat.js";
+export interface JitFieldNode extends FieldNode {
+    /**
+     * @deprecated Use __internalShouldIncludePath instead
+     * @see __internalShouldIncludePath
+     */
+    __internalShouldInclude?: string[];
+    __internalShouldIncludePath?: {
+        [path: string]: string[];
+    };
+}
+export interface FieldsAndNodes {
+    [key: string]: JitFieldNode[];
+}
+/**
+ * Given a selectionSet, adds all of the fields in that selection to
+ * the passed in map of fields, and returns it at the end.
+ *
+ * CollectFields requires the "runtime type" of an object. For a field which
+ * returns an Interface or Union type, the "runtime type" will be the actual
+ * Object type returned by that field.
+ */
+export declare function collectFields(compilationContext: CompilationContext, runtimeType: GraphQLObjectType, selectionSet: SelectionSetNode, fields: FieldsAndNodes, visitedFragmentNames: {
+    [key: string]: boolean;
+}, parentResponsePath?: ObjectPath): FieldsAndNodes;
+export { resolveFieldDef };
+export declare function collectSubfields(compilationContext: CompilationContext, returnType: GraphQLObjectType, fieldNodes: FieldNode[], parentResponsePath?: ObjectPath): {
+    [key: string]: FieldNode[];
+};
+type ResponsePathType = "variable" | "literal" | "meta";
+export interface ObjectPath {
+    prev: ObjectPath | undefined;
+    key: string;
+    type: ResponsePathType;
+}
+interface MissingVariablePath {
+    valueNode: VariableNode;
+    path?: ObjectPath;
+    argument?: {
+        definition: GraphQLArgument;
+        node: ArgumentNode;
+    };
+}
+export interface Arguments {
+    values: {
+        [argument: string]: any;
+    };
+    missing: MissingVariablePath[];
+}
+/**
+ * Prepares an object map of argument values given a list of argument
+ * definitions and list of argument AST nodes.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ */
+export declare function getArgumentDefs(def: GraphQLField<any, any> | GraphQLDirective, node: FieldNode | DirectiveNode): Arguments;
+interface ASTValueWithVariables {
+    value: object | string | boolean | symbol | number | null | any[];
+    variables: MissingVariablePath[];
+}
+interface ASTValue {
+    value: object | string | boolean | symbol | number | null | any[];
+}
+export declare function valueFromAST(valueNode: ValueNode, type: GraphQLInputType): undefined | ASTValue | ASTValueWithVariables;
+export declare function computeLocations(nodes: ASTNode[]): SourceLocation[];
+export declare function addPath(responsePath: ObjectPath | undefined, key: string, type?: ResponsePathType): ObjectPath;
+export declare function flattenPath(path: ObjectPath): Array<{
+    key: string;
+    type: ResponsePathType;
+}>;
+/**
+ * Serialize a path for use in the skip/include directives.
+ *
+ * @param path The path to serialize
+ * @returns The path serialized as a string, with the root path first.
+ */
+export declare function serializeObjectPathForSkipInclude(path: ObjectPath | undefined): string;
+/**
+ * join two path segments to a dot notation, handling empty strings
+ *
+ * @param a path segment
+ * @param b path segment
+ * @returns combined path in dot notation
+ */
+export declare function joinSkipIncludePath(a: string, b: string): string;