@soda-gql/core 0.0.9 → 0.2.0

package/dist/index.js

@@ -1,6 +1,53 @@
-import { a as createVarRefs, c as createExecutionResultParser, d as SlicedExecutionResultSuccess, f as Projection, i as createVarAssignments, l as SlicedExecutionResultEmpty, n as handleProjectionBuilder, o as mergeVarDefinitions, p as VarRef, s as mapValues, u as SlicedExecutionResultError } from "./slice-ua5mSfhV.js";
+import { a as unsafeOutputType, i as unsafeInputType, n as defineOperationRoots, o as parseModifiedTypeName, r as defineScalar, s as wrapByKey, t as define } from "./schema-D9wIW5Dl.js";
 import { Kind, OperationTypeNode } from "graphql";
 
+//#region packages/core/src/types/type-foundation/var-ref.ts
+var VarRef = class {
+	constructor(inner) {
+		this.inner = inner;
+	}
+	static getInner(varRef) {
+		return varRef.inner;
+	}
+};
+const isVarRef = (value) => {
+	return typeof value === "object" && value !== null && value instanceof VarRef;
+};
+const createVarRefFromVariable = (name) => {
+	return new VarRef({
+		type: "variable",
+		name
+	});
+};
+const createVarRefFromConstValue = (value) => {
+	return new VarRef({
+		type: "const-value",
+		value
+	});
+};
+const getVarRefInner = (varRef) => {
+	return VarRef.getInner(varRef);
+};
+/**
+* Get the variable name from a VarRef.
+* Throws if the VarRef contains a const-value instead of a variable reference.
+*/
+const getVarRefName = (varRef) => {
+	const inner = VarRef.getInner(varRef);
+	if (inner.type !== "variable") throw new Error("Expected variable reference, got const-value");
+	return inner.name;
+};
+/**
+* Get the const value from a VarRef.
+* Throws if the VarRef contains a variable reference instead of a const-value.
+*/
+const getVarRefValue = (varRef) => {
+	const inner = VarRef.getInner(varRef);
+	if (inner.type !== "const-value") throw new Error("Expected const-value, got variable reference");
+	return inner.value;
+};
+
+//#endregion
 //#region packages/core/src/composer/build-document.ts
 const buildArgumentValue = (value) => {
 	if (value === void 0) return null;
@@ -235,6 +282,161 @@ const buildDocument = (options) => {
 	};
 };
 
