grafast 0.1.1-beta.20 → 0.1.1-beta.21

package/dist/utils.d.ts

@@ -1,9 +1,9 @@
-import type { ConstValueNode, FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLSchema } from "graphql";
+import type { ConstValueNode, DirectiveNode, FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLSchema, ValueNode } from "graphql";
 import * as graphql from "graphql";
 import type { Deferred } from "./deferred.js";
 import type { OperationPlan } from "./engine/OperationPlan.js";
-import type { BaseGraphQLArguments, GrafastFieldConfig, GrafastInputFieldConfig, InputStep, OutputPlanForType } from "./interfaces.js";
-import type { ExecutableStep, ModifierStep } from "./step.js";
+import type { BaseGraphQLArguments, GrafastFieldConfig, GrafastInputFieldConfig, OutputPlanForType } from "./interfaces.js";
+import type { Step } from "./step.js";
 /**
  * The parent object is used as the key in `GetValueStepId()`; for root level
  * fields it's possible that the parent will be null/undefined (in all other
@@ -21,7 +21,7 @@ export declare function isPromise<T>(t: T | Promise<T>): t is Promise<T>;
 /**
  * Is "thenable".
  */
-export declare function isPromiseLike<T>(t: T | Promise<T> | PromiseLike<T>): t is PromiseLike<T> | Promise<T>;
+export declare function isPromiseLike<T>(t: T | PromiseLike<T>): t is PromiseLike<T>;
 /**
  * Is a promise that can be externally resolved.
  */
@@ -31,61 +31,62 @@ export declare function isDeferred<T>(t: T | Promise<T> | Deferred<T>): t is Def
  * values within them pass the `comparator` check (which defaults to `===`).
  */
 export declare function arraysMatch<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, comparator?: (val1: T, val2: T) => boolean): boolean;
