@gqloom/core 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -1,4 +1,6 @@
+import * as graphql from 'graphql';
 import { GraphQLOutputType, GraphQLObjectTypeConfig, GraphQLFieldConfig, GraphQLResolveInfo, GraphQLScalarType, GraphQLObjectType, GraphQLUnionType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLSchemaConfig, GraphQLFieldMap, GraphQLNamedType, GraphQLSchema, GraphQLFieldConfigArgumentMap, GraphQLType, GraphQLInputType, GraphQLInterfaceTypeConfig } from 'graphql';
+import * as graphql_jsutils_Maybe from 'graphql/jsutils/Maybe';
 import { AsyncLocalStorage } from 'async_hooks';
 
 /**
@@ -195,6 +197,70 @@ declare function getStandardValue<T>(result: StandardSchemaV1.Result<T>): T;
 declare function getStandardValue<T>(result?: StandardSchemaV1.Result<T>): T | undefined;
 declare function getStandardValue<T>(result: StandardSchemaV1.Result<T> | null): T | null;
 
+interface IChainFactory<TSchemaIO extends AbstractSchemaIO, TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined> {
+    description(description: GraphQLFieldOptions["description"]): this;
+    deprecationReason(deprecationReason: GraphQLFieldOptions["deprecationReason"]): this;
+    extensions(extensions: GraphQLFieldOptions["extensions"]): this;
+    output<TOutputNew extends TSchemaIO[0]>(output: TOutputNew): IChainFactory<TSchemaIO, TOutputNew, TInput>;
+    input<TInputNew extends InputSchema<TSchemaIO[0]>>(input: TInputNew): IChainFactory<TSchemaIO, TOutput, TInputNew>;
+}
+declare abstract class BaseChainFactory {
+    protected readonly options?: Partial<FieldOrOperation<any, any, any, any> & {
+        middlewares: Middleware[];
+    }> | undefined;
+    static methods(): {
+        description: (description: graphql_jsutils_Maybe.Maybe<string>) => BaseChainFactory;
+        deprecationReason: (deprecationReason: graphql_jsutils_Maybe.Maybe<string>) => BaseChainFactory;
+        extensions: (extensions: graphql_jsutils_Maybe.Maybe<Readonly<graphql.GraphQLFieldExtensions<any, any, any>>>) => BaseChainFactory;
+    };
+    constructor(options?: Partial<FieldOrOperation<any, any, any, any> & {
+        middlewares: Middleware[];
+    }> | undefined);
+    protected abstract clone(options?: Partial<FieldOrOperation<any, any, any, any> & {
+        middlewares: Middleware[];
+    }>): this;
+    description(description: GraphQLFieldOptions["description"]): this;
+    deprecationReason(deprecationReason: GraphQLFieldOptions["deprecationReason"]): this;
+    extensions(extensions: GraphQLFieldOptions["extensions"]): this;
+    use(...middlewares: Middleware[]): this;
+}
+declare class FieldChainFactory<TSchemaIO extends AbstractSchemaIO, TOutput extends TSchemaIO[0] = never, TInput extends InputSchema<TSchemaIO[0]> = undefined> extends BaseChainFactory implements IChainFactory<TSchemaIO, TOutput, TInput> {
+    static methods(): FieldChainFactory<any, never, undefined>;
+    protected clone(options?: Partial<FieldOrOperation<any, any, any, any>>): this;
+    use(...middlewares: Middleware<FieldOrOperation<any, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "field">>[]): this;
+    output<TOutputNew extends TSchemaIO[0]>(output: TOutputNew): FieldChainFactory<TSchemaIO, TOutputNew, TInput>;
+    input<TInputNew extends InputSchema<TSchemaIO[0]>>(input: TInputNew): FieldChainFactory<TSchemaIO, TOutput, TInputNew>;
+    resolve<TParent extends TSchemaIO[0]>(resolve: (parent: InferSchemaO<TParent, TSchemaIO>, input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>): FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "field">;
+}
+declare class QueryChainFactory<TSchemaIO extends AbstractSchemaIO, TOutput extends TSchemaIO[0] = never, TInput extends InputSchema<TSchemaIO[0]> = undefined> extends BaseChainFactory implements IChainFactory<TSchemaIO, TOutput, TInput> {
+    static methods(): QueryChainFactory<any, never, undefined>;
+    protected clone(options?: Partial<FieldOrOperation<any, any, any, any>>): this;
+    use(...middlewares: Middleware<FieldOrOperation<any, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "query">>[]): this;
+    output<TOutputNew extends TSchemaIO[0]>(output: TOutputNew): QueryChainFactory<TSchemaIO, TOutputNew, TInput>;
+    input<TInputNew extends InputSchema<TSchemaIO[0]>>(input: TInputNew): QueryChainFactory<TSchemaIO, TOutput, TInputNew>;
+    resolve(resolve: (input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>): any;
+}
+declare class MutationChainFactory<TSchemaIO extends AbstractSchemaIO, TOutput extends TSchemaIO[0] = never, TInput extends InputSchema<TSchemaIO[0]> = undefined> extends BaseChainFactory implements IChainFactory<TSchemaIO, TOutput, TInput> {
+    static methods(): MutationChainFactory<any, never, undefined>;
+    protected clone(options?: Partial<FieldOrOperation<any, any, any, any>>): this;
+    use(...middlewares: Middleware<FieldOrOperation<any, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "mutation">>[]): this;
+    output<TOutputNew extends TSchemaIO[0]>(output: TOutputNew): MutationChainFactory<TSchemaIO, TOutputNew, TInput>;
+    input<TInputNew extends InputSchema<TSchemaIO[0]>>(input: TInputNew): MutationChainFactory<TSchemaIO, TOutput, TInputNew>;
+    resolve(resolve: (input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>): any;
+}
+declare class SubscriptionChainFactory<TSchemaIO extends AbstractSchemaIO, TOutput extends TSchemaIO[0] = never, TInput extends InputSchema<TSchemaIO[0]> = undefined> extends BaseChainFactory implements IChainFactory<TSchemaIO, TOutput, TInput> {
+    static methods(): SubscriptionChainFactory<any, never, undefined>;
+    protected clone(options?: Partial<FieldOrOperation<any, any, any, any>>): this;
+    use(...middlewares: Middleware<FieldOrOperation<any, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "subscription">>[]): this;
+    output<TOutputNew extends TSchemaIO[0]>(output: TOutputNew): SubscriptionChainFactory<TSchemaIO, TOutputNew, TInput>;
+    input<TInputNew extends InputSchema<TSchemaIO[0]>>(input: TInputNew): SubscriptionChainFactory<TSchemaIO, TOutput, TInputNew>;
+    subscribe<TValue = InferSchemaO<TOutput, TSchemaIO>>(subscribe: (input: InferInputO<TInput, TSchemaIO>) => MayPromise<AsyncIterator<TValue>>): ResolvableSubscription<TSchemaIO, TOutput, TInput, TValue>;
+}
+interface ResolvableSubscription<TSchemaIO extends AbstractSchemaIO, TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined, TValue = InferSchemaO<TOutput, TSchemaIO>> extends Subscription<SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, TValue> {
+    resolve(resolve: (value: TValue, input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>): Subscription<SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, TValue>;
+    resolve(value: TValue, input: any): MayPromise<any>;
+}
+
 interface GraphQLSilk<TOutput = any, TInput = any> extends StandardSchemaV1<TInput, TOutput> {
     /**
      * GraphQL type for schema
@@ -254,12 +320,21 @@ interface QueryMutationOptions<TSchemaIO extends AbstractSchemaIO, TOutput exten
  */
 interface QueryFactory<TSchemaIO extends AbstractSchemaIO> {
     <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: (() => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | QueryMutationOptions<TSchemaIO, TOutput, TInput>): FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "query">;
+    <TOutput extends TSchemaIO[0]>(output: TOutput): QueryChainFactory<TSchemaIO, TOutput, undefined>;
+}
+interface QueryFactoryWithChain<TSchemaIO extends AbstractSchemaIO> extends QueryFactory<TSchemaIO>, QueryChainFactory<TSchemaIO, never, undefined> {
 }
 /**
  * Function to create a GraphQL mutation.
  */
 interface MutationFactory<TSchemaIO extends AbstractSchemaIO> {
     <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: (() => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | QueryMutationOptions<TSchemaIO, TOutput, TInput>): FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "mutation">;
+    <TOutput extends TSchemaIO[0]>(output: TOutput): MutationChainFactory<TSchemaIO, TOutput, undefined>;
+}
+/**
+ * Function to create a GraphQL mutation.
+ */
+interface MutationFactoryWithChain<TSchemaIO extends AbstractSchemaIO> extends MutationFactory<TSchemaIO>, MutationChainFactory<TSchemaIO, never, undefined> {
 }
 /**
  * Options for External Filed of existing GraphQL Object.
@@ -273,8 +348,9 @@ interface FieldOptions<TSchemaIO extends AbstractSchemaIO, TParent extends TSche
  */
 interface FieldFactory<TSchemaIO extends AbstractSchemaIO> {
     <TParent extends TSchemaIO[0], TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: ((parent: InferSchemaO<TParent, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | FieldOptions<TSchemaIO, TParent, TOutput, TInput>): FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "field">;
+    <TOutput extends TSchemaIO[0]>(output: TOutput): FieldChainFactory<TSchemaIO, TOutput, undefined>;
 }
-interface FieldFactoryWithUtils<TSchemaIO extends AbstractSchemaIO> extends FieldFactory<TSchemaIO> {
+interface FieldFactoryWithUtils<TSchemaIO extends AbstractSchemaIO> extends FieldFactory<TSchemaIO>, FieldChainFactory<TSchemaIO, never, undefined> {
     /** Set fields to be hidden in GraphQL Schema */
     hidden: typeof FIELD_HIDDEN;
 }
@@ -295,6 +371,9 @@ interface Subscription<TOutput extends GraphQLSilk, TInput extends InputSchema<G
  */
 interface SubscriptionFactory<TSchemaIO extends AbstractSchemaIO> {
     <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined, TValue = InferSchemaO<TOutput, TSchemaIO>>(output: TOutput, subscribeOrOptions: (() => MayPromise<AsyncIterator<InferSchemaO<TOutput, TSchemaIO>>>) | SubscriptionOptions<TSchemaIO, TOutput, TInput, TValue>): Subscription<SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, TValue>;
+    <TOutput extends TSchemaIO[0]>(output: TOutput): SubscriptionChainFactory<TSchemaIO, TOutput, undefined>;
+}
+interface SubscriptionFactoryWithChain<TSchemaIO extends AbstractSchemaIO> extends SubscriptionFactory<TSchemaIO>, SubscriptionChainFactory<TSchemaIO, never, undefined> {
 }
 interface ResolverFactory<TSchemaIO extends AbstractSchemaIO> {
     of<TParent extends TSchemaIO[0], TOperations extends Record<string, FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, any, any> | FieldOrOperation<undefined, any, any, OperationType> | typeof FIELD_HIDDEN>>(parent: TParent, operationOrFields: TOperations, options?: ResolverOptionsWithExtensions<OmitInUnion<ValueOf<TOperations>, typeof FIELD_HIDDEN>>): TOperations;
@@ -450,6 +529,9 @@ interface ReadOnlyObjMap<T> {
     readonly [key: string]: T;
 }
 
+declare function pascalCase(str: string): string;
+declare function capitalize<T extends string>(str: T): Capitalize<T>;
+
 declare function markErrorLocation<TError>(error: TError, ...locations: string[]): TError;
 declare function tryIn<T>(func: () => T, ...locations: string[]): T;
 /**
@@ -464,6 +546,25 @@ declare function tryIn<T>(func: () => T, ...locations: string[]): T;
  */
 declare function markLocation(message: string, ...locations: string[]): string;
 
+type BatchLoadFn<TKey, TData> = (keys: TKey[]) => Promise<(TData | Error)[]>;
+declare class EasyDataLoader<TKey, TData> {
+    protected readonly batchLoadFn: BatchLoadFn<TKey, TData>;
+    protected queue: TKey[];
+    protected cache: Map<TKey, Promise<TData>>;
+    protected resolvers: Map<TKey, [
+        resolve: (value: TData | PromiseLike<TData>) => void,
+        reject: (reason?: any) => void
+    ]>;
+    constructor(batchLoadFn: BatchLoadFn<TKey, TData>);
+    load(key: TKey): Promise<TData>;
+    clear(): void;
+    clearByKey(key: TKey): void;
+    protected executeBatchLoad(): Promise<void>;
+    protected nextTickPromise?: Promise<void>;
+    protected nextTickBatchLoad(): Promise<void>;
+    static nextTick(): Promise<void>;
+}
+
 /**
  * Create a Silk from Scalar.
  */
@@ -512,20 +613,24 @@ type InferScalarInternal<T extends GraphQLScalarType> = T extends GraphQLScalarT
 type InferScalarExternal<T extends GraphQLScalarType> = T extends GraphQLScalarType<any, infer TExternal> ? TExternal : never;
 type EnsureArray<T> = T extends Array<infer U> ? U[] : T[];
 
-declare const query: QueryFactory<GraphQLSilkIO>;
-declare const mutation: MutationFactory<GraphQLSilkIO>;
+declare const createQuery: (output: GraphQLSilk<any, any>, resolveOrOptions?: (() => MayPromise<unknown>) | QueryMutationOptions<GraphQLSilkIO, any, any>) => QueryChainFactory<AbstractSchemaIO, never, undefined> | FieldOrOperation<any, any, any, "query">;
+declare const query: QueryFactoryWithChain<GraphQLSilkIO>;
+declare const createMutation: (output: GraphQLSilk<any, any>, resolveOrOptions?: (() => MayPromise<unknown>) | QueryMutationOptions<GraphQLSilkIO, any, any>) => MutationChainFactory<AbstractSchemaIO, never, undefined> | FieldOrOperation<any, any, any, "mutation">;
+declare const mutation: MutationFactoryWithChain<GraphQLSilkIO>;
+declare const createField: (output: GraphQLSilk<any, any>, resolveOrOptions?: FieldOptions<GraphQLSilkIO, any, any, any> | ((parent: unknown) => unknown) | undefined) => FieldChainFactory<AbstractSchemaIO, never, undefined> | FieldOrOperation<any, any, any, "field">;
 declare const field: FieldFactoryWithUtils<GraphQLSilkIO>;
 declare const defaultSubscriptionResolve: (source: any) => any;
-declare const subscription: SubscriptionFactory<GraphQLSilkIO>;
+declare const createSubscription: (output: GraphQLSilk<any, any>, subscribeOrOptions?: (() => MayPromise<AsyncIterator<unknown>>) | SubscriptionOptions<GraphQLSilkIO, any, any, any>) => Subscription<any, any, any> | SubscriptionChainFactory<AbstractSchemaIO, never, undefined>;
+declare const subscription: SubscriptionFactoryWithChain<GraphQLSilkIO>;
 declare const ResolverOptionsMap: WeakMap<object, ResolverOptionsWithParent<GenericFieldOrOperation>>;
 declare function baseResolver(operations: Record<string, FieldOrOperation<any, any, any>>, options: ResolverOptionsWithParent | undefined): Record<string, FieldOrOperation<any, any, any, FieldOrOperationType>>;
 declare const resolver: ResolverFactory<GraphQLSilkIO>;
 declare const loom: {
-    query: QueryFactory<GraphQLSilkIO>;
+    query: QueryFactoryWithChain<GraphQLSilkIO>;
     resolver: ResolverFactory<GraphQLSilkIO>;
     field: FieldFactoryWithUtils<GraphQLSilkIO>;
-    subscription: SubscriptionFactory<GraphQLSilkIO>;
-    mutation: MutationFactory<GraphQLSilkIO>;
+    subscription: SubscriptionFactoryWithChain<GraphQLSilkIO>;
+    mutation: MutationFactoryWithChain<GraphQLSilkIO>;
 };
 
 declare function createResolverFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk): ResolverFactory<TSchemaIO>;
@@ -541,11 +646,11 @@ declare function createLoom<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema:
     subscription: SubscriptionFactory<TSchemaIO>;
 };
 
-interface SchemaVendorWeaver {
+interface SchemaWeaver {
     vendor: string;
     getGraphQLType: (schema: any) => GraphQLOutputType;
 }
-declare function isSchemaVendorWeaver(some: any): some is SchemaVendorWeaver;
+declare function isSchemaVendorWeaver(some: any): some is SchemaWeaver;
 
 interface WeaverContext {
     id: number;
@@ -561,11 +666,11 @@ interface WeaverContext {
     memoNamedType<TGraphQLType extends GraphQLOutputType = GraphQLOutputType>(gqlType: TGraphQLType): TGraphQLType;
     getNamedType<T extends GraphQLOutputType>(name: string): T | undefined;
     names: WeakMap<object, string>;
-    vendorWeavers: Map<string, SchemaVendorWeaver>;
+    vendorWeavers: Map<string, SchemaWeaver>;
 }
 interface WeaverConfig {
     [WEAVER_CONFIG]: string | symbol;
-    vendorWeaver?: SchemaVendorWeaver;
+    vendorWeaver?: SchemaWeaver;
 }
 declare function initWeaverContext(): WeaverContext;
 declare namespace initWeaverContext {
@@ -615,35 +720,44 @@ interface CoreSchemaWeaverConfig extends WeaverConfig, CoreSchemaWeaverConfigOpt
 declare class LoomObjectType extends GraphQLObjectType {
     protected extraFields: Map<string, SilkFieldOrOperation>;
     protected hiddenFields: Set<string>;
+    static AUTO_ALIASING: "__gqloom_auto_aliasing";
     protected weaverContext: WeaverContext;
     protected resolverOptions?: ResolvingOptions;
     constructor(objectOrGetter: string | GraphQLObjectType | GraphQLObjectTypeConfig<any, any> | (() => GraphQLObjectType | GraphQLObjectTypeConfig<any, any>), options?: {
         weaverContext?: WeaverContext;
         resolverOptions?: ResolvingOptions;
     });
+    protected hasExplicitName?: boolean;
+    protected _aliases: string[];
+    get aliases(): string[];
+    addAlias(name: string): void;
+    protected renameByAliases(): void;
     hideField(name: string): void;
     addField(name: string, resolver: SilkFieldOrOperation): void;
     mergeExtensions(extensions: GraphQLObjectTypeConfig<any, any>["extensions"]): void;
     private extraFieldMap?;
     getFields(): GraphQLFieldMap<any, any>;
     protected mapToFieldConfig(map: Map<string, SilkFieldOrOperation>): Record<string, GraphQLFieldConfig<any, any>>;
-    toFieldConfig(field: SilkFieldOrOperation): GraphQLFieldConfig<any, any>;
+    toFieldConfig(field: SilkFieldOrOperation, fieldName?: string): GraphQLFieldConfig<any, any>;
     protected provideForResolve(field: SilkFieldOrOperation): Pick<GraphQLFieldConfig<any, any>, "resolve"> | undefined;
     protected provideForSubscribe(field: SilkFieldOrOperation): Pick<GraphQLFieldConfig<any, any>, "subscribe"> | undefined;
-    protected getCacheType(gqlType: GraphQLOutputType): GraphQLOutputType;
+    protected getCacheType(gqlType: GraphQLOutputType, fieldName?: string): GraphQLOutputType;
     get options(): {
         resolverOptions: ResolvingOptions | undefined;
         weaverContext: WeaverContext;
     };
 }
+declare const OPERATION_OBJECT_NAMES: Set<string>;
 declare function getCacheType(gqlType: GraphQLOutputType, options?: {
     weaverContext?: WeaverContext;
     resolverOptions?: ResolvingOptions;
+    fieldName?: string;
+    parent?: LoomObjectType;
 }): GraphQLOutputType;
 
 interface SchemaWeaverParameters extends Partial<Record<"query" | "mutation" | "subscription", LoomObjectType>>, Pick<GraphQLSchemaConfig, "types"> {
 }
-declare class SchemaWeaver {
+declare class GraphQLSchemaLoom {
     query?: LoomObjectType;
     mutation?: LoomObjectType;
     subscription?: LoomObjectType;
@@ -659,7 +773,7 @@ declare class SchemaWeaver {
     constructor({ query, mutation, subscription, types }?: SchemaWeaverParameters, context?: WeaverContext);
     use(...middlewares: Middleware[]): this;
     add(resolver: SilkResolver): this;
-    addVendor(weaver: SchemaVendorWeaver): this;
+    addVendor(weaver: SchemaWeaver): this;
     addType(silk: GraphQLSilk): this;
     setConfig<TConfig extends WeaverConfig>(config: TConfig): this;
     weaveGraphQLSchema(): GraphQLSchema;
@@ -669,31 +783,34 @@ declare class SchemaWeaver {
         resolverOptions: ResolvingOptions | undefined;
         weaverContext: WeaverContext;
     };
-    static optionsFrom(...inputs: (SilkResolver | Middleware | SchemaVendorWeaver | WeaverConfig | GraphQLSilk)[]): {
+    static optionsFrom(...inputs: (SilkResolver | Middleware | SchemaWeaver | WeaverConfig | GraphQLSilk)[]): {
         context: WeaverContext | undefined;
         configs: Set<WeaverConfig>;
         middlewares: Set<Middleware>;
         resolvers: Set<SilkResolver>;
         silks: Set<GraphQLSilk<any, any>>;
-        weavers: Set<SchemaVendorWeaver>;
+        weavers: Set<SchemaWeaver>;
     };
     /**
      * Weave a GraphQL Schema from resolvers
-     * @param inputs Resolvers, Global Middlewares or WeaverConfigs
-     * @returns GraphQ LSchema
+     * @param inputs Resolvers, Global Middlewares, WeaverConfigs Or SchemaWeaver
+     * @returns GraphQL Schema
      */
-    static weave(...inputs: (SilkResolver | Middleware | SchemaVendorWeaver | WeaverConfig | GraphQLSilk)[]): GraphQLSchema;
+    static weave(...inputs: (SilkResolver | Middleware | SchemaWeaver | WeaverConfig | GraphQLSilk)[]): GraphQLSchema;
 }
 /**
  * Weave a GraphQL Schema from resolvers
  * @param inputs Resolvers, Global Middlewares or WeaverConfigs
  * @returns GraphQ LSchema
  */
-declare const weave: typeof SchemaWeaver.weave;
+declare const weave: typeof GraphQLSchemaLoom.weave;
 
-declare function inputToArgs(input: InputSchema<GraphQLSilk>): GraphQLFieldConfigArgumentMap | undefined;
-declare function ensureInputType(silkOrType: GraphQLType | GraphQLSilk): GraphQLInputType;
-declare function ensureInputObjectType(object: GraphQLObjectType | GraphQLInterfaceType | GraphQLInputObjectType): GraphQLInputObjectType;
+interface EnsureInputOptions {
+    fieldName?: string;
+}
+declare function inputToArgs(input: InputSchema<GraphQLSilk>, options: EnsureInputOptions | undefined): GraphQLFieldConfigArgumentMap | undefined;
+declare function ensureInputType(silkOrType: GraphQLType | GraphQLSilk, options: EnsureInputOptions | undefined): GraphQLInputType;
+declare function ensureInputObjectType(object: GraphQLObjectType | GraphQLInterfaceType | GraphQLInputObjectType, options: EnsureInputOptions | undefined): GraphQLInputObjectType;
 
 declare function ensureInterfaceType(gqlType: GraphQLOutputType, interfaceConfig?: Partial<GraphQLInterfaceTypeConfig<any, any>>): GraphQLInterfaceType;
 
@@ -711,4 +828,4 @@ interface GQLoomExtensionAttribute {
     directives?: string[];
 }
 
-export { type AbstractSchemaIO, type CallableContextMemoization, type CallableInputParser, type CallableMiddlewareOptions, ContextMemoization, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, type FieldConvertOptions, type FieldFactory, type FieldFactoryWithUtils, type FieldOptions, type FieldOrOperation, type FieldOrOperationType, type GQLoomExtensionAttribute, type GQLoomExtensions, type GenericFieldOrOperation, type GlobalWeaverContext, type GraphQLFieldOptions, type GraphQLSilk, type GraphQLSilkIO, type InferFieldInput, type InferFieldOutput, type InferFieldParent, type InferInputI, type InferInputO, type InferPropertyType, type InferSchemaI, type InferSchemaO, type InputSchema, type InputSchemaToSilk, type IsAny, type ListSilk, LoomObjectType, type MayPromise, type Middleware, type MiddlewareOptions, type MutationFactory, type NonNullSilk, type NullableSilk, type ObjectOrNever, type OnlyMemoizationPayload, type OperationType, type QueryFactory, type QueryMutationOptions, type ResolverFactory, type ResolverOptions, ResolverOptionsMap, type ResolverOptionsWithExtensions, type ResolverOptionsWithParent, type ResolverPayload, type ResolvingOptions, symbols as SYMBOLS, type SchemaToSilk, type SchemaVendorWeaver, SchemaWeaver, type SilkFieldOrOperation, type SilkResolver, StandardSchemaV1, type Subscription, type SubscriptionFactory, type SubscriptionOptions, type ValueOf, type WeaverConfig, type WeaverContext, type WrapPropertyType, applyMiddlewares, baseResolver, collectName, collectNames, compose, createFieldFactory, createInputParser, createLoom, createMemoization, createMutationFactory, createQueryFactory, createResolverFactory, createSubscriptionFactory, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, field, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getStandardValue, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSchemaVendorWeaver, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, mutation, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseSilk, provideWeaverContext, query, resolver, resolverPayloadStorage, silk, subscription, toObjMap, tryIn, useContext, useMemoizationMap, useResolverPayload, weave, weaverContext };
+export { type AbstractSchemaIO, type BatchLoadFn, type CallableContextMemoization, type CallableInputParser, type CallableMiddlewareOptions, ContextMemoization, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, EasyDataLoader, type FieldConvertOptions, type FieldFactory, type FieldFactoryWithUtils, type FieldOptions, type FieldOrOperation, type FieldOrOperationType, type GQLoomExtensionAttribute, type GQLoomExtensions, type GenericFieldOrOperation, type GlobalWeaverContext, type GraphQLFieldOptions, GraphQLSchemaLoom, type GraphQLSilk, type GraphQLSilkIO, type InferFieldInput, type InferFieldOutput, type InferFieldParent, type InferInputI, type InferInputO, type InferPropertyType, type InferSchemaI, type InferSchemaO, type InputSchema, type InputSchemaToSilk, type IsAny, type ListSilk, LoomObjectType, type MayPromise, type Middleware, type MiddlewareOptions, type MutationFactory, type MutationFactoryWithChain, type NonNullSilk, type NullableSilk, OPERATION_OBJECT_NAMES, type ObjectOrNever, type OnlyMemoizationPayload, type OperationType, type QueryFactory, type QueryFactoryWithChain, type QueryMutationOptions, type ResolverFactory, type ResolverOptions, ResolverOptionsMap, type ResolverOptionsWithExtensions, type ResolverOptionsWithParent, type ResolverPayload, type ResolvingOptions, symbols as SYMBOLS, type SchemaToSilk, type SchemaWeaver, type SilkFieldOrOperation, type SilkResolver, StandardSchemaV1, type Subscription, type SubscriptionFactory, type SubscriptionFactoryWithChain, type SubscriptionOptions, type ValueOf, type WeaverConfig, type WeaverContext, type WrapPropertyType, applyMiddlewares, baseResolver, capitalize, collectName, collectNames, compose, createField, createFieldFactory, createInputParser, createLoom, createMemoization, createMutation, createMutationFactory, createQuery, createQueryFactory, createResolverFactory, createSubscription, createSubscriptionFactory, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, field, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getStandardValue, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSchemaVendorWeaver, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, mutation, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseSilk, pascalCase, provideWeaverContext, query, resolver, resolverPayloadStorage, silk, subscription, toObjMap, tryIn, useContext, useMemoizationMap, useResolverPayload, weave, weaverContext };