+//#endregion
+//#region packages/core/src/composer/colocate.ts
+/**
+* Creates a $colocate helper function for fragment colocation.
+*
+* $colocate takes an object of { label: fields } and applies prefix-based
+* aliasing to each entry. This mirrors the structure of createExecutionResultParser
+* from @soda-gql/colocation-tools.
+*
+* @example
+* ```typescript
+* // In operation definition
+* query.operation({ name: "GetData" }, ({ f, $ }) => [
+*   $colocate({
+*     userCard: userCardFragment.embed({ userId: $.userId }),
+*     posts: postsFragment.embed({ userId: $.userId }),
+*   }),
+* ]);
+*
+* // In parser definition (same labels)
+* createExecutionResultParser({
+*   userCard: userCardProjection,
+*   posts: postsProjection,
+* });
+* ```
+*/
+const createColocateHelper = () => {
+	/**
+	* Colocate multiple field selections with labeled prefixes.
+	*
+	* @param entries - Object mapping labels to field selections
+	* @returns Merged object of all prefixed field entries
+	*/
+	const $colocate = (entries) => Object.fromEntries(Object.entries(entries).flatMap(([label, fields]) => Object.entries(fields).map(([key, value]) => [`${label}_${key}`, value])));
+	return $colocate;
+};
+
+//#endregion
+//#region packages/core/src/composer/field-path-context.ts
+/**
+* Shared mutable container for field path context.
+* Only synchronous access is supported.
+*/
+const fieldPathContext = { current: null };
+/**
+* Get the current field path.
+* Returns null if not in a field building context.
+*
+* @example
+* ```typescript
+* import { getCurrentFieldPath } from '@soda-gql/core';
+*
+* // Inside a field builder or model embed:
+* const path = getCurrentFieldPath();
+* console.log(path?.full); // "$.user.posts[].author"
+* ```
+*/
+const getCurrentFieldPath = () => fieldPathContext.current;
+/**
+* Run a function with a specific field path context.
+* Restores the previous path after the function completes.
+*
+* @internal
+*/
+const withFieldPath = (path, fn) => {
+	const previousPath = fieldPathContext.current;
+	fieldPathContext.current = path;
+	try {
+		return fn();
+	} finally {
+		fieldPathContext.current = previousPath;
+	}
+};
+/**
+* Append a new segment to the current path.
+*
+* @internal
+*/
+const appendToPath = (parent, segment) => {
+	const listSuffix = segment.isList ? "[]" : "";
+	const newSegment = {
+		field: segment.field,
+		parent: segment.parentType,
+		isList: segment.isList
+	};
+	if (!parent) return {
+		full: `$.${segment.field}${listSuffix}`,
+		segments: [newSegment]
+	};
+	return {
+		full: `${parent.full}.${segment.field}${listSuffix}`,
+		segments: [...parent.segments, newSegment]
+	};
+};
+/**
+* Check if a type specifier represents a list type.
+* Matches patterns like "Type:![]!", "Type:![]?", "Type:?[]!", etc.
+*
+* @internal
+*/
+const isListType = (typeString) => {
+	return typeString.includes("[]");
+};
+
+//#endregion
+//#region packages/core/src/types/element/fields-builder.ts
+const mergeFields = (fields) => Object.assign({}, ...fields);
+
+//#endregion
+//#region packages/core/src/types/element/lazy-evaluator.ts
+/**
+* Creates a lazy evaluator with caching, async support, and dependency ordering.
+*
+* @param define - Factory function that produces the value
+* @param getDeps - Optional function returning dependencies to evaluate first
+* @param createDepGenerator - Function to create evaluation generator for a dependency
+* @returns An executor generator function
+*/
+const createLazyEvaluator = (define$1, getDeps, createDepGenerator) => {
+	let cache = null;
+	let promise = null;
+	return function* execute(context) {
+		if (cache) return cache.value;
+		if (promise) {
+			yield promise;
+			return cache.value;
+		}
+		if (getDeps) for (const dep of getDeps()) yield* createDepGenerator(dep);
+		const defined = define$1(context);
+		if (!(defined instanceof Promise)) return (cache = { value: defined }).value;
+		promise = defined.then((value) => {
+			cache = { value };
+			promise = null;
+		});
+		yield promise;
+		return cache.value;
+	};
+};
+/**
+* Creates an evaluation generator from an executor.
+* Wraps the executor's generator and discards its return value.
+*/
+function* createEvaluationGenerator(executor, context) {
+	yield* executor(context);
+}
+/**
+* Executes the evaluator synchronously.
+* Throws if async operation is encountered.
+*/
+const evaluateSync = (executor, context) => {
+	const result = executor(context).next();
+	if (!result.done) throw new Error("Async operation is not supported in sync evaluation.");
+	return result.value;
+};
+
 //#endregion
 //#region packages/core/src/types/element/gql-element.ts
 const GQL_ELEMENT_FACTORY = Symbol("GQL_ELEMENT_FACTORY");
@@ -242,66 +444,58 @@ 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;
-		};
+	constructor(define$1, getDeps) {
+		this[GQL_ELEMENT_FACTORY] = createLazyEvaluator(define$1, getDeps, GqlElement.createEvaluationGenerator);
 		Object.defineProperty(this, "$infer", { get() {
 			throw new Error("This property is only for type meta. Do not access this property directly.");
 		} });
 	}
+	attach(attachment) {
+		let cache = null;
+		Object.defineProperty(this, attachment.name, { get() {
+			if (cache) return cache;
+			GqlElement.evaluateInstantly(this);
+			return cache = attachment.createValue(this);
+		} });
+		return this;
+	}
 	static setContext(element, context) {
 		element[GQL_ELEMENT_CONTEXT] = context;
 	}
-	static evaluate(element) {
-		GqlElement.get(element);
+	static createEvaluationGenerator(element) {
+		return createEvaluationGenerator(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);
+	}
+	static evaluateInstantly(element) {
+		return evaluateSync(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);
+	}
+	static evaluateSync(element) {
+		GqlElement.evaluateInstantly(element);
 	}
 	static get(element) {
-		const context = element[GQL_ELEMENT_CONTEXT];
-		return element[GQL_ELEMENT_FACTORY](context);
+		return GqlElement.evaluateInstantly(element);
 	}
 };
 
 //#endregion