-export type ObjectTypeFields<TContext extends Grafast.Context, TParentStep extends ExecutableStep> = {
-    [key: string]: GrafastFieldConfig<GraphQLOutputType, TContext, TParentStep, any, any>;
+export type ObjectTypeFields<TParentStep extends Step> = {
+    [key: string]: GrafastFieldConfig<GraphQLOutputType, TParentStep, any, any>;
 };
-export type ObjectTypeSpec<TContext extends Grafast.Context, TParentStep extends ExecutableStep, TFields extends ObjectTypeFields<TContext, TParentStep>> = Omit<GraphQLObjectTypeConfig<any, TContext>, "fields"> & {
+export type ObjectTypeSpec<TParentStep extends Step, TFields extends ObjectTypeFields<TParentStep>> = Omit<GraphQLObjectTypeConfig<any, Grafast.Context>, "fields"> & {
     fields: TFields | (() => TFields);
-    assertStep?: TParentStep extends ExecutableStep ? ((step: ExecutableStep) => asserts step is TParentStep) | {
+    assertStep?: TParentStep extends Step ? ((step: Step) => asserts step is TParentStep) | {
         new (...args: any[]): TParentStep;
     } : null;
 };
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
-export declare function objectSpec<TContext extends Grafast.Context, TParentStep extends ExecutableStep, TFields extends ObjectTypeFields<TContext, TParentStep>>(spec: ObjectTypeSpec<TContext, TParentStep, TFields>): GraphQLObjectTypeConfig<any, TContext>;
-export type GrafastObjectType<TContext extends Grafast.Context, TParentStep extends ExecutableStep, TFields extends ObjectTypeFields<TContext, TParentStep>> = graphql.GraphQLObjectType<TParentStep extends ExecutableStep<infer U> ? U : never, TContext> & {
+export declare function objectSpec<TParentStep extends Step, TFields extends ObjectTypeFields<TParentStep>>(spec: ObjectTypeSpec<TParentStep, TFields>): GraphQLObjectTypeConfig<any, Grafast.Context>;
+export type GrafastObjectType<TParentStep extends Step, TFields extends ObjectTypeFields<TParentStep>> = graphql.GraphQLObjectType<TParentStep extends Step<infer U> ? U : never> & {
     TParentStep: TParentStep;
     TFields: TFields;
 };
 /**
  * @remarks This is a mess because the first two generics need to be specified manually, but the latter one we want inferred.
  */
-export declare function newObjectTypeBuilder<TContext extends Grafast.Context, TParentStep extends ExecutableStep>(assertStep: TParentStep extends ExecutableStep ? ((step: ExecutableStep) => asserts step is TParentStep) | {
+export declare function newObjectTypeBuilder<TParentStep extends Step>(assertStep: TParentStep extends Step ? ((step: Step) => asserts step is TParentStep) | {
     new (...args: any[]): TParentStep;
-} : never): <TFields extends ObjectTypeFields<TContext, TParentStep>>(spec: ObjectTypeSpec<TContext, TParentStep, TFields>) => GrafastObjectType<TContext, TParentStep, TFields>;
+} : never): <TFields extends ObjectTypeFields<TParentStep>>(spec: ObjectTypeSpec<TParentStep, TFields>) => GrafastObjectType<TParentStep, TFields>;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
-export declare function objectFieldSpec<TContext extends Grafast.Context, TSource extends ExecutableStep, TResult extends ExecutableStep = ExecutableStep, TArgs extends BaseGraphQLArguments = BaseGraphQLArguments>(grafastSpec: GrafastFieldConfig<GraphQLOutputType, TContext, TSource, TResult, TArgs>, path: string): GraphQLFieldConfig<any, TContext, TArgs>;
+export declare function objectFieldSpec<TSource extends Step, TResult extends Step = Step, TArgs extends BaseGraphQLArguments = BaseGraphQLArguments>(grafastSpec: GrafastFieldConfig<GraphQLOutputType, TSource, TResult, TArgs>, path: string): GraphQLFieldConfig<any, TArgs>;
 /**
  * "Constrainted identity function" for field configs.
  *
  * @see {@link https://kentcdodds.com/blog/how-to-write-a-constrained-identity-function-in-typescript}
  */
-export declare function newGrafastFieldConfigBuilder<TContext extends Grafast.Context, TParentStep extends ExecutableStep>(): <TType extends GraphQLOutputType, TFieldStep extends OutputPlanForType<TType>, TArgs extends BaseGraphQLArguments>(config: GrafastFieldConfig<TType, TContext, TParentStep, TFieldStep, TArgs>) => typeof config;
-export type GrafastInputFieldConfigMap<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>> = {
-    [key: string]: GrafastInputFieldConfig<GraphQLInputType, TContext, TParentStep, any, any>;
+export declare function newGrafastFieldConfigBuilder<TParentStep extends Step>(): <TType extends GraphQLOutputType, TFieldStep extends OutputPlanForType<TType>, TArgs extends BaseGraphQLArguments>(config: GrafastFieldConfig<TType, TParentStep, TFieldStep, TArgs>) => typeof config;
+export type GrafastInputFieldConfigMap<TParent> = {
+    [key: string]: GrafastInputFieldConfig<TParent, GraphQLInputType>;
 };
-export type InputObjectTypeSpec<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>, TFields extends GrafastInputFieldConfigMap<TContext, TParentStep>> = Omit<GraphQLInputObjectTypeConfig, "fields"> & {
-    fields: TFields | (() => TFields);
+export type InputObjectTypeSpec<TParent> = Omit<GraphQLInputObjectTypeConfig, "fields"> & {
+    fields: GrafastInputFieldConfigMap<TParent> | (() => GrafastInputFieldConfigMap<TParent>);
 };
-export type GrafastInputObjectType<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>, TFields extends GrafastInputFieldConfigMap<TContext, TParentStep>> = graphql.GraphQLInputObjectType & {
-    TContext: TContext;
-    TParentStep: TParentStep;
-    TFields: TFields;
+export type GrafastInputObjectType<TParent> = graphql.GraphQLInputObjectType & {
+    TParent: TParent;
 };
-export declare function newInputObjectTypeBuilder<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>>(): <TFields extends GrafastInputFieldConfigMap<TContext, TParentStep>>(spec: InputObjectTypeSpec<TContext, TParentStep, TFields>) => GrafastInputObjectType<TContext, TParentStep, TFields>;
+export declare function newInputObjectTypeBuilder<TParent = any>(): (spec: InputObjectTypeSpec<TParent>) => GrafastInputObjectType<TParent>;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
-export declare function inputObjectFieldSpec<TContext extends Grafast.Context, TParent extends ModifierStep<any>, TResult extends ModifierStep<TParent> = ModifierStep<TParent>, TInput extends InputStep = InputStep>(grafastSpec: GrafastInputFieldConfig<GraphQLInputType, TContext, TParent, TResult, TInput>, path: string): GraphQLInputFieldConfig;
+export declare function inputObjectFieldSpec<TParent>(grafastSpec: GrafastInputFieldConfig<TParent, GraphQLInputType>, path: string): GraphQLInputFieldConfig;
 declare module "graphql" {
     interface GraphQLEnumType {
         [$$valueConfigByValue]?: Record<string, GraphQLEnumValueConfig>;
     }
 }
 declare const $$valueConfigByValue: unique symbol;
+export declare function getEnumValueConfigs(enumType: graphql.GraphQLEnumType): {
+    [outputValue: string]: GraphQLEnumValueConfig | undefined;
+};
 /**
  * This would be equivalent to `enumType._valueLookup.get(outputValue)` except
  * that's not a public API so we have to do a bit of heavy lifting here. Since
@@ -97,6 +98,8 @@ export declare function getEnumValueConfig(enumType: graphql.GraphQLEnumType, ou
  * Ridiculously, this is faster than `new Array(length).fill(fill)`
  */
 export declare function arrayOfLength(length: number, fill?: any): any[];
+export declare const valueNodeToStaticValue: typeof graphql.valueFromAST;
+export declare function findVariableNamesUsedInValueNode(valueNode: ValueNode, variableNames: Set<string>): void;
 /**
  * Given a FieldNode, recursively walks and finds all the variable references,
  * returning a list of the (unique) variable names used.
@@ -107,12 +110,12 @@ export declare function isTypePlanned(schema: GraphQLSchema, namedType: GraphQLN
  * Returns `true` if the first argument depends on the second argument either
  * directly or indirectly (via a chain of dependencies).
  */
-export declare function stepADependsOnStepB(stepA: ExecutableStep, stepB: ExecutableStep): boolean;
+export declare function stepADependsOnStepB(stepA: Step, stepB: Step): boolean;
 /**
  * Returns true if stepA is allowed to depend on stepB, false otherwise. (This
  * mostly relates to heirarchy.)
  */
-export declare function stepAMayDependOnStepB($a: ExecutableStep, $b: ExecutableStep): boolean;
+export declare function stepAMayDependOnStepB($a: Step, $b: Step): boolean;
 /**
  * For a regular GraphQL query with no `@stream`/`@defer`, the entire result is
  * calculated and then the output is generated and sent to the client at once.
@@ -140,14 +143,14 @@ export declare function stepAMayDependOnStepB($a: ExecutableStep, $b: Executable
  * approach. Once you have, you can use this function to help you, should you
  * need it.
  */
-export declare function stepsAreInSamePhase(ancestor: ExecutableStep, descendent: ExecutableStep): boolean;
+export declare function stepsAreInSamePhase(ancestor: Step, descendent: Step): boolean;
 export declare const canonicalJSONStringify: (o: object) => string;
 export declare function assertNotAsync(fn: any, name: string): void;
 export declare function assertNotPromise<TVal>(value: TVal, fn: any, name: string): TVal;
-export declare function hasItemPlan(step: ExecutableStep & {
-    itemPlan?: ($item: ExecutableStep) => ExecutableStep;
-}): step is ExecutableStep & {
-    itemPlan: ($item: ExecutableStep) => ExecutableStep;
+export declare function hasItemPlan(step: Step & {
+    itemPlan?: ($item: Step) => Step;
+}): step is Step & {
+    itemPlan: ($item: Step) => Step;
 };
 export declare function exportNameHint(obj: any, nameHint: string): void;
 export declare function isTuple<T extends readonly [...(readonly any[])]>(t: any | T): t is T;
@@ -157,5 +160,14 @@ export declare function isTuple<T extends readonly [...(readonly any[])]>(t: any
  * than JSON.stringify().)
  */
 export declare function digestKeys(keys: ReadonlyArray<string | number | symbol>): string;
+/**
+ * If the directive has the argument `argName`, return a step representing that
+ * arguments value, whether that be a step representing the relevant variable
+ * or a constant step representing the hardcoded value in the document.
+ *
+ * @remarks NOT SUITABLE FOR USAGE WITH LISTS OR OBJECTS! Does not evaluate
+ * internal variable usages e.g. `[1, $b, 3]`
+ */
+export declare function directiveArgument<T>(operationPlan: OperationPlan, directive: DirectiveNode, argName: string, expectedKind: graphql.Kind.INT | graphql.Kind.FLOAT | graphql.Kind.BOOLEAN | graphql.Kind.STRING): Step<T> | undefined;
 export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -1,12 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.digestKeys = exports.isTuple = exports.exportNameHint = exports.hasItemPlan = exports.assertNotPromise = exports.assertNotAsync = exports.canonicalJSONStringify = exports.stepsAreInSamePhase = exports.stepAMayDependOnStepB = exports.stepADependsOnStepB = exports.writeableArray = exports.sudo = exports.isTypePlanned = exports.findVariableNamesUsed = exports.arrayOfLengthCb = exports.arrayOfLength = exports.stack = exports.sharedNull = exports.getEnumValueConfig = exports.inputObjectFieldSpec = exports.newInputObjectTypeBuilder = exports.newGrafastFieldConfigBuilder = exports.objectFieldSpec = exports.newObjectTypeBuilder = exports.objectSpec = exports.arraysMatch = exports.isDeferred = exports.isPromiseLike = exports.isPromise = exports.defaultValueToValueNode = exports.assertNullPrototype = exports.ROOT_VALUE_OBJECT = void 0;
+exports.canonicalJSONStringify = exports.valueNodeToStaticValue = exports.sharedNull = exports.ROOT_VALUE_OBJECT = void 0;
+exports.assertNullPrototype = assertNullPrototype;
+exports.defaultValueToValueNode = defaultValueToValueNode;
+exports.isPromise = isPromise;
+exports.isPromiseLike = isPromiseLike;
+exports.isDeferred = isDeferred;
+exports.arraysMatch = arraysMatch;
+exports.objectSpec = objectSpec;
+exports.newObjectTypeBuilder = newObjectTypeBuilder;
+exports.objectFieldSpec = objectFieldSpec;
+exports.newGrafastFieldConfigBuilder = newGrafastFieldConfigBuilder;
+exports.newInputObjectTypeBuilder = newInputObjectTypeBuilder;
+exports.inputObjectFieldSpec = inputObjectFieldSpec;
+exports.getEnumValueConfigs = getEnumValueConfigs;
+exports.getEnumValueConfig = getEnumValueConfig;
+exports.stack = stack;
+exports.arrayOfLength = arrayOfLength;
+exports.arrayOfLengthCb = arrayOfLengthCb;
+exports.findVariableNamesUsedInValueNode = findVariableNamesUsedInValueNode;
+exports.findVariableNamesUsed = findVariableNamesUsed;
+exports.isTypePlanned = isTypePlanned;
+exports.sudo = sudo;
+exports.writeableArray = writeableArray;
+exports.stepADependsOnStepB = stepADependsOnStepB;
+exports.stepAMayDependOnStepB = stepAMayDependOnStepB;
+exports.stepsAreInSamePhase = stepsAreInSamePhase;
+exports.assertNotAsync = assertNotAsync;
+exports.assertNotPromise = assertNotPromise;
+exports.hasItemPlan = hasItemPlan;
+exports.exportNameHint = exportNameHint;
+exports.isTuple = isTuple;
+exports.digestKeys = digestKeys;
+exports.directiveArgument = directiveArgument;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const assert = tslib_1.__importStar(require("./assert.js"));
 const dev_js_1 = require("./dev.js");
 const error_js_1 = require("./error.js");
 const inspect_js_1 = require("./inspect.js");
+const constant_js_1 = require("./steps/constant.js");
 const { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLString, GraphQLUnionType, Kind, } = graphql;
 /**
  * The parent object is used as the key in `GetValueStepId()`; for root level
@@ -20,7 +53,6 @@ function assertNullPrototype(object, description) {
         assert.strictEqual(Object.getPrototypeOf(object), null, `Expected ${description} to have a null prototype`);
     }
 }
-exports.assertNullPrototype = assertNullPrototype;
 /**
  * Converts a JSON value into the equivalent ValueNode _without_ checking that
  * it's compatible with the expected type. Typically only used with scalars
@@ -181,21 +213,18 @@ function defaultValueToValueNode(type, defaultValue) {
     }
     return rawValueToValueNode(type, defaultValue);
 }
-exports.defaultValueToValueNode = defaultValueToValueNode;
 function isPromise(t) {
     return (typeof t === "object" &&
         t !== null &&
         typeof t.then === "function" &&
         typeof t.catch === "function");
 }
-exports.isPromise = isPromise;
 /**
  * Is "thenable".
  */
 function isPromiseLike(t) {
     return t != null && typeof t.then === "function";
 }
-exports.isPromiseLike = isPromiseLike;
 /**
  * Is a promise that can be externally resolved.
  */
@@ -204,7 +233,6 @@ function isDeferred(t) {
         typeof t.resolve === "function" &&
         typeof t.reject === "function");
 }
-exports.isDeferred = isDeferred;
 /**
  * Returns true if array1 and array2 have the same length, and every pair of
  * values within them pass the `comparator` check (which defaults to `===`).
@@ -232,7 +260,6 @@ function arraysMatch(array1, array2, comparator) {
     }
     return true;
 }
-exports.arraysMatch = arraysMatch;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
@@ -262,14 +289,12 @@ function objectSpec(spec) {
     };
     return modifiedSpec;
 }
-exports.objectSpec = objectSpec;
 /**
  * @remarks This is a mess because the first two generics need to be specified manually, but the latter one we want inferred.
  */
 function newObjectTypeBuilder(assertStep) {
     return (spec) => new GraphQLObjectType(objectSpec({ assertStep, ...spec }));
 }
-exports.newObjectTypeBuilder = newObjectTypeBuilder;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
@@ -279,23 +304,26 @@ function objectFieldSpec(grafastSpec, path) {
     assertNotAsync(subscribePlan, `${path ?? "?"}.subscribePlan`);
     const argsWithExtensions = args
         ? Object.keys(args).reduce((memo, argName) => {
-            const { inputPlan, applyPlan, autoApplyAfterParentPlan, autoApplyAfterParentSubscribePlan, ...argSpec } = args[argName];
-            assertNotAsync(inputPlan, `${path ?? "?"}(${argName}:).inputPlan`);
+            const grafastArgSpec = args[argName];
+            // TODO: remove this code
+            if (grafastArgSpec.inputPlan ||
+                grafastArgSpec.autoApplyAfterParentPlan ||
+                grafastArgSpec.autoApplyAfterParentSubscribePlan) {
+                throw new Error(`Argument at ${path} has inputPlan or autoApplyAfterParentPlan or autoApplyAfterParentSubscribePlan set; these properties no longer do anything and should be removed.`);
+            }
+            const { applyPlan, applySubscribePlan, ...argSpec } = grafastArgSpec;
             assertNotAsync(applyPlan, `${path ?? "?"}(${argName}:).applyPlan`);
+            assertNotAsync(applySubscribePlan, `${path ?? "?"}(${argName}:).applySubscribePlan`);
             memo[argName] = {
                 ...argSpec,
-                ...(inputPlan || applyPlan
+                ...(applyPlan || applySubscribePlan
                     ? {
                         extensions: {
+                            ...argSpec.extensions,
                             grafast: {
-                                ...(inputPlan ? { inputPlan } : null),
-                                ...(autoApplyAfterParentPlan
-                                    ? { autoApplyAfterParentPlan }
-                                    : null),
+                                ...argSpec.extensions?.grafast,
                                 ...(applyPlan ? { applyPlan } : null),
-                                ...(autoApplyAfterParentSubscribePlan
-                                    ? { autoApplyAfterParentSubscribePlan }
-                                    : null),
+                                ...(applySubscribePlan ? { applySubscribePlan } : null),
                             },
                         },
                     }
@@ -321,7 +349,6 @@ function objectFieldSpec(grafastSpec, path) {
             : null),
     };
 }
-exports.objectFieldSpec = objectFieldSpec;
 /**
  * "Constrainted identity function" for field configs.
  *
@@ -330,7 +357,6 @@ exports.objectFieldSpec = objectFieldSpec;
 function newGrafastFieldConfigBuilder() {
     return (config) => config;
 }
-exports.newGrafastFieldConfigBuilder = newGrafastFieldConfigBuilder;
 function inputObjectSpec(spec) {
     const modifiedSpec = {
         ...spec,
@@ -348,52 +374,53 @@ function inputObjectSpec(spec) {
 function newInputObjectTypeBuilder() {
     return (spec) => new GraphQLInputObjectType(inputObjectSpec(spec));
 }
-exports.newInputObjectTypeBuilder = newInputObjectTypeBuilder;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
 function inputObjectFieldSpec(grafastSpec, path) {
-    const { inputPlan, applyPlan, autoApplyAfterParentInputPlan, autoApplyAfterParentApplyPlan, ...spec } = grafastSpec;
-    assertNotAsync(inputPlan, `${path ?? "?"}.inputPlan`);
-    assertNotAsync(applyPlan, `${path ?? "?"}.applyPlan`);
-    return inputPlan || applyPlan
+    // TODO: remove this code
+    if (grafastSpec.applyPlan ||
+        grafastSpec.inputPlan ||
+        grafastSpec.autoApplyAfterParentApplyPlan ||
+        grafastSpec.autoApplyAfterParentInputPlan) {
+        throw new Error(`Input field at ${path} has applyPlan or inputPlan or autoApplyAfterParentApplyPlan or autoApplyAfterParentInputPlan set; these properties no longer do anything and should be removed.`);
+    }
+    const { apply, ...spec } = grafastSpec;
+    assertNotAsync(apply, `${path ?? "?"}.apply`);
+    return apply
         ? {
             ...spec,
             extensions: {
+                ...spec.extensions,
                 grafast: {
-                    ...(inputPlan ? { inputPlan } : null),
-                    ...(applyPlan ? { applyPlan } : null),
-                    ...(autoApplyAfterParentInputPlan
-                        ? { autoApplyAfterParentInputPlan }
-                        : null),
-                    ...(autoApplyAfterParentApplyPlan
-                        ? { autoApplyAfterParentApplyPlan }
-                        : null),
+                    ...spec.extensions?.grafast,
+                    apply,
                 },
             },
         }
         : spec;
 }
-exports.inputObjectFieldSpec = inputObjectFieldSpec;
 const $$valueConfigByValue = Symbol("valueConfigByValue");
-/**
- * This would be equivalent to `enumType._valueLookup.get(outputValue)` except
- * that's not a public API so we have to do a bit of heavy lifting here. Since
- * it is heavy lifting, we cache the result, but we don't know when enumType
- * will go away so we use a weakmap.
- */
-function getEnumValueConfig(enumType, outputValue) {
+function getEnumValueConfigs(enumType) {
     // We cache onto the enumType directly so that garbage collection can clear up after us easily.
-    if (!enumType[$$valueConfigByValue]) {
+    if (enumType[$$valueConfigByValue] === undefined) {
         const config = enumType.toConfig();
         enumType[$$valueConfigByValue] = Object.values(config.values).reduce((memo, value) => {
             memo[value.value] = value;
             return memo;
         }, Object.create(null));
     }
-    return enumType[$$valueConfigByValue][outputValue];
+    return enumType[$$valueConfigByValue];
+}
+/**
+ * This would be equivalent to `enumType._valueLookup.get(outputValue)` except
+ * that's not a public API so we have to do a bit of heavy lifting here. Since
+ * it is heavy lifting, we cache the result, but we don't know when enumType
+ * will go away so we use a weakmap.
+ */
+function getEnumValueConfig(enumType, outputValue) {
+    return getEnumValueConfigs(enumType)[outputValue];
 }
-exports.getEnumValueConfig = getEnumValueConfig;
 /**
  * It's a peculiarity of V8 that `{}` is twice as fast as
  * `Object.create(null)`, but `Object.create(sharedNull)` is the same speed as
@@ -427,7 +454,6 @@ function stack(message, length = 4) {
         console.log(mapped.join("\n"));
     }
 }
-exports.stack = stack;
 /**
  * Ridiculously, this is faster than `new Array(length).fill(fill)`
  */
@@ -438,7 +464,6 @@ function arrayOfLength(length, fill) {
     }
     return arr;
 }
-exports.arrayOfLength = arrayOfLength;
 /**
  * Builds an array of length `length` calling `fill` for each entry in the
  * list and storing the result.
@@ -452,7 +477,7 @@ function arrayOfLengthCb(length, fill) {
     }
     return arr;
 }
-exports.arrayOfLengthCb = arrayOfLengthCb;
+exports.valueNodeToStaticValue = graphql.valueFromAST;
 function findVariableNamesUsedInValueNode(valueNode, variableNames) {
     switch (valueNode.kind) {
         case Kind.INT:
@@ -555,7 +580,6 @@ function findVariableNamesUsed(operationPlan, field) {
     findVariableNamesUsedInFieldNode(operationPlan, field, variableNames);
     return [...variableNames].sort();
 }
-exports.findVariableNamesUsed = findVariableNamesUsed;
 function isTypePlanned(schema, namedType) {
     if (namedType instanceof GraphQLObjectType) {
         return !!namedType.extensions?.grafast?.assertStep;
@@ -584,7 +608,6 @@ function isTypePlanned(schema, namedType) {
         return false;
     }
 }
-exports.isTypePlanned = isTypePlanned;
 /**
  * Make protected/private methods accessible.
  *
@@ -593,7 +616,6 @@ exports.isTypePlanned = isTypePlanned;
 function sudo(obj) {
     return obj;
 }
-exports.sudo = sudo;
 /**
  * We want everything else to treat things like `dependencies` as read only,
  * however we ourselves want to be able to write to them, so we can use
@@ -604,7 +626,6 @@ exports.sudo = sudo;
 function writeableArray(a) {
     return a;
 }
-exports.writeableArray = writeableArray;
 /**
  * Returns `true` if the first argument depends on the second argument either
  * directly or indirectly (via a chain of dependencies).
@@ -627,7 +648,6 @@ function stepADependsOnStepB(stepA, stepB) {
     }
     return false;
 }
-exports.stepADependsOnStepB = stepADependsOnStepB;
 /**
  * Returns true if stepA is allowed to depend on stepB, false otherwise. (This
  * mostly relates to heirarchy.)
@@ -644,7 +664,6 @@ function stepAMayDependOnStepB($a, $b) {
     }
     return !stepADependsOnStepB($b, $a);
 }
-exports.stepAMayDependOnStepB = stepAMayDependOnStepB;
 /**
  * For a regular GraphQL query with no `@stream`/`@defer`, the entire result is
  * calculated and then the output is generated and sent to the client at once.
@@ -715,7 +734,6 @@ function stepsAreInSamePhase(ancestor, descendent) {
     } while ((currentLayerPlan = currentLayerPlan.parentLayerPlan));
     throw new Error(`${descendent} is not dependent on ${ancestor}, perhaps you passed the arguments in the wrong order?`);
 }
-exports.stepsAreInSamePhase = stepsAreInSamePhase;
 // ENHANCE: implement this!
 const canonicalJSONStringify = (o) => JSON.stringify(o);
 exports.canonicalJSONStringify = canonicalJSONStringify;
@@ -725,7 +743,6 @@ function assertNotAsync(fn, name) {
         throw new Error(`Plans must be synchronous, but this schema has an async function at '${name}': ${fn.toString()}`);
     }
 }
-exports.assertNotAsync = assertNotAsync;
 // PERF: only do this if isDev; otherwise replace with NOOP?
 function assertNotPromise(value, fn, name) {
     if (isPromiseLike(value)) {
@@ -733,11 +750,9 @@ function assertNotPromise(value, fn, name) {
     }
     return value;
 }
-exports.assertNotPromise = assertNotPromise;
 function hasItemPlan(step) {
     return "itemPlan" in step && typeof step.itemPlan === "function";
 }
-exports.hasItemPlan = hasItemPlan;
 function exportNameHint(obj, nameHint) {
     if ((typeof obj === "object" && obj != null) || typeof obj === "function") {
         if (!("$exporter$name" in obj)) {
@@ -751,11 +766,9 @@ function exportNameHint(obj, nameHint) {
         }
     }
 }
-exports.exportNameHint = exportNameHint;
 function isTuple(t) {
     return Array.isArray(t);
 }
-exports.isTuple = isTuple;
 /**
  * Turns an array of keys into a digest, avoiding conflicts.
  * Symbols are treated as equivalent. (Theoretically faster
@@ -778,5 +791,28 @@ function digestKeys(keys) {
     }
     return str;
 }
-exports.digestKeys = digestKeys;
+/**
+ * If the directive has the argument `argName`, return a step representing that
+ * arguments value, whether that be a step representing the relevant variable
+ * or a constant step representing the hardcoded value in the document.
+ *
+ * @remarks NOT SUITABLE FOR USAGE WITH LISTS OR OBJECTS! Does not evaluate
+ * internal variable usages e.g. `[1, $b, 3]`
+ */
+function directiveArgument(operationPlan, directive, argName, expectedKind) {
+    const arg = directive.arguments?.find((n) => n.name.value === argName);
+    if (!arg)
+        return undefined;
+    const val = arg.value;
+    return val.kind === graphql.Kind.VARIABLE
+        ? operationPlan.variableValuesStep.get(val.name.value)
+        : val.kind === expectedKind
+            ? (0, constant_js_1.constant)(val.kind === Kind.INT
+                ? parseInt(val.value, 10)
+                : val.kind === Kind.FLOAT
+                    ? parseFloat(val.value)
+                    : // boolean, string
+                        val.value)
+            : undefined;
+}
 //# sourceMappingURL=utils.js.map

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.1.1-beta.20";
+export declare const version = "0.1.1-beta.21";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // This file is autogenerated by /scripts/postversion.mjs
-exports.version = "0.1.1-beta.20";
+exports.version = "0.1.1-beta.21";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafast",
-  "version": "0.1.1-beta.20",
+  "version": "0.1.1-beta.21",
   "description": "Cutting edge GraphQL planning and execution engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -59,7 +59,7 @@
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "eventemitter3": "^5.0.1",
-    "graphile-config": "^0.0.1-beta.14",
+    "graphile-config": "^0.0.1-beta.15",
     "graphql": "^16.1.0-experimental-stream-defer.6",
     "iterall": "^1.3.0",
     "tamedevil": "^0.0.0-beta.7",