grafast 0.0.1-alpha.12 → 0.0.1-alpha.13

package/dist/input.d.ts

@@ -3,5 +3,5 @@ import type { OperationPlan } from "./engine/OperationPlan.js";
 import type { AnyInputStep } from "./interfaces.js";
 export declare function assertInputStep(itemPlan: unknown): asserts itemPlan is AnyInputStep;
 export declare function graphqlGetTypeForNode(operationPlan: OperationPlan, node: NamedTypeNode | ListTypeNode | NonNullTypeNode): GraphQLType;
-export declare function inputPlan(operationPlan: OperationPlan, inputType: GraphQLInputType, rawInputValue: ValueNode | undefined, defaultValue?: ConstValueNode | undefined): AnyInputStep;
+export declare function inputStep(operationPlan: OperationPlan, inputType: GraphQLInputType, rawInputValue: ValueNode | undefined, defaultValue?: ConstValueNode | undefined): AnyInputStep;
 //# sourceMappingURL=input.d.ts.map

package/dist/interfaces.d.ts

@@ -1,7 +1,10 @@
+import type LRU from "@graphile/lru";
 import type EventEmitter from "eventemitter3";
 import type { PluginHook } from "graphile-config";
-import type { ASTNode, ExecutionArgs, GraphQLArgument, GraphQLArgumentConfig, GraphQLField, GraphQLFieldConfig, GraphQLInputField, GraphQLInputFieldConfig, GraphQLInputObjectType, GraphQLInputType, GraphQLList, GraphQLNonNull, GraphQLOutputType, GraphQLScalarType, GraphQLSchema, GraphQLType, ValueNode, VariableNode } from "graphql";
+import type { ASTNode, DocumentNode, ExecutionArgs, FragmentDefinitionNode, GraphQLArgument, GraphQLArgumentConfig, GraphQLError, GraphQLField, GraphQLFieldConfig, GraphQLInputField, GraphQLInputFieldConfig, GraphQLInputObjectType, GraphQLInputType, GraphQLList, GraphQLNonNull, GraphQLOutputType, GraphQLScalarType, GraphQLSchema, GraphQLType, OperationDefinitionNode, ValueNode, VariableNode } from "graphql";
 import type { Bucket, RequestTools } from "./bucket.js";
+import type { OperationPlan } from "./engine/OperationPlan.js";
+import type { SafeError } from "./error.js";
 import type { ExecutableStep, ListCapableStep, ModifierStep } from "./step.js";
 import type { __InputDynamicScalarStep } from "./steps/__inputDynamicScalar.js";
 import type { __InputListStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __TrackedValueStep, __TrackedValueStepWithDollars, ConstantStep } from "./steps/index.js";
@@ -12,16 +15,77 @@ export interface GrafastTimeouts {
     execution?: number;
 }
 export interface GrafastOptions {
-    context?: Record<string, any> | (<TContext extends Record<string, any>>(ctx: Partial<Grafast.RequestContext>, currentContext?: Partial<TContext>) => PromiseOrValue<Partial<TContext>>);
+    context?: Partial<Grafast.Context> | ((ctx: Partial<Grafast.RequestContext>, args: ExecutionArgs) => PromiseOrValue<Partial<Grafast.Context>>);
     explain?: boolean | string[];
     timeouts?: GrafastTimeouts;
 }
