@gqloom/core 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -43,20 +43,24 @@ __export(src_exports, {
   ensureInputObjectType: () => ensureInputObjectType,
   ensureInputType: () => ensureInputType,
   ensureInterfaceType: () => ensureInterfaceType,
+  field: () => field,
   getCacheType: () => getCacheType,
   getFieldOptions: () => getFieldOptions,
   getGraphQLType: () => getGraphQLType,
   getOperationOptions: () => getOperationOptions,
+  getStandardValue: () => getStandardValue,
   getSubscriptionOptions: () => getSubscriptionOptions,
   initWeaverContext: () => initWeaverContext,
   inputToArgs: () => inputToArgs,
   isOnlyMemoryPayload: () => isOnlyMemoryPayload,
+  isSchemaVendorWeaver: () => isSchemaVendorWeaver,
   isSilk: () => isSilk,
   listSilk: () => listSilk,
   loom: () => loom,
   mapValue: () => mapValue,
   markErrorLocation: () => markErrorLocation,
   markLocation: () => markLocation,
+  mutation: () => mutation,
   nonNullSilk: () => nonNullSilk,
   notNullish: () => notNullish,
   nullableSilk: () => nullableSilk,
@@ -64,13 +68,11 @@ __export(src_exports, {
   parseInputValue: () => parseInputValue,
   parseSilk: () => parseSilk,
   provideWeaverContext: () => provideWeaverContext,
+  query: () => query,
+  resolver: () => resolver,
   resolverPayloadStorage: () => resolverPayloadStorage,
   silk: () => silk,
-  silkField: () => silkField,
-  silkMutation: () => silkMutation,
-  silkQuery: () => silkQuery,
-  silkResolver: () => silkResolver,
-  silkSubscription: () => silkSubscription,
+  subscription: () => subscription,
   toObjMap: () => toObjMap,
   tryIn: () => tryIn,
   useContext: () => useContext,
@@ -82,6 +84,9 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/resolver/silk.ts
+var import_graphql2 = require("graphql");
+
+// src/schema/weaver-context.ts
 var import_graphql = require("graphql");
 
 // src/utils/symbols.ts
@@ -90,22 +95,146 @@ __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 ((0, import_graphql.isObjectType)(gqlType) || (0, import_graphql.isUnionType)(gqlType) || (0, import_graphql.isEnumType)(gqlType) || (0, import_graphql.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;
@@ -115,55 +244,66 @@ silk.list = listSilk;
 silk.nullable = nullableSilk;
 function nonNullSilk(origin) {
   return {
+    ...origin,
     [GET_GRAPHQL_TYPE]: () => {
       const originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql.GraphQLNonNull) {
+      if (originType instanceof import_graphql2.GraphQLNonNull) {
         return originType;
       } else {
-        return new import_graphql.GraphQLNonNull(originType);
+        return new import_graphql2.GraphQLNonNull(originType);
       }
-    },
-    [PARSE]: (input) => origin[PARSE]?.(input)
+    }
   };
 }
 function listSilk(origin) {
   return {
+    ...origin,
     [GET_GRAPHQL_TYPE]: () => {
       let originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql.GraphQLNonNull && originType.ofType instanceof import_graphql.GraphQLList) {
+      if (originType instanceof import_graphql2.GraphQLNonNull && originType.ofType instanceof import_graphql2.GraphQLList) {
         originType = originType.ofType;
       }
-      if (originType instanceof import_graphql.GraphQLList) {
+      if (originType instanceof import_graphql2.GraphQLList) {
         originType = originType.ofType;
       }
-      return new import_graphql.GraphQLNonNull(new import_graphql.GraphQLList(originType));
+      return new import_graphql2.GraphQLNonNull(new import_graphql2.GraphQLList(originType));
     }
   };
 }
 function nullableSilk(origin) {
   return {
+    ...origin,
     [GET_GRAPHQL_TYPE]: () => {
       const originType = getGraphQLType(origin);
-      if (originType instanceof import_graphql.GraphQLNonNull) {
+      if (originType instanceof import_graphql2.GraphQLNonNull) {
         return originType.ofType;
       } 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
@@ -380,6 +520,7 @@ function markLocation(message, ...locations) {
 }
 
 // src/resolver/input.ts
+var import_graphql3 = require("graphql");
 function createInputParser(schema, value) {
   let result;
   const parse = async () => {
@@ -396,32 +537,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 import_graphql3.GraphQLError(issues?.[0]?.message ?? "Invalid input", {
+      extensions: { issues }
+    });
+  }
+  if ("value" in result) return result.value;
+  else throw new import_graphql3.GraphQLError("Invalid input");
 }
 
 // src/resolver/resolver.ts
-var silkQuery = (output, resolveOrOptions) => {
+var query = (output, resolveOrOptions) => {
   const options = getOperationOptions(resolveOrOptions);
   const type = "query";
   return {
@@ -432,14 +584,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 {
@@ -450,7 +602,7 @@ 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 }
       );
     },
@@ -468,21 +620,21 @@ var baseSilkField = (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 silkField = Object.assign(
+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 {
@@ -496,7 +648,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 }
       );
     },
@@ -543,7 +695,7 @@ function extraOperationOptions(operation, options) {
       };
   }
 }
-var silkResolver = Object.assign(
+var resolver = Object.assign(
   baseResolver,
   {
     of: (parent, operations, options) => baseResolver(
@@ -553,11 +705,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
@@ -587,7 +739,7 @@ function createFieldFactory(toSilk, isSchema) {
     const options = getOperationOptions(
       resolveOrOptions
     );
-    return silkField(toSilk(output), {
+    return field(toSilk(output), {
       ...options,
       input: toSilkInput(options.input, toSilk, isSchema)
     });
@@ -599,7 +751,7 @@ function createFieldFactory(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)
     });
@@ -608,7 +760,7 @@ function createQueryFactory(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)
     });
@@ -617,7 +769,7 @@ function createMutationFactory(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)
     });
@@ -634,135 +786,16 @@ function createLoom(toSilk, isSchema) {
 }
 
 // src/schema/object.ts
-var import_graphql4 = require("graphql");
-
-// src/schema/weaver-context.ts
-var import_graphql2 = require("graphql");
-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 ((0, import_graphql2.isObjectType)(gqlType) || (0, import_graphql2.isUnionType)(gqlType) || (0, import_graphql2.isEnumType)(gqlType) || (0, import_graphql2.isScalarType)(gqlType)) {
-        this.namedTypes.set(gqlType.name, gqlType);
-      }
-      return gqlTypeValue;
-    },
-    getNamedType(name) {
-      return this.namedTypes.get(name);
-    }
-  };
-}
-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;
-  },
-  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;
-}
+var import_graphql5 = require("graphql");
 
 // src/schema/input.ts
-var import_graphql3 = require("graphql");
+var import_graphql4 = require("graphql");
 function inputToArgs(input) {
   if (input === void 0) return void 0;
   if (isSilk(input)) {
     let inputType = getGraphQLType(input);
-    if ((0, import_graphql3.isNonNullType)(inputType)) inputType = inputType.ofType;
-    if ((0, import_graphql3.isObjectType)(inputType)) {
+    if ((0, import_graphql4.isNonNullType)(inputType)) inputType = inputType.ofType;
+    if ((0, import_graphql4.isObjectType)(inputType)) {
       return mapValue(
         inputType.toConfig().fields,
         (it) => toInputFieldConfig(it)
@@ -771,11 +804,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);
   });
@@ -788,20 +821,20 @@ function ensureInputType(silkOrType) {
     }
     return silkOrType;
   })();
-  if ((0, import_graphql3.isUnionType)(gqlType))
+  if ((0, import_graphql4.isUnionType)(gqlType))
     throw new Error(`Cannot convert union type ${gqlType.name} to input type`);
-  if ((0, import_graphql3.isNonNullType)(gqlType)) {
-    return new import_graphql3.GraphQLNonNull(ensureInputType(gqlType.ofType));
+  if ((0, import_graphql4.isNonNullType)(gqlType)) {
+    return new import_graphql4.GraphQLNonNull(ensureInputType(gqlType.ofType));
   }
-  if ((0, import_graphql3.isListType)(gqlType)) {
-    return new import_graphql3.GraphQLList(ensureInputType(gqlType.ofType));
+  if ((0, import_graphql4.isListType)(gqlType)) {
+    return new import_graphql4.GraphQLList(ensureInputType(gqlType.ofType));
   }
-  if ((0, import_graphql3.isObjectType)(gqlType) || (0, import_graphql3.isInterfaceType)(gqlType))
+  if ((0, import_graphql4.isObjectType)(gqlType) || (0, import_graphql4.isInterfaceType)(gqlType))
     return ensureInputObjectType(gqlType);
   return gqlType;
 }
 function ensureInputObjectType(object) {
-  if ((0, import_graphql3.isInputObjectType)(object)) return object;
+  if ((0, import_graphql4.isInputObjectType)(object)) return object;
   const existing = weaverContext.inputMap?.get(object);
   if (existing != null) return existing;
   const {
@@ -811,7 +844,7 @@ function ensureInputObjectType(object) {
     ...config
   } = object.toConfig();
   const getInputObjectName = weaverContext.getConfig("gqloom.core.schema")?.getInputObjectName ?? ((name) => name);
-  const input = new import_graphql3.GraphQLInputObjectType({
+  const input = new import_graphql4.GraphQLInputObjectType({
     ...config,
     name: getInputObjectName(object.name),
     fields: provideWeaverContext.inherit(
@@ -830,7 +863,7 @@ function toInputFieldConfig({
 }
 
 // src/schema/object.ts
-var LoomObjectType = class extends import_graphql4.GraphQLObjectType {
+var LoomObjectType = class extends import_graphql5.GraphQLObjectType {
   extraFields = /* @__PURE__ */ new Map();
   hiddenFields = /* @__PURE__ */ new Set();
   weaverContext;
@@ -838,7 +871,7 @@ var LoomObjectType = class extends import_graphql4.GraphQLObjectType {
   constructor(objectOrGetter, options = {}) {
     const origin = typeof objectOrGetter === "function" ? objectOrGetter() : objectOrGetter;
     const config = (() => {
-      if ((0, import_graphql4.isObjectType)(origin)) {
+      if ((0, import_graphql5.isObjectType)(origin)) {
         return origin.toConfig();
       } else if (typeof origin === "string") {
         return { name: origin, fields: {} };
@@ -853,12 +886,12 @@ var LoomObjectType = class extends import_graphql4.GraphQLObjectType {
   hideField(name) {
     this.hiddenFields.add(name);
   }
-  addField(name, resolver) {
+  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);
@@ -867,7 +900,7 @@ var LoomObjectType = class extends import_graphql4.GraphQLObjectType {
   getFields() {
     const fieldsBySuper = super.getFields();
     Object.values(fieldsBySuper).forEach(
-      (field) => field.type = this.getCacheType(field.type)
+      (field2) => field2.type = this.getCacheType(field2.type)
     );
     const extraFields = provideWeaverContext(
       () => defineFieldMap(this.mapToFieldConfig(this.extraFields)),
@@ -887,47 +920,47 @@ var LoomObjectType = class extends import_graphql4.GraphQLObjectType {
   }
   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)
       )
     };
   }
@@ -951,11 +984,11 @@ function extract({
   };
 }
 function defineFieldMap(fields) {
-  const fieldMap = (0, import_graphql4.resolveObjMapThunk)(fields);
+  const fieldMap = (0, import_graphql5.resolveObjMapThunk)(fields);
   return mapValue(fieldMap, (fieldConfig, fieldName) => {
     const argsConfig = fieldConfig.args ?? {};
     return {
-      name: (0, import_graphql4.assertName)(fieldName),
+      name: (0, import_graphql5.assertName)(fieldName),
       description: fieldConfig.description,
       type: fieldConfig.type,
       args: defineArguments(argsConfig),
@@ -969,7 +1002,7 @@ function defineFieldMap(fields) {
 }
 function defineArguments(args) {
   return Object.entries(args).map(([argName, argConfig]) => ({
-    name: (0, import_graphql4.assertName)(argName),
+    name: (0, import_graphql5.assertName)(argName),
     description: argConfig.description,
     type: argConfig.type,
     defaultValue: argConfig.defaultValue,
@@ -981,21 +1014,21 @@ function defineArguments(args) {
 function getCacheType(gqlType, options = {}) {
   const context = options.weaverContext ?? weaverContext;
   if (gqlType instanceof LoomObjectType) return gqlType;
-  if ((0, import_graphql4.isObjectType)(gqlType)) {
+  if ((0, import_graphql5.isObjectType)(gqlType)) {
     const gqlObject = context.loomObjectMap?.get(gqlType);
     if (gqlObject != null) return gqlObject;
     const loomObject = new LoomObjectType(gqlType, options);
     context.loomObjectMap?.set(gqlType, loomObject);
     return loomObject;
-  } else if ((0, import_graphql4.isListType)(gqlType)) {
-    return new import_graphql4.GraphQLList(getCacheType(gqlType.ofType, options));
-  } else if ((0, import_graphql4.isNonNullType)(gqlType)) {
-    return new import_graphql4.GraphQLNonNull(getCacheType(gqlType.ofType, options));
-  } else if ((0, import_graphql4.isUnionType)(gqlType)) {
+  } else if ((0, import_graphql5.isListType)(gqlType)) {
+    return new import_graphql5.GraphQLList(getCacheType(gqlType.ofType, options));
+  } else if ((0, import_graphql5.isNonNullType)(gqlType)) {
+    return new import_graphql5.GraphQLNonNull(getCacheType(gqlType.ofType, options));
+  } else if ((0, import_graphql5.isUnionType)(gqlType)) {
     const existing = context.loomUnionMap?.get(gqlType);
     if (existing != null) return existing;
     const config = gqlType.toConfig();
-    const unionType = new import_graphql4.GraphQLUnionType({
+    const unionType = new import_graphql5.GraphQLUnionType({
       ...config,
       types: config.types.map(
         (type) => getCacheType(type, options)
@@ -1007,8 +1040,17 @@ 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
-var import_graphql5 = require("graphql");
+var import_graphql6 = require("graphql");
 var SchemaWeaver = class _SchemaWeaver {
   query;
   mutation;
@@ -1027,10 +1069,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();
   }
@@ -1040,21 +1082,25 @@ 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) {
     const gqlType = provideWeaverContext(() => {
       let gqlType2 = getGraphQLType(silk2);
-      if ((0, import_graphql5.isNonNullType)(gqlType2)) gqlType2 = gqlType2.ofType;
-      if ((0, import_graphql5.isObjectType)(gqlType2)) {
+      if ((0, import_graphql6.isNonNullType)(gqlType2)) gqlType2 = gqlType2.ofType;
+      if ((0, import_graphql6.isObjectType)(gqlType2)) {
         const existing = this.context.loomObjectMap.get(gqlType2);
         if (existing != null) return existing;
         const extraObject = new LoomObjectType(gqlType2, this.fieldOptions);
         this.context.loomObjectMap.set(gqlType2, extraObject);
         return extraObject;
-      } else if ((0, import_graphql5.isUnionType)(gqlType2) || (0, import_graphql5.isEnumType)(gqlType2)) {
+      } else if ((0, import_graphql6.isUnionType)(gqlType2) || (0, import_graphql6.isEnumType)(gqlType2)) {
         return gqlType2;
       }
       throw new Error(
@@ -1070,25 +1116,25 @@ 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 import_graphql5.GraphQLSchema({
-      query,
-      mutation,
-      subscription,
+    const schema = new import_graphql6.GraphQLSchema({
+      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;
       let gqlType = getGraphQLType(parent);
-      if ((0, import_graphql5.isNonNullType)(gqlType)) gqlType = gqlType.ofType;
-      if ((0, import_graphql5.isObjectType)(gqlType)) {
+      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);
@@ -1101,7 +1147,7 @@ var SchemaWeaver = class _SchemaWeaver {
     })();
     if (resolverOptions?.extensions && parentObject)
       parentObject.mergeExtensions(resolverOptions.extensions);
-    Object.entries(resolver).forEach(([name, operation]) => {
+    Object.entries(resolver2).forEach(([name, operation]) => {
       if (operation === FIELD_HIDDEN) {
         if (parentObject == null) return;
         parentObject.hideField(name);
@@ -1149,12 +1195,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;
         }
@@ -1164,7 +1214,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
@@ -1172,9 +1222,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));
@@ -1184,10 +1235,10 @@ var SchemaWeaver = class _SchemaWeaver {
 var weave = SchemaWeaver.weave;
 
 // src/schema/interface.ts
-var import_graphql6 = require("graphql");
+var import_graphql7 = require("graphql");
 function ensureInterfaceType(gqlType, interfaceConfig) {
-  if ((0, import_graphql6.isInterfaceType)(gqlType)) return gqlType;
-  if (!(0, import_graphql6.isObjectType)(gqlType))
+  if ((0, import_graphql7.isInterfaceType)(gqlType)) return gqlType;
+  if (!(0, import_graphql7.isObjectType)(gqlType))
     throw new Error(`${gqlType.toString()} is not an object`);
   const key = gqlType;
   const existing = weaverContext.interfaceMap?.get(key);
@@ -1198,11 +1249,11 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
     fields,
     ...config
   } = gqlType.toConfig();
-  const interfaceType = new import_graphql6.GraphQLInterfaceType({
+  const interfaceType = new import_graphql7.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);
@@ -1233,20 +1284,24 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   ensureInputObjectType,
   ensureInputType,
   ensureInterfaceType,
+  field,
   getCacheType,
   getFieldOptions,
   getGraphQLType,
   getOperationOptions,
+  getStandardValue,
   getSubscriptionOptions,
   initWeaverContext,
   inputToArgs,
   isOnlyMemoryPayload,
+  isSchemaVendorWeaver,
   isSilk,
   listSilk,
   loom,
   mapValue,
   markErrorLocation,
   markLocation,
+  mutation,
   nonNullSilk,
   notNullish,
   nullableSilk,
@@ -1254,13 +1309,11 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   parseInputValue,
   parseSilk,
   provideWeaverContext,
+  query,
+  resolver,
   resolverPayloadStorage,
   silk,
-  silkField,
-  silkMutation,
-  silkQuery,
-  silkResolver,
-  silkSubscription,
+  subscription,
   toObjMap,
   tryIn,
   useContext,