@soda-gql/core 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,4 +1,4 @@
-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 { a as unsafeOutputType, i as unsafeInputType, n as defineOperationRoots, o as wrapByKey, r as defineScalar, t as define } from "./schema-BbCrsNkQ.js";
 import { Kind, OperationTypeNode } from "graphql";
 
 //#region packages/core/src/types/type-foundation/var-ref.ts
@@ -13,15 +13,25 @@ var VarRef = class {
 const isVarRef = (value) => {
 	return typeof value === "object" && value !== null && value instanceof VarRef;
 };
+/**
+* Recursively checks if a NestedValue contains any VarRef.
+* Used by getVarRefValue to determine if it's safe to return as ConstValue.
+*/
+const hasVarRefInside = (value) => {
+	if (isVarRef(value)) return true;
+	if (Array.isArray(value)) return value.some(hasVarRefInside);
+	if (typeof value === "object" && value !== null) return Object.values(value).some(hasVarRefInside);
+	return false;
+};
 const createVarRefFromVariable = (name) => {
 	return new VarRef({
 		type: "variable",
 		name
 	});
 };
-const createVarRefFromConstValue = (value) => {
+const createVarRefFromNestedValue = (value) => {
 	return new VarRef({
-		type: "const-value",
+		type: "nested-value",
 		value
 	});
 };
@@ -30,22 +40,97 @@ const getVarRefInner = (varRef) => {
 };
 /**
 * Get the variable name from a VarRef.
-* Throws if the VarRef contains a const-value instead of a variable reference.
+* Throws if the VarRef contains a nested-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");
+	if (inner.type !== "variable") throw new Error("Expected variable reference, got nested-value");
 	return inner.name;
 };
 /**
 * Get the const value from a VarRef.
-* Throws if the VarRef contains a variable reference instead of a const-value.
+* Throws if the VarRef contains a variable reference instead of a nested-value,
+* or if the nested-value contains any VarRef inside.
 */
 const getVarRefValue = (varRef) => {
 	const inner = VarRef.getInner(varRef);
-	if (inner.type !== "const-value") throw new Error("Expected const-value, got variable reference");
+	if (inner.type !== "nested-value") throw new Error("Expected nested-value, got variable reference");
+	if (hasVarRefInside(inner.value)) throw new Error("Cannot get const value: nested-value contains VarRef");
 	return inner.value;
 };
+const ProxyInnerRegistry = /* @__PURE__ */ new WeakMap();
+const getProxyInner = (proxy) => {
+	const inner = ProxyInnerRegistry.get(proxy);
+	if (!inner) throw new Error(`Proxy inner not found`);
+	return inner;
+};
+const createProxy = (current) => {
+	const proxy = new Proxy(Object.create(null), { get(_, property) {
+		if (typeof property === "symbol") throw new Error(`Prohibited property access: ${String(property)}`);
+		if (current.inner.type === "variable") throw new Error(`Cannot access children of variable at path [${current.segments.join(".")}]`);
+		if (typeof current.inner.value === "object" && current.inner.value !== null) {
+			const value = current.inner.value[property];
+			return createProxy({
+				inner: isVarRef(value) ? getVarRefInner(value) : {
+					type: "nested-value",
+					value
+				},
+				segments: [...current.segments, property]
+			});
+		}
+		throw new Error(`Cannot access children of primitive value at path [${current.segments.join(".")}]`);
+	} });
+	ProxyInnerRegistry.set(proxy, {
+		inner: current.inner,
+		segments: current.segments
+	});
+	return proxy;
+};
+/**
+* Get the variable name from a VarRef at a specific path.
+*
+* @param varRef - The VarRef containing a nested-value
+* @param selector - Path builder function, e.g., p => p.user.age
+* @returns The variable name at the specified path
+* @throws If path doesn't lead to a VarRef with type "variable"
+*
+* @example
+* const ref = createVarRefFromNestedValue({
+*   user: { age: someVariableRef }
+* });
+* getNameAt(ref, p => p.user.age); // returns the variable name
+*/
+const getNameAt = (varRef, selector) => {
+	const inner = getProxyInner(selector(createProxy({
+		inner: VarRef.getInner(varRef),
+		segments: []
+	})));
+	if (inner.inner.type !== "variable") throw new Error(`Value at path [${inner.segments.join(".")}] is not a variable`);
+	return inner.inner.name;
+};
+/**
+* Get the const value from a nested-value VarRef at a specific path.
+*
+* @param varRef - The VarRef containing a nested-value
+* @param pathFn - Path builder function, e.g., p => p.user.name
+* @returns The const value at the specified path
+* @throws If path leads to a VarRef or if value contains VarRef inside
+*
+* @example
+* const ref = createVarRefFromNestedValue({
+*   user: { name: "Alice", age: someVariableRef }
+* });
+* getValueAt(ref, p => p.user.name); // returns "Alice"
+*/
+const getValueAt = (varRef, selector) => {
+	const inner = getProxyInner(selector(createProxy({
+		inner: VarRef.getInner(varRef),
+		segments: []
+	})));
+	if (inner.inner.type !== "nested-value") throw new Error(`Value at path [${inner.segments.join(".")}] is not a nested-value`);
+	if (hasVarRefInside(inner.inner.value)) throw new Error(`Value at path [${inner.segments.join(".")}] contains nested VarRef`);
+	return inner.inner.value;
+};
 
 //#endregion
 //#region packages/core/src/composer/build-document.ts
@@ -61,7 +146,7 @@ const buildArgumentValue = (value) => {
 				value: inner.name
 			}
 		};
-		if (inner.type === "const-value") return buildConstValueNode(inner.value);
+		if (inner.type === "nested-value") return buildArgumentValue(inner.value);
 		throw new Error(`Unknown var ref type: ${inner}`);
 	}
 	if (Array.isArray(value)) return {
@@ -294,12 +379,13 @@ const buildDocument = (options) => {
 * @example
 * ```typescript
 * // In operation definition
-* query.operation({ name: "GetData" }, ({ f, $ }) => [
-*   $colocate({
-*     userCard: userCardFragment.embed({ userId: $.userId }),
-*     posts: postsFragment.embed({ userId: $.userId }),
+* query.operation({
+*   name: "GetData",
+*   fields: ({ $ }) => $colocate({
+*     userCard: userCardFragment.spread({ userId: $.userId }),
+*     posts: postsFragment.spread({ userId: $.userId }),
 *   }),
-* ]);
+* });
 *
 * // In parser definition (same labels)
 * createExecutionResultParser({
@@ -334,7 +420,7 @@ const fieldPathContext = { current: null };
 * ```typescript
 * import { getCurrentFieldPath } from '@soda-gql/core';
 *
-* // Inside a field builder or model embed:
+* // Inside a field builder or model spread:
 * const path = getCurrentFieldPath();
 * console.log(path?.full); // "$.user.posts[].author"
 * ```
@@ -387,8 +473,91 @@ const isListType = (typeString) => {
 };
 
 //#endregion
-//#region packages/core/src/types/element/fields-builder.ts
-const mergeFields = (fields) => Object.assign({}, ...fields);
+//#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
+//#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) => {
+					const nestedFields = withFieldPath(appendToPath(getCurrentFieldPath(), {
+						field: fieldName,
+						parentType: typeName,
+						isList: isListType(type.modifier)
+					}), () => 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) => {
+					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 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({
+				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/types/element/lazy-evaluator.ts
@@ -485,8 +654,8 @@ var Fragment = class Fragment extends GqlElement {
 	get typename() {
 		return GqlElement.get(this).typename;
 	}
-	get embed() {
-		return GqlElement.get(this).embed;
+	get spread() {
+		return GqlElement.get(this).spread;
 	}
 	static create(define$1) {
 		return new Fragment(define$1);
@@ -522,93 +691,6 @@ var Operation = class Operation extends GqlElement {
 	}
 };
 
-//#endregion
-//#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
-//#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) => {
-					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) => {
-					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({
-				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/fragment-usage-context.ts
 /**
@@ -636,7 +718,7 @@ const withFragmentUsageCollection = (fn) => {
 	}
 };
 /**
-* Record a fragment usage. Called when fragment.embed() is invoked.
+* Record a fragment usage. Called when fragment.spread() is invoked.
 * No-op if not in a collection context.
 *
 * @internal
@@ -647,14 +729,13 @@ const recordFragmentUsage = (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);
+		if (!providedValues || providedValues[varName] === void 0) return createVarRefFromNestedValue(void 0);
 		const provided = providedValues[varName];
 		if (isVarRef(provided)) return provided;
-		return createVarRefFromConstValue(provided);
+		return createVarRefFromNestedValue(provided);
 	});
 };
 const createVarRefs = (definitions) => mapValues(definitions, (_ref, name) => createVarRefFromVariable(name));
@@ -663,22 +744,22 @@ const createVarRefs = (definitions) => mapValues(definitions, (_ref, name) => cr
 //#region packages/core/src/composer/fragment.ts
 const createGqlFragmentComposers = (schema, _adapter) => {
 	const createFragmentComposer = (typename) => {
-		return (options, builder) => {
-			const varDefinitions = mergeVarDefinitions(options.variables ?? []);
-			const { metadata } = options;
+		return (options) => {
+			const varDefinitions = options.variables ?? {};
+			const { metadata, fields } = options;
 			return Fragment.create(() => ({
 				typename,
-				embed: (variables) => {
+				spread: (variables) => {
 					const f = createFieldFactories(schema, typename);
 					const $ = createVarAssignments(varDefinitions, variables);
 					recordFragmentUsage({
 						metadataBuilder: metadata ? () => metadata({ $ }) : null,
 						path: getCurrentFieldPath()
 					});
-					return mergeFields(builder({
+					return fields({
 						f,
 						$
-					}));
+					});
 				}
 			}));
 		};
@@ -705,16 +786,16 @@ const createOperationComposerFactory = (schema, adapter) => {
 	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 (options) => {
 			return Operation.create(() => {
 				const { name: operationName } = options;
-				const variables = mergeVarDefinitions(options.variables ?? []);
+				const variables = options.variables ?? {};
 				const $ = createVarRefs(variables);
 				const f = createFieldFactories(schema, operationTypeName);
-				const { result: fields, usages: fragmentUsages } = withFragmentUsageCollection(() => mergeFields(fieldBuilder({
+				const { result: fields, usages: fragmentUsages } = withFragmentUsageCollection(() => options.fields({
 					f,
 					$
-				})));
+				}));
 				const document = buildDocument({
 					operationName,
 					operationType,
@@ -759,55 +840,87 @@ const createOperationComposerFactory = (schema, adapter) => {
 
 //#endregion
 //#region packages/core/src/composer/var-builder.ts
-const createVarBuilder = (schema) => {
+/**
+* Creates a variable method for a specific input type.
+* This is used by codegen to generate type-specific variable methods.
+*
+* @deprecated Use createVarMethodFactory instead for proper type inference with nested input objects.
+*/
+const createVarMethod = (kind, typeName) => {
+	return (modifier, extras) => ({
+		kind,
+		name: typeName,
+		modifier,
+		defaultValue: extras?.default ? { default: extras.default() } : null,
+		directives: extras?.directives ?? {}
+	});
+};
+/**
+* Creates a factory function for generating schema-scoped variable methods.
+* This ensures proper type inference for nested input objects by binding the schema type upfront.
+*
+* @example
+* ```typescript
+* const createMethod = createVarMethodFactory<typeof schema>();
+* const inputTypeMethods = {
+*   Boolean: createMethod("scalar", "Boolean"),
+*   user_bool_exp: createMethod("input", "user_bool_exp"),
+* } satisfies InputTypeMethods<typeof schema>;
+* ```
+*/
+const createVarMethodFactory = () => {
+	return (kind, typeName) => {
+		return ((modifier, extras) => ({
+			kind,
+			name: typeName,
+			modifier,
+			defaultValue: extras?.default ? { default: extras.default() } : null,
+			directives: extras?.directives ?? {}
+		}));
+	};
+};
+/**
+* Creates a variable builder that uses injected input type methods.
+*/
+const createVarBuilder = (inputTypeMethods) => {
 	const varBuilder = (varName) => {
-		const createVarSpecifierBuilder = (kind) => {
-			return (type, extras) => wrapByKey(varName, {
-				kind,
-				...parseModifiedTypeName(type),
-				defaultValue: extras?.default ? { default: extras.default() } : null
-			});
-		};
-		return {
-			scalar: createVarSpecifierBuilder("scalar"),
-			enum: createVarSpecifierBuilder("enum"),
-			input: createVarSpecifierBuilder("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 };
-			}
-		};
+		const wrappedMethods = {};
+		for (const [typeName, method] of Object.entries(inputTypeMethods)) Object.defineProperty(wrappedMethods, typeName, {
+			value: ((modifier, extras) => wrapByKey(varName, method(modifier, extras))),
+			writable: false,
+			configurable: true
+		});
+		return wrappedMethods;
 	};
 	varBuilder.getName = getVarRefName;
 	varBuilder.getValue = getVarRefValue;
 	varBuilder.getInner = getVarRefInner;
+	varBuilder.getNameAt = getNameAt;
+	varBuilder.getValueAt = getValueAt;
 	return varBuilder;
 };
 
 //#endregion
 //#region packages/core/src/composer/gql-composer.ts
-const createGqlElementComposer = (schema, options = {}) => {
-	const { adapter } = options;
+const createGqlElementComposer = (schema, options) => {
+	const { adapter, inputTypeMethods } = options;
 	const helpers = adapter?.helpers;
 	const metadataAdapter = adapter?.metadata;
 	const fragment = createGqlFragmentComposers(schema, metadataAdapter);
 	const createOperationComposer = createOperationComposerFactory(schema, metadataAdapter);
-	const composers = {
+	const context = {
 		fragment,
 		query: { operation: createOperationComposer("query") },
 		mutation: { operation: createOperationComposer("mutation") },
-		subscription: { operation: createOperationComposer("subscription") }
-	};
-	const helper = {
-		$var: createVarBuilder(schema),
+		subscription: { operation: createOperationComposer("subscription") },
+		$var: createVarBuilder(inputTypeMethods),
 		$colocate: createColocateHelper(),
 		...helpers ?? {}
 	};
-	const elementComposer = (composeElement) => composeElement(composers, helper);
+	const elementComposer = (composeElement) => composeElement(context);
 	return elementComposer;
 };
 
 //#endregion
-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 };
+export { Fragment, GqlElement, Operation, appendToPath, buildArgumentValue, buildConstValueNode, buildDocument, buildOperationTypeNode, buildWithTypeModifier, createColocateHelper, createDefaultAdapter, createFieldFactories, createGqlElementComposer, createGqlFragmentComposers, createOperationComposerFactory, createVarAssignments, createVarBuilder, createVarMethod, createVarMethodFactory, createVarRefs, defaultMetadataAdapter, define, defineOperationRoots, defineScalar, getCurrentFieldPath, getVarRefInner, getVarRefName, getVarRefValue, isListType, recordFragmentUsage, unsafeInputType, unsafeOutputType, withFieldPath, withFragmentUsageCollection };
 //# sourceMappingURL=index.js.map