@soda-gql/core 0.0.1

package/dist/index.cjs

@@ -0,0 +1,733 @@
+//#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 __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
+const require_slice = require('./slice-DhwBAhCw.cjs');
+let graphql = require("graphql");
+graphql = __toESM(graphql);
+
+//#region packages/core/src/composer/build-document.ts
+const buildArgumentValue = (value) => {
+	if (value === void 0) return null;
+	if (value === null) return { kind: graphql.Kind.NULL };
+	if (value instanceof require_slice.VarRef) return {
+		kind: graphql.Kind.VARIABLE,
+		name: {
+			kind: graphql.Kind.NAME,
+			value: value.name
+		}
+	};
+	if (Array.isArray(value)) return {
+		kind: graphql.Kind.LIST,
+		values: value.map((item) => buildArgumentValue(item)).filter((item) => item !== null)
+	};
+	if (typeof value === "object") return {
+		kind: graphql.Kind.OBJECT,
+		fields: Object.entries(value).map(([key, value$1]) => {
+			const valueNode = buildArgumentValue(value$1);
+			return valueNode ? {
+				kind: graphql.Kind.OBJECT_FIELD,
+				name: {
+					kind: graphql.Kind.NAME,
+					value: key
+				},
+				value: valueNode
+			} : null;
+		}).filter((item) => item !== null)
+	};
+	if (typeof value === "string") return {
+		kind: graphql.Kind.STRING,
+		value
+	};
+	if (typeof value === "number") return {
+		kind: !Number.isInteger(value) || value.toString().includes(".") ? graphql.Kind.FLOAT : graphql.Kind.INT,
+		value: value.toString()
+	};
+	if (typeof value === "boolean") return {
+		kind: graphql.Kind.BOOLEAN,
+		value
+	};
+	throw new Error(`Unknown value type: ${typeof value}`);
+};
+const buildArguments = (args) => Object.entries(args ?? {}).map(([name, value]) => {
+	const valueNode = buildArgumentValue(value);
+	return valueNode ? {
+		kind: graphql.Kind.ARGUMENT,
+		name: {
+			kind: graphql.Kind.NAME,
+			value: name
+		},
+		value: valueNode
+	} : null;
+}).filter((item) => item !== null);
+const buildUnionSelection = (union) => Object.entries(union).map(([typeName, object]) => {
+	return object ? {
+		kind: graphql.Kind.INLINE_FRAGMENT,
+		typeCondition: {
+			kind: graphql.Kind.NAMED_TYPE,
+			name: {
+				kind: graphql.Kind.NAME,
+				value: typeName
+			}
+		},
+		selectionSet: {
+			kind: graphql.Kind.SELECTION_SET,
+			selections: buildField(object)
+		}
+	} : null;
+}).filter((item) => item !== null);
+const buildField = (field) => Object.entries(field).map(([alias, { args, field: field$1, object, union }]) => ({
+	kind: graphql.Kind.FIELD,
+	name: {
+		kind: graphql.Kind.NAME,
+		value: field$1
+	},
+	alias: alias !== field$1 ? {
+		kind: graphql.Kind.NAME,
+		value: alias
+	} : void 0,
+	arguments: buildArguments(args),
+	selectionSet: object ? {
+		kind: graphql.Kind.SELECTION_SET,
+		selections: buildField(object)
+	} : union ? {
+		kind: graphql.Kind.SELECTION_SET,
+		selections: buildUnionSelection(union)
+	} : void 0
+}));
+const buildConstValueNode = (value) => {
+	if (value === void 0) return null;
+	if (value === null) return { kind: graphql.Kind.NULL };
+	if (typeof value === "string") return {
+		kind: graphql.Kind.STRING,
+		value
+	};
+	if (typeof value === "boolean") return {
+		kind: graphql.Kind.BOOLEAN,
+		value
+	};
+	if (typeof value === "number") return {
+		kind: !Number.isInteger(value) || value.toString().includes(".") ? graphql.Kind.FLOAT : graphql.Kind.INT,
+		value: value.toString()
+	};
+	if (Array.isArray(value)) return {
+		kind: graphql.Kind.LIST,
+		values: value.map((item) => buildConstValueNode(item)).filter((item) => item !== null)
+	};
+	if (typeof value === "object") return {
+		kind: graphql.Kind.OBJECT,
+		fields: Object.entries(value).map(([key, value$1]) => {
+			const valueNode = buildConstValueNode(value$1);
+			return valueNode ? {
+				kind: graphql.Kind.OBJECT_FIELD,
+				name: {
+					kind: graphql.Kind.NAME,
+					value: key
+				},
+				value: valueNode
+			} : null;
+		}).filter((item) => item !== null)
+	};
+	throw new Error(`Unknown value type: ${typeof value}`);
+};
+const buildWithTypeModifier = (modifier, buildType) => {
+	const baseType = buildType();
+	if (modifier === "?") return baseType;
+	let curr = {
+		modifier,
+		type: baseType
+	};
+	while (curr.modifier.length > 0) {
+		if (curr.modifier.startsWith("!")) {
+			curr = {
+				modifier: curr.modifier.slice(1),
+				type: curr.type.kind === graphql.Kind.NON_NULL_TYPE ? curr.type : {
+					kind: graphql.Kind.NON_NULL_TYPE,
+					type: curr.type
+				}
+			};
+			continue;
+		}
+		if (curr.modifier.startsWith("[]")) {
+			curr = {
+				modifier: curr.modifier.slice(2),
+				type: {
+					kind: graphql.Kind.LIST_TYPE,
+					type: curr.type
+				}
+			};
+			continue;
+		}
+		throw new Error(`Unknown modifier: ${curr.modifier}`);
+	}
+	return curr.type;
+};
+const buildVariables = (variables) => {
+	return Object.entries(variables).map(([name, ref]) => ({
+		kind: graphql.Kind.VARIABLE_DEFINITION,
+		variable: {
+			kind: graphql.Kind.VARIABLE,
+			name: {
+				kind: graphql.Kind.NAME,
+				value: name
+			}
+		},
+		defaultValue: ref.defaultValue && buildConstValueNode(ref.defaultValue.default) || void 0,
+		type: buildWithTypeModifier(ref.modifier, () => ({
+			kind: graphql.Kind.NAMED_TYPE,
+			name: {
+				kind: graphql.Kind.NAME,
+				value: ref.name
+			}
+		}))
+	}));
+};
+const buildOperationTypeNode = (operation) => {
+	switch (operation) {
+		case "query": return graphql.OperationTypeNode.QUERY;
+		case "mutation": return graphql.OperationTypeNode.MUTATION;
+		case "subscription": return graphql.OperationTypeNode.SUBSCRIPTION;
+		default: throw new Error(`Unknown operation type: ${operation}`);
+	}
+};
+const buildDocument = (options) => {
+	const { operationName, operationType, variables, fields } = options;
+	return {
+		kind: graphql.Kind.DOCUMENT,
+		definitions: [{
+			kind: graphql.Kind.OPERATION_DEFINITION,
+			operation: buildOperationTypeNode(operationType),
+			name: {
+				kind: graphql.Kind.NAME,
+				value: operationName
+			},
+			variableDefinitions: buildVariables(variables),
+			selectionSet: {
+				kind: graphql.Kind.SELECTION_SET,
+				selections: buildField(fields)
+			}
+		}]
+	};
+};
+
+//#endregion
+//#region packages/core/src/types/element/gql-element.ts
+const GQL_ELEMENT_FACTORY = Symbol("GQL_ELEMENT_FACTORY");
+const GQL_ELEMENT_CONTEXT = Symbol("GQL_ELEMENT_CONTEXT");
+var GqlElement = class GqlElement {
+	[GQL_ELEMENT_FACTORY];
+	[GQL_ELEMENT_CONTEXT] = null;
+	constructor(define$1) {
+		let cache = null;
+		this[GQL_ELEMENT_FACTORY] = (context) => {
+			if (cache) return cache.value;
+			const value = define$1(context);
+			cache = { value };
+			return value;
+		};
+	}
+	static setContext(element, context) {
+		element[GQL_ELEMENT_CONTEXT] = context;
+	}
+	static evaluate(element) {
+		GqlElement.get(element);
+	}
+	static get(element) {
+		const context = element[GQL_ELEMENT_CONTEXT];
+		return element[GQL_ELEMENT_FACTORY](context);
+	}
+};
+
+//#endregion
+//#region packages/core/src/types/element/composed-operation.ts
+var ComposedOperation = class ComposedOperation extends GqlElement {
+	constructor(define$1) {
+		super(define$1);
+	}
+	get operationType() {
+		return GqlElement.get(this).operationType;
+	}
+	get operationName() {
+		return GqlElement.get(this).operationName;
+	}
+	get variableNames() {
+		return GqlElement.get(this).variableNames;
+	}
+	get projectionPathGraph() {
+		return GqlElement.get(this).projectionPathGraph;
+	}
+	get document() {
+		return GqlElement.get(this).document;
+	}
+	get parse() {
+		return GqlElement.get(this).parse;
+	}
+	static create(define$1) {
+		return new ComposedOperation(define$1);
+	}
+};
+
+//#endregion
+//#region packages/core/src/types/element/fields-builder.ts
+const mergeFields = (fields) => Object.assign({}, ...fields);
+
+//#endregion
+//#region packages/core/src/types/element/inline-operation.ts
+var InlineOperation = class InlineOperation extends GqlElement {
+	constructor(define$1) {
+		super(define$1);
+	}
+	get operationType() {
+		return GqlElement.get(this).operationType;
+	}
+	get operationName() {
+		return GqlElement.get(this).operationName;
+	}
+	get variableNames() {
+		return GqlElement.get(this).variableNames;
+	}
+	get documentSource() {
+		return GqlElement.get(this).documentSource;
+	}
+	get document() {
+		return GqlElement.get(this).document;
+	}
+	static create(define$1) {
+		return new InlineOperation(define$1);
+	}
+};
+
+//#endregion
+//#region packages/core/src/types/element/model.ts
+var Model = class Model extends GqlElement {
+	constructor(define$1) {
+		super(define$1);
+	}
+	get typename() {
+		return GqlElement.get(this).typename;
+	}
+	get fragment() {
+		return GqlElement.get(this).fragment;
+	}
+	get normalize() {
+		return GqlElement.get(this).normalize;
+	}
+	static create(define$1) {
+		return new Model(define$1);
+	}
+};
+
+//#endregion
+//#region packages/core/src/types/element/slice.ts
+var Slice = class Slice extends GqlElement {
+	constructor(define$1) {
+		super(define$1);
+	}
+	get operationType() {
+		return GqlElement.get(this).operationType;
+	}
+	get embed() {
+		return GqlElement.get(this).embed;
+	}
+	static create(define$1) {
+		return new Slice(define$1);
+	}
+};
+
+//#endregion
+//#region packages/core/src/composer/projection-path-graph.ts
+function createPathGraph(paths) {
+	const intermediate = paths.reduce((acc, { label, raw, segments: [segment, ...segments] }) => {
+		if (segment) (acc[segment] || (acc[segment] = [])).push({
+			label,
+			raw,
+			segments
+		});
+		return acc;
+	}, {});
+	return {
+		matches: paths.map(({ label, raw, segments }) => ({
+			label,
+			path: raw,
+			exact: segments.length === 0
+		})),
+		children: require_slice.mapValues(intermediate, (paths$1) => createPathGraph(paths$1))
+	};
+}
+function createPathGraphFromSliceEntries(fragments) {
+	return createPathGraph(Object.entries(fragments).flatMap(([label, slice]) => Array.from(new Map(slice.projection.paths.map(({ full: raw, segments }) => {
+		const [first, ...rest] = segments;
+		return [raw, {
+			label,
+			raw,
+			segments: [`${label}_${first}`, ...rest]
+		}];
+	})).values())));
+}
+
+//#endregion
+//#region packages/core/src/composer/composed-operation.ts
+const createComposedOperationComposerFactory = () => {
+	return (operationType) => {
+		return (options, builder) => {
+			return ComposedOperation.create(() => {
+				const { operationName } = options;
+				const variables = require_slice.mergeVarDefinitions(options.variables ?? []);
+				const fragments = builder({ $: require_slice.createVarRefs(variables) });
+				const fields = Object.fromEntries(Object.entries(fragments).flatMap(([label, { getFields: fields$1 }]) => Object.entries(fields$1).map(([key, reference]) => [`${label}_${key}`, reference])));
+				const projectionPathGraph = createPathGraphFromSliceEntries(fragments);
+				return {
+					operationType,
+					operationName,
+					variableNames: Object.keys(variables),
+					projectionPathGraph,
+					document: buildDocument({
+						operationName,
+						operationType,
+						variables,
+						fields
+					}),
+					parse: require_slice.createExecutionResultParser({
+						fragments,
+						projectionPathGraph
+					})
+				};
+			});
+		};
+	};
+};
+
+//#endregion
+//#region packages/core/src/utils/wrap-by-key.ts
+const wrapByKey = (name, value) => ({ [name]: value });
+
+//#endregion
+//#region packages/core/src/composer/fields-builder.ts
+const cacheMapBySchema = /* @__PURE__ */ new WeakMap();
+const ensureCacheMapBySchema = (schema) => {
+	const cachedCacheMap = cacheMapBySchema.get(schema);
+	if (cachedCacheMap) return cachedCacheMap;
+	const cacheMap = /* @__PURE__ */ new Map();
+	cacheMapBySchema.set(schema, cacheMap);
+	return cacheMap;
+};
+const createFieldFactories = (schema, typeName) => {
+	const cacheMap = ensureCacheMapBySchema(schema);
+	const cached = cacheMap.get(typeName);
+	if (cached) return cached;
+	const factories = createFieldFactoriesInner(schema, typeName);
+	cacheMap.set(typeName, factories);
+	return factories;
+};
+const createFieldFactoriesInner = (schema, typeName) => {
+	const typeDef = schema.object[typeName];
+	if (!typeDef) throw new Error(`Type ${typeName} is not defined in schema objects`);
+	const entries = Object.entries(typeDef.fields).map(([fieldName, type]) => {
+		const factory = (fieldArgs, extras) => {
+			const wrap = (value) => wrapByKey(extras?.alias ?? fieldName, value);
+			if (type.kind === "object") {
+				const factoryReturn = ((nest) => wrap({
+					parent: typeName,
+					field: fieldName,
+					type,
+					args: fieldArgs ?? {},
+					directives: extras?.directives ?? {},
+					object: mergeFields(nest({ f: createFieldFactories(schema, type.name) })),
+					union: null
+				}));
+				return factoryReturn;
+			}
+			if (type.kind === "union") {
+				const factoryReturn = ((nest) => wrap({
+					parent: typeName,
+					field: fieldName,
+					type,
+					args: fieldArgs ?? {},
+					directives: extras?.directives ?? {},
+					object: null,
+					union: require_slice.mapValues(nest, (builder, memberName) => {
+						if (!builder) throw new Error(`Builder is undefined for member name: ${memberName}`);
+						return mergeFields(builder({ f: createFieldFactories(schema, memberName) }));
+					})
+				}));
+				return factoryReturn;
+			}
+			if (type.kind === "scalar" || type.kind === "enum" || type.kind === "typename") return wrap({
+				parent: typeName,
+				field: fieldName,
+				type,
+				args: fieldArgs ?? {},
+				directives: extras?.directives ?? {},
+				object: null,
+				union: null
+			});
+			throw new Error(`Unsupported field type: ${type}`);
+		};
+		return [fieldName, factory];
+	});
+	return Object.fromEntries(entries);
+};
+
+//#endregion
+//#region packages/core/src/composer/inline-operation.ts
+const createInlineOperationComposerFactory = (schema) => {
+	return (operationType) => {
+		const operationTypeName = schema.operations[operationType];
+		if (operationTypeName === null) throw new Error(`Operation type ${operationType} is not defined in schema roots`);
+		return (options, fieldBuilder) => {
+			return InlineOperation.create(() => {
+				const { operationName } = options;
+				const variables = require_slice.mergeVarDefinitions(options.variables ?? []);
+				const $ = require_slice.createVarRefs(variables);
+				const fields = mergeFields(fieldBuilder({
+					f: createFieldFactories(schema, operationTypeName),
+					$
+				}));
+				return {
+					operationType,
+					operationName,
+					variableNames: Object.keys(variables),
+					documentSource: () => fields,
+					document: buildDocument({
+						operationName,
+						operationType,
+						variables,
+						fields
+					})
+				};
+			});
+		};
+	};
+};
+
+//#endregion
+//#region packages/core/src/composer/model.ts
+const createGqlModelComposers = (schema) => {
+	const createModelComposer = (typename) => {
+		return (options, builder, normalize) => Model.create(() => {
+			const varDefinitions = require_slice.mergeVarDefinitions(options.variables ?? []);
+			return {
+				typename,
+				fragment: (variables) => {
+					return mergeFields(builder({
+						f: createFieldFactories(schema, typename),
+						$: require_slice.createVarAssignments(varDefinitions, variables)
+					}));
+				},
+				normalize
+			};
+		});
+	};
+	return require_slice.mapValues(schema.object, (_, typename) => createModelComposer(typename));
+};
+
+//#endregion
+//#region packages/core/src/composer/slice.ts
+const createSliceComposerFactory = (schema) => {
+	return (operationType) => {
+		const operationTypeName = schema.operations[operationType];
+		if (operationTypeName === null) throw new Error(`Operation type ${operationType} is not defined in schema roots`);
+		return (options, fieldBuilder, projectionBuilder) => Slice.create(() => {
+			const varDefinitions = require_slice.mergeVarDefinitions(options.variables ?? []);
+			const projection = require_slice.handleProjectionBuilder(projectionBuilder);
+			return {
+				operationType,
+				embed: (variables) => {
+					const fields = mergeFields(fieldBuilder({
+						f: createFieldFactories(schema, operationTypeName),
+						$: require_slice.createVarAssignments(varDefinitions, variables)
+					}));
+					return {
+						variables,
+						getFields: () => fields,
+						projection
+					};
+				}
+			};
+		});
+	};
+};
+
+//#endregion
+//#region packages/core/src/types/schema/type-modifier.ts
+const parseModifiedTypeName = (nameAndModifier) => {
+	if (typeof nameAndModifier !== "string") throw new Error(`Invalid modified type name: ${nameAndModifier}`);
+	const [name, modifier] = nameAndModifier.split(":");
+	return {
+		name,
+		modifier
+	};
+};
+
+//#endregion
+//#region packages/core/src/composer/var-builder.ts
+const createVarBuilder = (schema) => {
+	const $ = (varName) => {
+		const createRefBuilder = (kind) => {
+			return (type, extras) => wrapByKey(varName, {
+				kind,
+				...parseModifiedTypeName(type),
+				defaultValue: extras?.default ? { default: extras.default() } : null,
+				directives: extras?.directives ?? {}
+			});
+		};
+		return {
+			scalar: createRefBuilder("scalar"),
+			enum: createRefBuilder("enum"),
+			input: createRefBuilder("input"),
+			byField: (typeName, fieldName, argName) => {
+				const argTypeRef = schema.object[typeName]?.fields[fieldName]?.arguments[argName];
+				if (!argTypeRef) throw new Error(`Argument ${argName} not found in field ${fieldName} of type ${typeName}`);
+				return { ...argTypeRef };
+			}
+		};
+	};
+	return { $ };
+};
+
+//#endregion
+//#region packages/core/src/composer/gql-composer.ts
+const createGqlElementComposer = (schema) => {
+	const model = createGqlModelComposers(schema);
+	const createSliceComposer = createSliceComposerFactory(schema);
+	const createComposedOperationFactory = createComposedOperationComposerFactory();
+	const createInlineOperationComposer = createInlineOperationComposerFactory(schema);
+	const composers = {
+		model,
+		query: {
+			slice: createSliceComposer("query"),
+			composed: createComposedOperationFactory("query"),
+			inline: createInlineOperationComposer("query")
+		},
+		mutation: {
+			slice: createSliceComposer("mutation"),
+			composed: createComposedOperationFactory("mutation"),
+			inline: createInlineOperationComposer("mutation")
+		},
+		subscription: {
+			slice: createSliceComposer("subscription"),
+			composed: createComposedOperationFactory("subscription"),
+			inline: createInlineOperationComposer("subscription")
+		}
+	};
+	const helper = { ...createVarBuilder(schema) };
+	const elementComposer = (composeElement) => composeElement(composers, helper);
+	return elementComposer;
+};
+
+//#endregion
+//#region packages/core/src/schema/type-specifier-builder.ts
+const createUnsafeInputTypeSpecifierFactory = (kind) => {
+	return (type, extras) => ({
+		kind,
+		...parseModifiedTypeName(type),
+		defaultValue: extras.default ? { default: extras.default() } : null,
+		directives: extras.directives ?? {}
+	});
+};
+const unsafeInputType = {
+	scalar: createUnsafeInputTypeSpecifierFactory("scalar"),
+	enum: createUnsafeInputTypeSpecifierFactory("enum"),
+	input: createUnsafeInputTypeSpecifierFactory("input")
+};
+const createUnsafeOutputTypeSpecifierFactory = (kind) => {
+	return (type, extras) => ({
+		kind,
+		...parseModifiedTypeName(type),
+		arguments: extras.arguments ?? {},
+		directives: extras.directives ?? {}
+	});
+};
+const unsafeOutputType = {
+	scalar: createUnsafeOutputTypeSpecifierFactory("scalar"),
+	enum: createUnsafeOutputTypeSpecifierFactory("enum"),
+	object: createUnsafeOutputTypeSpecifierFactory("object"),
+	union: createUnsafeOutputTypeSpecifierFactory("union"),
+	typename: createUnsafeOutputTypeSpecifierFactory("typename")
+};
+
+//#endregion
+//#region packages/core/src/schema/schema-builder.ts
+const defineScalar = (name, definition) => wrapByKey(name, {
+	_type: require_slice.hidden(),
+	name,
+	directives: definition({ type: require_slice.hidden }).directives
+});
+const define = (name) => ({
+	enum: (values, directives) => ({
+		_type: require_slice.hidden(),
+		name,
+		values,
+		directives
+	}),
+	input: (fields, directives) => ({
+		name,
+		fields,
+		directives
+	}),
+	object: (fields, directives) => ({
+		name,
+		fields: {
+			__typename: unsafeOutputType.typename(`${name}:!`, {}),
+			...fields
+		},
+		directives
+	}),
+	union: (types, directives) => ({
+		name,
+		types,
+		directives
+	})
+});
+const defineOperationRoots = (operationRoots) => operationRoots;
+
+//#endregion
+exports.ComposedOperation = ComposedOperation;
+exports.GqlElement = GqlElement;
+exports.InlineOperation = InlineOperation;
+exports.Model = Model;
+exports.Projection = require_slice.Projection;
+exports.Slice = Slice;
+exports.SlicedExecutionResultEmpty = require_slice.SlicedExecutionResultEmpty;
+exports.SlicedExecutionResultError = require_slice.SlicedExecutionResultError;
+exports.SlicedExecutionResultSuccess = require_slice.SlicedExecutionResultSuccess;
+exports.buildArgumentValue = buildArgumentValue;
+exports.buildConstValueNode = buildConstValueNode;
+exports.buildDocument = buildDocument;
+exports.buildOperationTypeNode = buildOperationTypeNode;
+exports.buildWithTypeModifier = buildWithTypeModifier;
+exports.createComposedOperationComposerFactory = createComposedOperationComposerFactory;
+exports.createFieldFactories = createFieldFactories;
+exports.createGqlElementComposer = createGqlElementComposer;
+exports.createGqlModelComposers = createGqlModelComposers;
+exports.createPathGraphFromSliceEntries = createPathGraphFromSliceEntries;
+exports.createSliceComposerFactory = createSliceComposerFactory;
+exports.createVarAssignments = require_slice.createVarAssignments;
+exports.createVarBuilder = createVarBuilder;
+exports.createVarRefs = require_slice.createVarRefs;
+exports.define = define;
+exports.defineOperationRoots = defineOperationRoots;
+exports.defineScalar = defineScalar;
+exports.mergeFields = mergeFields;
+exports.mergeVarDefinitions = require_slice.mergeVarDefinitions;
+exports.unsafeInputType = unsafeInputType;
+exports.unsafeOutputType = unsafeOutputType;