@gqloom/core 0.6.0 → 0.7.1

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.1",
   "description": "Create GraphQL schema and resolvers with TypeScript.",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,11 +21,9 @@
       }
     }
   },
-  "scripts": {
-    "build": "tsup --dts-resolve",
-    "check:type": "tsc --noEmit"
-  },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "peerDependencies": {
     "graphql": ">= 16.8.0"
   },
@@ -51,5 +49,9 @@
   },
   "devDependencies": {
     "@standard-schema/spec": "1.0.0-beta.4"
+  },
+  "scripts": {
+    "build": "tsup --dts-resolve",
+    "check:type": "tsc --noEmit"
   }
-}
+}