@gqloom/core 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -21,22 +21,29 @@ 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,
   ResolverOptionsMap: () => ResolverOptionsMap,
   SYMBOLS: () => symbols_exports,
-  SchemaWeaver: () => SchemaWeaver,
   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,
@@ -67,6 +74,7 @@ __export(src_exports, {
   onlyMemoization: () => onlyMemoization,
   parseInputValue: () => parseInputValue,
   parseSilk: () => parseSilk,
+  pascalCase: () => pascalCase,
   provideWeaverContext: () => provideWeaverContext,
   query: () => query,
   resolver: () => resolver,
@@ -263,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;
@@ -497,6 +505,16 @@ 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("");
+}
+function capitalize(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+
 // src/utils/error.ts
 function markErrorLocation(error, ...locations) {
   if (error instanceof Error) {
@@ -525,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) {
@@ -578,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 {
@@ -597,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 {
@@ -615,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 {
@@ -634,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 {
@@ -662,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 = {};
@@ -742,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
     );
@@ -750,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,
@@ -765,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,
@@ -774,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,
@@ -796,31 +1074,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);
@@ -830,48 +1115,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 = {}) {
@@ -888,6 +1181,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);
@@ -905,8 +1220,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)),
@@ -927,17 +1242,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)
       };
@@ -970,8 +1290,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;
@@ -1017,6 +1337,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;
@@ -1025,6 +1350,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));
@@ -1045,8 +1375,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")
@@ -1055,9 +1389,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;
@@ -1224,12 +1558,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));
@@ -1238,7 +1572,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");
@@ -1268,22 +1602,29 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ContextMemoization,
+  EasyDataLoader,
+  GraphQLSchemaLoom,
   LoomObjectType,
+  OPERATION_OBJECT_NAMES,
   ResolverOptionsMap,
   SYMBOLS,
-  SchemaWeaver,
   applyMiddlewares,
   baseResolver,
+  capitalize,
   collectName,
   collectNames,
   compose,
+  createField,
   createFieldFactory,
   createInputParser,
   createLoom,
   createMemoization,
+  createMutation,
   createMutationFactory,
+  createQuery,
   createQueryFactory,
   createResolverFactory,
+  createSubscription,
   createSubscriptionFactory,
   deepMerge,
   defaultSubscriptionResolve,
@@ -1314,6 +1655,7 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   onlyMemoization,
   parseInputValue,
   parseSilk,
+  pascalCase,
   provideWeaverContext,
   query,
   resolver,