@gqloom/core 0.6.0 → 0.7.0

package/README.md

@@ -2,18 +2,13 @@
 
 # GQLoom
 
-GQLoom is a GraphQL weaver for TypeScript/JavaScript that weaves GraphQL Schema using Valibot, Zod, or Yup, and supports sophisticated type inference to provide the best development experience.
+GQLoom is a **Code First** GraphQL Schema Loom used to weave **runtime types** in the **TypeScript/JavaScript** ecosystem into a GraphQL Schema.
 
-The design of GQLoom is inspired by [tRPC](https://trpc.io/), [TypeGraphQL](https://typegraphql.com/), [Pothos](https://pothos-graphql.dev/).
+Runtime validation libraries such as [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), and [Yup](https://github.com/jquense/yup) have been widely used in backend application development. Meanwhile, when using ORM libraries like [Prisma](https://www.prisma.io/), [MikroORM](https://mikro-orm.io/), and [Drizzle](https://orm.drizzle.team/), we also pre - define database table structures or entity models that contain runtime types.
+The responsibility of GQLoom is to weave these runtime types into a GraphQL Schema.
 
-## Features
-
-* 🚀 GraphQL: flexible and efficient, reducing redundant data transfers;
-* 🔒 Robust type safety: enjoy intelligent hints at development time to detect potential problems at compile time;
-* 🔋 Ready to go: middleware, contexts, subscriptions, federated graphs are ready to go;
-* 🔮 No extra magic: no decorators, no metadata and reflection, no code generation, you just need JavaScript/TypeScript;
-* 🧩 Familiar schema libraries: use the schema libraries you already know (Zod, Yup, Valibot) to build GraphQL Schema and validate inputs;
-* 🧑‍💻 Develop happily: highly readable and semantic APIs designed to keep your code tidy;
+When developing backend applications with GQLoom, you only need to write types using the Schema libraries you're familiar with. Modern Schema libraries will infer TypeScript types for you, and GQLoom will weave GraphQL types for you.
+In addition, the **resolver factory** of GQLoom can create CRUD interfaces for `Prisma`, `MikroORM`, and `Drizzle`, and supports custom input and adding middleware.
 
 ## Hello World
 
@@ -22,14 +17,23 @@ import { resolver, query, ValibotWeaver } from "@gqloom/valibot"
 import * as v from "valibot"
 
 const helloResolver = resolver({
-  hello: query(v.string(), () => "world"),
+  hello: query(v.string())
+  .input({ name: v.nullish(v.string(), "World") })
+  .resolve(({ name }) => `Hello, ${name}!`),
 })
 
 export const schema = ValibotWeaver.weave(helloResolver)
 ```
 
-Read [Introduction](https://gqloom.dev/guide/introduction.html) to learn more about GQLoom.
+## Highlights you should not miss
+
+- 🧑‍💻 **Development Experience**: Fewer boilerplate codes, semantic API design, and extensive ecosystem integration make development enjoyable.
+- 🔒 **Type Safety**: Automatically infer types from the Schema, enjoy intelligent code completion during development, and detect potential problems during compilation.
+- 🎯 **Interface Factory**: Ordinary CRUD interfaces are too simple yet too cumbersome. Let the resolver factory create them quickly.
+- 🔋 **Fully Prepared**: Middleware, context, subscriptions, and federated graphs are ready.
+- 🔮 **No Magic**: Without decorators, metadata, reflection, or code generation, it can run anywhere with just JavaScript/TypeScript.
+- 🧩 **Rich Integration**: Use your most familiar validation libraries and ORMs to build your next GraphQL application.
 
 ## Getting Started
 
-See [Getting Started](https://gqloom.dev/guide/getting-started.html) to learn how to use GQLoom.
+See [Getting Started](https://gqloom.dev/guide/getting-started.html) to learn how to use GQLoom.

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   ContextMemoization: () => ContextMemoization,
+  EasyDataLoader: () => EasyDataLoader,
   GraphQLSchemaLoom: () => GraphQLSchemaLoom,
   LoomObjectType: () => LoomObjectType,
   OPERATION_OBJECT_NAMES: () => OPERATION_OBJECT_NAMES,
@@ -28,16 +29,21 @@ __export(src_exports, {
   SYMBOLS: () => symbols_exports,
   applyMiddlewares: () => applyMiddlewares,
   baseResolver: () => baseResolver,
+  capitalize: () => capitalize,
   collectName: () => collectName,
   collectNames: () => collectNames,
   compose: () => compose,
+  createField: () => createField,
   createFieldFactory: () => createFieldFactory,
   createInputParser: () => createInputParser,
   createLoom: () => createLoom,
   createMemoization: () => createMemoization,
+  createMutation: () => createMutation,
   createMutationFactory: () => createMutationFactory,
+  createQuery: () => createQuery,
   createQueryFactory: () => createQueryFactory,
   createResolverFactory: () => createResolverFactory,
+  createSubscription: () => createSubscription,
   createSubscriptionFactory: () => createSubscriptionFactory,
   deepMerge: () => deepMerge,
   defaultSubscriptionResolve: () => defaultSubscriptionResolve,
@@ -265,7 +271,7 @@ function listSilk(origin) {
     [GET_GRAPHQL_TYPE]: () => {
       let originType = getGraphQLType(origin);
       if (originType instanceof import_graphql2.GraphQLNonNull && originType.ofType instanceof import_graphql2.GraphQLList) {
-        originType = originType.ofType;
+        originType = originType.ofType.ofType;
       }
       if (originType instanceof import_graphql2.GraphQLList) {
         originType = originType.ofType;
@@ -505,6 +511,9 @@ function pascalCase(str) {
     (word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)
   ).join("");
 }
+function capitalize(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
 
 // src/utils/error.ts
 function markErrorLocation(error, ...locations) {
@@ -534,6 +543,72 @@ function markLocation(message, ...locations) {
   return `[${combinedLocation}] ${newMessage}`;
 }
 
+// src/utils/loader.ts
+var EasyDataLoader = class _EasyDataLoader {
+  constructor(batchLoadFn) {
+    this.batchLoadFn = batchLoadFn;
+    this.queue = [];
+    this.cache = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+  }
+  queue;
+  cache;
+  resolvers;
+  load(key) {
+    const existing = this.cache.get(key);
+    if (existing) return existing;
+    const promise = new Promise((resolve, reject) => {
+      this.queue.push(key);
+      this.resolvers.set(key, [resolve, reject]);
+      this.nextTickBatchLoad();
+    });
+    this.cache.set(key, promise);
+    return promise;
+  }
+  clear() {
+    this.queue = [];
+    this.cache = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+  }
+  clearByKey(key) {
+    this.queue = this.queue.filter((k) => k !== key);
+    this.cache.delete(key);
+    this.resolvers.delete(key);
+  }
+  async executeBatchLoad() {
+    if (this.queue.length === 0) return;
+    const [keys, resolvers] = [this.queue, this.resolvers];
+    this.queue = [];
+    this.resolvers = /* @__PURE__ */ new Map();
+    try {
+      const list = await this.batchLoadFn(keys);
+      for (let i = 0; i < list.length; i++) {
+        const data = list[i];
+        const resolve = resolvers.get(keys[i])?.[0];
+        const reject = resolvers.get(keys[i])?.[1];
+        if (data instanceof Error) {
+          reject?.(data);
+        } else {
+          resolve?.(data);
+        }
+      }
+    } catch (error) {
+      for (const key of keys) {
+        const reject = resolvers.get(key)?.[1];
+        reject?.(error);
+      }
+    }
+  }
+  nextTickPromise;
+  nextTickBatchLoad() {
+    this.nextTickPromise ??= _EasyDataLoader.nextTick().then(() => this.executeBatchLoad()).finally(() => this.nextTickPromise = void 0);
+    return this.nextTickPromise;
+  }
+  static nextTick() {
+    return new Promise((resolve) => setTimeout(resolve));
+  }
+};
+
 // src/resolver/input.ts
 var import_graphql3 = require("graphql");
 function createInputParser(schema, value) {
@@ -587,8 +662,168 @@ function getStandardValue(result) {
   else throw new import_graphql3.GraphQLError("Invalid input");
 }
 
+// src/resolver/resolver-chain-factory.ts
+var BaseChainFactory = class _BaseChainFactory {
+  constructor(options) {
+    this.options = options;
+  }
+  static methods() {
+    return {
+      description: _BaseChainFactory.prototype.description,
+      deprecationReason: _BaseChainFactory.prototype.deprecationReason,
+      extensions: _BaseChainFactory.prototype.extensions
+    };
+  }
+  description(description) {
+    return this.clone({ description });
+  }
+  deprecationReason(deprecationReason) {
+    return this.clone({ deprecationReason });
+  }
+  extensions(extensions) {
+    return this.clone({ extensions });
+  }
+  use(...middlewares) {
+    return this.clone({
+      middlewares: [...this.options?.middlewares ?? [], ...middlewares]
+    });
+  }
+};
+var FieldChainFactory = class _FieldChainFactory extends BaseChainFactory {
+  static methods() {
+    return {
+      ...BaseChainFactory.methods(),
+      output: _FieldChainFactory.prototype.output,
+      input: _FieldChainFactory.prototype.input,
+      resolve: _FieldChainFactory.prototype.resolve,
+      clone: _FieldChainFactory.prototype.clone
+    };
+  }
+  clone(options) {
+    return new _FieldChainFactory({ ...this.options, ...options });
+  }
+  use(...middlewares) {
+    return super.use(...middlewares);
+  }
+  output(output) {
+    return new _FieldChainFactory({ ...this.options, output });
+  }
+  input(input) {
+    return new _FieldChainFactory({ ...this.options, input });
+  }
+  resolve(resolve) {
+    return createField(this.options?.output, {
+      ...this.options,
+      resolve
+    });
+  }
+};
+var QueryChainFactory = class _QueryChainFactory extends BaseChainFactory {
+  static methods() {
+    return {
+      ...BaseChainFactory.methods(),
+      output: _QueryChainFactory.prototype.output,
+      input: _QueryChainFactory.prototype.input,
+      resolve: _QueryChainFactory.prototype.resolve,
+      clone: _QueryChainFactory.prototype.clone
+    };
+  }
+  clone(options) {
+    return new _QueryChainFactory({ ...this.options, ...options });
+  }
+  use(...middlewares) {
+    return super.use(...middlewares);
+  }
+  output(output) {
+    return new _QueryChainFactory({ ...this.options, output });
+  }
+  input(input) {
+    return new _QueryChainFactory({ ...this.options, input });
+  }
+  resolve(resolve) {
+    return createQuery(this.options?.output, {
+      ...this.options,
+      resolve
+    });
+  }
+};
+var MutationChainFactory = class _MutationChainFactory extends BaseChainFactory {
+  static methods() {
+    return {
+      ...BaseChainFactory.methods(),
+      output: _MutationChainFactory.prototype.output,
+      input: _MutationChainFactory.prototype.input,
+      resolve: _MutationChainFactory.prototype.resolve,
+      clone: _MutationChainFactory.prototype.clone
+    };
+  }
+  clone(options) {
+    return new _MutationChainFactory({ ...this.options, ...options });
+  }
+  use(...middlewares) {
+    return super.use(...middlewares);
+  }
+  output(output) {
+    return new _MutationChainFactory({ ...this.options, output });
+  }
+  input(input) {
+    return new _MutationChainFactory({ ...this.options, input });
+  }
+  resolve(resolve) {
+    return createMutation(this.options?.output, {
+      ...this.options,
+      resolve
+    });
+  }
+};
+var SubscriptionChainFactory = class _SubscriptionChainFactory extends BaseChainFactory {
+  static methods() {
+    return {
+      ...BaseChainFactory.methods(),
+      output: _SubscriptionChainFactory.prototype.output,
+      input: _SubscriptionChainFactory.prototype.input,
+      subscribe: _SubscriptionChainFactory.prototype.subscribe,
+      clone: _SubscriptionChainFactory.prototype.clone
+    };
+  }
+  clone(options) {
+    return new _SubscriptionChainFactory({ ...this.options, ...options });
+  }
+  use(...middlewares) {
+    return super.use(...middlewares);
+  }
+  output(output) {
+    return new _SubscriptionChainFactory({ ...this.options, output });
+  }
+  input(input) {
+    return new _SubscriptionChainFactory({ ...this.options, input });
+  }
+  subscribe(subscribe) {
+    const options = this.options;
+    const subscription2 = createSubscription(options?.output, {
+      ...options,
+      subscribe
+    });
+    const subscriptionResolve = subscription2.resolve;
+    const resolve = (...args) => {
+      if (args.length === 1 && typeof args[0] === "function") {
+        return createSubscription(options?.output, {
+          ...options,
+          resolve: args[0],
+          subscribe
+        });
+      }
+      return subscriptionResolve(...args);
+    };
+    return Object.assign(subscription2, { resolve });
+  }
+};
+
 // src/resolver/resolver.ts
-var query = (output, resolveOrOptions) => {
+var createQuery = (output, resolveOrOptions) => {
+  if (resolveOrOptions == null) {
+    return new QueryChainFactory({ output });
+  }
   const options = getOperationOptions(resolveOrOptions);
   const type = "query";
   return {
@@ -606,7 +841,14 @@ var query = (output, resolveOrOptions) => {
     type
   };
 };
-var mutation = (output, resolveOrOptions) => {
+var query = Object.assign(
+  createQuery,
+  QueryChainFactory.methods()
+);
+var createMutation = (output, resolveOrOptions) => {
+  if (resolveOrOptions == null) {
+    return new MutationChainFactory({ output });
+  }
   const options = getOperationOptions(resolveOrOptions);
   const type = "mutation";
   return {
@@ -624,7 +866,14 @@ var mutation = (output, resolveOrOptions) => {
     type
   };
 };
-var baseSilkField = (output, resolveOrOptions) => {
+var mutation = Object.assign(
+  createMutation,
+  MutationChainFactory.methods()
+);
+var createField = (output, resolveOrOptions) => {
+  if (resolveOrOptions == null) {
+    return new FieldChainFactory({ output });
+  }
   const options = getOperationOptions(resolveOrOptions);
   const type = "field";
   return {
@@ -643,13 +892,15 @@ var baseSilkField = (output, resolveOrOptions) => {
   };
 };
 var field = Object.assign(
-  baseSilkField,
-  {
-    hidden: FIELD_HIDDEN
-  }
+  createField,
+  { hidden: FIELD_HIDDEN },
+  FieldChainFactory.methods()
 );
 var defaultSubscriptionResolve = (source) => source;
-var subscription = (output, subscribeOrOptions) => {
+var createSubscription = (output, subscribeOrOptions) => {
+  if (subscribeOrOptions == null) {
+    return new SubscriptionChainFactory({ output });
+  }
   const options = getSubscriptionOptions(subscribeOrOptions);
   const type = "subscription";
   return {
@@ -671,6 +922,10 @@ var subscription = (output, subscribeOrOptions) => {
     type
   };
 };
+var subscription = Object.assign(
+  createSubscription,
+  SubscriptionChainFactory.methods()
+);
 var ResolverOptionsMap = /* @__PURE__ */ new WeakMap();
 function baseResolver(operations, options) {
   const record = {};
@@ -751,6 +1006,9 @@ function createResolverFactory(toSilk) {
 }
 function createFieldFactory(toSilk, isSchema) {
   const baseFieldFunc = (output, resolveOrOptions) => {
+    if (resolveOrOptions == null) {
+      return new FieldChainFactory({ output: toSilk(output) });
+    }
     const options = getOperationOptions(
       resolveOrOptions
     );
@@ -759,12 +1017,17 @@ function createFieldFactory(toSilk, isSchema) {
       input: toSilkInput(options.input, toSilk, isSchema)
     });
   };
-  return Object.assign(baseFieldFunc, {
-    hidden: FIELD_HIDDEN
-  });
+  return Object.assign(
+    baseFieldFunc,
+    { hidden: FIELD_HIDDEN },
+    FieldChainFactory.methods()
+  );
 }
 function createQueryFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
+    if (resolveOrOptions == null) {
+      return new QueryChainFactory({ output: toSilk(output) });
+    }
     const options = getOperationOptions(resolveOrOptions);
     return query(toSilk(output), {
       ...options,
@@ -774,6 +1037,9 @@ function createQueryFactory(toSilk, isSchema) {
 }
 function createMutationFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
+    if (resolveOrOptions == null) {
+      return new MutationChainFactory({ output: toSilk(output) });
+    }
     const options = getOperationOptions(resolveOrOptions);
     return mutation(toSilk(output), {
       ...options,
@@ -783,6 +1049,9 @@ function createMutationFactory(toSilk, isSchema) {
 }
 function createSubscriptionFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
+    if (resolveOrOptions == null) {
+      return new SubscriptionChainFactory({ output: toSilk(output) });
+    }
     const options = getSubscriptionOptions(resolveOrOptions);
     return subscription(toSilk(output), {
       ...options,
@@ -1333,6 +1602,7 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ContextMemoization,
+  EasyDataLoader,
   GraphQLSchemaLoom,
   LoomObjectType,
   OPERATION_OBJECT_NAMES,
@@ -1340,16 +1610,21 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   SYMBOLS,
   applyMiddlewares,
   baseResolver,
+  capitalize,
   collectName,
   collectNames,
   compose,
+  createField,
   createFieldFactory,
   createInputParser,
   createLoom,
   createMemoization,
+  createMutation,
   createMutationFactory,
+  createQuery,
   createQueryFactory,
   createResolverFactory,
+  createSubscription,
   createSubscriptionFactory,
   deepMerge,
   defaultSubscriptionResolve,

package/dist/index.d.cts

@@ -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;
@@ -451,6 +530,7 @@ interface ReadOnlyObjMap<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;
@@ -466,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.
  */
@@ -514,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>;
@@ -725,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, 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 NonNullSilk, type NullableSilk, OPERATION_OBJECT_NAMES, 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 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, pascalCase, 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 };

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;
@@ -451,6 +530,7 @@ interface ReadOnlyObjMap<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;
@@ -466,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.
  */
@@ -514,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>;
@@ -725,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, 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 NonNullSilk, type NullableSilk, OPERATION_OBJECT_NAMES, 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 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, pascalCase, 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 };

package/dist/index.js

@@ -192,7 +192,7 @@ function listSilk(origin) {
     [GET_GRAPHQL_TYPE]: () => {
       let originType = getGraphQLType(origin);
       if (originType instanceof GraphQLNonNull && originType.ofType instanceof GraphQLList) {
-        originType = originType.ofType;
+        originType = originType.ofType.ofType;
       }
       if (originType instanceof GraphQLList) {
         originType = originType.ofType;
@@ -432,6 +432,9 @@ function pascalCase(str) {
     (word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)
   ).join("");
 }
+function capitalize(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
 
 // src/utils/error.ts
 function markErrorLocation(error, ...locations) {
@@ -461,6 +464,72 @@ function markLocation(message, ...locations) {
   return `[${combinedLocation}] ${newMessage}`;
 }
 
+// src/utils/loader.ts
+var EasyDataLoader = class _EasyDataLoader {
+  constructor(batchLoadFn) {
+    this.batchLoadFn = batchLoadFn;
+    this.queue = [];
+    this.cache = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+  }
+  queue;
+  cache;
+  resolvers;
+  load(key) {
+    const existing = this.cache.get(key);
+    if (existing) return existing;
+    const promise = new Promise((resolve, reject) => {
+      this.queue.push(key);
+      this.resolvers.set(key, [resolve, reject]);
+      this.nextTickBatchLoad();
+    });
+    this.cache.set(key, promise);
+    return promise;
+  }
+  clear() {
+    this.queue = [];
+    this.cache = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+  }
+  clearByKey(key) {
+    this.queue = this.queue.filter((k) => k !== key);
+    this.cache.delete(key);
+    this.resolvers.delete(key);
+  }
+  async executeBatchLoad() {
+    if (this.queue.length === 0) return;
+    const [keys, resolvers] = [this.queue, this.resolvers];
+    this.queue = [];
+    this.resolvers = /* @__PURE__ */ new Map();
+    try {
+      const list = await this.batchLoadFn(keys);
+      for (let i = 0; i < list.length; i++) {
+        const data = list[i];
+        const resolve = resolvers.get(keys[i])?.[0];
+        const reject = resolvers.get(keys[i])?.[1];
+        if (data instanceof Error) {
+          reject?.(data);
+        } else {
+          resolve?.(data);
+        }
+      }
+    } catch (error) {
+      for (const key of keys) {
+        const reject = resolvers.get(key)?.[1];
+        reject?.(error);
+      }
+    }
+  }
+  nextTickPromise;
+  nextTickBatchLoad() {
+    this.nextTickPromise ??= _EasyDataLoader.nextTick().then(() => this.executeBatchLoad()).finally(() => this.nextTickPromise = void 0);
+    return this.nextTickPromise;
+  }
+  static nextTick() {
+    return new Promise((resolve) => setTimeout(resolve));
+  }
+};
+
 // src/resolver/input.ts
 import { GraphQLError } from "graphql";
 function createInputParser(schema, value) {
@@ -514,8 +583,168 @@ function getStandardValue(result) {
   else throw new GraphQLError("Invalid input");
 }
 
+// src/resolver/resolver-chain-factory.ts
+var BaseChainFactory = class _BaseChainFactory {
+  constructor(options) {
+    this.options = options;
+  }
+  static methods() {
+    return {
+      description: _BaseChainFactory.prototype.description,
+      deprecationReason: _BaseChainFactory.prototype.deprecationReason,
+      extensions: _BaseChainFactory.prototype.extensions
+    };
+  }
+  description(description) {
+    return this.clone({ description });
+  }
+  deprecationReason(deprecationReason) {
+    return this.clone({ deprecationReason });
+  }
+  extensions(extensions) {
+    return this.clone({ extensions });
+  }
+  use(...middlewares) {
+    return this.clone({
+      middlewares: [...this.options?.middlewares ?? [], ...middlewares]
+    });
+  }
+};
+var FieldChainFactory = class _FieldChainFactory extends BaseChainFactory {
+  static methods() {
+    return {
+      ...BaseChainFactory.methods(),
+      output: _FieldChainFactory.prototype.output,
+      input: _FieldChainFactory.prototype.input,
+      resolve: _FieldChainFactory.prototype.resolve,
+      clone: _FieldChainFactory.prototype.clone
+    };
+  }
+  clone(options) {
+    return new _FieldChainFactory({ ...this.options, ...options });
+  }
+  use(...middlewares) {
+    return super.use(...middlewares);
+  }
+  output(output) {
+    return new _FieldChainFactory({ ...this.options, output });
+  }
+  input(input) {
+    return new _FieldChainFactory({ ...this.options, input });
+  }
+  resolve(resolve) {
+    return createField(this.options?.output, {
+      ...this.options,
+      resolve
+    });
+  }
+};
+var QueryChainFactory = class _QueryChainFactory extends BaseChainFactory {
+  static methods() {
+    return {
+      ...BaseChainFactory.methods(),
+      output: _QueryChainFactory.prototype.output,
+      input: _QueryChainFactory.prototype.input,
+      resolve: _QueryChainFactory.prototype.resolve,
+      clone: _QueryChainFactory.prototype.clone
+    };
+  }
+  clone(options) {
+    return new _QueryChainFactory({ ...this.options, ...options });
+  }
+  use(...middlewares) {
+    return super.use(...middlewares);
+  }
+  output(output) {
+    return new _QueryChainFactory({ ...this.options, output });
+  }
+  input(input) {
+    return new _QueryChainFactory({ ...this.options, input });
+  }
+  resolve(resolve) {
+    return createQuery(this.options?.output, {
+      ...this.options,
+      resolve
+    });
+  }
+};
+var MutationChainFactory = class _MutationChainFactory extends BaseChainFactory {
+  static methods() {
+    return {
+      ...BaseChainFactory.methods(),
+      output: _MutationChainFactory.prototype.output,
+      input: _MutationChainFactory.prototype.input,
+      resolve: _MutationChainFactory.prototype.resolve,
+      clone: _MutationChainFactory.prototype.clone
+    };
+  }
+  clone(options) {
+    return new _MutationChainFactory({ ...this.options, ...options });
+  }
+  use(...middlewares) {
+    return super.use(...middlewares);
+  }
+  output(output) {
+    return new _MutationChainFactory({ ...this.options, output });
+  }
+  input(input) {
+    return new _MutationChainFactory({ ...this.options, input });
+  }
+  resolve(resolve) {
+    return createMutation(this.options?.output, {
+      ...this.options,
+      resolve
+    });
+  }
+};
+var SubscriptionChainFactory = class _SubscriptionChainFactory extends BaseChainFactory {
+  static methods() {
+    return {
+      ...BaseChainFactory.methods(),
+      output: _SubscriptionChainFactory.prototype.output,
+      input: _SubscriptionChainFactory.prototype.input,
+      subscribe: _SubscriptionChainFactory.prototype.subscribe,
+      clone: _SubscriptionChainFactory.prototype.clone
+    };
+  }
+  clone(options) {
+    return new _SubscriptionChainFactory({ ...this.options, ...options });
+  }
+  use(...middlewares) {
+    return super.use(...middlewares);
+  }
+  output(output) {
+    return new _SubscriptionChainFactory({ ...this.options, output });
+  }
+  input(input) {
+    return new _SubscriptionChainFactory({ ...this.options, input });
+  }
+  subscribe(subscribe) {
+    const options = this.options;
+    const subscription2 = createSubscription(options?.output, {
+      ...options,
+      subscribe
+    });
+    const subscriptionResolve = subscription2.resolve;
+    const resolve = (...args) => {
+      if (args.length === 1 && typeof args[0] === "function") {
+        return createSubscription(options?.output, {
+          ...options,
+          resolve: args[0],
+          subscribe
+        });
+      }
+      return subscriptionResolve(...args);
+    };
+    return Object.assign(subscription2, { resolve });
+  }
+};
+
 // src/resolver/resolver.ts
-var query = (output, resolveOrOptions) => {
+var createQuery = (output, resolveOrOptions) => {
+  if (resolveOrOptions == null) {
+    return new QueryChainFactory({ output });
+  }
   const options = getOperationOptions(resolveOrOptions);
   const type = "query";
   return {
@@ -533,7 +762,14 @@ var query = (output, resolveOrOptions) => {
     type
   };
 };
-var mutation = (output, resolveOrOptions) => {
+var query = Object.assign(
+  createQuery,
+  QueryChainFactory.methods()
+);
+var createMutation = (output, resolveOrOptions) => {
+  if (resolveOrOptions == null) {
+    return new MutationChainFactory({ output });
+  }
   const options = getOperationOptions(resolveOrOptions);
   const type = "mutation";
   return {
@@ -551,7 +787,14 @@ var mutation = (output, resolveOrOptions) => {
     type
   };
 };
-var baseSilkField = (output, resolveOrOptions) => {
+var mutation = Object.assign(
+  createMutation,
+  MutationChainFactory.methods()
+);
+var createField = (output, resolveOrOptions) => {
+  if (resolveOrOptions == null) {
+    return new FieldChainFactory({ output });
+  }
   const options = getOperationOptions(resolveOrOptions);
   const type = "field";
   return {
@@ -570,13 +813,15 @@ var baseSilkField = (output, resolveOrOptions) => {
   };
 };
 var field = Object.assign(
-  baseSilkField,
-  {
-    hidden: FIELD_HIDDEN
-  }
+  createField,
+  { hidden: FIELD_HIDDEN },
+  FieldChainFactory.methods()
 );
 var defaultSubscriptionResolve = (source) => source;
-var subscription = (output, subscribeOrOptions) => {
+var createSubscription = (output, subscribeOrOptions) => {
+  if (subscribeOrOptions == null) {
+    return new SubscriptionChainFactory({ output });
+  }
   const options = getSubscriptionOptions(subscribeOrOptions);
   const type = "subscription";
   return {
@@ -598,6 +843,10 @@ var subscription = (output, subscribeOrOptions) => {
     type
   };
 };
+var subscription = Object.assign(
+  createSubscription,
+  SubscriptionChainFactory.methods()
+);
 var ResolverOptionsMap = /* @__PURE__ */ new WeakMap();
 function baseResolver(operations, options) {
   const record = {};
@@ -678,6 +927,9 @@ function createResolverFactory(toSilk) {
 }
 function createFieldFactory(toSilk, isSchema) {
   const baseFieldFunc = (output, resolveOrOptions) => {
+    if (resolveOrOptions == null) {
+      return new FieldChainFactory({ output: toSilk(output) });
+    }
     const options = getOperationOptions(
       resolveOrOptions
     );
@@ -686,12 +938,17 @@ function createFieldFactory(toSilk, isSchema) {
       input: toSilkInput(options.input, toSilk, isSchema)
     });
   };
-  return Object.assign(baseFieldFunc, {
-    hidden: FIELD_HIDDEN
-  });
+  return Object.assign(
+    baseFieldFunc,
+    { hidden: FIELD_HIDDEN },
+    FieldChainFactory.methods()
+  );
 }
 function createQueryFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
+    if (resolveOrOptions == null) {
+      return new QueryChainFactory({ output: toSilk(output) });
+    }
     const options = getOperationOptions(resolveOrOptions);
     return query(toSilk(output), {
       ...options,
@@ -701,6 +958,9 @@ function createQueryFactory(toSilk, isSchema) {
 }
 function createMutationFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
+    if (resolveOrOptions == null) {
+      return new MutationChainFactory({ output: toSilk(output) });
+    }
     const options = getOperationOptions(resolveOrOptions);
     return mutation(toSilk(output), {
       ...options,
@@ -710,6 +970,9 @@ function createMutationFactory(toSilk, isSchema) {
 }
 function createSubscriptionFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
+    if (resolveOrOptions == null) {
+      return new SubscriptionChainFactory({ output: toSilk(output) });
+    }
     const options = getSubscriptionOptions(resolveOrOptions);
     return subscription(toSilk(output), {
       ...options,
@@ -1290,6 +1553,7 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
 }
 export {
   ContextMemoization,
+  EasyDataLoader,
   GraphQLSchemaLoom,
   LoomObjectType,
   OPERATION_OBJECT_NAMES,
@@ -1297,16 +1561,21 @@ export {
   symbols_exports as SYMBOLS,
   applyMiddlewares,
   baseResolver,
+  capitalize,
   collectName,
   collectNames,
   compose,
+  createField,
   createFieldFactory,
   createInputParser,
   createLoom,
   createMemoization,
+  createMutation,
   createMutationFactory,
+  createQuery,
   createQueryFactory,
   createResolverFactory,
+  createSubscription,
   createSubscriptionFactory,
   deepMerge,
   defaultSubscriptionResolve,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gqloom/core",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Create GraphQL schema and resolvers with TypeScript.",
   "type": "module",
   "main": "./dist/index.js",