@gqloom/core 0.6.0 → 0.7.1

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Modevol https://www.modevol.com/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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.devgetting-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,