@gqloom/core 0.12.0 → 0.13.0

package/dist/index.cjs

@@ -1,125 +1,370 @@
-const require_context = require('./context-DshDoxiE.cjs');
+const require_parse_resolving_fields = require('./parse-resolving-fields-BXQG_2Z-.cjs');
 let graphql = require("graphql");
-graphql = require_context.__toESM(graphql);
+graphql = require_parse_resolving_fields.__toESM(graphql);
 
-//#region src/utils/args.ts
-function getOperationOptions(resolveOrOptions) {
-	if (typeof resolveOrOptions === "function") return { resolve: resolveOrOptions };
-	return resolveOrOptions;
+//#region src/schema/weaver-context.ts
+var WeaverContext = class WeaverContext {
+	static increasingID = 1;
+	static names = /* @__PURE__ */ new WeakMap();
+	static autoAliasTypes = /* @__PURE__ */ new WeakSet();
+	static _ref;
+	static get ref() {
+		return WeaverContext._ref;
+	}
+	id;
+	loomObjectMap;
+	loomUnionMap;
+	inputMap;
+	interfaceMap;
+	configs;
+	namedTypes;
+	vendorWeavers;
+	constructor() {
+		this.id = WeaverContext.increasingID++;
+		this.loomObjectMap = /* @__PURE__ */ new Map();
+		this.loomUnionMap = /* @__PURE__ */ new Map();
+		this.inputMap = /* @__PURE__ */ new Map();
+		this.interfaceMap = /* @__PURE__ */ new Map();
+		this.configs = /* @__PURE__ */ new Map();
+		this.namedTypes = /* @__PURE__ */ new Map();
+		this.vendorWeavers = /* @__PURE__ */ new Map();
+	}
+	getConfig(key) {
+		return this.configs.get(key);
+	}
+	setConfig(config) {
+		const key = config[require_parse_resolving_fields.WEAVER_CONFIG];
+		this.configs.set(key, config);
+	}
+	deleteConfig(key) {
+		this.configs.delete(key);
+	}
+	memoNamedType(gqlTypeValue) {
+		const gqlType = gqlTypeValue;
+		if ((0, graphql.isObjectType)(gqlType) || (0, graphql.isUnionType)(gqlType) || (0, graphql.isEnumType)(gqlType) || (0, graphql.isScalarType)(gqlType)) this.namedTypes.set(gqlType.name, gqlType);
+		return gqlTypeValue;
+	}
+	getNamedType(name) {
+		return this.namedTypes.get(name);
+	}
+	static namedTypes = {
+		Object: "Object",
+		Union: "Union",
+		Enum: "Enum",
+		Interface: "Interface",
+		Scalar: "Scalar"
+	};
+	aliasCounters = {};
+	setAlias(namedType, alias) {
+		if (namedType.name === require_parse_resolving_fields.AUTO_ALIASING) WeaverContext.autoAliasTypes.add(namedType);
+		if (!WeaverContext.autoAliasTypes.has(namedType)) return namedType.name;
+		if (WeaverContext.higherPriorityThan(alias, namedType.name) < 0) {
+			if (alias) return namedType.name = alias;
+		}
+		if (namedType.name === require_parse_resolving_fields.AUTO_ALIASING) {
+			if ((0, graphql.isObjectType)(namedType) || (0, graphql.isInputObjectType)(namedType)) {
+				this.aliasCounters["Object"] ??= 0;
+				return namedType.name = `Object${++this.aliasCounters["Object"]}`;
+			} else if ((0, graphql.isUnionType)(namedType)) {
+				this.aliasCounters["Union"] ??= 0;
+				return namedType.name = `Union${++this.aliasCounters["Union"]}`;
+			} else if ((0, graphql.isEnumType)(namedType)) {
+				this.aliasCounters["Enum"] ??= 0;
+				return namedType.name = `Enum${++this.aliasCounters["Enum"]}`;
+			} else if ((0, graphql.isInterfaceType)(namedType)) {
+				this.aliasCounters["Interface"] ??= 0;
+				return namedType.name = `Interface${++this.aliasCounters["Interface"]}`;
+			} else if ((0, graphql.isScalarType)(namedType)) {
+				this.aliasCounters["Scalar"] ??= 0;
+				return namedType.name = `Scalar${++this.aliasCounters["Scalar"]}`;
+			}
+		}
+	}
+	/**
+	* @returns -1 if a is better than b, 1 if b is better than a, 0 if they are equal
+	*/
+	static higherPriorityThan(a, b) {
+		if (a === require_parse_resolving_fields.AUTO_ALIASING || a === void 0) return 1;
+		else if (b === require_parse_resolving_fields.AUTO_ALIASING || b === void 0) return -1;
+		const compareLength = a.length - b.length;
+		if (compareLength !== 0) return compareLength;
+		const compareLocale = a.localeCompare(b);
+		if (compareLocale !== 0) return compareLocale;
+		return 0;
+	}
+	static provide(func, value) {
+		const lastRef = WeaverContext._ref;
+		WeaverContext._ref = value;
+		try {
+			return func();
+		} finally {
+			WeaverContext._ref = lastRef;
+		}
+	}
+};
+const initWeaverContext = () => new WeaverContext();
+const provideWeaverContext = Object.assign(WeaverContext.provide, { inherit: (func) => {
+	const weaverContextRef = WeaverContext.ref;
+	return () => WeaverContext.provide(func, weaverContextRef);
+} });
+var GlobalWeaverContext = class {
+	GraphQLTypes = /* @__PURE__ */ new WeakMap();
+	get id() {
+		return WeaverContext.ref?.id;
+	}
+	get loomObjectMap() {
+		return WeaverContext.ref?.loomObjectMap;
+	}
+	get loomUnionMap() {
+		return WeaverContext.ref?.loomUnionMap;
+	}
+	get inputMap() {
+		return WeaverContext.ref?.inputMap;
+	}
+	get interfaceMap() {
+		return WeaverContext.ref?.interfaceMap;
+	}
+	get configs() {
+		return WeaverContext.ref?.configs;
+	}
+	get vendorWeavers() {
+		return WeaverContext.ref?.vendorWeavers;
+	}
+	get names() {
+		return WeaverContext.names;
+	}
+	get autoAliasTypes() {
+		return WeaverContext.autoAliasTypes;
+	}
+	get value() {
+		return WeaverContext.ref;
+	}
+	getConfig(key) {
+		return WeaverContext.ref?.getConfig(key);
+	}
+	setConfig(config) {
+		WeaverContext.ref?.setConfig(config);
+	}
+	deleteConfig(key) {
+		WeaverContext.ref?.deleteConfig(key);
+	}
+	useConfig(config, callback) {
+		const context = this.value ?? initWeaverContext();
+		context.setConfig(config);
+		const result = provideWeaverContext(callback, context);
+		context.deleteConfig(config[require_parse_resolving_fields.WEAVER_CONFIG]);
+		return result;
+	}
+	getNamedType(name) {
+		return WeaverContext.ref?.getNamedType(name);
+	}
+	memoNamedType(gqlType) {
+		return WeaverContext.ref?.memoNamedType(gqlType) ?? gqlType;
+	}
+	getGraphQLType(origin) {
+		return this.GraphQLTypes.get(origin);
+	}
+	memoGraphQLType(origin, gqlType) {
+		this.GraphQLTypes.set(origin, gqlType);
+		return gqlType;
+	}
+	setAlias(namedType, alias) {
+		return WeaverContext.ref?.setAlias(namedType, alias);
+	}
+};
+const weaverContext = new GlobalWeaverContext();
+/**
+* collect names for schemas
+* @param namesList - names to collect
+* @returns namesRecord
+*/
+function collectNames(...namesList) {
+	const namesRecord = {};
+	for (const namesItem of namesList) for (const [name, schema] of Object.entries(namesItem)) {
+		WeaverContext.names.set(schema, name);
+		namesRecord[name] = schema;
+	}
+	return namesRecord;
 }
-function getSubscriptionOptions(subscribeOrOptions) {
-	if (typeof subscribeOrOptions === "function") return { subscribe: subscribeOrOptions };
-	return subscribeOrOptions;
+/**
+* collect name for schema
+* @param name - name for
+* @param schema - schema to be named
+* @returns schema
+*/
+function collectName(name, schema) {
+	WeaverContext.names.set(schema, name);
+	return schema;
 }
-function getFieldOptions({ description, deprecationReason, extensions }, extraExtensions) {
+
+//#endregion
+//#region src/resolver/silk.ts
+function silk(type, validate = (value) => ({ value: value ?? void 0 })) {
 	return {
-		description,
-		deprecationReason,
-		extensions: extraExtensions ? {
-			...extensions,
-			...extraExtensions
-		} : extensions
+		[require_parse_resolving_fields.GET_GRAPHQL_TYPE]: typeof type === "function" ? type : () => type,
+		"~standard": {
+			version: 1,
+			vendor: "gqloom.silk",
+			validate
+		}
 	};
 }
-
-//#endregion
-//#region src/utils/middleware.ts
-const defaultOperations = [
-	"field",
-	"mutation",
-	"query",
-	"subscription.subscribe"
-];
-function applyMiddlewares(options, resolveFunction, middlewares) {
-	const next = (index) => {
-		if (index >= middlewares.length) return resolveFunction();
-		const middleware = middlewares[index];
-		const callableOptions = Object.assign(() => next(index + 1), {
-			...options,
-			next: () => next(index + 1)
-		});
-		return middleware(callableOptions);
+silk.parse = parseSilk;
+silk.getType = getGraphQLType;
+silk.nonNull = nonNullSilk;
+silk.list = listSilk;
+silk.nullable = nullableSilk;
+/**
+* Non-nullable Silk.
+*/
+function nonNullSilk(origin) {
+	return {
+		...origin,
+		[require_parse_resolving_fields.GET_GRAPHQL_TYPE]: () => {
+			const originType = getGraphQLType(origin);
+			if (originType instanceof graphql.GraphQLNonNull) return originType;
+			else return new graphql.GraphQLNonNull(originType);
+		}
 	};
-	return next(0);
 }
-function filterMiddlewares(operation, ...middlewareList) {
-	return middlewareList.reduce((acc, m) => {
-		if (!m) return acc;
-		acc.push(...ensureArray(m).filter((m$1) => {
-			return (m$1.operations ?? defaultOperations).includes(operation);
-		}));
-		return acc;
-	}, []);
+/**
+* List Silk.
+*/
+function listSilk(origin) {
+	return {
+		...origin,
+		[require_parse_resolving_fields.GET_GRAPHQL_TYPE]: () => {
+			let originType = getGraphQLType(origin);
+			if (originType instanceof graphql.GraphQLNonNull && originType.ofType instanceof graphql.GraphQLList) originType = originType.ofType.ofType;
+			if (originType instanceof graphql.GraphQLList) originType = originType.ofType;
+			return new graphql.GraphQLNonNull(new graphql.GraphQLList(originType));
+		}
+	};
 }
-function ensureArray(value) {
-	if (value != null && typeof value === "object" && Symbol.iterator in value) return Array.from(value);
-	return [value];
+/**
+* Nullable Silk.
+*/
+function nullableSilk(origin) {
+	return {
+		...origin,
+		[require_parse_resolving_fields.GET_GRAPHQL_TYPE]: () => {
+			const originType = getGraphQLType(origin);
+			if (originType instanceof graphql.GraphQLNonNull) return originType.ofType;
+			else return originType;
+		}
+	};
 }
-
-//#endregion
-//#region src/utils/object.ts
 /**
-* Creates an object map with the same keys as `map` and values generated by
-* running each value of `record` thru `fn`.
+* Get GraphQL Output Type from Silk.
+* @param silk GraphQL Silk
+* @returns GraphQL Output Type
 */
-function mapValue(record, fn) {
-	const result = 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;
+function getGraphQLType(silk$1) {
+	if (require_parse_resolving_fields.GET_GRAPHQL_TYPE in silk$1 && silk$1[require_parse_resolving_fields.GET_GRAPHQL_TYPE] != null) return typeof silk$1[require_parse_resolving_fields.GET_GRAPHQL_TYPE] === "function" ? silk$1[require_parse_resolving_fields.GET_GRAPHQL_TYPE]() : silk$1[require_parse_resolving_fields.GET_GRAPHQL_TYPE];
+	const vendorWeavers = weaverContext.vendorWeavers;
+	if (vendorWeavers == null) throw new Error("Schema Weaver is not initialized");
+	const weaver = vendorWeavers.get(silk$1["~standard"].vendor);
+	if (weaver == null) throw new Error(`Schema Weaver for ${silk$1["~standard"].vendor} is not found`);
+	return weaver.getGraphQLType(silk$1);
 }
-const SKIP = Symbol.for("mapValue.skip");
-mapValue.SKIP = SKIP;
-function toObjMap(obj) {
-	if (obj == null) return Object.create(null);
-	if (Object.getPrototypeOf(obj) === null) return obj;
-	const map = Object.create(null);
-	for (const [key, value] of Object.entries(obj)) map[key] = value;
-	return map;
+/**
+* Get GraphQL Argument Config from Silk.
+* @param silk GraphQL Silk
+* @returns GraphQL Argument Config
+*/
+function getGraphQLArgumentConfig(silk$1) {
+	if (require_parse_resolving_fields.GET_GRAPHQL_ARGUMENT_CONFIG in silk$1 && silk$1[require_parse_resolving_fields.GET_GRAPHQL_ARGUMENT_CONFIG] != null) return typeof silk$1[require_parse_resolving_fields.GET_GRAPHQL_ARGUMENT_CONFIG] === "function" ? silk$1[require_parse_resolving_fields.GET_GRAPHQL_ARGUMENT_CONFIG]() : silk$1[require_parse_resolving_fields.GET_GRAPHQL_ARGUMENT_CONFIG];
+	const vendorWeavers = weaverContext.vendorWeavers;
+	if (vendorWeavers == null) return void 0;
+	const weaver = vendorWeavers.get(silk$1["~standard"]?.vendor);
+	if (weaver == null) return void 0;
+	if (weaver.getGraphQLArgumentConfig == null) return void 0;
+	return weaver.getGraphQLArgumentConfig(silk$1);
 }
-function notNullish(x) {
-	return x != null;
+/**
+* Validate and transform input to output
+* @param silk silk GraphQL Silk
+* @param input
+* @returns output
+*/
+function parseSilk(silk$1, input) {
+	return silk$1["~standard"].validate(input);
 }
-function deepMerge(...objects) {
+function isSilk(target) {
+	if (typeof target !== "object" && typeof target !== "function") return false;
+	if (target == null) return false;
+	if (require_parse_resolving_fields.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";
+}
+
+//#endregion
+//#region 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: (value$1) => result = value$1
+	});
+	Object.defineProperty(parse, "getResult", { value: async () => getStandardValue(await parse()) });
+	Object.defineProperty(parse, "setResult", { value: (value$1) => result = { value: value$1 } });
+	Object.defineProperty(parse, "clearResult", { value: () => result = void 0 });
+	return parse;
+}
+function parseInputValue(inputSchema, input) {
+	if (inputSchema === void 0) return { value: input };
+	if (isSilk(inputSchema)) return inputSchema["~standard"].validate(input);
+	return parseInputEntries(inputSchema, input);
+}
+async function parseInputEntries(inputSchema, input = {}) {
 	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;
+	const issues = [];
+	await Promise.all(Object.entries(inputSchema).map(async ([key, value]) => {
+		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 {
+		value: result,
+		...issues.length > 0 ? { issues } : null
+	};
 }
-/**
-* Wraps the provided data in an object with a single key `"~meta"`.
-*
-* @template T - The type of the data to be wrapped.
-* @param {T} data - The data to be wrapped.
-* @returns {{ "~meta": T }} - An object with a single key `"~meta"` containing the provided data.
-* @example
-* const originalData = { key: "value" };
-* const metaData = meta(originalData);
-* console.log(metaData); // Output: { "~meta": { key: "value" } }
-*/
-function meta(data) {
-	return { "~meta": data };
+function getStandardValue(result) {
+	if (result == null) return result;
+	const { issues } = result;
+	if (issues?.length) throw new graphql.GraphQLError(issues?.[0]?.message ?? "Invalid input", { extensions: { issues } });
+	if ("value" in result) return result.value;
+	else throw new graphql.GraphQLError("Invalid input");
 }
 
 //#endregion
-//#region src/utils/string.ts
-function pascalCase(str) {
-	return str.split(/[\s-_]+/).map((word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)).join("");
+//#region src/utils/args.ts
+function getOperationOptions(resolveOrOptions) {
+	if (typeof resolveOrOptions === "function") return { resolve: resolveOrOptions };
+	return resolveOrOptions;
 }
-function capitalize(str) {
-	return str.slice(0, 1).toUpperCase() + str.slice(1);
+function getSubscriptionOptions(subscribeOrOptions) {
+	if (typeof subscribeOrOptions === "function") return { subscribe: subscribeOrOptions };
+	return subscribeOrOptions;
 }
-function screamingSnakeCase(str) {
-	return str.replace(/([a-z])([A-Z])/g, "$1_$2").split(/[\s-_]+/).map((word) => word.toUpperCase()).join("_");
+function getFieldOptions({ description, deprecationReason, extensions }, extraExtensions) {
+	return {
+		description,
+		deprecationReason,
+		extensions: extraExtensions ? {
+			...extensions,
+			...extraExtensions
+		} : extensions
+	};
 }
 
 //#endregion
@@ -239,271 +484,102 @@ var EasyDataLoader = class extends LoomDataLoader {
 };
 
 //#endregion
-//#region src/schema/weaver-context.ts
-let ref;
-const names = /* @__PURE__ */ new WeakMap();
-const autoAliasTypes = /* @__PURE__ */ new WeakSet();
-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[require_context.WEAVER_CONFIG];
-			this.configs.set(key, config);
-		},
-		deleteConfig(key) {
-			this.configs.delete(key);
-		},
-		names,
-		autoAliasTypes,
-		namedTypes: /* @__PURE__ */ new Map(),
-		memoNamedType(gqlTypeValue) {
-			const gqlType = gqlTypeValue;
-			if ((0, graphql.isObjectType)(gqlType) || (0, graphql.isUnionType)(gqlType) || (0, graphql.isEnumType)(gqlType) || (0, 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;
-const 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[require_context.WEAVER_CONFIG]);
-		return result;
-	},
-	names,
-	autoAliasTypes,
-	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;
-	}
+//#region src/utils/middleware.ts
+const defaultOperations = [
+	"field",
+	"mutation",
+	"query",
+	"subscription.subscribe"
+];
+function applyMiddlewares(options, resolveFunction, middlewares) {
+	const next = (index) => {
+		if (index >= middlewares.length) return resolveFunction();
+		const middleware = middlewares[index];
+		return middleware(Object.assign(() => next(index + 1), {
+			...options,
+			next: () => next(index + 1)
+		}));
+	};
+	return next(0);
 }
-provideWeaverContext.inherit = (func) => {
-	const weaverContextRef = weaverContext.value;
-	return () => provideWeaverContext(func, weaverContextRef);
-};
-/**
-* collect names for schemas
-* @param namesList - names to collect
-* @returns namesRecord
-*/
-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 filterMiddlewares(operation, ...middlewareList) {
+	return middlewareList.reduce((acc, m) => {
+		if (!m) return acc;
+		acc.push(...ensureArray(m).filter((m$1) => {
+			return (m$1.operations ?? defaultOperations).includes(operation);
+		}));
+		return acc;
+	}, []);
 }
-/**
-* collect name for schema
-* @param name - name for
-* @param schema - schema to be named
-* @returns schema
-*/
-function collectName(name, schema) {
-	names.set(schema, name);
-	return schema;
+function ensureArray(value) {
+	if (value != null && typeof value === "object" && Symbol.iterator in value) return Array.from(value);
+	return [value];
 }
 
 //#endregion
-//#region src/resolver/silk.ts
-function silk(type, validate = (value) => ({ value: value ?? void 0 })) {
-	return {
-		[require_context.GET_GRAPHQL_TYPE]: typeof type === "function" ? type : () => type,
-		"~standard": {
-			version: 1,
-			vendor: "gqloom.silk",
-			validate
-		}
-	};
-}
-silk.parse = parseSilk;
-silk.getType = getGraphQLType;
-silk.nonNull = nonNullSilk;
-silk.list = listSilk;
-silk.nullable = nullableSilk;
+//#region src/utils/object.ts
 /**
-* Non-nullable Silk.
+* Creates an object map with the same keys as `map` and values generated by
+* running each value of `record` thru `fn`.
 */
-function nonNullSilk(origin) {
-	return {
-		...origin,
-		[require_context.GET_GRAPHQL_TYPE]: () => {
-			const originType = getGraphQLType(origin);
-			if (originType instanceof graphql.GraphQLNonNull) return originType;
-			else return new graphql.GraphQLNonNull(originType);
-		}
-	};
+function mapValue(record, fn) {
+	const result = 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;
 }
-/**
-* List Silk.
-*/
-function listSilk(origin) {
-	return {
-		...origin,
-		[require_context.GET_GRAPHQL_TYPE]: () => {
-			let originType = getGraphQLType(origin);
-			if (originType instanceof graphql.GraphQLNonNull && originType.ofType instanceof graphql.GraphQLList) originType = originType.ofType.ofType;
-			if (originType instanceof graphql.GraphQLList) originType = originType.ofType;
-			return new graphql.GraphQLNonNull(new graphql.GraphQLList(originType));
-		}
-	};
+const SKIP = Symbol.for("mapValue.skip");
+mapValue.SKIP = SKIP;
+function toObjMap(obj) {
+	if (obj == null) return Object.create(null);
+	if (Object.getPrototypeOf(obj) === null) return obj;
+	const map = Object.create(null);
+	for (const [key, value] of Object.entries(obj)) map[key] = value;
+	return map;
 }
-/**
-* Nullable Silk.
-*/
-function nullableSilk(origin) {
-	return {
-		...origin,
-		[require_context.GET_GRAPHQL_TYPE]: () => {
-			const originType = getGraphQLType(origin);
-			if (originType instanceof graphql.GraphQLNonNull) return originType.ofType;
-			else return originType;
-		}
-	};
+function notNullish(x) {
+	return x != null;
 }
-/**
-* Get GraphQL Output Type from Silk.
-* @param silk GraphQL Silk
-* @returns GraphQL Output Type
-*/
-function getGraphQLType(silk$1) {
-	if (require_context.GET_GRAPHQL_TYPE in silk$1 && silk$1[require_context.GET_GRAPHQL_TYPE] != null) return silk$1[require_context.GET_GRAPHQL_TYPE]();
-	const vendorWeavers = weaverContext.vendorWeavers;
-	if (vendorWeavers == null) throw new Error("Schema Weaver is not initialized");
-	const weaver = vendorWeavers.get(silk$1["~standard"].vendor);
-	if (weaver == null) throw new Error(`Schema Weaver for ${silk$1["~standard"].vendor} is not found`);
-	return weaver.getGraphQLType(silk$1);
+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;
 }
 /**
-* Validate and transform input to output
-* @param silk silk GraphQL Silk
-* @param input
-* @returns output
+* Wraps the provided data in an object with a single key `"~meta"`.
+*
+* @template T - The type of the data to be wrapped.
+* @param {T} data - The data to be wrapped.
+* @returns {{ "~meta": T }} - An object with a single key `"~meta"` containing the provided data.
+* @example
+* const originalData = { key: "value" };
+* const metaData = meta(originalData);
+* console.log(metaData); // Output: { "~meta": { key: "value" } }
 */
-function parseSilk(silk$1, input) {
-	return silk$1["~standard"].validate(input);
-}
-function isSilk(target) {
-	if (typeof target !== "object" && typeof target !== "function") return false;
-	if (target == null) return false;
-	if (require_context.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";
+function meta(data) {
+	return { "~meta": data };
 }
 
 //#endregion
-//#region 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: (value$1) => result = value$1
-	});
-	Object.defineProperty(parse, "getResult", { value: async () => getStandardValue(await parse()) });
-	Object.defineProperty(parse, "setResult", { value: (value$1) => result = { value: value$1 } });
-	Object.defineProperty(parse, "clearResult", { value: () => result = void 0 });
-	return parse;
-}
-function parseInputValue(inputSchema, input) {
-	if (inputSchema === void 0) return { value: input };
-	if (isSilk(inputSchema)) return inputSchema["~standard"].validate(input);
-	return parseInputEntries(inputSchema, input);
+//#region src/utils/string.ts
+function pascalCase(str) {
+	return str.split(/[\s-_]+/).map((word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)).join("");
 }
-async function parseInputEntries(inputSchema, input = {}) {
-	const result = {};
-	const issues = [];
-	await Promise.all(Object.entries(inputSchema).map(async ([key, value]) => {
-		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 {
-		value: result,
-		...issues.length > 0 ? { issues } : null
-	};
+function capitalize(str) {
+	return str.slice(0, 1).toUpperCase() + str.slice(1);
 }
-function getStandardValue(result) {
-	if (result == null) return result;
-	const { issues } = result;
-	if (issues?.length) throw new graphql.GraphQLError(issues?.[0]?.message ?? "Invalid input", { extensions: { issues } });
-	if ("value" in result) return result.value;
-	else throw new graphql.GraphQLError("Invalid input");
+function screamingSnakeCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1_$2").split(/[\s-_]+/).map((word) => word.toUpperCase()).join("_");
 }
 
 //#endregion
@@ -562,7 +638,7 @@ var BaseChainFactory = class BaseChainFactory {
 var FieldLoader = class FieldLoader extends LoomDataLoader {
 	static getByPath(payload, resolve, getByPath = true) {
 		if (!payload) return new FieldLoader(resolve);
-		const memoMap = require_context.getMemoizationMap(payload);
+		const memoMap = require_parse_resolving_fields.getMemoizationMap(payload);
 		if (!getByPath) {
 			const loader = memoMap.get(resolve) ?? new FieldLoader(resolve);
 			memoMap.set(resolve, loader);
@@ -1043,7 +1119,7 @@ const createField = (output, resolveOrOptions) => {
 	if (resolveOrOptions == null) return new FieldChainFactory({ output });
 	const options = getOperationOptions(resolveOrOptions);
 	return meta({
-		...getFieldOptions(options, { [require_context.DERIVED_DEPENDENCIES]: options.dependencies }),
+		...getFieldOptions(options, { [require_parse_resolving_fields.DERIVED_DEPENDENCIES]: options.dependencies }),
 		input: options.input,
 		dependencies: options.dependencies,
 		output,
@@ -1055,7 +1131,7 @@ const createField = (output, resolveOrOptions) => {
 /**
 * Factory function for creating GraphQL fields with chainable configuration
 */
-const field = Object.assign(createField, { hidden: require_context.FIELD_HIDDEN }, FieldChainFactory.methods());
+const field = Object.assign(createField, { hidden: require_parse_resolving_fields.FIELD_HIDDEN }, FieldChainFactory.methods());
 /**
 * Default subscription resolver that returns the source value
 * @param source - The source value to resolve
@@ -1108,7 +1184,7 @@ var ChainResolver = class {
 	*/
 	constructor(fields, options) {
 		this.meta = {
-			[require_context.IS_RESOLVER]: true,
+			[require_parse_resolving_fields.IS_RESOLVER]: true,
 			fields,
 			options
 		};
@@ -1133,7 +1209,7 @@ var ChainResolver = class {
 		return mapValue(this["~meta"].fields, (field$1) => this.toExecutorOperation(field$1, middlewares) ?? mapValue.SKIP);
 	}
 	toExecutorOperation(field$1, executorMiddlewares) {
-		if (field$1 === require_context.FIELD_HIDDEN || field$1["~meta"].operation === "subscription") return;
+		if (field$1 === require_parse_resolving_fields.FIELD_HIDDEN || field$1["~meta"].operation === "subscription") return;
 		const operation = field$1["~meta"].operation;
 		const middlewares = filterMiddlewares(operation, executorMiddlewares, this.meta.options?.middlewares, field$1["~meta"].middlewares);
 		if (field$1["~meta"].operation === "field") {
@@ -1179,7 +1255,7 @@ var ObjectChainResolver = class extends ChainResolver {
 	constructor(parent, fields, options) {
 		super(fields, options);
 		this.meta = {
-			[require_context.IS_RESOLVER]: true,
+			[require_parse_resolving_fields.IS_RESOLVER]: true,
 			fields,
 			parent,
 			options
@@ -1206,15 +1282,6 @@ var ObjectChainResolver = class extends ChainResolver {
 	}
 };
 
-//#endregion
-//#region src/schema/alias.ts
-function setAlias(namedType, alias, context) {
-	if (namedType.name === require_context.AUTO_ALIASING) context.autoAliasTypes.add(namedType);
-	if (!context.autoAliasTypes.has(namedType) || !alias) return;
-	if (namedType.name === require_context.AUTO_ALIASING) namedType.name = alias;
-	namedType.name = alias.length < namedType.name.length ? alias : namedType.name;
-}
-
 //#endregion
 //#region src/schema/input.ts
 function inputToArgs(input, options) {
@@ -1223,8 +1290,7 @@ function inputToArgs(input, options) {
 		let inputType = getGraphQLType(input);
 		if ((0, graphql.isNonNullType)(inputType)) inputType = inputType.ofType;
 		if ((0, graphql.isObjectType)(inputType)) return mapValue(inputType.toConfig().fields, (it, key) => {
-			const fieldName = `${pascalCase(options.fieldName)}${pascalCase(key)}`;
-			return toInputFieldConfig(it, { fieldName });
+			return toInputFieldConfig(it, { fieldName: `${pascalCase(options.fieldName)}${pascalCase(key)}` });
 		});
 		throw new Error(`Cannot convert ${inputType.toString()} to input type`);
 	}
@@ -1233,7 +1299,7 @@ function inputToArgs(input, options) {
 		tryIn(() => {
 			const fieldName = `${pascalCase(options.fieldName)}${pascalCase(name)}`;
 			args[name] = {
-				...field$1,
+				...getGraphQLArgumentConfig(field$1),
 				type: ensureInputType(field$1, { fieldName })
 			};
 		}, name);
@@ -1250,9 +1316,9 @@ function ensureInputType(silkOrType, options) {
 	if ((0, graphql.isListType)(gqlType)) return new graphql.GraphQLList(ensureInputType(gqlType.ofType, options));
 	if ((0, graphql.isObjectType)(gqlType) || (0, graphql.isInterfaceType)(gqlType)) return ensureInputObjectType(gqlType, options);
 	if ((0, graphql.isEnumType)(gqlType)) {
-		if (gqlType.name === require_context.AUTO_ALIASING) {
+		if (gqlType.name === require_parse_resolving_fields.AUTO_ALIASING) {
 			const alias = `${pascalCase(options.fieldName)}Input`;
-			setAlias(gqlType, alias, weaverContext);
+			weaverContext.setAlias(gqlType, alias);
 		}
 		return gqlType;
 	}
@@ -1262,9 +1328,9 @@ function ensureInputObjectType(object, options) {
 	if ((0, graphql.isInputObjectType)(object)) return object;
 	const existing = weaverContext.inputMap?.get(object);
 	if (existing != null) return existing;
-	const { astNode, extensionASTNodes, fields,...config } = object.toConfig();
+	const { astNode: _1, extensionASTNodes: _2, fields,...config } = object.toConfig();
 	let name = object.name;
-	if (name === require_context.AUTO_ALIASING) name = `${pascalCase(options.fieldName)}Input`;
+	if (name === require_parse_resolving_fields.AUTO_ALIASING) name = `${pascalCase(options.fieldName)}Input`;
 	name = (weaverContext.getConfig("gqloom.core.schema")?.getInputObjectName ?? ((n) => n))(name);
 	const input = new graphql.GraphQLInputObjectType({
 		...config,
@@ -1310,10 +1376,10 @@ var LoomObjectType = class extends graphql.GraphQLObjectType {
 		this.globalOptions = options.globalOptions;
 		this.weaverContext = options.weaverContext ?? initWeaverContext();
 		this.resolvers = /* @__PURE__ */ new Map();
-		if (this.name === require_context.AUTO_ALIASING) this.weaverContext.autoAliasTypes.add(this);
+		if (this.name === require_parse_resolving_fields.AUTO_ALIASING) WeaverContext.autoAliasTypes.add(this);
 	}
 	addAlias(alias) {
-		if (!this.weaverContext.autoAliasTypes.has(this) || !alias) return;
+		if (!WeaverContext.autoAliasTypes.has(this) || !alias) return;
 		this.name = alias.length < this.name.length ? alias : this.name;
 	}
 	hideField(name) {
@@ -1328,10 +1394,14 @@ var LoomObjectType = class extends graphql.GraphQLObjectType {
 	mergeExtensions(extensions) {
 		this.extensions = deepMerge(this.extensions, extensions);
 	}
+	collectedFieldNames() {
+		const fieldsBySuper = super.getFields();
+		Object.entries(fieldsBySuper).forEach(([fieldName, field$1]) => field$1.type = this.getCacheType(field$1.type, fieldName));
+	}
 	extraFieldMap;
 	getFields() {
 		const fieldsBySuper = super.getFields();
-		Object.entries(fieldsBySuper).forEach(([fieldName, field$1]) => field$1.type = this.getCacheType(field$1.type, fieldName));
+		this.collectedFieldNames();
 		const extraFields = provideWeaverContext(() => defineFieldMap(this.mapToFieldConfig(this.extraFields)), this.weaverContext);
 		if (Object.keys(this.extraFieldMap ?? {}).join() !== Object.keys(extraFields).join()) this.extraFieldMap = extraFields;
 		const answer = {
@@ -1471,8 +1541,7 @@ function extract(field$1) {
 	};
 }
 function defineFieldMap(fields) {
-	const fieldMap = (0, graphql.resolveObjMapThunk)(fields);
-	return mapValue(fieldMap, (fieldConfig, fieldName) => {
+	return mapValue((0, graphql.resolveObjMapThunk)(fields), (fieldConfig, fieldName) => {
 		const argsConfig = fieldConfig.args ?? {};
 		return {
 			name: (0, graphql.assertName)(fieldName),
@@ -1515,7 +1584,7 @@ function getCacheType(gqlType, options = {}) {
 		if (gqlObject != null) return gqlObject;
 		const loomObject = new LoomObjectType(gqlType, options);
 		context.loomObjectMap?.set(gqlType, loomObject);
-		setAlias(loomObject, getAlias(), context);
+		context.setAlias(loomObject, getAlias());
 		return loomObject;
 	} else if ((0, graphql.isListType)(gqlType)) return new graphql.GraphQLList(getCacheType(gqlType.ofType, options));
 	else if ((0, graphql.isNonNullType)(gqlType)) return new graphql.GraphQLNonNull(getCacheType(gqlType.ofType, options));
@@ -1527,14 +1596,14 @@ function getCacheType(gqlType, options = {}) {
 			...config,
 			types: config.types.map((type, i) => getCacheType(type, {
 				...options,
-				fieldName: options.fieldName ? `${options.fieldName}${i + 1}` : void 0
+				fieldName: options.fieldName ? `${options.fieldName}Item${i + 1}` : void 0
 			}))
 		});
 		context.loomUnionMap?.set(gqlType, unionType);
-		setAlias(unionType, getAlias(), context);
+		context.setAlias(unionType, getAlias());
 		return unionType;
-	} else if ((0, graphql.isEnumType)(gqlType)) {
-		setAlias(gqlType, getAlias(), context);
+	} else if ((0, graphql.isEnumType)(gqlType) || (0, graphql.isInterfaceType)(gqlType) || (0, graphql.isScalarType)(gqlType)) {
+		context.setAlias(gqlType, getAlias());
 		return gqlType;
 	}
 	return gqlType;
@@ -1544,6 +1613,29 @@ function parentName(name) {
 	return name;
 }
 
+//#endregion
+//#region src/schema/interface.ts
+function ensureInterfaceType(gqlType, interfaceConfig) {
+	if ((0, graphql.isInterfaceType)(gqlType)) return gqlType;
+	if (!(0, graphql.isObjectType)(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 graphql.GraphQLInterfaceType({
+		...config,
+		...interfaceConfig,
+		fields: mapValue(fields, (field$1) => {
+			return {
+				...field$1,
+				type: getCacheType(field$1.type)
+			};
+		})
+	});
+	weaverContext.interfaceMap?.set(key, interfaceType);
+	return interfaceType;
+}
+
 //#endregion
 //#region src/schema/schema-weaver.ts
 function isSchemaVendorWeaver(some) {
@@ -1571,7 +1663,7 @@ var GraphQLSchemaLoom = class GraphQLSchemaLoom {
 	static config(config) {
 		return {
 			...config,
-			[require_context.WEAVER_CONFIG]: "gqloom.core.schema"
+			[require_parse_resolving_fields.WEAVER_CONFIG]: "gqloom.core.schema"
 		};
 	}
 	constructor({ query: query$1, mutation: mutation$1, subscription: subscription$1, types } = {}, context) {
@@ -1596,18 +1688,10 @@ var GraphQLSchemaLoom = class GraphQLSchemaLoom {
 		return this;
 	}
 	addType(silk$1) {
-		const gqlType = provideWeaverContext(() => {
-			let gqlType$1 = getGraphQLType(silk$1);
-			if ((0, graphql.isNonNullType)(gqlType$1)) gqlType$1 = gqlType$1.ofType;
-			if ((0, graphql.isObjectType)(gqlType$1)) {
-				const existing = this.context.loomObjectMap.get(gqlType$1);
-				if (existing != null) return existing;
-				const extraObject = new LoomObjectType(gqlType$1, this.fieldOptions);
-				this.context.loomObjectMap.set(gqlType$1, extraObject);
-				return extraObject;
-			} else if ((0, graphql.isUnionType)(gqlType$1) || (0, graphql.isEnumType)(gqlType$1)) return gqlType$1;
-			throw new Error(`${gqlType$1?.name ?? gqlType$1.toString()} is not a named type`);
+		let gqlType = provideWeaverContext(() => {
+			return getCacheType(getGraphQLType(silk$1));
 		}, this.context);
+		while ((0, graphql.isNonNullType)(gqlType) || (0, graphql.isListType)(gqlType)) gqlType = gqlType.ofType;
 		this.types.add(gqlType);
 		return this;
 	}
@@ -1632,8 +1716,8 @@ var GraphQLSchemaLoom = class GraphQLSchemaLoom {
 		let parentObject = (() => {
 			if (parent == null) return void 0;
 			let gqlType = getGraphQLType(parent);
-			if ((0, graphql.isNonNullType)(gqlType)) gqlType = gqlType.ofType;
-			if (!(0, graphql.isObjectType)(gqlType)) throw new Error(`${gqlType?.name ?? gqlType.toString()} is not an object type`);
+			while ((0, graphql.isNonNullType)(gqlType) || (0, graphql.isListType)(gqlType)) gqlType = gqlType.ofType;
+			if (!(0, graphql.isObjectType)(gqlType)) throw new Error(`${gqlType.name} is not an object type`);
 			const existing = this.context.loomObjectMap.get(gqlType);
 			if (existing != null) return existing;
 			const extraObject = new LoomObjectType(gqlType, this.fieldOptions);
@@ -1644,7 +1728,7 @@ var GraphQLSchemaLoom = class GraphQLSchemaLoom {
 		if (resolverOptions?.extensions && parentObject) parentObject.mergeExtensions(resolverOptions.extensions);
 		if (modifyParent != null && parentObject) parentObject = modifyParent(parentObject);
 		Object.entries(resolver$1["~meta"].fields).forEach(([name, field$1]) => {
-			if (field$1 === require_context.FIELD_HIDDEN) {
+			if (field$1 === require_parse_resolving_fields.FIELD_HIDDEN) {
 				if (parentObject == null) return;
 				parentObject.hideField(name);
 			} else if (field$1["~meta"].operation === "field") {
@@ -1694,12 +1778,12 @@ var GraphQLSchemaLoom = class GraphQLSchemaLoom {
 			if (item == null) continue;
 			if (isSchemaVendorWeaver(item)) weavers.add(item);
 			else if (typeof item === "function") middlewares.add(item);
-			else if (require_context.WEAVER_CONFIG in item) {
+			else if (require_parse_resolving_fields.WEAVER_CONFIG in item) {
 				configs.add(item);
 				if (item.vendorWeaver) weavers.add(item.vendorWeaver);
-				if (item[require_context.WEAVER_CONFIG] === "gqloom.core.schema") context = item.weaverContext;
+				if (item[require_parse_resolving_fields.WEAVER_CONFIG] === "gqloom.core.schema") context = item.weaverContext;
 			} else if (isSilk(item)) silks.add(item);
-			else if (item["~meta"][require_context.IS_RESOLVER]) resolvers.add(item);
+			else if (item["~meta"][require_parse_resolving_fields.IS_RESOLVER]) resolvers.add(item);
 		}
 		return {
 			context,
@@ -1734,36 +1818,14 @@ var GraphQLSchemaLoom = class GraphQLSchemaLoom {
 const weave = GraphQLSchemaLoom.weave;
 
 //#endregion
-//#region src/schema/interface.ts
-function ensureInterfaceType(gqlType, interfaceConfig) {
-	if ((0, graphql.isInterfaceType)(gqlType)) return gqlType;
-	if (!(0, graphql.isObjectType)(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 graphql.GraphQLInterfaceType({
-		...config,
-		...interfaceConfig,
-		fields: mapValue(fields, (field$1) => {
-			return {
-				...field$1,
-				type: getCacheType(field$1.type)
-			};
-		})
-	});
-	weaverContext.interfaceMap?.set(key, interfaceType);
-	return interfaceType;
-}
-
-//#endregion
-exports.AUTO_ALIASING = require_context.AUTO_ALIASING;
+exports.AUTO_ALIASING = require_parse_resolving_fields.AUTO_ALIASING;
 exports.BaseChainFactory = BaseChainFactory;
 exports.ChainResolver = ChainResolver;
-exports.DERIVED_DEPENDENCIES = require_context.DERIVED_DEPENDENCIES;
+exports.DERIVED_DEPENDENCIES = require_parse_resolving_fields.DERIVED_DEPENDENCIES;
 exports.EasyDataLoader = EasyDataLoader;
 exports.FieldChainFactory = FieldChainFactory;
 exports.FieldFactoryWithResolve = FieldFactoryWithResolve;
+exports.GlobalWeaverContext = GlobalWeaverContext;
 exports.GraphQLSchemaLoom = GraphQLSchemaLoom;
 exports.LoomDataLoader = LoomDataLoader;
 exports.LoomObjectType = LoomObjectType;
@@ -1776,12 +1838,13 @@ exports.QueryFactoryWithResolve = QueryFactoryWithResolve;
 Object.defineProperty(exports, 'SYMBOLS', {
   enumerable: true,
   get: function () {
-    return require_context.symbols_exports;
+    return require_parse_resolving_fields.symbols_exports;
   }
 });
 exports.SubscriptionChainFactory = SubscriptionChainFactory;
+exports.WeaverContext = WeaverContext;
 exports.applyMiddlewares = applyMiddlewares;
-exports.assignContextMap = require_context.assignContextMap;
+exports.assignContextMap = require_parse_resolving_fields.assignContextMap;
 exports.capitalize = capitalize;
 exports.collectName = collectName;
 exports.collectNames = collectNames;
@@ -1798,17 +1861,18 @@ exports.ensureInterfaceType = ensureInterfaceType;
 exports.field = field;
 exports.filterMiddlewares = filterMiddlewares;
 exports.getCacheType = getCacheType;
-exports.getDeepResolvingFields = require_context.getDeepResolvingFields;
+exports.getDeepResolvingFields = require_parse_resolving_fields.getDeepResolvingFields;
 exports.getFieldOptions = getFieldOptions;
+exports.getGraphQLArgumentConfig = getGraphQLArgumentConfig;
 exports.getGraphQLType = getGraphQLType;
-exports.getMemoizationMap = require_context.getMemoizationMap;
+exports.getMemoizationMap = require_parse_resolving_fields.getMemoizationMap;
 exports.getOperationOptions = getOperationOptions;
-exports.getResolvingFields = require_context.getResolvingFields;
+exports.getResolvingFields = require_parse_resolving_fields.getResolvingFields;
 exports.getStandardValue = getStandardValue;
 exports.getSubscriptionOptions = getSubscriptionOptions;
 exports.initWeaverContext = initWeaverContext;
 exports.inputToArgs = inputToArgs;
-exports.isOnlyMemoryPayload = require_context.isOnlyMemoryPayload;
+exports.isOnlyMemoryPayload = require_parse_resolving_fields.isOnlyMemoryPayload;
 exports.isSchemaVendorWeaver = isSchemaVendorWeaver;
 exports.isSilk = isSilk;
 exports.listSilk = listSilk;
@@ -1821,9 +1885,9 @@ exports.mutation = mutation;
 exports.nonNullSilk = nonNullSilk;
 exports.notNullish = notNullish;
 exports.nullableSilk = nullableSilk;
-exports.onlyMemoization = require_context.onlyMemoization;
+exports.onlyMemoization = require_parse_resolving_fields.onlyMemoization;
 exports.parseInputValue = parseInputValue;
-exports.parseResolvingFields = require_context.parseResolvingFields;
+exports.parseResolvingFields = require_parse_resolving_fields.parseResolvingFields;
 exports.parseSilk = parseSilk;
 exports.pascalCase = pascalCase;
 exports.provideWeaverContext = provideWeaverContext;