grafast 0.0.0 → 0.0.1-0.2

package/dist/steps/partitionByIndex.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutableStep } from "../step.js";
+import type { __ListTransformStep, ListTransformItemPlanCallback } from "./listTransform.js";
+export declare function partitionByIndex<TListStep extends ExecutableStep<readonly any[]>, TItemStep extends ExecutableStep<number>>(listPlan: TListStep, mapper: ListTransformItemPlanCallback<TListStep, TItemStep>, startIndex?: 0 | 1): __ListTransformStep<TListStep, TItemStep, unknown[][], any>;
+//# sourceMappingURL=partitionByIndex.d.ts.map

package/dist/steps/proxy.d.ts

@@ -0,0 +1,22 @@
+import type { GrafastResultsList, GrafastValuesList } from "../index.js";
+import type { ExecutionExtra } from "../interfaces.js";
+import type { ExecutableStep } from "../step.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare class ProxyStep<T> extends UnbatchedExecutableStep<T> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private $depId;
+    constructor($dep: ExecutableStep<T>, $actualDep: ExecutableStep);
+    toStringMeta(): string | null;
+    addDependency(step: ExecutableStep<any>): number;
+    execute(values: [GrafastValuesList<T>]): GrafastResultsList<T>;
+    unbatchedExecute(extra: ExecutionExtra, value: T): T;
+    stream: undefined;
+}
+export declare function proxy<TData, TStep extends ExecutableStep<TData>>($step: TStep, $actualDep?: ExecutableStep): TStep & {
+    addDependency(step: ExecutableStep): number;
+};
+//# sourceMappingURL=proxy.d.ts.map

package/dist/steps/reverse.d.ts

@@ -0,0 +1,18 @@
+import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
+import type { ExecutableStep } from "../step.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare function reverseArray<TData = any>(list: readonly TData[]): TData[];
+export declare class ReverseStep<TData> extends UnbatchedExecutableStep<readonly TData[]> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    constructor(plan: ExecutableStep<readonly TData[]>);
+    execute(values: [GrafastValuesList<TData[]>]): GrafastResultsList<TData[]>;
+    unbatchedExecute(extra: ExecutionExtra, arr: TData[]): TData[];
+    deduplicate(peers: ReverseStep<TData>[]): ReverseStep<TData>[];
+}
+export declare function reverse<TData>(plan: ExecutableStep<readonly TData[]>): ReverseStep<TData>;
+//# sourceMappingURL=reverse.d.ts.map

package/dist/steps/setter.d.ts

@@ -0,0 +1,27 @@
+import type { BaseStep, ExecutableStep } from "../step.js";
+import { ModifierStep } from "../step.js";
+export interface SetterCapableStep<TPlans extends {
+    [key: string]: ExecutableStep<any>;
+}> extends BaseStep {
+    set<TKey extends keyof TPlans>(key: TKey, value: TPlans[TKey]): void;
+}
+export declare class SetterStep<TPlans extends {
+    [key: string]: ExecutableStep<any>;
+} = {
+    [key: string]: ExecutableStep<any>;
+}, TParentStep extends SetterCapableStep<TPlans> = SetterCapableStep<TPlans>> extends ModifierStep<TParentStep> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    private setters;
+    constructor($parent: TParentStep);
+    set<TKey extends keyof TPlans>(key: TKey, valuePlan: TPlans[TKey]): void;
+    apply(): void;
+}
+export declare function setter<TPlans extends {
+    [key: string]: ExecutableStep<any>;
+} = {
+    [key: string]: ExecutableStep<any>;
+}, TParentStep extends SetterCapableStep<TPlans> = SetterCapableStep<TPlans>>($parent: TParentStep): SetterStep<TPlans, TParentStep>;
+//# sourceMappingURL=setter.d.ts.map

package/dist/stringifyPayload.d.ts

@@ -0,0 +1,3 @@
+import type { JSONObject } from "./interfaces.js";
+export declare function stringifyPayload(payload: JSONObject, asString: boolean | undefined): string;
+//# sourceMappingURL=stringifyPayload.d.ts.map

package/dist/stripAnsi.d.ts