-//#region packages/core/src/types/element/composed-operation.ts
-var ComposedOperation = class ComposedOperation extends GqlElement {
+//#region packages/core/src/types/element/fragment.ts
+var Fragment = class Fragment 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 typename() {
+		return GqlElement.get(this).typename;
 	}
-	get parse() {
-		return GqlElement.get(this).parse;
+	get embed() {
+		return GqlElement.get(this).embed;
 	}
 	static create(define$1) {
-		return new ComposedOperation(define$1);
+		return new Fragment(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 {
+//#region packages/core/src/types/element/operation.ts
+var Operation = class Operation extends GqlElement {
 	constructor(define$1) {
 		super(define$1);
 	}
@@ -320,115 +514,18 @@ var InlineOperation = class InlineOperation extends GqlElement {
 	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;
+	get metadata() {
+		return GqlElement.get(this).metadata;
 	}
 	static create(define$1) {
-		return new Slice(define$1);
+		return new Operation(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: 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 = mergeVarDefinitions(options.variables ?? []);
-				const fragments = builder({ $: 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: createExecutionResultParser({
-						fragments,
-						projectionPathGraph
-					})
-				};
-			});
-		};
-	};
-};
-
-//#endregion
-//#region packages/core/src/utils/wrap-by-key.ts
-function wrapByKey(name, value) {
-	return { [name]: value };
+//#region packages/core/src/utils/map-values.ts
+function mapValues(obj, fn) {
+	return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value, key)]));
 }
 
 //#endregion
@@ -456,30 +553,44 @@ const createFieldFactoriesInner = (schema, typeName) => {
 		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
-				}));
+				const factoryReturn = ((nest) => {
+					const nestedFields = withFieldPath(appendToPath(getCurrentFieldPath(), {
+						field: fieldName,
+						parentType: typeName,
+						isList: isListType(type.modifier)
+					}), () => mergeFields(nest({ f: createFieldFactories(schema, type.name) })));
+					return wrap({
+						parent: typeName,
+						field: fieldName,
+						type,
+						args: fieldArgs ?? {},
+						directives: extras?.directives ?? {},
+						object: nestedFields,
+						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: mapValues(nest, (builder, memberName) => {
+				const factoryReturn = ((nest) => {
+					const nestedUnion = withFieldPath(appendToPath(getCurrentFieldPath(), {
+						field: fieldName,
+						parentType: typeName,
+						isList: isListType(type.modifier)
+					}), () => mapValues(nest, (builder, memberName) => {
 						if (!builder) throw new Error(`Builder is undefined for member name: ${memberName}`);
 						return mergeFields(builder({ f: createFieldFactories(schema, memberName) }));
-					})
-				}));
+					}));
+					return wrap({
+						parent: typeName,
+						field: fieldName,
+						type,
+						args: fieldArgs ?? {},
+						directives: extras?.directives ?? {},
+						object: null,
+						union: nestedUnion
+					});
+				});
 				return factoryReturn;
 			}
 			if (type.kind === "scalar" || type.kind === "enum" || type.kind === "typename") return wrap({
@@ -499,100 +610,157 @@ const createFieldFactoriesInner = (schema, typeName) => {
 };
 
 //#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 = mergeVarDefinitions(options.variables ?? []);
-				const $ = 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
-					})
-				};
-			});
+//#region packages/core/src/composer/fragment-usage-context.ts
+/**
+* Shared mutable container for collecting fragment usages.
+* Only synchronous access is supported.
+*/
+const fragmentUsageContext = { current: null };
+/**
+* Run a function with fragment usage collection enabled.
+* Returns both the function result and collected fragment usages.
+*
+* @internal
+*/
+const withFragmentUsageCollection = (fn) => {
+	const previousCollector = fragmentUsageContext.current;
+	const usages = [];
+	fragmentUsageContext.current = usages;
+	try {
+		return {
+			result: fn(),
+			usages
 		};
-	};
+	} finally {
+		fragmentUsageContext.current = previousCollector;
+	}
+};
+/**
+* Record a fragment usage. Called when fragment.embed() is invoked.
+* No-op if not in a collection context.
+*
+* @internal
+*/
+const recordFragmentUsage = (record) => {
+	if (fragmentUsageContext.current) fragmentUsageContext.current.push(record);
+};
+
+//#endregion
+//#region packages/core/src/composer/input.ts
+const mergeVarDefinitions = (definitions) => Object.assign({}, ...definitions);
+const createVarAssignments = (definitions, providedValues) => {
+	return mapValues(definitions, (_definition, key) => {
+		const varName = key;
+		if (!providedValues || providedValues[varName] === void 0) return createVarRefFromConstValue(void 0);
+		const provided = providedValues[varName];
+		if (isVarRef(provided)) return provided;
+		return createVarRefFromConstValue(provided);
+	});
 };
+const createVarRefs = (definitions) => mapValues(definitions, (_ref, name) => createVarRefFromVariable(name));
 
 //#endregion