+export declare const $$queryCache: unique symbol;
+export declare const $$cacheByOperation: unique symbol;
+export type Fragments = {
+    [key: string]: FragmentDefinitionNode;
+};
+export type OperationPlanOrError = OperationPlan | Error | SafeError<{
+    [$$timeout]: number;
+    [$$ts]: number;
+} | {
+    [$$timeout]?: undefined;
+    [$$ts]?: undefined;
+} | undefined>;
+export interface CacheByOperationEntry {
+    possibleOperationPlans: LinkedList<OperationPlanOrError> | null;
+    fragments: Fragments;
+}
+export interface LinkedList<T> {
+    value: T;
+    next: LinkedList<T> | null;
+}
 declare global {
     namespace Grafast {
         interface RequestContext {
         }
         interface Context {
         }
+        interface FieldExtensions {
+            plan?: FieldPlanResolver<any, any, any>;
+            subscribePlan?: FieldPlanResolver<any, any, any>;
+        }
+        interface ArgumentExtensions {
+            inputPlan?: ArgumentInputPlanResolver;
+            applyPlan?: ArgumentApplyPlanResolver;
+            autoApplyAfterParentPlan?: boolean;
+            autoApplyAfterParentSubscribePlan?: boolean;
+        }
+        interface InputObjectTypeExtensions {
+            inputPlan?: InputObjectTypeInputPlanResolver;
+        }
+        interface InputFieldExtensions {
+            inputPlan?: InputObjectFieldInputPlanResolver;
+            applyPlan?: InputObjectFieldApplyPlanResolver;
+            autoApplyAfterParentInputPlan?: boolean;
+            autoApplyAfterParentApplyPlan?: boolean;
+        }
+        interface ObjectTypeExtensions {
+            assertStep?: ((step: ExecutableStep) => asserts step is ExecutableStep) | {
+                new (...args: any[]): ExecutableStep;
+            } | null;
+        }
+        interface EnumTypeExtensions {
+        }
+        interface EnumValueExtensions {
+            applyPlan?: EnumValueApplyPlanResolver<any>;
+        }
+        interface ScalarTypeExtensions {
+            plan?: ScalarPlanResolver;
+            inputPlan?: ScalarInputPlanResolver;
+            idempotent?: boolean;
+        }
+        interface SchemaExtensions {
+            queryCacheMaxLength?: number;
+            [$$queryCache]?: LRU<string, DocumentNode | ReadonlyArray<GraphQLError>>;
+            operationsCacheMaxLength?: number;
+            operationOperationPlansCacheMaxLength?: number;
+            [$$cacheByOperation]?: LRU<OperationDefinitionNode, CacheByOperationEntry>;
+        }
     }
     namespace GraphileConfig {
         interface Preset {
@@ -41,64 +105,33 @@ declare global {
         }
     }
 }
-export interface GrafastFieldExtensions {
-    plan?: FieldPlanResolver<any, any, any>;
-    subscribePlan?: FieldPlanResolver<any, any, any>;
-}
-export interface GrafastArgumentExtensions {
-    inputPlan?: ArgumentInputPlanResolver;
-    applyPlan?: ArgumentApplyPlanResolver;
-    autoApplyAfterParentPlan?: boolean;
-    autoApplyAfterParentSubscribePlan?: boolean;
-}
-export interface GrafastInputObjectTypeExtensions {
-    inputPlan?: InputObjectTypeInputPlanResolver;
-}
-export interface GrafastInputFieldExtensions {
-    inputPlan?: InputObjectFieldInputPlanResolver;
-    applyPlan?: InputObjectFieldApplyPlanResolver;
-    autoApplyAfterParentInputPlan?: boolean;
-    autoApplyAfterParentApplyPlan?: boolean;
-}
-export interface GrafastObjectTypeExtensions {
-    assertStep?: ((step: ExecutableStep) => asserts step is ExecutableStep) | {
-        new (...args: any[]): ExecutableStep;
-    } | null;
-}
-export interface GrafastEnumTypeExtensions {
-}
-export interface GrafastEnumValueExtensions {
-    applyPlan?: EnumValueApplyPlanResolver<any>;
-}
-export interface GrafastScalarTypeExtensions {
-    plan?: ScalarPlanResolver;
-    inputPlan?: ScalarInputPlanResolver;
-    idempotent?: boolean;
-}
 declare module "graphql" {
     interface GraphQLFieldExtensions<_TSource, _TContext, _TArgs = any> {
-        grafast?: GrafastFieldExtensions;
+        grafast?: Grafast.FieldExtensions;
     }
     interface GraphQLArgumentExtensions {
-        grafast?: GrafastArgumentExtensions;
+        grafast?: Grafast.ArgumentExtensions;
     }
     interface GraphQLInputObjectTypeExtensions {
-        grafast?: GrafastInputObjectTypeExtensions;
+        grafast?: Grafast.InputObjectTypeExtensions;
     }
     interface GraphQLInputFieldExtensions {
-        grafast?: GrafastInputFieldExtensions;
+        grafast?: Grafast.InputFieldExtensions;
     }
     interface GraphQLObjectTypeExtensions<_TSource = any, _TContext = any> {
-        grafast?: GrafastObjectTypeExtensions;
+        grafast?: Grafast.ObjectTypeExtensions;
     }
     interface GraphQLEnumTypeExtensions {
-        grafast?: GrafastEnumTypeExtensions;
+        grafast?: Grafast.EnumTypeExtensions;
     }
     interface GraphQLEnumValueExtensions {
-        grafast?: GrafastEnumValueExtensions;
+        grafast?: Grafast.EnumValueExtensions;
     }
     interface GraphQLScalarTypeExtensions {
-        grafast?: GrafastScalarTypeExtensions;
+        grafast?: Grafast.ScalarTypeExtensions;
+    }
+    interface GraphQLSchemaExtensions {
+        grafast?: Grafast.SchemaExtensions;
     }
 }
 export declare const $$grafastContext: unique symbol;
@@ -182,7 +215,7 @@ export type ScalarInputPlanResolver<TResultStep extends ExecutableStep = Executa
 }) => TResultStep;
 export type EnumValueApplyPlanResolver<TParentStep extends ExecutableStep | ModifierStep = ExecutableStep | ModifierStep> = ($parent: TParentStep) => ModifierStep | void;
 type OutputPlanForNamedType<TType extends GraphQLType> = TType extends GrafastObjectType<any, infer TStep, any> ? TStep : ExecutableStep;