@@ -0,0 +1,3 @@
+export declare const ANSI_REGEXP: RegExp;
+export declare function stripAnsi(str: string): string;
+//# sourceMappingURL=stripAnsi.d.ts.map

package/dist/subscribe.d.ts

@@ -0,0 +1,4 @@
+import type { AsyncExecutionResult, ExecutionArgs, ExecutionResult } from "graphql";
+import type { PromiseOrValue } from "graphql/jsutils/PromiseOrValue";
+export declare function subscribe(args: ExecutionArgs, resolvedPreset?: GraphileConfig.ResolvedPreset, asString?: boolean): PromiseOrValue<AsyncGenerator<ExecutionResult | AsyncExecutionResult, void, void> | ExecutionResult>;
+//# sourceMappingURL=subscribe.d.ts.map

package/dist/utils.d.ts

@@ -0,0 +1,60 @@
+import type { FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLSchema, ValueNode } from "graphql";
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLObjectType } from "graphql";
+import type { Deferred } from "./deferred.js";
+import type { OperationPlan } from "./engine/OperationPlan.js";
+import type { InputStep } from "./input.js";
+import type { BaseGraphQLArguments, BaseGraphQLContext, GraphileFieldConfig, GraphileInputFieldConfig, OutputPlanForType } from "./interfaces.js";
+import type { ExecutableStep, ModifierStep } from "./step.js";
+export declare const ROOT_VALUE_OBJECT: any;
+export declare function assertNullPrototype(object: Record<string, unknown>, description: string): void;
+export declare function defaultValueToValueNode(type: GraphQLInputType, defaultValue: unknown): ValueNode | undefined;
+export declare function isPromise<T>(t: T | Promise<T>): t is Promise<T>;
+export declare function isPromiseLike<T>(t: T | Promise<T> | PromiseLike<T>): t is PromiseLike<T>;
+export declare function isDeferred<T>(t: T | Promise<T> | Deferred<T>): t is Deferred<T>;
+export declare function arraysMatch<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, comparator?: (val1: T, val2: T) => boolean): boolean;
+export declare type ObjectTypeFields<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>> = {
+    [key: string]: GraphileFieldConfig<GraphQLOutputType, TContext, TParentStep, any, any>;
+};
+export declare type ObjectTypeSpec<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>, TFields extends ObjectTypeFields<TContext, TParentStep>> = Omit<GraphQLObjectTypeConfig<any, TContext>, "fields"> & {
+    fields: TFields | (() => TFields);
+};
+export declare function objectSpec<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>, TFields extends ObjectTypeFields<TContext, TParentStep>>(spec: ObjectTypeSpec<TContext, TParentStep, TFields>, Step: {
+    new (...args: any[]): TParentStep;
+} | null): GraphQLObjectTypeConfig<any, TContext>;
+export declare type GraphileObjectType<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>, TFields extends ObjectTypeFields<TContext, TParentStep>> = GraphQLObjectType<TParentStep extends ExecutableStep<infer U> ? U : never, TContext> & {
+    TParentStep: TParentStep;
+    TFields: TFields;
+};
+export declare function newObjectTypeBuilder<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>>(Step: {
+    new (...args: any[]): TParentStep;
+}): <TFields extends ObjectTypeFields<TContext, TParentStep>>(spec: ObjectTypeSpec<TContext, TParentStep, TFields>) => GraphileObjectType<TContext, TParentStep, TFields>;
+export declare function objectFieldSpec<TContext extends BaseGraphQLContext, TSource extends ExecutableStep<any>, TResult extends ExecutableStep<any> = ExecutableStep<any>, TArgs extends BaseGraphQLArguments = BaseGraphQLArguments>(graphileSpec: GraphileFieldConfig<GraphQLOutputType, TContext, TSource, TResult, TArgs>): GraphQLFieldConfig<any, TContext, TArgs>;
+export declare function newGraphileFieldConfigBuilder<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>>(): <TType extends GraphQLOutputType, TFieldStep extends OutputPlanForType<TType>, TArgs extends BaseGraphQLArguments>(config: GraphileFieldConfig<TType, TContext, TParentStep, TFieldStep, TArgs>) => typeof config;
+export declare type GraphileInputFieldConfigMap<TContext extends BaseGraphQLContext, TParentStep extends ModifierStep<any>> = {
+    [key: string]: GraphileInputFieldConfig<GraphQLInputType, TContext, TParentStep, any, any>;
+};
+export declare type InputObjectTypeSpec<TContext extends BaseGraphQLContext, TParentStep extends ModifierStep<any>, TFields extends GraphileInputFieldConfigMap<TContext, TParentStep>> = Omit<GraphQLInputObjectTypeConfig, "fields"> & {
+    fields: TFields | (() => TFields);
+};
+export declare type GraphileInputObjectType<TContext extends BaseGraphQLContext, TParentStep extends ModifierStep<any>, TFields extends GraphileInputFieldConfigMap<TContext, TParentStep>> = GraphQLInputObjectType & {
+    TContext: TContext;
+    TParentStep: TParentStep;
+    TFields: TFields;
+};
+export declare function newInputObjectTypeBuilder<TContext extends BaseGraphQLContext, TParentStep extends ModifierStep<any>>(): <TFields extends GraphileInputFieldConfigMap<TContext, TParentStep>>(spec: InputObjectTypeSpec<TContext, TParentStep, TFields>) => GraphileInputObjectType<TContext, TParentStep, TFields>;
+export declare function inputObjectFieldSpec<TContext extends BaseGraphQLContext, TParent extends ModifierStep<any>, TResult extends ModifierStep<TParent> = ModifierStep<TParent>, TInput extends InputStep = InputStep>(graphileSpec: GraphileInputFieldConfig<GraphQLInputType, TContext, TParent, TResult, TInput>): GraphQLInputFieldConfig;
+export declare function getEnumValueConfig(enumType: GraphQLEnumType, outputValue: unknown): GraphQLEnumValueConfig | undefined;
+export declare const sharedNull: any;
+export declare function stack(message: string, length?: number): void;
+export declare function arrayOfLength(length: number, fill?: any): any[];
+export declare function arrayOfLengthCb(length: number, fill: () => any): any[];
+export declare function findVariableNamesUsed(operationPlan: OperationPlan, field: FieldNode): string[];
+export declare function isTypePlanned(schema: GraphQLSchema, namedType: GraphQLNamedType): boolean;
+export declare function stepADependsOnStepB(stepA: ExecutableStep, stepB: ExecutableStep): boolean;
+export declare function stepAMayDependOnStepB($a: ExecutableStep, $b: ExecutableStep): boolean;
+export declare function stepsAreInSamePhase(ancestor: ExecutableStep, descendent: ExecutableStep): boolean;
+export declare const canonicalJSONStringify: (o: object) => string;
+export declare const isSafeObjectPropertyName: (key: string) => boolean;
+export declare const canRepresentAsIdentifier: (key: string) => boolean;
+export declare const evalSafeProperty: (key: string) => string;
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,14 +1,65 @@
 {
   "name": "grafast",
-  "version": "0.0.0",
-  "description": "Coming 2023!",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "0.0.1-0.2",
+  "description": "Cutting edge GraphQL planning and execution engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "node": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./envelop": {
+      "types": "./dist/envelop.d.ts",
+      "node": "./dist/envelop.js",
+      "default": "./dist/envelop.js"
+    }
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/graphile/heart.git"
+  },
+  "keywords": [
+    "grafast",
+    "graphile",
+    "graphql",
+    "performance",
+    "fast",
+    "engine",
+    "graphqljs",
+    "execute",
+    "plan",
+    "planning",
+    "grafast",
+    "dataplanner",
+    "graphite"
+  ],
   "author": "Benjie Gillam <code@benjiegillam.com>",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "bugs": {
+    "url": "https://github.com/graphile/heart/issues"
+  },
+  "homepage": "https://grafast.org",
+  "engines": {
+    "node": ">=14.17"
+  },
+  "dependencies": {
+    "@graphile/lru": "^5.0.0-0.1"
+  },
+  "peerDependencies": {
+    "graphile-config": "^0.0.1-0.0",
+    "graphql": "*"
+  },
+  "peerDependenciesMeta": {
+    "graphile-config": {
+      "optional": true
+    }
+  },
   "files": [
-    "index.js"
-  ]
-}
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/index.js

@@ -1 +0,0 @@
-console.log('Grafast is coming soon!')