-//#region packages/core/src/composer/model.ts
-const createGqlModelComposers = (schema) => {
-	const createModelComposer = (typename) => {
-		return (options, builder, normalize) => Model.create(() => {
+//#region packages/core/src/composer/fragment.ts
+const createGqlFragmentComposers = (schema, _adapter) => {
+	const createFragmentComposer = (typename) => {
+		return (options, builder) => {
 			const varDefinitions = mergeVarDefinitions(options.variables ?? []);
-			return {
+			const { metadata } = options;
+			return Fragment.create(() => ({
 				typename,
-				fragment: (variables) => {
+				embed: (variables) => {
+					const f = createFieldFactories(schema, typename);
+					const $ = createVarAssignments(varDefinitions, variables);
+					recordFragmentUsage({
+						metadataBuilder: metadata ? () => metadata({ $ }) : null,
+						path: getCurrentFieldPath()
+					});
 					return mergeFields(builder({
-						f: createFieldFactories(schema, typename),
-						$: createVarAssignments(varDefinitions, variables)
+						f,
+						$
 					}));
-				},
-				normalize
-			};
-		});
+				}
+			}));
+		};
 	};
-	return mapValues(schema.object, (_, typename) => createModelComposer(typename));
+	return mapValues(schema.object, (_, typename) => createFragmentComposer(typename));
 };
 
 //#endregion
-//#region packages/core/src/composer/slice.ts
-const createSliceComposerFactory = (schema) => {
+//#region packages/core/src/types/metadata/adapter.ts
+/**
+* Creates the default adapter instance.
+* @internal
+*/
+const createDefaultAdapter = () => ({ aggregateFragmentMetadata: (fragments) => fragments.map((m) => m.metadata) });
+/**
+* The default adapter instance.
+*/
+const defaultMetadataAdapter = createDefaultAdapter();
+
+//#endregion
+//#region packages/core/src/composer/operation.ts
+const createOperationComposerFactory = (schema, adapter) => {
+	const resolvedAdapter = adapter ?? defaultMetadataAdapter;
 	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 = mergeVarDefinitions(options.variables ?? []);
-			const projection = handleProjectionBuilder(projectionBuilder);
-			return {
-				operationType,
-				embed: (variables) => {
-					const fields = mergeFields(fieldBuilder({
-						f: createFieldFactories(schema, operationTypeName),
-						$: createVarAssignments(varDefinitions, variables)
+		return (options, fieldBuilder) => {
+			return Operation.create(() => {
+				const { name: operationName } = options;
+				const variables = mergeVarDefinitions(options.variables ?? []);
+				const $ = createVarRefs(variables);
+				const f = createFieldFactories(schema, operationTypeName);
+				const { result: fields, usages: fragmentUsages } = withFragmentUsageCollection(() => mergeFields(fieldBuilder({
+					f,
+					$
+				})));
+				const document = buildDocument({
+					operationName,
+					operationType,
+					variables,
+					fields
+				});
+				const createDefinition = (metadata) => ({
+					operationType,
+					operationName,
+					variableNames: Object.keys(variables),
+					documentSource: () => fields,
+					document,
+					metadata
+				});
+				if (!fragmentUsages.some((u) => u.metadataBuilder) && !options.metadata) return createDefinition(void 0);
+				const fragmentMetadataResults = fragmentUsages.map((usage) => usage.metadataBuilder ? usage.metadataBuilder() : void 0);
+				const hasAsyncFragmentMetadata = fragmentMetadataResults.some((r) => r instanceof Promise);
+				const buildOperationMetadata = (resolvedFragmentMetadata) => {
+					const fragmentMetaInfos = fragmentUsages.map((usage, index) => ({
+						metadata: resolvedFragmentMetadata[index],
+						fieldPath: usage.path
 					}));
-					return {
-						variables,
-						getFields: () => fields,
-						projection
-					};
-				}
-			};
-		});
+					const aggregatedFragmentMetadata = resolvedAdapter.aggregateFragmentMetadata(fragmentMetaInfos);
+					const schemaLevel = resolvedAdapter.schemaLevel;
+					return options.metadata?.({
+						$,
+						document,
+						fragmentMetadata: aggregatedFragmentMetadata,
+						schemaLevel
+					});
+				};
+				if (hasAsyncFragmentMetadata) return Promise.all(fragmentMetadataResults).then(async (resolvedFragmentMetadata) => {
+					return createDefinition(await buildOperationMetadata(resolvedFragmentMetadata));
+				});
+				const operationMetadataResult = buildOperationMetadata(fragmentMetadataResults);
+				if (operationMetadataResult instanceof Promise) return operationMetadataResult.then(createDefinition);
+				return createDefinition(operationMetadataResult);
+			});
+		};
 	};
 };
 
-//#endregion
-//#region packages/core/src/types/type-foundation/modified-type-name.ts
-function 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 varBuilder = (varName) => {
 		const createVarSpecifierBuilder = (kind) => {
 			return (type, extras) => wrapByKey(varName, {
 				kind,
@@ -611,106 +779,35 @@ const createVarBuilder = (schema) => {
 			}
 		};
 	};
-	return { $ };
+	varBuilder.getName = getVarRefName;
+	varBuilder.getValue = getVarRefValue;
+	varBuilder.getInner = getVarRefInner;
+	return varBuilder;
 };
 
 //#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 createGqlElementComposer = (schema, options = {}) => {
+	const { adapter } = options;
+	const helpers = adapter?.helpers;
+	const metadataAdapter = adapter?.metadata;
+	const fragment = createGqlFragmentComposers(schema, metadataAdapter);
+	const createOperationComposer = createOperationComposerFactory(schema, metadataAdapter);
 	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")
-		}
+		fragment,
+		query: { operation: createOperationComposer("query") },
+		mutation: { operation: createOperationComposer("mutation") },
+		subscription: { operation: createOperationComposer("subscription") }
+	};
+	const helper = {
+		$var: createVarBuilder(schema),
+		$colocate: createColocateHelper(),
+		...helpers ?? {}
 	};
-	const helper = { ...createVarBuilder(schema) };
 	const elementComposer = (composeElement) => composeElement(composers, helper);
 	return elementComposer;
 };
 
 //#endregion
-//#region packages/core/src/utils/type-meta.ts
-const withTypeMeta = (target) => {
-	if (process.env.NODE_ENV !== "production") {
-		if (typeof target !== "object" && typeof target !== "function" || target === null) throw new Error("Target must be an object or a function.");
-		Object.defineProperty(target, "$type", { get() {
-			throw new Error("This property is only for type inference. Do not access this property directly.");
-		} });
-	}
-	return target;
-};
-
-//#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
-	});
-};
-const unsafeInputType = {
-	scalar: createUnsafeInputTypeSpecifierFactory("scalar"),
-	enum: createUnsafeInputTypeSpecifierFactory("enum"),
-	input: createUnsafeInputTypeSpecifierFactory("input")
-};
-const createUnsafeOutputTypeSpecifierFactory = (kind) => {
-	return (type, extras) => ({
-		kind,
-		...parseModifiedTypeName(type),
-		arguments: extras.arguments ?? {}
-	});
-};
-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) => wrapByKey(name, withTypeMeta({ name }));
-const define = (name) => ({
-	enum: (values) => withTypeMeta({
-		name,
-		values
-	}),
-	input: (fields) => ({
-		name,
-		fields
-	}),
-	object: (fields) => ({
-		name,
-		fields: {
-			__typename: unsafeOutputType.typename(`${name}:!`, {}),
-			...fields
-		}
-	}),
-	union: (types) => ({
-		name,
-		types
-	})
-});
-const defineOperationRoots = (operationRoots) => operationRoots;
-
-//#endregion
-export { ComposedOperation, GqlElement, InlineOperation, Model, Projection, Slice, SlicedExecutionResultEmpty, SlicedExecutionResultError, SlicedExecutionResultSuccess, buildArgumentValue, buildConstValueNode, buildDocument, buildOperationTypeNode, buildWithTypeModifier, createComposedOperationComposerFactory, createFieldFactories, createGqlElementComposer, createGqlModelComposers, createPathGraphFromSliceEntries, createSliceComposerFactory, createVarAssignments, createVarBuilder, createVarRefs, define, defineOperationRoots, defineScalar, mergeFields, mergeVarDefinitions, unsafeInputType, unsafeOutputType };
+export { Fragment, GqlElement, Operation, appendToPath, buildArgumentValue, buildConstValueNode, buildDocument, buildOperationTypeNode, buildWithTypeModifier, createColocateHelper, createDefaultAdapter, createFieldFactories, createGqlElementComposer, createGqlFragmentComposers, createOperationComposerFactory, createVarAssignments, createVarBuilder, createVarRefs, defaultMetadataAdapter, define, defineOperationRoots, defineScalar, getCurrentFieldPath, getVarRefInner, getVarRefName, getVarRefValue, isListType, mergeFields, mergeVarDefinitions, recordFragmentUsage, unsafeInputType, unsafeOutputType, withFieldPath, withFragmentUsageCollection };
 //# sourceMappingURL=index.js.map