@soda-gql/core 0.3.0 → 0.4.1

package/dist/index.js

@@ -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,117 @@ 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 SelectableProxyInnerRegistry = /* @__PURE__ */ new WeakMap();
+const getSelectableProxyInner = (proxy) => {
+	const inner = SelectableProxyInnerRegistry.get(proxy);
+	if (!inner) throw new Error(`Proxy inner not found`);
+	return inner;
+};
+const createSelectableProxy = (current) => {
+	const proxy = new Proxy(Object.create(null), { get(_, property) {
+		if (typeof property === "symbol") throw new Error(`Prohibited property access: ${String(property)}`);
+		const nextSegments = [...current.segments, property];
+		if (current.varInner.type === "virtual") return createSelectableProxy({
+			varInner: current.varInner,
+			segments: nextSegments
+		});
+		if (current.varInner.type === "variable") return createSelectableProxy({
+			varInner: {
+				type: "virtual",
+				varName: current.varInner.name,
+				varSegments: nextSegments
+			},
+			segments: nextSegments
+		});
+		if (typeof current.varInner.value === "object" && current.varInner.value !== null) {
+			const value = current.varInner.value[property];
+			return createSelectableProxy({
+				varInner: isVarRef(value) ? getVarRefInner(value) : {
+					type: "nested-value",
+					value
+				},
+				segments: nextSegments
+			});
+		}
+		throw new Error(`Cannot access children of primitive value at path [${current.segments.join(".")}]`);
+	} });
+	SelectableProxyInnerRegistry.set(proxy, current);
+	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 = getSelectableProxyInner(selector(createSelectableProxy({
+		varInner: VarRef.getInner(varRef),
+		segments: []
+	})));
+	if (inner.varInner.type === "virtual") throw new Error(`Value at path [${inner.segments.join(".")}] is inside a variable`);
+	if (inner.varInner.type !== "variable") throw new Error(`Value at path [${inner.segments.join(".")}] is not a variable`);
+	return inner.varInner.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 = getSelectableProxyInner(selector(createSelectableProxy({
+		varInner: VarRef.getInner(varRef),
+		segments: []
+	})));
+	if (inner.varInner.type === "virtual") throw new Error(`Value at path [${inner.segments.join(".")}] is inside a variable`);
+	if (inner.varInner.type !== "nested-value") throw new Error(`Value at path [${inner.segments.join(".")}] is not a nested-value`);
+	if (hasVarRefInside(inner.varInner.value)) throw new Error(`Value at path [${inner.segments.join(".")}] contains nested VarRef`);
+	return inner.varInner.value;
+};
+const getVariablePath = (varRef, selector) => {
+	const inner = getSelectableProxyInner(selector(createSelectableProxy({
+		varInner: VarRef.getInner(varRef),
+		segments: []
+	})));
+	if (inner.varInner.type === "virtual") return [`$${inner.varInner.varName}`, ...inner.segments.slice(inner.varInner.varSegments.length)];
+	if (inner.varInner.type === "variable") return [`$${inner.varInner.name}`];
+	throw new Error(`Value at path [${inner.segments.join(".")}] is not a variable or inside a variable`);
+};
 
 //#endregion
 //#region packages/core/src/composer/build-document.ts
@@ -61,7 +166,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 {
@@ -297,8 +402,8 @@ const buildDocument = (options) => {
 * query.operation({
 *   name: "GetData",
 *   fields: ({ $ }) => $colocate({
-*     userCard: userCardFragment.embed({ userId: $.userId }),
-*     posts: postsFragment.embed({ userId: $.userId }),
+*     userCard: userCardFragment.spread({ userId: $.userId }),
+*     posts: postsFragment.spread({ userId: $.userId }),
 *   }),
 * });
 *
@@ -335,7 +440,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"
 * ```
@@ -569,8 +674,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);
@@ -633,7 +738,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,10 +752,10 @@ const recordFragmentUsage = (record) => {
 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));
@@ -664,7 +769,7 @@ const createGqlFragmentComposers = (schema, _adapter) => {
 			const { metadata, fields } = options;
 			return Fragment.create(() => ({
 				typename,
-				embed: (variables) => {
+				spread: (variables) => {
 					const f = createFieldFactories(schema, typename);
 					const $ = createVarAssignments(varDefinitions, variables);
 					recordFragmentUsage({
@@ -758,6 +863,8 @@ const createOperationComposerFactory = (schema, adapter) => {
 /**
 * 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) => ({
@@ -769,6 +876,30 @@ const createVarMethod = (kind, typeName) => {
 	});
 };
 /**
+* 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) => {
@@ -784,6 +915,9 @@ const createVarBuilder = (inputTypeMethods) => {
 	varBuilder.getName = getVarRefName;
 	varBuilder.getValue = getVarRefValue;
 	varBuilder.getInner = getVarRefInner;
+	varBuilder.getNameAt = getNameAt;
+	varBuilder.getValueAt = getValueAt;
+	varBuilder.getVariablePath = getVariablePath;
 	return varBuilder;
 };
 
@@ -795,21 +929,19 @@ const createGqlElementComposer = (schema, options) => {
 	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 = {
+		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, createVarMethod, createVarRefs, defaultMetadataAdapter, define, defineOperationRoots, defineScalar, getCurrentFieldPath, getVarRefInner, getVarRefName, getVarRefValue, isListType, 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