-export type OutputPlanForType<TType extends GraphQLOutputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep : TType extends GraphQLNonNull<GraphQLList<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep : TType extends GraphQLList<GraphQLNonNull<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep : TType extends GraphQLList<infer U> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep : TType extends GraphQLNonNull<infer U> ? OutputPlanForNamedType<U> : OutputPlanForNamedType<TType>;
+export type OutputPlanForType<TType extends GraphQLOutputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep<ReadonlyArray<any>> : TType extends GraphQLNonNull<GraphQLList<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep<ReadonlyArray<any>> : TType extends GraphQLList<GraphQLNonNull<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep<ReadonlyArray<any>> : TType extends GraphQLList<infer U> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep<ReadonlyArray<any>> : TType extends GraphQLNonNull<infer U> ? OutputPlanForNamedType<U> : OutputPlanForNamedType<TType>;
 type InputPlanForNamedType<TType extends GraphQLType> = TType extends GrafastInputObjectType<any, infer U, any> ? U : ModifierStep<any>;
 type InputPlanForType<TType extends GraphQLInputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? InputPlanForNamedType<U> : TType extends GraphQLNonNull<GraphQLList<infer U>> ? InputPlanForNamedType<U> : TType extends GraphQLList<GraphQLNonNull<infer U>> ? InputPlanForNamedType<U> : TType extends GraphQLList<infer U> ? InputPlanForNamedType<U> : TType extends GraphQLNonNull<infer U> ? InputPlanForNamedType<U> : InputPlanForNamedType<TType>;
 type InputTypeForNamedType<TType extends GraphQLType> = TType extends GraphQLScalarType<infer U> ? U : any;
@@ -231,19 +264,16 @@ export type GrafastSubscriber<TTopics extends {
     subscribe<TTopic extends keyof TTopics = keyof TTopics>(topic: TTopic): PromiseOrDirect<AsyncIterableIterator<TTopics[TTopic]>>;
 };
 export interface NodeIdCodec<T = any> {
+    name: string;
     encode(value: T): string | null;
     decode(value: string): T;
 }
