@gqloom/core 0.10.1 → 0.11.1

package/dist/context-CnY_BFnk.cjs

@@ -0,0 +1,415 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let graphql = require("graphql");
+graphql = __toESM(graphql);
+
+//#region src/utils/constants.ts
+const DERIVED_DEPENDENCIES = "loom.derived-from-dependencies";
+
+//#endregion
+//#region src/utils/type.ts
+function unwrapType(gqlType) {
+	if ((0, graphql.isNonNullType)(gqlType)) return unwrapType(gqlType.ofType);
+	if ((0, graphql.isListType)(gqlType)) return unwrapType(gqlType.ofType);
+	return gqlType;
+}
+
+//#endregion
+//#region src/utils/parse-resolving-fields.ts
+/**
+* Analyzes and processes field resolution in a GraphQL query deeply.
+*
+* @param payload - The resolver payload containing the current field resolution context
+* @param [maxDepth=Infinity] - Maximum depth of nested fields to parse
+* @returns A map of field paths to their resolving fields
+*/
+function getDeepResolvingFields(payload, maxDepth = Infinity) {
+	const result = /* @__PURE__ */ new Map();
+	const requestedFieldsByPath = ResolvingFieldsParser.parseDeep(payload.info, maxDepth);
+	const rootType = unwrapType(payload.info.returnType);
+	for (const [path, requestedFields] of requestedFieldsByPath.entries()) {
+		let currentType = rootType;
+		if (path) {
+			const pathParts = path.split(".");
+			let tempType = rootType;
+			for (const part of pathParts) {
+				const unwrapped = unwrapType(tempType);
+				if ((0, graphql.isObjectType)(unwrapped) || (0, graphql.isInterfaceType)(unwrapped)) {
+					const field = unwrapped.getFields()[part];
+					if (field) tempType = field.type;
+					else {
+						tempType = void 0;
+						break;
+					}
+				} else {
+					tempType = void 0;
+					break;
+				}
+			}
+			if (!tempType) continue;
+			currentType = tempType;
+		}
+		const unwrappedCurrentType = unwrapType(currentType);
+		if ((0, graphql.isObjectType)(unwrappedCurrentType)) {
+			const derivedFields = /* @__PURE__ */ new Set();
+			const derivedDependencies = /* @__PURE__ */ new Set();
+			const objectFields = unwrappedCurrentType.getFields();
+			for (const requestedFieldName of requestedFields) {
+				const field = objectFields[requestedFieldName];
+				if (field) {
+					const deps = field.extensions?.[DERIVED_DEPENDENCIES];
+					if (deps && Array.isArray(deps) && deps.length > 0) {
+						derivedFields.add(requestedFieldName);
+						for (const d of deps) derivedDependencies.add(d);
+					}
+				}
+			}
+			const selectedFields = new Set(requestedFields);
+			for (const f of derivedFields) selectedFields.delete(f);
+			for (const d of derivedDependencies) selectedFields.add(d);
+			result.set(path, {
+				requestedFields,
+				derivedFields,
+				derivedDependencies,
+				selectedFields
+			});
+		}
+	}
+	return result;
+}
+/**
+* Analyzes and processes field resolution in a GraphQL query.
+*
+* @param payload - The resolver payload containing the current field resolution context
+* @returns An object containing sets of different field types
+*/
+function getResolvingFields(payload) {
+	const requestedFields = parseResolvingFields(payload.info);
+	const derivedFields = /* @__PURE__ */ new Set();
+	const derivedDependencies = /* @__PURE__ */ new Set();
+	const resolvingObject = unwrapType(payload.info.returnType);
+	if ((0, graphql.isObjectType)(resolvingObject)) {
+		const objectFields = resolvingObject.getFields();
+		for (const fieldName of requestedFields) {
+			const field = objectFields[fieldName];
+			if (field) {
+				const deps = field.extensions?.[DERIVED_DEPENDENCIES];
+				if (deps && Array.isArray(deps)) {
+					derivedFields.add(fieldName);
+					for (const d of deps) derivedDependencies.add(d);
+				}
+			}
+		}
+	}
+	const selectedFields = new Set(requestedFields);
+	for (const f of derivedFields) selectedFields.delete(f);
+	for (const d of derivedDependencies) selectedFields.add(d);
+	return {
+		requestedFields,
+		derivedFields,
+		derivedDependencies,
+		selectedFields
+	};
+}
+/**
+* Parses the GraphQL resolve info to extract all requested fields.
+* Returns a Set of field paths where nested fields are represented as 'parent.field'.
+* Supports @include, @skip directives, fragments, and variables.
+*
+* @param info - The GraphQL resolve info object containing the query information
+* @param maxDepth - Maximum depth of nested fields to parse (default: 1)
+* @returns A Set of field paths
+*/
+function parseResolvingFields(info, maxDepth = 1) {
+	return ResolvingFieldsParser.parse(info, maxDepth);
+}
+/**
+* Class responsible for parsing GraphQL resolve info to extract all requested fields.
+*/
+var ResolvingFieldsParser = class ResolvingFieldsParser {
+	/** Store unique field paths grouped by parent path */
+	fields = /* @__PURE__ */ new Map();
+	/** Track visited fragments to prevent circular references */
+	visitedFragments = /* @__PURE__ */ new Set();
+	/** The GraphQL resolve info object */
+	info;
+	/** Maximum depth of nested fields to parse */
+	maxDepth;
+	static parse(info, maxDepth) {
+		return new ResolvingFieldsParser(info, maxDepth).parse();
+	}
+	static parseDeep(info, maxDepth) {
+		return new ResolvingFieldsParser(info, maxDepth).parseDeep();
+	}
+	constructor(info, maxDepth) {
+		this.info = info;
+		this.maxDepth = maxDepth;
+		for (const fieldNode of this.info.fieldNodes) this.collectFields(fieldNode.selectionSet, "", 0);
+	}
+	/**
+	* Parses the GraphQL resolve info to extract all requested fields into a flat set.
+	* @returns A Set of field paths
+	*/
+	parse() {
+		const flatFields = /* @__PURE__ */ new Set();
+		for (const [path, fieldSet] of this.fields.entries()) for (const fieldName of fieldSet) {
+			const fullPath = path ? `${path}.${fieldName}` : fieldName;
+			flatFields.add(fullPath);
+		}
+		for (const path of this.fields.keys()) if (path) flatFields.add(path);
+		return flatFields;
+	}
+	/**
+	* Parses the GraphQL resolve info to extract all requested fields.
+	* @returns A map of field paths to their requested fields
+	*/
+	parseDeep() {
+		return this.fields;
+	}
+	/**
+	* Recursively collects fields from a selection set.
+	* Handles fields, inline fragments, and fragment spreads.
+	*
+	* @param selectionSet - The selection set to process
+	* @param parentPath - The path of the parent field (for nested fields)
+	* @param currentDepth - Current depth of recursion
+	*/
+	collectFields(selectionSet, parentPath = "", currentDepth = 0) {
+		if (!selectionSet?.selections.length || currentDepth >= this.maxDepth) return;
+		if (!this.fields.has(parentPath)) this.fields.set(parentPath, /* @__PURE__ */ new Set());
+		const currentFields = this.fields.get(parentPath);
+		for (const selection of selectionSet.selections) {
+			if (!this.shouldIncludeNode(selection)) continue;
+			switch (selection.kind) {
+				case graphql.Kind.FIELD: {
+					const fieldName = selection.name.value;
+					currentFields.add(fieldName);
+					if (selection.selectionSet != null) {
+						const fieldPath = parentPath ? `${parentPath}.${fieldName}` : fieldName;
+						this.collectFields(selection.selectionSet, fieldPath, currentDepth + 1);
+					}
+					break;
+				}
+				case graphql.Kind.INLINE_FRAGMENT:
+					if (selection.selectionSet) this.collectFields(selection.selectionSet, parentPath, currentDepth);
+					break;
+				case graphql.Kind.FRAGMENT_SPREAD: {
+					const fragmentName = selection.name.value;
+					if (this.visitedFragments.has(fragmentName)) continue;
+					this.visitedFragments.add(fragmentName);
+					const fragment = this.info.fragments[fragmentName];
+					if (fragment) this.collectFields(fragment.selectionSet, parentPath, currentDepth);
+					break;
+				}
+			}
+		}
+	}
+	/**
+	* Extracts the boolean value from a directive's 'if' argument.
+	* Handles both literal boolean values and variables.
+	*
+	* @param directive - The directive node to extract value from
+	* @returns The boolean value of the directive's condition
+	*/
+	getDirectiveValue(directive) {
+		const ifArg = directive.arguments?.find((arg) => arg.name.value === "if");
+		if (!ifArg) return true;
+		const value = ifArg.value;
+		if (value.kind === graphql.Kind.BOOLEAN) return value.value;
+		if (value.kind === graphql.Kind.VARIABLE) {
+			const variableName = value.name.value;
+			return this.info.variableValues?.[variableName] === true;
+		}
+		return true;
+	}
+	/**
+	* Determines if a selection node should be included based on its directives.
+	* Handles both @include and @skip directives.
+	*
+	* @param node - The selection node to check
+	* @returns Whether the node should be included
+	*/
+	shouldIncludeNode(node) {
+		if (!node.directives?.length) return true;
+		return node.directives.every((directive) => {
+			if (directive.name.value === "include") return this.getDirectiveValue(directive);
+			if (directive.name.value === "skip") return !this.getDirectiveValue(directive);
+			return true;
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/symbols.ts
+var symbols_exports = /* @__PURE__ */ __export({
+	CONTEXT_MAP_KEY: () => CONTEXT_MAP_KEY,
+	FIELD_HIDDEN: () => FIELD_HIDDEN,
+	GET_GRAPHQL_TYPE: () => GET_GRAPHQL_TYPE,
+	IS_RESOLVER: () => IS_RESOLVER,
+	RESOLVER_OPTIONS_KEY: () => RESOLVER_OPTIONS_KEY,
+	WEAVER_CONFIG: () => WEAVER_CONFIG
+});
+/**
+* The symbol to get GraphQL type for schema
+*/
+const GET_GRAPHQL_TYPE = Symbol.for("gqloom.get_graphql_type");
+/**
+* The symbol to get and store weaver config
+*/
+const WEAVER_CONFIG = Symbol.for("gqloom.weaver_config");
+/**
+* The symbol to get resolver options
+*/
+const RESOLVER_OPTIONS_KEY = Symbol.for("gqloom.resolver-options");
+/**
+* The symbol to check if an object is a resolver
+*/
+const IS_RESOLVER = Symbol.for("gqloom.is-resolver");
+/**
+* The symbol to assign a WeakMap to an object
+*/
+const CONTEXT_MAP_KEY = Symbol.for("gqloom.context-map");
+/**
+* Set fields to be hidden
+*/
+const FIELD_HIDDEN = false;
+
+//#endregion
+//#region src/utils/context.ts
+/**
+* Create an empty memoization payload for the resolver
+* @returns the empty memoization payload
+*/
+function onlyMemoization() {
+	return {
+		memoization: /* @__PURE__ */ new WeakMap(),
+		isMemoization: true
+	};
+}
+function isOnlyMemoryPayload(payload) {
+	return payload.isMemoization === true;
+}
+function getMemoizationMap(payload) {
+	if (isOnlyMemoryPayload(payload)) return payload.memoization;
+	if (typeof payload.context === "undefined") Object.defineProperty(payload, "context", { value: {} });
+	return assignContextMap(payload.context);
+}
+function assignContextMap(target) {
+	target[CONTEXT_MAP_KEY] ??= /* @__PURE__ */ new WeakMap();
+	return target[CONTEXT_MAP_KEY];
+}
+
+//#endregion
+Object.defineProperty(exports, 'DERIVED_DEPENDENCIES', {
+  enumerable: true,
+  get: function () {
+    return DERIVED_DEPENDENCIES;
+  }
+});
+Object.defineProperty(exports, 'FIELD_HIDDEN', {
+  enumerable: true,
+  get: function () {
+    return FIELD_HIDDEN;
+  }
+});
+Object.defineProperty(exports, 'GET_GRAPHQL_TYPE', {
+  enumerable: true,
+  get: function () {
+    return GET_GRAPHQL_TYPE;
+  }
+});
+Object.defineProperty(exports, 'IS_RESOLVER', {
+  enumerable: true,
+  get: function () {
+    return IS_RESOLVER;
+  }
+});
+Object.defineProperty(exports, 'WEAVER_CONFIG', {
+  enumerable: true,
+  get: function () {
+    return WEAVER_CONFIG;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'assignContextMap', {
+  enumerable: true,
+  get: function () {
+    return assignContextMap;
+  }
+});
+Object.defineProperty(exports, 'getDeepResolvingFields', {
+  enumerable: true,
+  get: function () {
+    return getDeepResolvingFields;
+  }
+});
+Object.defineProperty(exports, 'getMemoizationMap', {
+  enumerable: true,
+  get: function () {
+    return getMemoizationMap;
+  }
+});
+Object.defineProperty(exports, 'getResolvingFields', {
+  enumerable: true,
+  get: function () {
+    return getResolvingFields;
+  }
+});
+Object.defineProperty(exports, 'isOnlyMemoryPayload', {
+  enumerable: true,
+  get: function () {
+    return isOnlyMemoryPayload;
+  }
+});
+Object.defineProperty(exports, 'onlyMemoization', {
+  enumerable: true,
+  get: function () {
+    return onlyMemoization;
+  }
+});
+Object.defineProperty(exports, 'parseResolvingFields', {
+  enumerable: true,
+  get: function () {
+    return parseResolvingFields;
+  }
+});
+Object.defineProperty(exports, 'symbols_exports', {
+  enumerable: true,
+  get: function () {
+    return symbols_exports;
+  }
+});