@gqloom/core 0.4.0 → 0.6.0

package/README.md

@@ -8,24 +8,24 @@ The design of GQLoom is inspired by [tRPC](https://trpc.io/), [TypeGraphQL](http
 
 ## 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;
+* 🚀 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;
 
 ## Hello World
 
 ```ts
-import { resolver, query, weave } from "@gqloom/valibot"
+import { resolver, query, ValibotWeaver } from "@gqloom/valibot"
 import * as v from "valibot"
 
-const HelloResolver = resolver({
+const helloResolver = resolver({
   hello: query(v.string(), () => "world"),
 })
 
-export const schema = weave(HelloResolver)
+export const schema = ValibotWeaver.weave(helloResolver)
 ```
 
 Read [Introduction](https://gqloom.dev/guide/introduction.html) to learn more about GQLoom.

package/dist/index.cjs

@@ -21,10 +21,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   ContextMemoization: () => ContextMemoization,
+  GraphQLSchemaLoom: () => GraphQLSchemaLoom,
   LoomObjectType: () => LoomObjectType,
+  OPERATION_OBJECT_NAMES: () => OPERATION_OBJECT_NAMES,
   ResolverOptionsMap: () => ResolverOptionsMap,
   SYMBOLS: () => symbols_exports,
-  SchemaWeaver: () => SchemaWeaver,
   applyMiddlewares: () => applyMiddlewares,
   baseResolver: () => baseResolver,
   collectName: () => collectName,
@@ -67,6 +68,7 @@ __export(src_exports, {
   onlyMemoization: () => onlyMemoization,
   parseInputValue: () => parseInputValue,
   parseSilk: () => parseSilk,
+  pascalCase: () => pascalCase,
   provideWeaverContext: () => provideWeaverContext,
   query: () => query,
   resolver: () => resolver,
@@ -227,7 +229,9 @@ function collectName(name, schema) {
 }
 
 // src/resolver/silk.ts
-function silk(type, validate = (value) => ({ value: value ?? void 0 })) {
+function silk(type, validate = (value) => ({
+  value: value ?? void 0
+})) {
   return {
     [GET_GRAPHQL_TYPE]: typeof type === "function" ? type : () => type,
     "~standard": {
@@ -332,13 +336,17 @@ function getFieldOptions({
 }
 
 // src/utils/middleware.ts
-function applyMiddlewares(middlewares, resolveFunction, payload) {
+function applyMiddlewares(middlewares, resolveFunction, options) {
   const next = (index) => {
     if (index >= middlewares.length) {
       return resolveFunction();
     }
     const middleware = middlewares[index];
-    return middleware(() => next(index + 1), payload);
+    const callableOptions = Object.assign(() => next(index + 1), {
+      ...options,
+      next: () => next(index + 1)
+    });
+    return middleware(callableOptions);
   };
   return next(0);
 }
@@ -491,6 +499,13 @@ function deepMerge(...objects) {
   return result;
 }
 
+// src/utils/string.ts
+function pascalCase(str) {
+  return str.split(/[\s-_]+/).map(
+    (word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)
+  ).join("");
+}
+
 // src/utils/error.ts
 function markErrorLocation(error, ...locations) {
   if (error instanceof Error) {
@@ -790,31 +805,38 @@ var import_graphql5 = require("graphql");
 
 // src/schema/input.ts
 var import_graphql4 = require("graphql");
-function inputToArgs(input) {
+function inputToArgs(input, options) {
   if (input === void 0) return void 0;
   if (isSilk(input)) {
     let inputType = getGraphQLType(input);
     if ((0, import_graphql4.isNonNullType)(inputType)) inputType = inputType.ofType;
     if ((0, import_graphql4.isObjectType)(inputType)) {
-      return mapValue(
-        inputType.toConfig().fields,
-        (it) => toInputFieldConfig(it)
-      );
+      return mapValue(inputType.toConfig().fields, (it, key) => {
+        let fieldName;
+        if (options?.fieldName) {
+          fieldName = `${pascalCase(options.fieldName)}${pascalCase(key)}`;
+        }
+        return toInputFieldConfig(it, { fieldName });
+      });
     }
     throw new Error(`Cannot convert ${inputType.toString()} to input type`);
   }
   const args = {};
   Object.entries(input).forEach(([name, field2]) => {
     tryIn(() => {
+      let fieldName;
+      if (options?.fieldName) {
+        fieldName = `${pascalCase(options.fieldName)}${pascalCase(name)}`;
+      }
       args[name] = {
         ...field2,
-        type: ensureInputType(field2)
+        type: ensureInputType(field2, { fieldName })
       };
     }, name);
   });
   return args;
 }
-function ensureInputType(silkOrType) {
+function ensureInputType(silkOrType, options) {
   const gqlType = (() => {
     if (isSilk(silkOrType)) {
       return getGraphQLType(silkOrType);
@@ -824,48 +846,56 @@ function ensureInputType(silkOrType) {
   if ((0, import_graphql4.isUnionType)(gqlType))
     throw new Error(`Cannot convert union type ${gqlType.name} to input type`);
   if ((0, import_graphql4.isNonNullType)(gqlType)) {
-    return new import_graphql4.GraphQLNonNull(ensureInputType(gqlType.ofType));
+    return new import_graphql4.GraphQLNonNull(ensureInputType(gqlType.ofType, options));
   }
   if ((0, import_graphql4.isListType)(gqlType)) {
-    return new import_graphql4.GraphQLList(ensureInputType(gqlType.ofType));
+    return new import_graphql4.GraphQLList(ensureInputType(gqlType.ofType, options));
   }
   if ((0, import_graphql4.isObjectType)(gqlType) || (0, import_graphql4.isInterfaceType)(gqlType))
-    return ensureInputObjectType(gqlType);
+    return ensureInputObjectType(gqlType, options);
   return gqlType;
 }
-function ensureInputObjectType(object) {
+function ensureInputObjectType(object, options) {
   if ((0, import_graphql4.isInputObjectType)(object)) return object;
   const existing = weaverContext.inputMap?.get(object);
   if (existing != null) return existing;
-  const {
-    astNode: _,
-    extensionASTNodes: __,
-    fields,
-    ...config
-  } = object.toConfig();
-  const getInputObjectName = weaverContext.getConfig("gqloom.core.schema")?.getInputObjectName ?? ((name) => name);
+  const { astNode, extensionASTNodes, fields, ...config } = object.toConfig();
+  let name = object.name;
+  if (name === LoomObjectType.AUTO_ALIASING) {
+    name = `${pascalCase(options?.fieldName ?? "")}Input`;
+  }
+  const getInputObjectName = weaverContext.getConfig("gqloom.core.schema")?.getInputObjectName ?? ((n) => n);
+  name = getInputObjectName(name);
   const input = new import_graphql4.GraphQLInputObjectType({
     ...config,
-    name: getInputObjectName(object.name),
+    name,
     fields: provideWeaverContext.inherit(
-      () => mapValue(fields, (it) => toInputFieldConfig(it))
+      () => mapValue(
+        fields,
+        (it, key) => toInputFieldConfig(it, {
+          fieldName: inputFieldName(name) + pascalCase(key)
+        })
+      )
     )
   });
   weaverContext.inputMap?.set(object, input);
   return input;
 }
-function toInputFieldConfig({
-  astNode: _,
-  resolve: _1,
-  ...config
-}) {
-  return { ...config, type: ensureInputType(config.type) };
+function toInputFieldConfig({ astNode, resolve, ...config }, options) {
+  return { ...config, type: ensureInputType(config.type, options) };
+}
+function inputFieldName(name) {
+  while (name.endsWith("Input")) {
+    name = name.slice(0, -"Input".length);
+  }
+  return name;
 }
 
 // src/schema/object.ts
-var LoomObjectType = class extends import_graphql5.GraphQLObjectType {
+var LoomObjectType = class _LoomObjectType extends import_graphql5.GraphQLObjectType {
   extraFields = /* @__PURE__ */ new Map();
   hiddenFields = /* @__PURE__ */ new Set();
+  static AUTO_ALIASING = "__gqloom_auto_aliasing";
   weaverContext;
   resolverOptions;
   constructor(objectOrGetter, options = {}) {
@@ -882,6 +912,28 @@ var LoomObjectType = class extends import_graphql5.GraphQLObjectType {
     super(config);
     this.resolverOptions = options.resolverOptions;
     this.weaverContext = options.weaverContext ?? initWeaverContext();
+    if (this.name !== _LoomObjectType.AUTO_ALIASING) {
+      this.hasExplicitName = true;
+    }
+  }
+  hasExplicitName;
+  _aliases = [];
+  get aliases() {
+    return this._aliases;
+  }
+  addAlias(name) {
+    if (this.hasExplicitName) return;
+    this._aliases.push(name);
+    this.renameByAliases();
+  }
+  renameByAliases() {
+    let name;
+    for (const alias of this.aliases) {
+      if (name === void 0 || alias.length < name.length) {
+        name = alias;
+      }
+    }
+    if (name) this.name = name;
   }
   hideField(name) {
     this.hiddenFields.add(name);
@@ -899,8 +951,8 @@ var LoomObjectType = class extends import_graphql5.GraphQLObjectType {
   extraFieldMap;
   getFields() {
     const fieldsBySuper = super.getFields();
-    Object.values(fieldsBySuper).forEach(
-      (field2) => field2.type = this.getCacheType(field2.type)
+    Object.entries(fieldsBySuper).forEach(
+      ([fieldName, field2]) => field2.type = this.getCacheType(field2.type, fieldName)
     );
     const extraFields = provideWeaverContext(
       () => defineFieldMap(this.mapToFieldConfig(this.extraFields)),
@@ -921,17 +973,22 @@ var LoomObjectType = class extends import_graphql5.GraphQLObjectType {
   mapToFieldConfig(map) {
     const record = {};
     for (const [name, field2] of map.entries()) {
-      record[name] = this.toFieldConfig(field2);
+      record[name] = this.toFieldConfig(field2, name);
     }
     return record;
   }
-  toFieldConfig(field2) {
+  toFieldConfig(field2, fieldName) {
     try {
-      const outputType = this.getCacheType(getGraphQLType(field2.output));
+      const outputType = this.getCacheType(
+        getGraphQLType(field2.output),
+        fieldName
+      );
       return {
         ...extract(field2),
         type: outputType,
-        args: inputToArgs(field2.input),
+        args: inputToArgs(field2.input, {
+          fieldName: fieldName ? parentName(this.name) + fieldName : void 0
+        }),
         ...this.provideForResolve(field2),
         ...this.provideForSubscribe(field2)
       };
@@ -964,8 +1021,8 @@ var LoomObjectType = class extends import_graphql5.GraphQLObjectType {
       )
     };
   }
-  getCacheType(gqlType) {
-    return getCacheType(gqlType, this.options);
+  getCacheType(gqlType, fieldName) {
+    return getCacheType(gqlType, { ...this.options, fieldName, parent: this });
   }
   get options() {
     const { resolverOptions, weaverContext: weaverContext2 } = this;
@@ -1011,6 +1068,11 @@ function defineArguments(args) {
     astNode: argConfig.astNode
   }));
 }
+var OPERATION_OBJECT_NAMES = /* @__PURE__ */ new Set([
+  "Query",
+  "Mutation",
+  "Subscription"
+]);
 function getCacheType(gqlType, options = {}) {
   const context = options.weaverContext ?? weaverContext;
   if (gqlType instanceof LoomObjectType) return gqlType;
@@ -1019,6 +1081,11 @@ function getCacheType(gqlType, options = {}) {
     if (gqlObject != null) return gqlObject;
     const loomObject = new LoomObjectType(gqlType, options);
     context.loomObjectMap?.set(gqlType, loomObject);
+    if (options.fieldName && options.parent) {
+      loomObject.addAlias(
+        parentName(options.parent.name) + pascalCase(options.fieldName)
+      );
+    }
     return loomObject;
   } else if ((0, import_graphql5.isListType)(gqlType)) {
     return new import_graphql5.GraphQLList(getCacheType(gqlType.ofType, options));
@@ -1039,8 +1106,12 @@ function getCacheType(gqlType, options = {}) {
   }
   return gqlType;
 }
+function parentName(name) {
+  if (OPERATION_OBJECT_NAMES.has(name)) name = "";
+  return name;
+}
 
-// src/schema/schema-vendor-weaver.ts
+// src/schema/schema-weaver.ts
 function isSchemaVendorWeaver(some) {
   if (typeof some !== "object" && typeof some !== "function") return false;
   if (!("getGraphQLType" in some) || typeof some.getGraphQLType !== "function")
@@ -1049,9 +1120,9 @@ function isSchemaVendorWeaver(some) {
   return true;
 }
 
-// src/schema/schema-weaver.ts
+// src/schema/schema-loom.ts
 var import_graphql6 = require("graphql");
-var SchemaWeaver = class _SchemaWeaver {
+var GraphQLSchemaLoom = class _GraphQLSchemaLoom {
   query;
   mutation;
   subscription;
@@ -1073,7 +1144,7 @@ var SchemaWeaver = class _SchemaWeaver {
     if (query2 != null) this.query = query2;
     if (mutation2 != null) this.mutation = mutation2;
     if (subscription2 != null) this.subscription = subscription2;
-    if (types != null) this.types = types.slice();
+    this.types = new Set(types ?? []);
     this.context = context ?? initWeaverContext();
   }
   use(...middlewares) {
@@ -1107,8 +1178,7 @@ var SchemaWeaver = class _SchemaWeaver {
         `${gqlType2?.name ?? gqlType2.toString()} is not a named type`
       );
     }, this.context);
-    this.types ??= [];
-    this.types.push(gqlType);
+    this.types.add(gqlType);
     return this;
   }
   setConfig(config) {
@@ -1134,16 +1204,17 @@ var SchemaWeaver = class _SchemaWeaver {
       if (parent == null) return void 0;
       let gqlType = getGraphQLType(parent);
       if ((0, import_graphql6.isNonNullType)(gqlType)) gqlType = gqlType.ofType;
-      if ((0, import_graphql6.isObjectType)(gqlType)) {
-        const existing = this.context.loomObjectMap.get(gqlType);
-        if (existing != null) return existing;
-        const extraObject = new LoomObjectType(gqlType, this.fieldOptions);
-        this.context.loomObjectMap.set(gqlType, extraObject);
-        return extraObject;
+      if (!(0, import_graphql6.isObjectType)(gqlType)) {
+        throw new Error(
+          `${gqlType?.name ?? gqlType.toString()} is not an object type`
+        );
       }
-      throw new Error(
-        `${gqlType?.name ?? gqlType.toString()} is not an object type`
-      );
+      const existing = this.context.loomObjectMap.get(gqlType);
+      if (existing != null) return existing;
+      const extraObject = new LoomObjectType(gqlType, this.fieldOptions);
+      this.context.loomObjectMap.set(gqlType, extraObject);
+      this.types.add(extraObject);
+      return extraObject;
     })();
     if (resolverOptions?.extensions && parentObject)
       parentObject.mergeExtensions(resolverOptions.extensions);
@@ -1218,12 +1289,12 @@ var SchemaWeaver = class _SchemaWeaver {
   }
   /**
    * Weave a GraphQL Schema from resolvers
-   * @param inputs Resolvers, Global Middlewares or WeaverConfigs
-   * @returns GraphQ LSchema
+   * @param inputs Resolvers, Global Middlewares, WeaverConfigs Or SchemaWeaver
+   * @returns GraphQL Schema
    */
   static weave(...inputs) {
-    const { context, configs, middlewares, resolvers, silks, weavers } = _SchemaWeaver.optionsFrom(...inputs);
-    const weaver = new _SchemaWeaver({}, context);
+    const { context, configs, middlewares, resolvers, silks, weavers } = _GraphQLSchemaLoom.optionsFrom(...inputs);
+    const weaver = new _GraphQLSchemaLoom({}, context);
     configs.forEach((it) => weaver.setConfig(it));
     weavers.forEach((it) => weaver.addVendor(it));
     middlewares.forEach((it) => weaver.use(it));
@@ -1232,7 +1303,7 @@ var SchemaWeaver = class _SchemaWeaver {
     return weaver.weaveGraphQLSchema();
   }
 };
-var weave = SchemaWeaver.weave;
+var weave = GraphQLSchemaLoom.weave;
 
 // src/schema/interface.ts
 var import_graphql7 = require("graphql");
@@ -1262,10 +1333,11 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ContextMemoization,
+  GraphQLSchemaLoom,
   LoomObjectType,
+  OPERATION_OBJECT_NAMES,
   ResolverOptionsMap,
   SYMBOLS,
-  SchemaWeaver,
   applyMiddlewares,
   baseResolver,
   collectName,
@@ -1308,6 +1380,7 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   onlyMemoization,
   parseInputValue,
   parseSilk,
+  pascalCase,
   provideWeaverContext,
   query,
   resolver,