@gqloom/core 0.2.2 → 0.4.0

package/dist/index.js

@@ -6,30 +6,164 @@ var __export = (target, all) => {
 
 // src/resolver/silk.ts
 import {
-  GraphQLNonNull,
-  GraphQLList
+  GraphQLList,
+  GraphQLNonNull
+} from "graphql";
+
+// src/schema/weaver-context.ts
+import {
+  isEnumType,
+  isObjectType,
+  isScalarType,
+  isUnionType
 } from "graphql";
 
 // src/utils/symbols.ts
 var symbols_exports = {};
 __export(symbols_exports, {
   CONTEXT_MEMORY_MAP_KEY: () => CONTEXT_MEMORY_MAP_KEY,
+  FIELD_HIDDEN: () => FIELD_HIDDEN,
   GET_GRAPHQL_TYPE: () => GET_GRAPHQL_TYPE,
-  PARSE: () => PARSE,
   RESOLVER_OPTIONS_KEY: () => RESOLVER_OPTIONS_KEY,
   WEAVER_CONFIG: () => WEAVER_CONFIG
 });
 var GET_GRAPHQL_TYPE = Symbol.for("gqloom.get_graphql_type");
-var PARSE = Symbol.for("gqloom.parse");
 var WEAVER_CONFIG = Symbol.for("gqloom.weaver_config");
 var RESOLVER_OPTIONS_KEY = Symbol.for("gqloom.resolver-options");
 var CONTEXT_MEMORY_MAP_KEY = Symbol.for("gqloom.context-memory");
+var FIELD_HIDDEN = Symbol.for("gqloom.field-hidden");
+
+// src/schema/weaver-context.ts
+var ref;
+var names = /* @__PURE__ */ new WeakMap();
+function initWeaverContext() {
+  return {
+    id: initWeaverContext.increasingID++,
+    loomObjectMap: /* @__PURE__ */ new Map(),
+    loomUnionMap: /* @__PURE__ */ new Map(),
+    inputMap: /* @__PURE__ */ new Map(),
+    interfaceMap: /* @__PURE__ */ new Map(),
+    configs: /* @__PURE__ */ new Map(),
+    getConfig(key) {
+      return this.configs.get(key);
+    },
+    setConfig(config) {
+      const key = config[WEAVER_CONFIG];
+      this.configs.set(key, config);
+    },
+    deleteConfig(key) {
+      this.configs.delete(key);
+    },
+    names,
+    namedTypes: /* @__PURE__ */ new Map(),
+    memoNamedType(gqlTypeValue) {
+      const gqlType = gqlTypeValue;
+      if (isObjectType(gqlType) || isUnionType(gqlType) || isEnumType(gqlType) || isScalarType(gqlType)) {
+        this.namedTypes.set(gqlType.name, gqlType);
+      }
+      return gqlTypeValue;
+    },
+    getNamedType(name) {
+      return this.namedTypes.get(name);
+    },
+    vendorWeavers: /* @__PURE__ */ new Map()
+  };
+}
+initWeaverContext.increasingID = 1;
+var weaverContext = {
+  get id() {
+    return ref?.id;
+  },
+  get loomObjectMap() {
+    return ref?.loomObjectMap;
+  },
+  get loomUnionMap() {
+    return ref?.loomUnionMap;
+  },
+  get inputMap() {
+    return ref?.inputMap;
+  },
+  get interfaceMap() {
+    return ref?.interfaceMap;
+  },
+  get configs() {
+    return ref?.configs;
+  },
+  get vendorWeavers() {
+    return ref?.vendorWeavers;
+  },
+  getConfig(key) {
+    return ref?.getConfig(key);
+  },
+  setConfig(config) {
+    ref?.setConfig(config);
+  },
+  deleteConfig(key) {
+    ref?.deleteConfig(key);
+  },
+  get value() {
+    return ref;
+  },
+  useConfig(config, callback) {
+    const context = weaverContext.value ?? initWeaverContext();
+    context.setConfig(config);
+    const result = provideWeaverContext(callback, context);
+    context.deleteConfig(config[WEAVER_CONFIG]);
+    return result;
+  },
+  names,
+  getNamedType(name) {
+    return ref?.getNamedType(name);
+  },
+  memoNamedType(gqlType) {
+    return ref?.memoNamedType(gqlType) ?? gqlType;
+  },
+  GraphQLTypes: /* @__PURE__ */ new WeakMap(),
+  getGraphQLType(origin) {
+    return this.GraphQLTypes.get(origin);
+  },
+  memoGraphQLType(origin, gqlType) {
+    this.GraphQLTypes.set(origin, gqlType);
+    return gqlType;
+  }
+};
+function provideWeaverContext(func, value) {
+  const lastRef = ref;
+  ref = value;
+  try {
+    return func();
+  } finally {
+    ref = lastRef;
+  }
+}
+provideWeaverContext.inherit = (func) => {
+  const weaverContextRef = weaverContext.value;
+  return () => provideWeaverContext(func, weaverContextRef);
+};
+function collectNames(...namesList) {
+  const namesRecord = {};
+  for (const namesItem of namesList) {
+    for (const [name, schema] of Object.entries(namesItem)) {
+      names.set(schema, name);
+      namesRecord[name] = schema;
+    }
+  }
+  return namesRecord;
+}
+function collectName(name, schema) {
+  names.set(schema, name);
+  return schema;
+}
 
 // src/resolver/silk.ts
-function silk(type, parse) {
+function silk(type, validate = (value) => ({ value: value ?? void 0 })) {
   return {
     [GET_GRAPHQL_TYPE]: typeof type === "function" ? type : () => type,
-    [PARSE]: parse
+    "~standard": {
+      version: 1,
+      vendor: "gqloom.silk",
+      validate
+    }
   };
 }
 silk.parse = parseSilk;
@@ -39,6 +173,7 @@ silk.list = listSilk;
 silk.nullable = nullableSilk;
 function nonNullSilk(origin) {
   return {
+    ...origin,
     [GET_GRAPHQL_TYPE]: () => {
       const originType = getGraphQLType(origin);
       if (originType instanceof GraphQLNonNull) {
@@ -46,12 +181,12 @@ function nonNullSilk(origin) {
       } else {
         return new GraphQLNonNull(originType);
       }
-    },
-    [PARSE]: (input) => origin[PARSE]?.(input)
+    }
   };
 }
 function listSilk(origin) {
   return {
+    ...origin,
     [GET_GRAPHQL_TYPE]: () => {
       let originType = getGraphQLType(origin);
       if (originType instanceof GraphQLNonNull && originType.ofType instanceof GraphQLList) {
@@ -66,6 +201,7 @@ function listSilk(origin) {
 }
 function nullableSilk(origin) {
   return {
+    ...origin,
     [GET_GRAPHQL_TYPE]: () => {
       const originType = getGraphQLType(origin);
       if (originType instanceof GraphQLNonNull) {
@@ -73,21 +209,30 @@ function nullableSilk(origin) {
       } else {
         return originType;
       }
-    },
-    [PARSE]: (input) => origin[PARSE]?.(input)
+    }
   };
 }
 function getGraphQLType(silk2) {
-  return silk2[GET_GRAPHQL_TYPE]();
+  if (GET_GRAPHQL_TYPE in silk2 && silk2[GET_GRAPHQL_TYPE] != null)
+    return silk2[GET_GRAPHQL_TYPE]();
+  const vendorWeavers = weaverContext.vendorWeavers;
+  if (vendorWeavers == null) throw new Error("Schema Weaver is not initialized");
+  const weaver = vendorWeavers.get(silk2["~standard"].vendor);
+  if (weaver == null)
+    throw new Error(
+      `Schema Weaver for ${silk2["~standard"].vendor} is not found`
+    );
+  return weaver.getGraphQLType(silk2);
 }
 function parseSilk(silk2, input) {
-  if (silk2[PARSE] == null) return input;
-  return silk2[PARSE](input);
+  return silk2["~standard"].validate(input);
 }
 function isSilk(target) {
   if (typeof target !== "object") return false;
   if (target == null) return false;
-  return GET_GRAPHQL_TYPE in target;
+  if (GET_GRAPHQL_TYPE in target) return true;
+  if (!("~standard" in target)) return false;
+  return "vendor" in target["~standard"] && typeof target["~standard"].vendor === "string" && "version" in target["~standard"] && typeof target["~standard"].version === "number";
 }
 
 // src/utils/args.ts
@@ -304,6 +449,7 @@ function markLocation(message, ...locations) {
 }
 
 // src/resolver/input.ts
+import { GraphQLError } from "graphql";
 function createInputParser(schema, value) {
   let result;
   const parse = async () => {
@@ -320,32 +466,43 @@ function createInputParser(schema, value) {
 }
 function parseInputValue(inputSchema, input) {
   if (inputSchema === void 0) {
-    return input;
+    return { value: input };
   }
   if (isSilk(inputSchema)) {
-    if (typeof inputSchema[symbols_exports.PARSE] === "function") {
-      return inputSchema[symbols_exports.PARSE](input);
-    }
-    return input;
+    return inputSchema["~standard"].validate(input);
   }
   return parseInputEntries(inputSchema, input);
 }
 async function parseInputEntries(inputSchema, input = {}) {
   const result = {};
+  const issues = [];
   await Promise.all(
     Object.entries(inputSchema).map(async ([key, value]) => {
-      if (typeof value[symbols_exports.PARSE] === "function") {
-        result[key] = await value[symbols_exports.PARSE](input[key]);
-      } else {
-        result[key] = input[key];
+      const res = await value["~standard"].validate(input[key]);
+      if ("value" in res) {
+        result[key] = res.value;
+      }
+      if (res.issues) {
+        issues.push(...res.issues.slice());
       }
     })
   );
-  return result;
+  return { value: result, ...issues.length > 0 ? { issues } : null };
+}
+function getStandardValue(result) {
+  if (result == null) return result;
+  const { issues } = result;
+  if (issues?.length) {
+    throw new GraphQLError(issues?.[0]?.message ?? "Invalid input", {
+      extensions: { issues }
+    });
+  }
+  if ("value" in result) return result.value;
+  else throw new GraphQLError("Invalid input");
 }
 
 // src/resolver/resolver.ts
-var silkQuery = (output, resolveOrOptions) => {
+var query = (output, resolveOrOptions) => {
   const options = getOperationOptions(resolveOrOptions);
   const type = "query";
   return {
@@ -356,14 +513,14 @@ var silkQuery = (output, resolveOrOptions) => {
       const parseInput = createInputParser(options.input, inputValue);
       return applyMiddlewares(
         compose(extraOptions?.middlewares, options.middlewares),
-        async () => options.resolve(await parseInput()),
+        async () => options.resolve(getStandardValue(await parseInput())),
         { parseInput, parent: void 0, outputSilk: output, type }
       );
     },
     type
   };
 };
-var silkMutation = (output, resolveOrOptions) => {
+var mutation = (output, resolveOrOptions) => {
   const options = getOperationOptions(resolveOrOptions);
   const type = "mutation";
   return {
@@ -374,14 +531,14 @@ var silkMutation = (output, resolveOrOptions) => {
       const parseInput = createInputParser(options.input, inputValue);
       return applyMiddlewares(
         compose(extraOptions?.middlewares, options.middlewares),
-        async () => options.resolve(await parseInput()),
+        async () => options.resolve(getStandardValue(await parseInput())),
         { parseInput, parent: void 0, outputSilk: output, type }
       );
     },
     type
   };
 };
-var silkField = (output, resolveOrOptions) => {
+var baseSilkField = (output, resolveOrOptions) => {
   const options = getOperationOptions(resolveOrOptions);
   const type = "field";
   return {
@@ -392,15 +549,21 @@ var silkField = (output, resolveOrOptions) => {
       const parseInput = createInputParser(options.input, inputValue);
       return applyMiddlewares(
         compose(extraOptions?.middlewares, options.middlewares),
-        async () => options.resolve(parent, await parseInput()),
+        async () => options.resolve(parent, getStandardValue(await parseInput())),
         { parseInput, parent, outputSilk: output, type }
       );
     },
     type
   };
 };
+var field = Object.assign(
+  baseSilkField,
+  {
+    hidden: FIELD_HIDDEN
+  }
+);
 var defaultSubscriptionResolve = (source) => source;
-var silkSubscription = (output, subscribeOrOptions) => {
+var subscription = (output, subscribeOrOptions) => {
   const options = getSubscriptionOptions(subscribeOrOptions);
   const type = "subscription";
   return {
@@ -414,7 +577,7 @@ var silkSubscription = (output, subscribeOrOptions) => {
           extraOptions?.middlewares,
           options.middlewares
         ),
-        async () => options.subscribe(await parseInput()),
+        async () => options.subscribe(getStandardValue(await parseInput())),
         { parseInput, parent: void 0, outputSilk: output, type }
       );
     },
@@ -433,6 +596,7 @@ function baseResolver(operations, options) {
 }
 function extraOperationOptions(operation, options) {
   const composeMiddlewares = (extraOptions) => compose(extraOptions?.middlewares, options?.middlewares);
+  if (typeof operation === "symbol") return operation;
   switch (operation.type) {
     case "field":
       return {
@@ -460,7 +624,7 @@ function extraOperationOptions(operation, options) {
       };
   }
 }
-var silkResolver = Object.assign(
+var resolver = Object.assign(
   baseResolver,
   {
     of: (parent, operations, options) => baseResolver(
@@ -470,11 +634,11 @@ var silkResolver = Object.assign(
   }
 );
 var loom = {
-  query: silkQuery,
-  resolver: silkResolver,
-  field: silkField,
-  subscription: silkSubscription,
-  mutation: silkMutation
+  query,
+  resolver,
+  field,
+  subscription,
+  mutation
 };
 
 // src/helper/create-loom.ts
@@ -491,7 +655,7 @@ function toSilkInput(schema, toSilk, isSchema) {
   }
   return record;
 }
-function createResolverBobbin(toSilk) {
+function createResolverFactory(toSilk) {
   return Object.assign(baseResolver, {
     of: (parent, operations, options) => baseResolver(
       operations,
@@ -499,39 +663,42 @@ function createResolverBobbin(toSilk) {
     )
   });
 }
-function createFieldBobbin(toSilk, isSchema) {
-  return (output, resolveOrOptions) => {
+function createFieldFactory(toSilk, isSchema) {
+  const baseFieldFunc = (output, resolveOrOptions) => {
     const options = getOperationOptions(
       resolveOrOptions
     );
-    return silkField(toSilk(output), {
+    return field(toSilk(output), {
       ...options,
       input: toSilkInput(options.input, toSilk, isSchema)
     });
   };
+  return Object.assign(baseFieldFunc, {
+    hidden: FIELD_HIDDEN
+  });
 }
-function createQueryBobbin(toSilk, isSchema) {
+function createQueryFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
     const options = getOperationOptions(resolveOrOptions);
-    return silkQuery(toSilk(output), {
+    return query(toSilk(output), {
       ...options,
       input: toSilkInput(options.input, toSilk, isSchema)
     });
   };
 }
-function createMutationBobbin(toSilk, isSchema) {
+function createMutationFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
     const options = getOperationOptions(resolveOrOptions);
-    return silkMutation(toSilk(output), {
+    return mutation(toSilk(output), {
       ...options,
       input: toSilkInput(options.input, toSilk, isSchema)
     });
   };
 }
-function createSubscriptionBobbin(toSilk, isSchema) {
+function createSubscriptionFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
     const options = getSubscriptionOptions(resolveOrOptions);
-    return silkSubscription(toSilk(output), {
+    return subscription(toSilk(output), {
       ...options,
       input: toSilkInput(options.input, toSilk, isSchema)
     });
@@ -539,149 +706,39 @@ function createSubscriptionBobbin(toSilk, isSchema) {
 }
 function createLoom(toSilk, isSchema) {
   return {
-    query: createQueryBobbin(toSilk, isSchema),
-    mutation: createMutationBobbin(toSilk, isSchema),
-    field: createFieldBobbin(toSilk, isSchema),
-    resolver: createResolverBobbin(toSilk),
-    subscription: createSubscriptionBobbin(toSilk, isSchema)
+    query: createQueryFactory(toSilk, isSchema),
+    mutation: createMutationFactory(toSilk, isSchema),
+    field: createFieldFactory(toSilk, isSchema),
+    resolver: createResolverFactory(toSilk),
+    subscription: createSubscriptionFactory(toSilk, isSchema)
   };
 }
 
 // src/schema/object.ts
 import {
+  GraphQLList as GraphQLList3,
+  GraphQLNonNull as GraphQLNonNull3,
   GraphQLObjectType,
+  GraphQLUnionType,
   assertName,
-  isObjectType as isObjectType3,
-  resolveObjMapThunk,
   isListType as isListType2,
-  GraphQLList as GraphQLList3,
-  GraphQLNonNull as GraphQLNonNull3,
   isNonNullType as isNonNullType2,
+  isObjectType as isObjectType3,
   isUnionType as isUnionType3,
-  GraphQLUnionType
+  resolveObjMapThunk
 } from "graphql";
 
-// src/schema/weaver-context.ts
-import {
-  isEnumType,
-  isObjectType,
-  isUnionType
-} from "graphql";
-var ref;
-var names = /* @__PURE__ */ new WeakMap();
-function initWeaverContext() {
-  return {
-    loomObjectMap: /* @__PURE__ */ new Map(),
-    loomUnionMap: /* @__PURE__ */ new Map(),
-    inputMap: /* @__PURE__ */ new Map(),
-    interfaceMap: /* @__PURE__ */ new Map(),
-    configs: /* @__PURE__ */ new Map(),
-    getConfig(key) {
-      return this.configs.get(key);
-    },
-    setConfig(config) {
-      const key = config[WEAVER_CONFIG];
-      this.configs.set(key, config);
-    },
-    deleteConfig(key) {
-      this.configs.delete(key);
-    },
-    names,
-    namedTypes: /* @__PURE__ */ new Map(),
-    memoNamedType(gqlTypeValue) {
-      const gqlType = gqlTypeValue;
-      if (isObjectType(gqlType) || isUnionType(gqlType) || isEnumType(gqlType)) {
-        this.namedTypes.set(gqlType.name, gqlType);
-      }
-      return gqlTypeValue;
-    },
-    getNamedType(name) {
-      return this.namedTypes.get(name);
-    }
-  };
-}
-var weaverContext = {
-  get loomObjectMap() {
-    return ref?.loomObjectMap;
-  },
-  get loomUnionMap() {
-    return ref?.loomUnionMap;
-  },
-  get inputMap() {
-    return ref?.inputMap;
-  },
-  get interfaceMap() {
-    return ref?.interfaceMap;
-  },
-  get configs() {
-    return ref?.configs;
-  },
-  getConfig(key) {
-    return ref?.getConfig(key);
-  },
-  setConfig(config) {
-    ref?.setConfig(config);
-  },
-  deleteConfig(key) {
-    ref?.deleteConfig(key);
-  },
-  get value() {
-    return ref;
-  },
-  useConfig(config, callback) {
-    const context = weaverContext.value ?? initWeaverContext();
-    context.setConfig(config);
-    const result = provideWeaverContext(callback, context);
-    context.deleteConfig(config[WEAVER_CONFIG]);
-    return result;
-  },
-  names,
-  getNamedType(name) {
-    return ref?.getNamedType(name);
-  },
-  memoNamedType(gqlType) {
-    return ref?.memoNamedType(gqlType) ?? gqlType;
-  },
-  GraphQLTypes: /* @__PURE__ */ new WeakMap(),
-  getGraphQLType(origin) {
-    return this.GraphQLTypes.get(origin);
-  },
-  memoGraphQLType(origin, gqlType) {
-    this.GraphQLTypes.set(origin, gqlType);
-    return gqlType;
-  }
-};
-function provideWeaverContext(func, value) {
-  const lastRef = ref;
-  ref = value;
-  try {
-    return func();
-  } finally {
-    ref = lastRef;
-  }
-}
-function collectNames(...namesList) {
-  const namesRecord = {};
-  for (const namesItem of namesList) {
-    for (const [name, schema] of Object.entries(namesItem)) {
-      names.set(schema, name);
-      namesRecord[name] = schema;
-    }
-  }
-  return namesRecord;
-}
-
 // src/schema/input.ts
 import {
   GraphQLInputObjectType,
   GraphQLList as GraphQLList2,
   GraphQLNonNull as GraphQLNonNull2,
+  isInputObjectType,
   isInterfaceType,
   isListType,
   isNonNullType,
   isObjectType as isObjectType2,
-  isUnionType as isUnionType2,
-  isInputObjectType
+  isUnionType as isUnionType2
 } from "graphql";
 function inputToArgs(input) {
   if (input === void 0) return void 0;
@@ -697,11 +754,11 @@ function inputToArgs(input) {
     throw new Error(`Cannot convert ${inputType.toString()} to input type`);
   }
   const args = {};
-  Object.entries(input).forEach(([name, field]) => {
+  Object.entries(input).forEach(([name, field2]) => {
     tryIn(() => {
       args[name] = {
-        ...field,
-        type: ensureInputType(field)
+        ...field2,
+        type: ensureInputType(field2)
       };
     }, name);
   });
@@ -740,7 +797,9 @@ function ensureInputObjectType(object) {
   const input = new GraphQLInputObjectType({
     ...config,
     name: getInputObjectName(object.name),
-    fields: mapValue(fields, (it) => toInputFieldConfig(it))
+    fields: provideWeaverContext.inherit(
+      () => mapValue(fields, (it) => toInputFieldConfig(it))
+    )
   });
   weaverContext.inputMap?.set(object, input);
   return input;
@@ -756,6 +815,7 @@ function toInputFieldConfig({
 // src/schema/object.ts
 var LoomObjectType = class extends GraphQLObjectType {
   extraFields = /* @__PURE__ */ new Map();
+  hiddenFields = /* @__PURE__ */ new Set();
   weaverContext;
   resolverOptions;
   constructor(objectOrGetter, options = {}) {
@@ -773,77 +833,84 @@ var LoomObjectType = class extends GraphQLObjectType {
     this.resolverOptions = options.resolverOptions;
     this.weaverContext = options.weaverContext ?? initWeaverContext();
   }
-  addField(name, resolver) {
+  hideField(name) {
+    this.hiddenFields.add(name);
+  }
+  addField(name, resolver2) {
     const existing = this.extraFields.get(name);
-    if (existing && existing !== resolver) {
+    if (existing && existing !== resolver2) {
       throw new Error(`Field ${name} already exists in ${this.name}`);
     }
-    this.extraFields.set(name, resolver);
+    this.extraFields.set(name, resolver2);
   }
   mergeExtensions(extensions) {
     this.extensions = deepMerge(this.extensions, extensions);
   }
-  extraField;
+  extraFieldMap;
   getFields() {
-    const fields = super.getFields();
-    Object.values(fields).forEach(
-      (field) => field.type = this.getCacheType(field.type)
+    const fieldsBySuper = super.getFields();
+    Object.values(fieldsBySuper).forEach(
+      (field2) => field2.type = this.getCacheType(field2.type)
     );
-    const extraField = provideWeaverContext(
+    const extraFields = provideWeaverContext(
       () => defineFieldMap(this.mapToFieldConfig(this.extraFields)),
       this.weaverContext
     );
-    if (Object.keys(this.extraField ?? {}).join() !== Object.keys(extraField).join()) {
-      this.extraField = extraField;
+    if (Object.keys(this.extraFieldMap ?? {}).join() !== Object.keys(extraFields).join()) {
+      this.extraFieldMap = extraFields;
     }
-    return {
-      ...fields,
-      ...this.extraField
+    const answer = {
+      ...fieldsBySuper,
+      ...this.extraFieldMap
     };
+    for (const fieldName of this.hiddenFields) {
+      delete answer[fieldName];
+    }
+    return answer;
   }
   mapToFieldConfig(map) {
     const record = {};
-    for (const [name, field] of map.entries()) {
-      record[name] = this.toFieldConfig(field);
+    for (const [name, field2] of map.entries()) {
+      record[name] = this.toFieldConfig(field2);
     }
     return record;
   }
-  toFieldConfig(field) {
+  toFieldConfig(field2) {
     try {
-      const outputType = this.getCacheType(getGraphQLType(field.output));
+      const outputType = this.getCacheType(getGraphQLType(field2.output));
       return {
-        ...extract(field),
+        ...extract(field2),
         type: outputType,
-        args: inputToArgs(field.input),
-        ...this.provideForResolve(field),
-        ...this.provideForSubscribe(field)
+        args: inputToArgs(field2.input),
+        ...this.provideForResolve(field2),
+        ...this.provideForSubscribe(field2)
       };
     } catch (error) {
       throw markErrorLocation(error);
     }
   }
-  provideForResolve(field) {
-    if (field?.resolve == null) return;
-    if (field.resolve === defaultSubscriptionResolve)
+  provideForResolve(field2) {
+    if (field2?.resolve == null) return;
+    if (field2.resolve === defaultSubscriptionResolve)
       return { resolve: defaultSubscriptionResolve };
-    const resolve = field.type === "field" ? (root, args, context, info) => resolverPayloadStorage.run(
-      { root, args, context, info, field },
-      () => field.resolve(root, args, this.resolverOptions)
-    ) : field.type === "subscription" ? (root, args, context, info) => resolverPayloadStorage.run(
-      { root, args, context, info, field },
-      () => field.resolve(root, args)
+    const resolve = field2.type === "field" ? (root, args, context, info) => resolverPayloadStorage.run(
+      { root, args, context, info, field: field2 },
+      () => field2.resolve(root, args, this.resolverOptions)
+    ) : field2.type === "subscription" ? (root, args, context, info) => resolverPayloadStorage.run(
+      { root, args, context, info, field: field2 },
+      () => field2.resolve(root, args)
     ) : (root, args, context, info) => resolverPayloadStorage.run(
-      { root, args, context, info, field },
-      () => field.resolve(args, this.resolverOptions)
+      { root, args, context, info, field: field2 },
+      () => field2.resolve(args, this.resolverOptions)
     );
     return { resolve };
   }
-  provideForSubscribe(field) {
-    if (field?.subscribe == null) return;
+  provideForSubscribe(field2) {
+    if (field2?.subscribe == null) return;
     return {
       subscribe: (root, args, context, info) => resolverPayloadStorage.run(
-        { root, args, context, info, field },
-        () => field.subscribe?.(args, this.resolverOptions)
+        { root, args, context, info, field: field2 },
+        () => field2.subscribe?.(args, this.resolverOptions)
       )
     };
   }
@@ -923,12 +990,21 @@ function getCacheType(gqlType, options = {}) {
   return gqlType;
 }
 
+// src/schema/schema-vendor-weaver.ts
+function isSchemaVendorWeaver(some) {
+  if (typeof some !== "object" && typeof some !== "function") return false;
+  if (!("getGraphQLType" in some) || typeof some.getGraphQLType !== "function")
+    return false;
+  if (!("vendor" in some) || typeof some.vendor !== "string") return false;
+  return true;
+}
+
 // src/schema/schema-weaver.ts
 import {
   GraphQLSchema,
-  isObjectType as isObjectType4,
-  isNonNullType as isNonNullType3,
   isEnumType as isEnumType2,
+  isNonNullType as isNonNullType3,
+  isObjectType as isObjectType4,
   isUnionType as isUnionType4
 } from "graphql";
 var SchemaWeaver = class _SchemaWeaver {
@@ -949,10 +1025,10 @@ var SchemaWeaver = class _SchemaWeaver {
       [WEAVER_CONFIG]: "gqloom.core.schema"
     };
   }
-  constructor({ query, mutation, subscription, types } = {}, context) {
-    if (query != null) this.query = query;
-    if (mutation != null) this.mutation = mutation;
-    if (subscription != null) this.subscription = subscription;
+  constructor({ query: query2, mutation: mutation2, subscription: subscription2, types } = {}, context) {
+    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.context = context ?? initWeaverContext();
   }
@@ -962,8 +1038,12 @@ var SchemaWeaver = class _SchemaWeaver {
     this.resolverOptions.middlewares.push(...middlewares);
     return this;
   }
-  add(resolver) {
-    provideWeaverContext(() => this.addResolver(resolver), this.context);
+  add(resolver2) {
+    provideWeaverContext(() => this.addResolver(resolver2), this.context);
+    return this;
+  }
+  addVendor(weaver) {
+    this.context.vendorWeavers.set(weaver.vendor, weaver);
     return this;
   }
   addType(silk2) {
@@ -992,19 +1072,19 @@ var SchemaWeaver = class _SchemaWeaver {
     return this;
   }
   weaveGraphQLSchema() {
-    const { query, mutation, subscription, types } = this;
+    const { query: query2, mutation: mutation2, subscription: subscription2, types } = this;
     const config = this.context.getConfig("gqloom.core.schema");
     const schema = new GraphQLSchema({
-      query,
-      mutation,
-      subscription,
+      query: query2,
+      mutation: mutation2,
+      subscription: subscription2,
       types: [...types ?? [], ...config?.types ?? []],
       ...config
     });
     return schema;
   }
-  addResolver(resolver) {
-    const resolverOptions = ResolverOptionsMap.get(resolver);
+  addResolver(resolver2) {
+    const resolverOptions = ResolverOptionsMap.get(resolver2);
     const parent = resolverOptions?.parent;
     const parentObject = (() => {
       if (parent == null) return void 0;
@@ -1023,8 +1103,11 @@ var SchemaWeaver = class _SchemaWeaver {
     })();
     if (resolverOptions?.extensions && parentObject)
       parentObject.mergeExtensions(resolverOptions.extensions);
-    Object.entries(resolver).forEach(([name, operation]) => {
-      if (operation.type === "field") {
+    Object.entries(resolver2).forEach(([name, operation]) => {
+      if (operation === FIELD_HIDDEN) {
+        if (parentObject == null) return;
+        parentObject.hideField(name);
+      } else if (operation.type === "field") {
         if (parentObject == null) return;
         parentObject.addField(name, operation);
       } else {
@@ -1068,12 +1151,16 @@ var SchemaWeaver = class _SchemaWeaver {
     const middlewares = /* @__PURE__ */ new Set();
     const resolvers = /* @__PURE__ */ new Set();
     const silks = /* @__PURE__ */ new Set();
+    const weavers = /* @__PURE__ */ new Set();
     let context;
     for (const item of inputs) {
-      if (typeof item === "function") {
+      if (isSchemaVendorWeaver(item)) {
+        weavers.add(item);
+      } else if (typeof item === "function") {
         middlewares.add(item);
       } else if (WEAVER_CONFIG in item) {
         configs.add(item);
+        if (item.vendorWeaver) weavers.add(item.vendorWeaver);
         if (item[WEAVER_CONFIG] === "gqloom.core.schema") {
           context = item.weaverContext;
         }
@@ -1083,7 +1170,7 @@ var SchemaWeaver = class _SchemaWeaver {
         resolvers.add(item);
       }
     }
-    return { context, configs, middlewares, resolvers, silks };
+    return { context, configs, middlewares, resolvers, silks, weavers };
   }
   /**
    * Weave a GraphQL Schema from resolvers
@@ -1091,9 +1178,10 @@ var SchemaWeaver = class _SchemaWeaver {
    * @returns GraphQ LSchema
    */
   static weave(...inputs) {
-    const { context, configs, middlewares, resolvers, silks } = _SchemaWeaver.optionsFrom(...inputs);
+    const { context, configs, middlewares, resolvers, silks, weavers } = _SchemaWeaver.optionsFrom(...inputs);
     const weaver = new _SchemaWeaver({}, context);
     configs.forEach((it) => weaver.setConfig(it));
+    weavers.forEach((it) => weaver.addVendor(it));
     middlewares.forEach((it) => weaver.use(it));
     resolvers.forEach((it) => weaver.add(it));
     silks.forEach((it) => weaver.addType(it));
@@ -1124,18 +1212,13 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   const interfaceType = new GraphQLInterfaceType({
     ...config,
     ...interfaceConfig,
-    fields: mapValue(fields, (field) => {
-      return { ...field, type: getCacheType(field.type) };
+    fields: mapValue(fields, (field2) => {
+      return { ...field2, type: getCacheType(field2.type) };
     })
   });
   weaverContext.interfaceMap?.set(key, interfaceType);
   return interfaceType;
 }
-
-// src/schema/extensions.ts
-function mergeExtensions(...extensionsList) {
-  return deepMerge(...extensionsList);
-}
 export {
   ContextMemoization,
   LoomObjectType,
@@ -1144,36 +1227,40 @@ export {
   SchemaWeaver,
   applyMiddlewares,
   baseResolver,
+  collectName,
   collectNames,
   compose,
-  createFieldBobbin,
+  createFieldFactory,
   createInputParser,
   createLoom,
   createMemoization,
-  createMutationBobbin,
-  createQueryBobbin,
-  createResolverBobbin,
-  createSubscriptionBobbin,
+  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,
-  mergeExtensions,
+  mutation,
   nonNullSilk,
   notNullish,
   nullableSilk,
@@ -1181,13 +1268,11 @@ export {
   parseInputValue,
   parseSilk,
   provideWeaverContext,
+  query,
+  resolver,
   resolverPayloadStorage,
   silk,
-  silkField,
-  silkMutation,
-  silkQuery,
-  silkResolver,
-  silkSubscription,
+  subscription,
   toObjMap,
   tryIn,
   useContext,