-export type NodeIdHandler<TCodecs extends {
-    [key: string]: NodeIdCodec<any>;
-} = {
-    [key: string]: NodeIdCodec<any>;
-}, TCodecName extends keyof TCodecs = keyof TCodecs, TNodeStep extends ExecutableStep = ExecutableStep, TSpec = any> = {
+export type NodeIdHandler<TCodec extends NodeIdCodec<any> = NodeIdCodec<any>, TNodeStep extends ExecutableStep = ExecutableStep, TSpec = any> = {
     typeName: string;
-    codecName: TCodecName & string;
-    match(specifier: TCodecs[TCodecName] extends NodeIdCodec<infer U> ? U : any): boolean;
-    plan($thing: TNodeStep): ExecutableStep<TCodecs[TCodecName] extends NodeIdCodec<infer U> ? U : any>;
-    getSpec(plan: ExecutableStep<TCodecs[TCodecName] extends NodeIdCodec<infer U> ? U : any>): TSpec;
+    codec: TCodec;
+    match(specifier: TCodec extends NodeIdCodec<infer U> ? U : any): boolean;
+    plan($thing: TNodeStep): ExecutableStep<TCodec extends NodeIdCodec<infer U> ? U : any>;
+    getSpec(plan: ExecutableStep<TCodec extends NodeIdCodec<infer U> ? U : any>): TSpec;
     get(spec: TSpec): TNodeStep;
     deprecationReason?: string;
 };

package/dist/makeGrafastSchema.d.ts

@@ -1,5 +1,5 @@
 import type { GraphQLFieldResolver, GraphQLScalarLiteralParser, GraphQLScalarSerializer, GraphQLScalarValueParser, GraphQLSchema } from "graphql";
-import type { EnumValueApplyPlanResolver, FieldPlanResolver, GrafastArgumentExtensions, GrafastInputFieldExtensions, ScalarPlanResolver } from "./interfaces.js";
+import type { EnumValueApplyPlanResolver, FieldPlanResolver, ScalarPlanResolver } from "./interfaces.js";
 import type { ExecutableStep } from "./step.js";
 export type FieldPlans = FieldPlanResolver<any, any, any> | {
     plan?: FieldPlanResolver<any, any, any>;
@@ -7,7 +7,7 @@ export type FieldPlans = FieldPlanResolver<any, any, any> | {
     resolve?: GraphQLFieldResolver<any, any>;
     subscribe?: GraphQLFieldResolver<any, any>;
     args?: {
-        [argName: string]: GrafastArgumentExtensions;
+        [argName: string]: Grafast.ArgumentExtensions;
     };
 };
 export type ObjectPlans = {
@@ -18,7 +18,7 @@ export type ObjectPlans = {
     [fieldName: string]: FieldPlans;
 };
 export type InputObjectPlans = {
-    [fieldName: string]: GrafastInputFieldExtensions;
+    [fieldName: string]: Grafast.InputFieldExtensions;
 };
 export type InterfaceOrUnionPlans = {
     __resolveType?: (o: unknown) => string;

package/dist/steps/access.d.ts

@@ -16,6 +16,7 @@ export declare class AccessStep<TData> extends UnbatchedExecutableStep<TData> {
     get<TAttr extends keyof TData>(attrName: TAttr): AccessStep<TData[TAttr]>;
     at<TIndex extends keyof TData>(index: TIndex): AccessStep<TData[TIndex]>;
     optimize(): AccessStep<TData>;
+    finalize(): void;
     unbatchedExecute(_extra: ExecutionExtra, ..._values: any[]): any;
     deduplicate(peers: AccessStep<unknown>[]): AccessStep<TData>[];
 }

package/dist/steps/{deepEval.d.ts → applyTransforms.d.ts}

@@ -4,7 +4,7 @@ import type { GrafastError } from "../error.js";
 import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
 import type { ListCapableStep } from "../step.js";
 import { ExecutableStep } from "../step.js";
-export declare class DeepEvalStep extends ExecutableStep {
+export declare class ApplyTransformsStep extends ExecutableStep {
     static $$export: {
         moduleName: string;
         exportName: string;
@@ -15,5 +15,5 @@ export declare class DeepEvalStep extends ExecutableStep {
     constructor(listPlan: ListCapableStep<any, any>);
     execute(_count: number, values: [GrafastValuesList<any[] | null | undefined | GrafastError>], extra: ExecutionExtra): Promise<GrafastResultsList<any[]>>;
 }
-export declare function deepEval($step: ExecutableStep): ExecutableStep<any>;
-//# sourceMappingURL=deepEval.d.ts.map
+export declare function applyTransforms($step: ExecutableStep): ExecutableStep<any>;
+//# sourceMappingURL=applyTransforms.d.ts.map

package/dist/steps/constant.d.ts

@@ -2,12 +2,13 @@ import type { GrafastResultsList } from "../interfaces.js";
 import { UnbatchedExecutableStep } from "../step.js";
 export declare class ConstantStep<TData> extends UnbatchedExecutableStep<TData> {
     readonly data: TData;
+    readonly isSensitive: boolean;
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
-    constructor(data: TData);
+    constructor(data: TData, isSensitive?: boolean);
     toStringMeta(): string;
     deduplicate(peers: readonly ConstantStep<any>[]): ConstantStep<any>[];
     execute(count: number): GrafastResultsList<TData>;
@@ -18,6 +19,6 @@ export declare class ConstantStep<TData> extends UnbatchedExecutableStep<TData>
     isNull(): boolean;
     isUndefined(): boolean;
 }
-export declare function constant(strings: TemplateStringsArray & [string]): ConstantStep<string>;
-export declare function constant<TData>(data: TData): ConstantStep<TData>;
+export declare function constant<const TString extends string>(strings: TemplateStringsArray & [TString]): ConstantStep<TString>;
+export declare function constant<TData>(data: TData, isSecret?: boolean): ConstantStep<TData>;
 //# sourceMappingURL=constant.d.ts.map

package/dist/steps/index.d.ts

@@ -28,7 +28,7 @@ export { __InputStaticLeafStep } from "./__inputStaticLeaf.js";
 export { __ItemStep } from "./__item.js";
 export { __TrackedValueStep, __TrackedValueStepWithDollars, } from "./__trackedValue.js";
 export { __ValueStep } from "./__value.js";
-export { deepEval, DeepEvalStep } from "./deepEval.js";
+export { applyTransforms, ApplyTransformsStep } from "./applyTransforms.js";
 export { GraphQLItemHandler, graphqlItemHandler, graphqlResolver, GraphQLResolverStep, } from "./graphqlResolver.js";
 export { LoadedRecordStep, loadMany, LoadManyCallback, loadManyCallback, loadOne, LoadOneCallback, loadOneCallback, LoadOptions, LoadStep, } from "./load.js";
 export { proxy, ProxyStep } from "./proxy.js";

package/dist/steps/node.d.ts

@@ -1,10 +1,8 @@
 import type { GraphQLObjectType } from "graphql";
-import type { ExecutionExtra, NodeIdCodec, NodeIdHandler, PolymorphicData } from "../interfaces.js";
+import type { ExecutionExtra, NodeIdHandler, PolymorphicData } from "../interfaces.js";
 import type { ExecutableStep, PolymorphicStep } from "../step.js";
 import { UnbatchedExecutableStep } from "../step.js";
-export declare class NodeStep<TCodecs extends {
-    [key: string]: NodeIdCodec<any>;
-}> extends UnbatchedExecutableStep implements PolymorphicStep {
+export declare class NodeStep extends UnbatchedExecutableStep implements PolymorphicStep {
     private possibleTypes;
     static $$export: {
         moduleName: string;
@@ -13,17 +11,15 @@ export declare class NodeStep<TCodecs extends {
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
     private specPlanDep;
-    constructor(codecs: TCodecs, possibleTypes: {
-        [typeName: string]: NodeIdHandler<TCodecs>;
+    constructor(possibleTypes: {
+        [typeName: string]: NodeIdHandler;
     }, $id: ExecutableStep<string>);
     planForType(type: GraphQLObjectType): ExecutableStep;
     private getTypeNameFromSpecifier;
     unbatchedExecute: (_extra: ExecutionExtra, specifier: any) => PolymorphicData<string, ReadonlyArray<any>> | null;
 }
-export declare function node<TCodecs extends {
-    [key: string]: NodeIdCodec<any>;
-}>(codecs: TCodecs, possibleTypes: {
-    [typeName: string]: NodeIdHandler<TCodecs>;
-}, $id: ExecutableStep<string>): NodeStep<TCodecs>;
-export declare function specFromNodeId(codec: NodeIdCodec<any>, handler: NodeIdHandler<any>, $id: ExecutableStep<string>): any;
+export declare function node(possibleTypes: {
+    [typeName: string]: NodeIdHandler;
+}, $id: ExecutableStep<string>): NodeStep;
+export declare function specFromNodeId(handler: NodeIdHandler<any>, $id: ExecutableStep<string>): any;
 //# sourceMappingURL=node.d.ts.map

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.0.1-alpha.12";
+export declare const version = "0.0.1-alpha.13";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafast",
-  "version": "0.0.1-alpha.12",
+  "version": "0.0.1-alpha.13",
   "description": "Cutting edge GraphQL planning and execution engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,6 +14,11 @@
       "types": "./dist/envelop.d.ts",
       "node": "./dist/envelop.js",
       "default": "./dist/envelop.js"
+    },
+    "./graphql": {
+      "types": "./fwd/graphql/index.d.ts",
+      "node": "./fwd/graphql/index.js",
+      "default": "./fwd/graphql/index.js"
     }
   },
   "repository": {
@@ -47,6 +52,7 @@
   "dependencies": {
     "@graphile/lru": "^5.0.0-alpha.2",
     "debug": "^4.3.3",
+    "graphql": "^16.1.0-experimental-stream-defer.6",
     "tamedevil": "^0.0.0-alpha.4"
   },
   "peerDependencies": {
@@ -64,6 +70,7 @@
     }
   },
   "files": [
+    "fwd",
     "dist"
   ],
   "publishConfig": {