@gqloom/core 0.2.0

package/dist/index.js

@@ -0,0 +1,1198 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/resolver/silk.ts
+import {
+  GraphQLNonNull,
+  GraphQLList
+} from "graphql";
+
+// src/utils/symbols.ts
+var symbols_exports = {};
+__export(symbols_exports, {
+  CONTEXT_MEMORY_MAP_KEY: () => CONTEXT_MEMORY_MAP_KEY,
+  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");
+
+// src/resolver/silk.ts
+function silk(type, parse) {
+  return {
+    [GET_GRAPHQL_TYPE]: typeof type === "function" ? type : () => type,
+    [PARSE]: parse
+  };
+}
+silk.parse = parseSilk;
+silk.getType = getGraphQLType;
+silk.nonNull = nonNullSilk;
+silk.list = listSilk;
+silk.nullable = nullableSilk;
+function nonNullSilk(origin) {
+  return {
+    [GET_GRAPHQL_TYPE]: () => {
+      const originType = getGraphQLType(origin);
+      if (originType instanceof GraphQLNonNull) {
+        return originType;
+      } else {
+        return new GraphQLNonNull(originType);
+      }
+    },
+    [PARSE]: (input) => origin[PARSE]?.(input)
+  };
+}
+function listSilk(origin) {
+  return {
+    [GET_GRAPHQL_TYPE]: () => {
+      let originType = getGraphQLType(origin);
+      if (originType instanceof GraphQLNonNull && originType.ofType instanceof GraphQLList) {
+        originType = originType.ofType;
+      }
+      if (originType instanceof GraphQLList) {
+        originType = originType.ofType;
+      }
+      return new GraphQLNonNull(new GraphQLList(originType));
+    }
+  };
+}
+function nullableSilk(origin) {
+  return {
+    [GET_GRAPHQL_TYPE]: () => {
+      const originType = getGraphQLType(origin);
+      if (originType instanceof GraphQLNonNull) {
+        return originType.ofType;
+      } else {
+        return originType;
+      }
+    },
+    [PARSE]: (input) => origin[PARSE]?.(input)
+  };
+}
+function getGraphQLType(silk2) {
+  return silk2[GET_GRAPHQL_TYPE]();
+}
+function parseSilk(silk2, input) {
+  if (silk2[PARSE] == null) return input;
+  return silk2[PARSE](input);
+}
+function isSilk(target) {
+  if (typeof target !== "object") return false;
+  if (target == null) return false;
+  return GET_GRAPHQL_TYPE in target;
+}
+
+// src/utils/args.ts
+function getOperationOptions(resolveOrOptions) {
+  if (typeof resolveOrOptions === "function") {
+    return { resolve: resolveOrOptions };
+  }
+  return resolveOrOptions;
+}
+function getSubscriptionOptions(subscribeOrOptions) {
+  if (typeof subscribeOrOptions === "function") {
+    return { subscribe: subscribeOrOptions };
+  }
+  return subscribeOrOptions;
+}
+function getFieldOptions({
+  description,
+  deprecationReason,
+  extensions
+}) {
+  return {
+    description,
+    deprecationReason,
+    extensions
+  };
+}
+
+// src/utils/middleware.ts
+function applyMiddlewares(middlewares, resolveFunction, payload) {
+  const next = (index) => {
+    if (index >= middlewares.length) {
+      return resolveFunction();
+    }
+    const middleware = middlewares[index];
+    return middleware(() => next(index + 1), payload);
+  };
+  return next(0);
+}
+function compose(...lists) {
+  const list = [];
+  for (const item of lists) {
+    if (item != null) {
+      list.push(...item);
+    }
+  }
+  return list;
+}
+
+// src/utils/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+function onlyMemoization() {
+  return { memoization: /* @__PURE__ */ new WeakMap(), isMemoization: true };
+}
+function isOnlyMemoryPayload(payload) {
+  return payload.isMemoization === true;
+}
+var resolverPayloadStorage = new AsyncLocalStorage();
+function useResolverPayload() {
+  const payload = resolverPayloadStorage.getStore();
+  if (payload === void 0 || isOnlyMemoryPayload(payload)) return;
+  return payload;
+}
+function useContext() {
+  return useResolverPayload()?.context;
+}
+function useMemoizationMap() {
+  const payload = resolverPayloadStorage.getStore();
+  if (payload == null) return;
+  if (isOnlyMemoryPayload(payload)) return payload.memoization;
+  return ContextMemoization.assignMemoizationMap(payload.context);
+}
+var ContextMemoization = class {
+  constructor(getter, options = {}) {
+    this.getter = getter;
+    this.getter = getter;
+    this.getMemoizationMap = options.getMemoizationMap ?? useMemoizationMap;
+    this.key = options.key ?? this.getter;
+  }
+  getMemoizationMap;
+  key;
+  /**
+   * Get the value in memoization or call the getter function
+   * @returns the value of the getter function
+   */
+  get() {
+    const map = this.getMemoizationMap();
+    if (!map) return this.getter();
+    if (!map.has(this.key)) {
+      map.set(this.key, this.getter());
+    }
+    return map.get(this.key);
+  }
+  /**
+   * Clear the memoization
+   * @returns true if the memoization is cleared, undefined if the context is not found
+   */
+  clear() {
+    const map = this.getMemoizationMap();
+    if (!map) return;
+    return map.delete(this.key);
+  }
+  /**
+   * Check if the memoization exists
+   * @returns true if the memoization exists, undefined if the context is not found
+   */
+  exists() {
+    const map = this.getMemoizationMap();
+    if (!map) return;
+    return map.has(this.key);
+  }
+  /**
+   * Set a new value to the memoization
+   * @param value  the new value to set
+   * @returns the memoization map or undefined if the context is not found
+   */
+  set(value) {
+    const map = this.getMemoizationMap();
+    if (!map) return;
+    return map.set(this.key, value);
+  }
+  static assignMemoizationMap(target) {
+    target[CONTEXT_MEMORY_MAP_KEY] ??= /* @__PURE__ */ new WeakMap();
+    return target[CONTEXT_MEMORY_MAP_KEY];
+  }
+};
+function createMemoization(...args) {
+  const memoization = new ContextMemoization(...args);
+  const callable = () => memoization.get();
+  return Object.assign(callable, {
+    get: () => memoization.get(),
+    set: (value) => memoization.set(value),
+    clear: () => memoization.clear(),
+    exists: () => memoization.exists(),
+    getter: memoization.getter
+  });
+}
+
+// src/utils/object.ts
+function mapValue(record, fn) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(record)) {
+    const value = fn(record[key], key);
+    if (value === SKIP) continue;
+    result[key] = value;
+  }
+  return result;
+}
+var SKIP = Symbol.for("mapValue.skip");
+mapValue.SKIP = SKIP;
+function toObjMap(obj) {
+  if (obj == null) {
+    return /* @__PURE__ */ Object.create(null);
+  }
+  if (Object.getPrototypeOf(obj) === null) {
+    return obj;
+  }
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(obj)) {
+    map[key] = value;
+  }
+  return map;
+}
+function notNullish(x) {
+  return x != null;
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (obj == null) continue;
+    for (const [key, value] of Object.entries(obj)) {
+      if (value !== null && typeof value === "object") {
+        if (Array.isArray(value)) {
+          if (!Array.isArray(result[key])) {
+            result[key] = [];
+          }
+          result[key] = [...result[key], ...value];
+        } else {
+          result[key] = deepMerge(result[key], value);
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/utils/error.ts
+function markErrorLocation(error, ...locations) {
+  if (error instanceof Error) {
+    error.message = markLocation(error.message, ...locations);
+  }
+  return error;
+}
+function tryIn(func, ...locations) {
+  try {
+    return func();
+  } catch (error) {
+    throw markErrorLocation(error, ...locations);
+  }
+}
+function markLocation(message, ...locations) {
+  if (locations.length === 0) {
+    return message;
+  }
+  const [existingPrefix, newMessage] = (() => {
+    const existingPrefixPattern = /^\[(.*?)\]/;
+    const match = existingPrefixPattern.exec(message);
+    if (match) return [match[1], message.slice(match[0].length).trim()];
+    return [void 0, message];
+  })();
+  const combinedLocation = locations.concat(existingPrefix ? [existingPrefix] : []).join(".");
+  return `[${combinedLocation}] ${newMessage}`;
+}
+
+// src/resolver/input.ts
+function createInputParser(schema, value) {
+  let result;
+  const parse = async () => {
+    if (result !== void 0) return result;
+    result = await parseInputValue(schema, value);
+    return result;
+  };
+  Object.assign(parse, { schema, value });
+  Object.defineProperty(parse, "result", {
+    get: () => result,
+    set: (value2) => result = value2
+  });
+  return parse;
+}
+function parseInputValue(inputSchema, input) {
+  if (inputSchema === void 0) {
+    return input;
+  }
+  if (isSilk(inputSchema)) {
+    if (typeof inputSchema[symbols_exports.PARSE] === "function") {
+      return inputSchema[symbols_exports.PARSE](input);
+    }
+    return input;
+  }
+  return parseInputEntries(inputSchema, input);
+}
+async function parseInputEntries(inputSchema, input = {}) {
+  const result = {};
+  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];
+      }
+    })
+  );
+  return result;
+}
+
+// src/resolver/resolver.ts
+var silkQuery = (output, resolveOrOptions) => {
+  const options = getOperationOptions(resolveOrOptions);
+  const type = "query";
+  return {
+    ...getFieldOptions(options),
+    input: options.input,
+    output,
+    resolve: (inputValue, extraOptions) => {
+      const parseInput = createInputParser(options.input, inputValue);
+      return applyMiddlewares(
+        compose(extraOptions?.middlewares, options.middlewares),
+        async () => options.resolve(await parseInput()),
+        { parseInput, parent: void 0, outputSilk: output, type }
+      );
+    },
+    type
+  };
+};
+var silkMutation = (output, resolveOrOptions) => {
+  const options = getOperationOptions(resolveOrOptions);
+  const type = "mutation";
+  return {
+    ...getFieldOptions(options),
+    input: options.input,
+    output,
+    resolve: (inputValue, extraOptions) => {
+      const parseInput = createInputParser(options.input, inputValue);
+      return applyMiddlewares(
+        compose(extraOptions?.middlewares, options.middlewares),
+        async () => options.resolve(await parseInput()),
+        { parseInput, parent: void 0, outputSilk: output, type }
+      );
+    },
+    type
+  };
+};
+var silkField = (output, resolveOrOptions) => {
+  const options = getOperationOptions(resolveOrOptions);
+  const type = "field";
+  return {
+    ...getFieldOptions(options),
+    input: options.input,
+    output,
+    resolve: (parent, inputValue, extraOptions) => {
+      const parseInput = createInputParser(options.input, inputValue);
+      return applyMiddlewares(
+        compose(extraOptions?.middlewares, options.middlewares),
+        async () => options.resolve(parent, await parseInput()),
+        { parseInput, parent, outputSilk: output, type }
+      );
+    },
+    type
+  };
+};
+var defaultSubscriptionResolve = (source) => source;
+var silkSubscription = (output, subscribeOrOptions) => {
+  const options = getSubscriptionOptions(subscribeOrOptions);
+  const type = "subscription";
+  return {
+    ...getFieldOptions(options),
+    input: options.input,
+    output,
+    subscribe: (inputValue, extraOptions) => {
+      const parseInput = createInputParser(options.input, inputValue);
+      return applyMiddlewares(
+        compose(
+          extraOptions?.middlewares,
+          options.middlewares
+        ),
+        async () => options.subscribe(await parseInput()),
+        { parseInput, parent: void 0, outputSilk: output, type }
+      );
+    },
+    resolve: options.resolve ?? defaultSubscriptionResolve,
+    type
+  };
+};
+var ResolverOptionsMap = /* @__PURE__ */ new WeakMap();
+function baseResolver(operations, options) {
+  const record = {};
+  Object.entries(operations).forEach(([name, operation]) => {
+    record[name] = extraOperationOptions(operation, options);
+  });
+  if (options) ResolverOptionsMap.set(record, options);
+  return record;
+}
+function extraOperationOptions(operation, options) {
+  const composeMiddlewares = (extraOptions) => compose(extraOptions?.middlewares, options?.middlewares);
+  switch (operation.type) {
+    case "field":
+      return {
+        ...operation,
+        resolve: (parent, input, extraOptions) => operation.resolve(parent, input, {
+          ...extraOptions,
+          middlewares: composeMiddlewares(extraOptions)
+        })
+      };
+    case "subscription":
+      return {
+        ...operation,
+        subscribe: (input, extraOptions) => operation.subscribe(input, {
+          ...extraOptions,
+          middlewares: composeMiddlewares(extraOptions)
+        })
+      };
+    default:
+      return {
+        ...operation,
+        resolve: (input, extraOptions) => operation.resolve(input, {
+          ...extraOptions,
+          middlewares: composeMiddlewares(extraOptions)
+        })
+      };
+  }
+}
+var silkResolver = Object.assign(
+  baseResolver,
+  {
+    of: (parent, operations, options) => baseResolver(
+      operations,
+      { ...options, parent }
+    )
+  }
+);
+var loom = {
+  query: silkQuery,
+  resolver: silkResolver,
+  field: silkField,
+  subscription: silkSubscription,
+  mutation: silkMutation
+};
+
+// src/helper/create-loom.ts
+function toSilkInput(schema, toSilk, isSchema) {
+  if (schema == null) {
+    return schema;
+  }
+  if (isSchema(schema)) {
+    return toSilk(schema);
+  }
+  const record = {};
+  for (const [key, value] of Object.entries(schema)) {
+    record[key] = toSilk(value);
+  }
+  return record;
+}
+function createResolverBobbin(toSilk) {
+  return Object.assign(baseResolver, {
+    of: (parent, operations, options) => baseResolver(
+      operations,
+      { ...options, parent: toSilk(parent) }
+    )
+  });
+}
+function createFieldBobbin(toSilk, isSchema) {
+  return (output, resolveOrOptions) => {
+    const options = getOperationOptions(
+      resolveOrOptions
+    );
+    return silkField(toSilk(output), {
+      ...options,
+      input: toSilkInput(options.input, toSilk, isSchema)
+    });
+  };
+}
+function createQueryBobbin(toSilk, isSchema) {
+  return (output, resolveOrOptions) => {
+    const options = getOperationOptions(resolveOrOptions);
+    return silkQuery(toSilk(output), {
+      ...options,
+      input: toSilkInput(options.input, toSilk, isSchema)
+    });
+  };
+}
+function createMutationBobbin(toSilk, isSchema) {
+  return (output, resolveOrOptions) => {
+    const options = getOperationOptions(resolveOrOptions);
+    return silkMutation(toSilk(output), {
+      ...options,
+      input: toSilkInput(options.input, toSilk, isSchema)
+    });
+  };
+}
+function createSubscriptionBobbin(toSilk, isSchema) {
+  return (output, resolveOrOptions) => {
+    const options = getSubscriptionOptions(resolveOrOptions);
+    return silkSubscription(toSilk(output), {
+      ...options,
+      input: toSilkInput(options.input, 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)
+  };
+}
+
+// src/schema/object.ts
+import {
+  GraphQLObjectType,
+  assertName,
+  isObjectType as isObjectType3,
+  resolveObjMapThunk,
+  isListType as isListType2,
+  GraphQLList as GraphQLList3,
+  GraphQLNonNull as GraphQLNonNull3,
+  isNonNullType as isNonNullType2,
+  isUnionType as isUnionType3,
+  GraphQLUnionType
+} 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,
+  isInterfaceType,
+  isListType,
+  isNonNullType,
+  isObjectType as isObjectType2,
+  isUnionType as isUnionType2,
+  isInputObjectType
+} from "graphql";
+function inputToArgs(input) {
+  if (input === void 0) return void 0;
+  if (isSilk(input)) {
+    let inputType = getGraphQLType(input);
+    if (isNonNullType(inputType)) inputType = inputType.ofType;
+    if (isObjectType2(inputType)) {
+      return mapValue(
+        inputType.toConfig().fields,
+        (it) => toInputFieldConfig(it)
+      );
+    }
+    throw new Error(`Cannot convert ${inputType.toString()} to input type`);
+  }
+  const args = {};
+  Object.entries(input).forEach(([name, field]) => {
+    tryIn(() => {
+      args[name] = {
+        ...field,
+        type: ensureInputType(field)
+      };
+    }, name);
+  });
+  return args;
+}
+function ensureInputType(silkOrType) {
+  const gqlType = (() => {
+    if (isSilk(silkOrType)) {
+      return getGraphQLType(silkOrType);
+    }
+    return silkOrType;
+  })();
+  if (isUnionType2(gqlType))
+    throw new Error(`Cannot convert union type ${gqlType.name} to input type`);
+  if (isNonNullType(gqlType)) {
+    return new GraphQLNonNull2(ensureInputType(gqlType.ofType));
+  }
+  if (isListType(gqlType)) {
+    return new GraphQLList2(ensureInputType(gqlType.ofType));
+  }
+  if (isObjectType2(gqlType) || isInterfaceType(gqlType))
+    return ensureInputObjectType(gqlType);
+  return gqlType;
+}
+function ensureInputObjectType(object) {
+  if (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 input = new GraphQLInputObjectType({
+    ...config,
+    name: getInputObjectName(object.name),
+    fields: mapValue(fields, (it) => toInputFieldConfig(it))
+  });
+  weaverContext.inputMap?.set(object, input);
+  return input;
+}
+function toInputFieldConfig({
+  astNode: _,
+  resolve: _1,
+  ...config
+}) {
+  return { ...config, type: ensureInputType(config.type) };
+}
+
+// src/schema/object.ts
+var LoomObjectType = class extends GraphQLObjectType {
+  extraFields = /* @__PURE__ */ new Map();
+  weaverContext;
+  resolverOptions;
+  constructor(objectOrGetter, options = {}) {
+    const origin = typeof objectOrGetter === "function" ? objectOrGetter() : objectOrGetter;
+    const config = (() => {
+      if (isObjectType3(origin)) {
+        return origin.toConfig();
+      } else if (typeof origin === "string") {
+        return { name: origin, fields: {} };
+      } else {
+        return origin;
+      }
+    })();
+    super(config);
+    this.resolverOptions = options.resolverOptions;
+    this.weaverContext = options.weaverContext ?? initWeaverContext();
+  }
+  addField(name, resolver) {
+    const existing = this.extraFields.get(name);
+    if (existing && existing !== resolver) {
+      throw new Error(`Field ${name} already exists in ${this.name}`);
+    }
+    this.extraFields.set(name, resolver);
+  }
+  mergeExtensions(extensions) {
+    this.extensions = deepMerge(this.extensions, extensions);
+  }
+  extraField;
+  getFields() {
+    const fields = super.getFields();
+    Object.values(fields).forEach(
+      (field) => field.type = this.getCacheType(field.type)
+    );
+    const extraField = provideWeaverContext(
+      () => defineFieldMap(this.mapToFieldConfig(this.extraFields)),
+      this.weaverContext
+    );
+    if (Object.keys(this.extraField ?? {}).join() !== Object.keys(extraField).join()) {
+      this.extraField = extraField;
+    }
+    return {
+      ...fields,
+      ...this.extraField
+    };
+  }
+  mapToFieldConfig(map) {
+    const record = {};
+    for (const [name, field] of map.entries()) {
+      record[name] = this.toFieldConfig(field);
+    }
+    return record;
+  }
+  toFieldConfig(field) {
+    try {
+      const outputType = this.getCacheType(getGraphQLType(field.output));
+      return {
+        ...extract(field),
+        type: outputType,
+        args: inputToArgs(field.input),
+        ...this.provideForResolve(field),
+        ...this.provideForSubscribe(field)
+      };
+    } catch (error) {
+      throw markErrorLocation(error);
+    }
+  }
+  provideForResolve(field) {
+    if (field?.resolve == null) return;
+    if (field.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)
+    ) : (root, args, context, info) => resolverPayloadStorage.run(
+      { root, args, context, info, field },
+      () => field.resolve(args, this.resolverOptions)
+    );
+    return { resolve };
+  }
+  provideForSubscribe(field) {
+    if (field?.subscribe == null) return;
+    return {
+      subscribe: (root, args, context, info) => resolverPayloadStorage.run(
+        { root, args, context, info, field },
+        () => field.subscribe?.(args, this.resolverOptions)
+      )
+    };
+  }
+  getCacheType(gqlType) {
+    return getCacheType(gqlType, this.options);
+  }
+  get options() {
+    const { resolverOptions, weaverContext: weaverContext2 } = this;
+    return { resolverOptions, weaverContext: weaverContext2 };
+  }
+};
+function extract({
+  deprecationReason,
+  description,
+  extensions
+}) {
+  return {
+    description,
+    deprecationReason,
+    extensions
+  };
+}
+function defineFieldMap(fields) {
+  const fieldMap = resolveObjMapThunk(fields);
+  return mapValue(fieldMap, (fieldConfig, fieldName) => {
+    const argsConfig = fieldConfig.args ?? {};
+    return {
+      name: assertName(fieldName),
+      description: fieldConfig.description,
+      type: fieldConfig.type,
+      args: defineArguments(argsConfig),
+      resolve: fieldConfig.resolve,
+      subscribe: fieldConfig.subscribe,
+      deprecationReason: fieldConfig.deprecationReason,
+      extensions: toObjMap(fieldConfig.extensions),
+      astNode: fieldConfig.astNode
+    };
+  });
+}
+function defineArguments(args) {
+  return Object.entries(args).map(([argName, argConfig]) => ({
+    name: assertName(argName),
+    description: argConfig.description,
+    type: argConfig.type,
+    defaultValue: argConfig.defaultValue,
+    deprecationReason: argConfig.deprecationReason,
+    extensions: toObjMap(argConfig.extensions),
+    astNode: argConfig.astNode
+  }));
+}
+function getCacheType(gqlType, options = {}) {
+  const context = options.weaverContext ?? weaverContext;
+  if (gqlType instanceof LoomObjectType) return gqlType;
+  if (isObjectType3(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 (isListType2(gqlType)) {
+    return new GraphQLList3(getCacheType(gqlType.ofType, options));
+  } else if (isNonNullType2(gqlType)) {
+    return new GraphQLNonNull3(getCacheType(gqlType.ofType, options));
+  } else if (isUnionType3(gqlType)) {
+    const existing = context.loomUnionMap?.get(gqlType);
+    if (existing != null) return existing;
+    const config = gqlType.toConfig();
+    const unionType = new GraphQLUnionType({
+      ...config,
+      types: config.types.map(
+        (type) => getCacheType(type, options)
+      )
+    });
+    context.loomUnionMap?.set(gqlType, unionType);
+    return unionType;
+  }
+  return gqlType;
+}
+
+// src/schema/schema-weaver.ts
+import {
+  GraphQLSchema,
+  isObjectType as isObjectType4,
+  isNonNullType as isNonNullType3,
+  isEnumType as isEnumType2,
+  isUnionType as isUnionType4
+} from "graphql";
+var SchemaWeaver = class _SchemaWeaver {
+  query;
+  mutation;
+  subscription;
+  types;
+  context;
+  resolverOptions;
+  /**
+   * Create a Schema Weaver config object
+   * @param config Schema Weaver config options
+   * @returns a Schema Weaver config object
+   */
+  static config(config) {
+    return {
+      ...config,
+      [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;
+    if (types != null) this.types = types.slice();
+    this.context = context ?? initWeaverContext();
+  }
+  use(...middlewares) {
+    this.resolverOptions ??= {};
+    this.resolverOptions.middlewares ??= [];
+    this.resolverOptions.middlewares.push(...middlewares);
+    return this;
+  }
+  add(resolver) {
+    provideWeaverContext(() => this.addResolver(resolver), this.context);
+    return this;
+  }
+  addType(silk2) {
+    const gqlType = provideWeaverContext(() => {
+      let gqlType2 = getGraphQLType(silk2);
+      if (isNonNullType3(gqlType2)) gqlType2 = gqlType2.ofType;
+      if (isObjectType4(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 (isUnionType4(gqlType2) || isEnumType2(gqlType2)) {
+        return gqlType2;
+      }
+      throw new Error(
+        `${gqlType2?.name ?? gqlType2.toString()} is not a named type`
+      );
+    }, this.context);
+    this.types ??= [];
+    this.types.push(gqlType);
+    return this;
+  }
+  setConfig(config) {
+    this.context.setConfig(config);
+    return this;
+  }
+  weaveGraphQLSchema() {
+    const { query, mutation, subscription, types } = this;
+    const config = this.context.getConfig("gqloom.core.schema");
+    const schema = new GraphQLSchema({
+      query,
+      mutation,
+      subscription,
+      types: [...types ?? [], ...config?.types ?? []],
+      ...config
+    });
+    return schema;
+  }
+  addResolver(resolver) {
+    const resolverOptions = ResolverOptionsMap.get(resolver);
+    const parent = resolverOptions?.parent;
+    const parentObject = (() => {
+      if (parent == null) return void 0;
+      let gqlType = getGraphQLType(parent);
+      if (isNonNullType3(gqlType)) gqlType = gqlType.ofType;
+      if (isObjectType4(gqlType)) {
+        const existing = this.context.loomObjectMap.get(gqlType);
+        if (existing != null) return existing;
+        const extraObject = new LoomObjectType(gqlType, this.fieldOptions);
+        this.context.loomObjectMap.set(gqlType, extraObject);
+        return extraObject;
+      }
+      throw new Error(
+        `${gqlType?.name ?? gqlType.toString()} is not an object type`
+      );
+    })();
+    if (resolverOptions?.extensions && parentObject)
+      parentObject.mergeExtensions(resolverOptions.extensions);
+    Object.entries(resolver).forEach(([name, operation]) => {
+      if (operation.type === "field") {
+        if (parentObject == null) return;
+        parentObject.addField(name, operation);
+      } else {
+        const operationObject = this.getOperationObject(operation.type);
+        operationObject.addField(name, operation);
+      }
+    });
+    return this;
+  }
+  getOperationObject(type) {
+    switch (type) {
+      case "query": {
+        this.query ??= new LoomObjectType(
+          { name: "Query", fields: {} },
+          this.fieldOptions
+        );
+        return this.query;
+      }
+      case "mutation": {
+        this.mutation ??= new LoomObjectType(
+          { name: "Mutation", fields: {} },
+          this.fieldOptions
+        );
+        return this.mutation;
+      }
+      case "subscription": {
+        this.subscription ??= new LoomObjectType(
+          { name: "Subscription", fields: {} },
+          this.fieldOptions
+        );
+        return this.subscription;
+      }
+    }
+  }
+  get fieldOptions() {
+    const { resolverOptions, context } = this;
+    return { resolverOptions, weaverContext: context };
+  }
+  static optionsFrom(...inputs) {
+    const configs = /* @__PURE__ */ new Set();
+    const middlewares = /* @__PURE__ */ new Set();
+    const resolvers = /* @__PURE__ */ new Set();
+    const silks = /* @__PURE__ */ new Set();
+    let context;
+    for (const item of inputs) {
+      if (typeof item === "function") {
+        middlewares.add(item);
+      } else if (WEAVER_CONFIG in item) {
+        configs.add(item);
+        if (item[WEAVER_CONFIG] === "gqloom.core.schema") {
+          context = item.weaverContext;
+        }
+      } else if (isSilk(item)) {
+        silks.add(item);
+      } else {
+        resolvers.add(item);
+      }
+    }
+    return { context, configs, middlewares, resolvers, silks };
+  }
+  /**
+   * Weave a GraphQL Schema from resolvers
+   * @param inputs Resolvers, Global Middlewares or WeaverConfigs
+   * @returns GraphQ LSchema
+   */
+  static weave(...inputs) {
+    const { context, configs, middlewares, resolvers, silks } = _SchemaWeaver.optionsFrom(...inputs);
+    const weaver = new _SchemaWeaver({}, context);
+    configs.forEach((it) => weaver.setConfig(it));
+    middlewares.forEach((it) => weaver.use(it));
+    resolvers.forEach((it) => weaver.add(it));
+    silks.forEach((it) => weaver.addType(it));
+    return weaver.weaveGraphQLSchema();
+  }
+};
+var weave = SchemaWeaver.weave;
+
+// src/schema/interface.ts
+import {
+  GraphQLInterfaceType,
+  isInterfaceType as isInterfaceType2,
+  isObjectType as isObjectType5
+} from "graphql";
+function ensureInterfaceType(gqlType, interfaceConfig) {
+  if (isInterfaceType2(gqlType)) return gqlType;
+  if (!isObjectType5(gqlType))
+    throw new Error(`${gqlType.toString()} is not an object`);
+  const key = gqlType;
+  const existing = weaverContext.interfaceMap?.get(key);
+  if (existing != null) return existing;
+  const {
+    astNode: _,
+    extensionASTNodes: _1,
+    fields,
+    ...config
+  } = gqlType.toConfig();
+  const interfaceType = new GraphQLInterfaceType({
+    ...config,
+    ...interfaceConfig,
+    fields: mapValue(fields, (field) => {
+      return { ...field, type: getCacheType(field.type) };
+    })
+  });
+  weaverContext.interfaceMap?.set(key, interfaceType);
+  return interfaceType;
+}
+
+// src/schema/extensions.ts
+function mergeExtensions(...extensionsList) {
+  return deepMerge(...extensionsList);
+}
+export {
+  ContextMemoization,
+  LoomObjectType,
+  ResolverOptionsMap,
+  symbols_exports as SYMBOLS,
+  SchemaWeaver,
+  applyMiddlewares,
+  baseResolver,
+  collectNames,
+  compose,
+  createFieldBobbin,
+  createInputParser,
+  createLoom,
+  createMemoization,
+  createMutationBobbin,
+  createQueryBobbin,
+  createResolverBobbin,
+  createSubscriptionBobbin,
+  deepMerge,
+  defaultSubscriptionResolve,
+  ensureInputObjectType,
+  ensureInputType,
+  ensureInterfaceType,
+  getCacheType,
+  getFieldOptions,
+  getGraphQLType,
+  getOperationOptions,
+  getSubscriptionOptions,
+  initWeaverContext,
+  inputToArgs,
+  isOnlyMemoryPayload,
+  isSilk,
+  listSilk,
+  loom,
+  mapValue,
+  markErrorLocation,
+  markLocation,
+  mergeExtensions,
+  nonNullSilk,
+  notNullish,
+  nullableSilk,
+  onlyMemoization,
+  parseInputValue,
+  parseSilk,
+  provideWeaverContext,
+  resolverPayloadStorage,
+  silk,
+  silkField,
+  silkMutation,
+  silkQuery,
+  silkResolver,
+  silkSubscription,
+  toObjMap,
+  tryIn,
+  useContext,
+  useMemoizationMap,
+  useResolverPayload,
+  weave,
+  weaverContext
+};