@soda-gql/core 0.0.8 → 0.1.0

package/dist/index.js

@@ -1,4 +1,5 @@
-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 createVarRefs, c as createExecutionResultParser, d as SlicedExecutionResultSuccess, f as Projection, g as getVarRefValue, h as getVarRefName, i as createVarAssignments, l as SlicedExecutionResultEmpty, m as getVarRefInner, n as handleProjectionBuilder, o as mergeVarDefinitions, p as VarRef, s as mapValues, u as SlicedExecutionResultError } from "./slice-BuSNc8vw.js";
+import { t as defaultMergeSliceMetadata } from "./merge-CeMx09is.js";
 import { Kind, OperationTypeNode } from "graphql";
 
 //#region packages/core/src/composer/build-document.ts
@@ -242,13 +243,24 @@ const GQL_ELEMENT_CONTEXT = Symbol("GQL_ELEMENT_CONTEXT");
 var GqlElement = class GqlElement {
 	[GQL_ELEMENT_FACTORY];
 	[GQL_ELEMENT_CONTEXT] = null;
-	constructor(define$1) {
+	constructor(define$1, getDeps) {
 		let cache = null;
-		this[GQL_ELEMENT_FACTORY] = (context) => {
+		let promise = null;
+		this[GQL_ELEMENT_FACTORY] = function* execute(context) {
 			if (cache) return cache.value;
-			const value = define$1(context);
-			cache = { value };
-			return value;
+			if (promise) {
+				yield promise;
+				return cache.value;
+			}
+			if (getDeps) for (const dep of getDeps()) yield* GqlElement.createEvaluationGenerator(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;
 		};
 		Object.defineProperty(this, "$infer", { get() {
 			throw new Error("This property is only for type meta. Do not access this property directly.");
@@ -257,12 +269,21 @@ var GqlElement = class GqlElement {
 	static setContext(element, context) {
 		element[GQL_ELEMENT_CONTEXT] = context;
 	}
-	static evaluate(element) {
-		GqlElement.get(element);
+	static *createEvaluationGenerator(element) {
+		const context = element[GQL_ELEMENT_CONTEXT];
+		yield* element[GQL_ELEMENT_FACTORY](context);
 	}
-	static get(element) {
+	static evaluateInstantly(element) {
 		const context = element[GQL_ELEMENT_CONTEXT];
-		return element[GQL_ELEMENT_FACTORY](context);
+		const result = element[GQL_ELEMENT_FACTORY](context).next();
+		if (!result.done) throw new Error("Async operation is not supported in sync evaluation.");
+		return result.value;
+	}
+	static evaluateSync(element) {
+		GqlElement.evaluateInstantly(element);
+	}
+	static get(element) {
+		return GqlElement.evaluateInstantly(element);
 	}
 };
 
@@ -290,6 +311,9 @@ var ComposedOperation = class ComposedOperation extends GqlElement {
 	get parse() {
 		return GqlElement.get(this).parse;
 	}
+	get metadata() {
+		return GqlElement.get(this).metadata;
+	}
 	static create(define$1) {
 		return new ComposedOperation(define$1);
 	}
@@ -320,6 +344,9 @@ var InlineOperation = class InlineOperation extends GqlElement {
 	get document() {
 		return GqlElement.get(this).document;
 	}
+	get metadata() {
+		return GqlElement.get(this).metadata;
+	}
 	static create(define$1) {
 		return new InlineOperation(define$1);
 	}
@@ -395,31 +422,48 @@ function createPathGraphFromSliceEntries(fragments) {
 
 //#endregion
 //#region packages/core/src/composer/composed-operation.ts
-const createComposedOperationComposerFactory = () => {
+const createComposedOperationComposerFactory = (options = {}) => {
+	const { metadataAdapter } = options;
 	return (operationType) => {
-		return (options, builder) => {
+		return (options$1, builder) => {
 			return ComposedOperation.create(() => {
-				const { operationName } = options;
-				const variables = mergeVarDefinitions(options.variables ?? []);
-				const fragments = builder({ $: createVarRefs(variables) });
+				const { operationName } = options$1;
+				const variables = mergeVarDefinitions(options$1.variables ?? []);
+				const $ = createVarRefs(variables);
+				const fragments = builder({ $ });
 				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,
+				const document = buildDocument({
 					operationName,
-					variableNames: Object.keys(variables),
-					projectionPathGraph,
-					document: buildDocument({
-						operationName,
+					operationType,
+					variables,
+					fields
+				});
+				const operationMetadataResult = options$1.metadata?.({
+					$,
+					document
+				});
+				const sliceMetadataResults = Object.values(fragments).map((fragment) => fragment.metadata).filter((m) => m != null);
+				const mergeSliceMetadata = metadataAdapter?.mergeSliceMetadata ?? defaultMergeSliceMetadata;
+				const createDefinition = (operationMetadata, sliceMetadataList) => {
+					const metadata = mergeSliceMetadata(operationMetadata ?? {}, sliceMetadataList);
+					return {
 						operationType,
-						variables,
-						fields
-					}),
-					parse: createExecutionResultParser({
-						fragments,
-						projectionPathGraph
-					})
+						operationName,
+						variableNames: Object.keys(variables),
+						projectionPathGraph,
+						document,
+						parse: createExecutionResultParser({
+							fragments,
+							projectionPathGraph
+						}),
+						metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+					};
 				};
+				const hasAsyncOperationMetadata = operationMetadataResult instanceof Promise;
+				const hasAsyncSliceMetadata = sliceMetadataResults.some((m) => m instanceof Promise);
+				if (hasAsyncOperationMetadata || hasAsyncSliceMetadata) return Promise.all([hasAsyncOperationMetadata ? operationMetadataResult : Promise.resolve(operationMetadataResult), Promise.all(sliceMetadataResults.map((m) => m instanceof Promise ? m : Promise.resolve(m)))]).then(([operationMetadata, sliceMetadataList]) => createDefinition(operationMetadata, sliceMetadataList));
+				return createDefinition(operationMetadataResult, sliceMetadataResults);
 			});
 		};
 	};
@@ -513,18 +557,26 @@ const createInlineOperationComposerFactory = (schema) => {
 					f: createFieldFactories(schema, operationTypeName),
 					$
 				}));
-				return {
+				const document = buildDocument({
+					operationName,
+					operationType,
+					variables,
+					fields
+				});
+				const metadataResult = options.metadata?.({
+					$,
+					document
+				});
+				const createDefinition = (metadata) => ({
 					operationType,
 					operationName,
 					variableNames: Object.keys(variables),
 					documentSource: () => fields,
-					document: buildDocument({
-						operationName,
-						operationType,
-						variables,
-						fields
-					})
-				};
+					document,
+					metadata
+				});
+				if (metadataResult instanceof Promise) return metadataResult.then(createDefinition);
+				return createDefinition(metadataResult);
 			});
 		};
 	};
@@ -560,17 +612,21 @@ const createSliceComposerFactory = (schema) => {
 		return (options, fieldBuilder, projectionBuilder) => Slice.create(() => {
 			const varDefinitions = mergeVarDefinitions(options.variables ?? []);
 			const projection = handleProjectionBuilder(projectionBuilder);
+			const { metadata: metadataOption } = options;
 			return {
 				operationType,
 				embed: (variables) => {
+					const f = createFieldFactories(schema, operationTypeName);
+					const $ = createVarAssignments(varDefinitions, variables);
 					const fields = mergeFields(fieldBuilder({
-						f: createFieldFactories(schema, operationTypeName),
-						$: createVarAssignments(varDefinitions, variables)
+						f,
+						$
 					}));
 					return {
 						variables,
 						getFields: () => fields,
-						projection
+						projection,
+						metadata: metadataOption?.({ $ })
 					};
 				}
 			};
@@ -592,7 +648,7 @@ function parseModifiedTypeName(nameAndModifier) {
 //#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,15 +667,20 @@ const createVarBuilder = (schema) => {
 			}
 		};
 	};
-	return { $ };
+	return { $var: Object.assign(varBuilder, {
+		getName: getVarRefName,
+		getValue: getVarRefValue,
+		getInner: getVarRefInner
+	}) };
 };
 
 //#endregion
 //#region packages/core/src/composer/gql-composer.ts
-const createGqlElementComposer = (schema) => {
+const createGqlElementComposer = (schema, options = {}) => {
+	const { metadataAdapter, helpers } = options;
 	const model = createGqlModelComposers(schema);
 	const createSliceComposer = createSliceComposerFactory(schema);
-	const createComposedOperationFactory = createComposedOperationComposerFactory();
+	const createComposedOperationFactory = createComposedOperationComposerFactory({ metadataAdapter });
 	const createInlineOperationComposer = createInlineOperationComposerFactory(schema);
 	const composers = {
 		model,
@@ -639,11 +700,34 @@ const createGqlElementComposer = (schema) => {
 			inline: createInlineOperationComposer("subscription")
 		}
 	};
-	const helper = { ...createVarBuilder(schema) };
+	const helper = {
+		...createVarBuilder(schema),
+		...helpers ?? {}
+	};
 	const elementComposer = (composeElement) => composeElement(composers, helper);
 	return elementComposer;
 };
 
+//#endregion
+//#region packages/core/src/composer/helpers.ts
+/**
+* Helper function for defining typed helpers with better inference.
+* Use this when you need explicit typing or when type inference needs assistance.
+*
+* @example
+* ```typescript
+* const gql = createGqlElementComposer(schema, {
+*   helpers: defineHelpers({
+*     auth: {
+*       requiresLogin: () => ({ requiresAuth: true }),
+*       adminOnly: () => ({ requiresAuth: true, role: 'admin' }),
+*     },
+*   }),
+* });
+* ```
+*/
+const defineHelpers = (helpers) => helpers;
+
 //#endregion
 //#region packages/core/src/utils/type-meta.ts
 const withTypeMeta = (target) => {
@@ -712,5 +796,5 @@ const define = (name) => ({
 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 { ComposedOperation, GqlElement, InlineOperation, Model, Projection, Slice, SlicedExecutionResultEmpty, SlicedExecutionResultError, SlicedExecutionResultSuccess, buildArgumentValue, buildConstValueNode, buildDocument, buildOperationTypeNode, buildWithTypeModifier, createComposedOperationComposerFactory, createFieldFactories, createGqlElementComposer, createGqlModelComposers, createPathGraphFromSliceEntries, createSliceComposerFactory, createVarAssignments, createVarBuilder, createVarRefs, define, defineHelpers, defineOperationRoots, defineScalar, getVarRefInner, getVarRefName, getVarRefValue, mergeFields, mergeVarDefinitions, unsafeInputType, unsafeOutputType };
 //# sourceMappingURL=index.js.map