@soda-gql/core 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -1,4 +1,4 @@
-const require_schema = require('./schema-Bip7o0g3.cjs');
+const require_schema = require('./schema-DuWaRhdp.cjs');
 let graphql = require("graphql");
 
 //#region packages/core/src/types/type-foundation/var-ref.ts
@@ -294,12 +294,13 @@ const buildDocument = (options) => {
 * @example
 * ```typescript
 * // In operation definition
-* query.operation({ name: "GetData" }, ({ f, $ }) => [
-*   $colocate({
+* query.operation({
+*   name: "GetData",
+*   fields: ({ $ }) => $colocate({
 *     userCard: userCardFragment.embed({ userId: $.userId }),
 *     posts: postsFragment.embed({ userId: $.userId }),
 *   }),
-* ]);
+* });
 *
 * // In parser definition (same labels)
 * createExecutionResultParser({
@@ -387,8 +388,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) => require_schema.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
@@ -522,93 +606,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) => require_schema.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
 /**
@@ -647,7 +644,6 @@ 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;
@@ -663,9 +659,9 @@ 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) => {
@@ -675,10 +671,10 @@ const createGqlFragmentComposers = (schema, _adapter) => {
 						metadataBuilder: metadata ? () => metadata({ $ }) : null,
 						path: getCurrentFieldPath()
 					});
-					return mergeFields(builder({
+					return fields({
 						f,
 						$
-					}));
+					});
 				}
 			}));
 		};
@@ -705,16 +701,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,25 +755,31 @@ 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.
+*/
+const createVarMethod = (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) => require_schema.wrapByKey(varName, {
-				kind,
-				...require_schema.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) => require_schema.wrapByKey(varName, method(modifier, extras))),
+			writable: false,
+			configurable: true
+		});
+		return wrappedMethods;
 	};
 	varBuilder.getName = getVarRefName;
 	varBuilder.getValue = getVarRefValue;
@@ -787,8 +789,8 @@ const createVarBuilder = (schema) => {
 
 //#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);
@@ -800,7 +802,7 @@ const createGqlElementComposer = (schema, options = {}) => {
 		subscription: { operation: createOperationComposer("subscription") }
 	};
 	const helper = {
-		$var: createVarBuilder(schema),
+		$var: createVarBuilder(inputTypeMethods),
 		$colocate: createColocateHelper(),
 		...helpers ?? {}
 	};
@@ -826,6 +828,7 @@ exports.createGqlFragmentComposers = createGqlFragmentComposers;
 exports.createOperationComposerFactory = createOperationComposerFactory;
 exports.createVarAssignments = createVarAssignments;
 exports.createVarBuilder = createVarBuilder;
+exports.createVarMethod = createVarMethod;
 exports.createVarRefs = createVarRefs;
 exports.defaultMetadataAdapter = defaultMetadataAdapter;
 exports.define = require_schema.define;
@@ -836,8 +839,6 @@ exports.getVarRefInner = getVarRefInner;
 exports.getVarRefName = getVarRefName;
 exports.getVarRefValue = getVarRefValue;
 exports.isListType = isListType;
-exports.mergeFields = mergeFields;
-exports.mergeVarDefinitions = mergeVarDefinitions;
 exports.recordFragmentUsage = recordFragmentUsage;
 exports.unsafeInputType = require_schema.unsafeInputType;
 exports.unsafeOutputType = require_schema.unsafeOutputType;