@soda-gql/core 0.9.1 → 0.10.0

package/dist/index.cjs

@@ -1,37 +1,6 @@
-const require_schema = require('./schema-D2MW4DOF.cjs');
+const require_schema_builder = require('./schema-builder-D2ay11cE.cjs');
 let graphql = require("graphql");
 
-//#region packages/core/src/types/type-foundation/directive-ref.ts
-/**
-* A reference to a directive that can be applied to fields.
-*
-* DirectiveRef carries type information about the directive via the TBrand
-* type parameter, but this information is only used for type inference,
-* not for runtime validation.
-*
-* @example
-* ```typescript
-* const skipDirective = new DirectiveRef({
-*   name: "skip",
-*   arguments: { if: true },
-*   locations: ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
-* });
-* ```
-*/
-var DirectiveRef = class {
-	constructor(inner) {
-		this.inner = inner;
-	}
-	/**
-	* Extracts the inner structure from a DirectiveRef.
-	* Used by build-document.ts to generate DirectiveNode.
-	*/
-	static getInner(ref) {
-		return ref.inner;
-	}
-};
-
-//#endregion
 //#region packages/core/src/types/type-foundation/var-ref.ts
 var VarRef = class {
 	constructor(inner) {
@@ -62,6 +31,37 @@ function createVarRefFromNestedValue(value) {
 	});
 }
 
+//#endregion
+//#region packages/core/src/types/type-foundation/directive-ref.ts
+/**
+* A reference to a directive that can be applied to fields.
+*
+* DirectiveRef carries type information about the directive via the TBrand
+* type parameter, but this information is only used for type inference,
+* not for runtime validation.
+*
+* @example
+* ```typescript
+* const skipDirective = new DirectiveRef({
+*   name: "skip",
+*   arguments: { if: true },
+*   locations: ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
+* });
+* ```
+*/
+var DirectiveRef = class {
+	constructor(inner) {
+		this.inner = inner;
+	}
+	/**
+	* Extracts the inner structure from a DirectiveRef.
+	* Used by build-document.ts to generate DirectiveNode.
+	*/
+	static getInner(ref) {
+		return ref.inner;
+	}
+};
+
 //#endregion
 //#region packages/core/src/composer/build-document.ts
 /**
@@ -598,7 +598,7 @@ const createFieldFactoriesInner = (schema, 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);
+			const wrap = (value) => require_schema_builder.wrapByKey(extras?.alias ?? fieldName, value);
 			const directives = extras?.directives ?? [];
 			if (type.kind === "object") {
 				const factoryReturn = ((nest) => {
@@ -667,7 +667,7 @@ const createFieldFactoriesInner = (schema, typeName) => {
 * @param createDepGenerator - Function to create evaluation generator for a dependency
 * @returns An executor generator function
 */
-const createLazyEvaluator = (define$1, getDeps, createDepGenerator) => {
+const createLazyEvaluator = (define, getDeps, createDepGenerator) => {
 	let cache = null;
 	let promise = null;
 	return function* execute(context) {
@@ -677,7 +677,7 @@ const createLazyEvaluator = (define$1, getDeps, createDepGenerator) => {
 			return cache.value;
 		}
 		if (getDeps) for (const dep of getDeps()) yield* createDepGenerator(dep);
-		const defined = define$1(context);
+		const defined = define(context);
 		if (!(defined instanceof Promise)) return (cache = { value: defined }).value;
 		promise = defined.then((value) => {
 			cache = { value };
@@ -720,8 +720,8 @@ const GQL_ELEMENT_CONTEXT = Symbol("GQL_ELEMENT_CONTEXT");
 var GqlElement = class GqlElement {
 	[GQL_ELEMENT_FACTORY];
 	[GQL_ELEMENT_CONTEXT] = null;
-	constructor(define$1, getDeps) {
-		this[GQL_ELEMENT_FACTORY] = createLazyEvaluator(define$1, getDeps, GqlElement.createEvaluationGenerator);
+	constructor(define, getDeps) {
+		this[GQL_ELEMENT_FACTORY] = createLazyEvaluator(define, getDeps, GqlElement.createEvaluationGenerator);
 		Object.defineProperty(this, "$infer", { get() {
 			throw new Error("This property is only for type meta. Do not access this property directly.");
 		} });
@@ -792,15 +792,28 @@ var GqlElement = class GqlElement {
 * @template TVariables - Variables required when spreading
 * @template TFields - The selected fields structure
 * @template TOutput - Inferred output type from selected fields
+* @template TKey - Optional unique key for prebuilt type lookup
 */
 var Fragment = class Fragment extends GqlElement {
-	constructor(define$1) {
-		super(define$1);
+	constructor(define) {
+		super(define);
 	}
 	/** The GraphQL type name this fragment selects from. */
 	get typename() {
 		return GqlElement.get(this).typename;
 	}
+	/** Optional unique key for prebuilt type lookup. */
+	get key() {
+		return GqlElement.get(this).key;
+	}
+	/** The schema label this fragment belongs to. */
+	get schemaLabel() {
+		return GqlElement.get(this).schemaLabel;
+	}
+	/** Variable definitions for this fragment. */
+	get variableDefinitions() {
+		return GqlElement.get(this).variableDefinitions;
+	}
 	/**
 	* Spreads this fragment's fields into a parent selection.
 	* Pass variables if the fragment defines any.
@@ -813,8 +826,8 @@ var Fragment = class Fragment extends GqlElement {
 	* Prefer using the `gql(({ fragment }) => ...)` API instead.
 	* @internal
 	*/
-	static create(define$1) {
-		return new Fragment(define$1);
+	static create(define) {
+		return new Fragment(define);
 	}
 };
 
@@ -834,8 +847,8 @@ var Fragment = class Fragment extends GqlElement {
 * @template TData - Inferred response data type
 */
 var Operation = class Operation extends GqlElement {
-	constructor(define$1) {
-		super(define$1);
+	constructor(define) {
+		super(define);
 	}
 	/** The operation type: 'query', 'mutation', or 'subscription'. */
 	get operationType() {
@@ -845,6 +858,10 @@ var Operation = class Operation extends GqlElement {
 	get operationName() {
 		return GqlElement.get(this).operationName;
 	}
+	/** The schema label this operation belongs to. */
+	get schemaLabel() {
+		return GqlElement.get(this).schemaLabel;
+	}
 	/** List of variable names defined for this operation. */
 	get variableNames() {
 		return GqlElement.get(this).variableNames;
@@ -869,8 +886,8 @@ var Operation = class Operation extends GqlElement {
 	* Prefer using the `gql(({ query }) => ...)` API instead.
 	* @internal
 	*/
-	static create(define$1) {
-		return new Operation(define$1);
+	static create(define) {
+		return new Operation(define);
 	}
 };
 
@@ -968,9 +985,12 @@ const createGqlFragmentComposers = (schema, _adapter) => {
 	const createFragmentComposer = (typename) => {
 		return (options) => {
 			const varDefinitions = options.variables ?? {};
-			const { metadata, fields } = options;
+			const { key, metadata, fields } = options;
 			return Fragment.create(() => ({
 				typename,
+				key,
+				schemaLabel: schema.label,
+				variableDefinitions: varDefinitions,
 				spread: (variables) => {
 					const f = createFieldFactories(schema, typename);
 					const $ = createVarAssignments(varDefinitions, variables);
@@ -1048,6 +1068,7 @@ const createOperationComposerFactory = (schema, adapter, transformDocument) => {
 				if (!fragmentUsages.some((u) => u.metadataBuilder) && !options.metadata && !transformDocument && !options.transformDocument) return {
 					operationType,
 					operationName,
+					schemaLabel: schema.label,
 					variableNames,
 					documentSource: () => fields,
 					document,
@@ -1088,6 +1109,7 @@ const createOperationComposerFactory = (schema, adapter, transformDocument) => {
 						return {
 							operationType,
 							operationName,
+							schemaLabel: schema.label,
 							variableNames,
 							documentSource: () => fields,
 							document: finalDocument,
@@ -1307,7 +1329,7 @@ const createVarBuilder = (inputTypeMethods) => {
 	const varBuilder = (varName) => {
 		const wrappedMethods = {};
 		for (const [typeName, method] of Object.entries(inputTypeMethods)) Object.defineProperty(wrappedMethods, typeName, {
-			value: ((modifier, extras) => require_schema.wrapByKey(varName, method(modifier, extras))),
+			value: ((modifier, extras) => require_schema_builder.wrapByKey(varName, method(modifier, extras))),
 			writable: false,
 			configurable: true
 		});
@@ -1377,16 +1399,313 @@ const createGqlElementComposer = (schema, options) => {
 	return elementComposer;
 };
 
+//#endregion
+//#region packages/core/src/composer/prebuilt-composer.ts
+/**
+* Creates a prebuilt GQL element composer for a given schema.
+*
+* This composer has the same runtime behavior as `createGqlElementComposer`,
+* but the returned elements have their types resolved from the PrebuiltTypeRegistry
+* instead of using complex type inference.
+*
+* Use this when bundling with tools like tsdown that may lose type information.
+*
+* @param schema - The GraphQL schema definition
+* @param options - Configuration including input type methods and optional adapter
+* @returns Prebuilt element composer function
+*
+* @example
+* ```typescript
+* // Generated by codegen in prebuilt/index.ts
+* import type { PrebuiltTypes } from "./types";
+*
+* const gql = createPrebuiltGqlElementComposer<
+*   Schema,
+*   PrebuiltTypes,
+*   FragmentBuilders,
+*   DirectiveMethods,
+*   Context
+* >(schema, { inputTypeMethods });
+*
+* // Types are resolved from PrebuiltTypes registry
+* const GetUser = gql(({ query }) =>
+*   query.operation({
+*     name: "GetUser",
+*     fields: ({ f }) => ({ ...f.user({ id: "1" })(({ f }) => ({ ...f.id() })) }),
+*   })
+* );
+* // GetUser.$infer.output is PrebuiltTypes["operations"]["GetUser"]["output"]
+* ```
+*/
+const createPrebuiltGqlElementComposer = (schema, options) => {
+	return createGqlElementComposer(schema, options);
+};
+
+//#endregion
+//#region packages/core/src/prebuilt/type-calculator.ts
+/**
+* Type calculator for generating TypeScript type strings from field selections.
+*
+* This is a runtime reimplementation of the InferFields type-level computation,
+* used for generating prebuilt types that can be bundled without losing type information.
+*
+* @module
+*/
+/**
+* Apply a type modifier to a base type string.
+*
+* Modifier format:
+* - "!" = required (T)
+* - "?" = optional (T | null | undefined)
+* - "![]!" = required array of required items (T[])
+* - "![]?" = optional array of required items (T[] | null | undefined)
+* - "?[]!" = required array of optional items ((T | null | undefined)[])
+* - "?[]?" = optional array of optional items ((T | null | undefined)[] | null | undefined)
+* - Deeper nesting follows the same pattern
+*/
+const applyTypeModifier = (baseType, modifier) => {
+	if (modifier === "!") return baseType;
+	if (modifier === "?") return `(${baseType} | null | undefined)`;
+	const parts = modifier.split("[]");
+	if (parts.length < 2) return baseType;
+	let result = baseType;
+	if (parts[0] === "?") result = `(${result} | null | undefined)`;
+	for (let i = 1; i < parts.length; i++) {
+		const arrayNullability = parts[i];
+		result = `(${result})[]`;
+		if (arrayNullability === "?") result = `(${result} | null | undefined)`;
+	}
+	return result;
+};
+/**
+* Get the TypeScript type string for a scalar output type from the schema.
+*
+* Returns a `ScalarOutput<"Name">` reference for all scalars in the schema.
+* The actual type is resolved at compile time from the inject file's scalar definitions.
+* This allows users to customize even built-in scalars (ID, String, etc.).
+*/
+const getScalarOutputType = (schema, scalarName) => {
+	if (schema.scalar[scalarName]) return `ScalarOutput<"${scalarName}">`;
+	return "unknown";
+};
+/**
+* Get the TypeScript type string for a scalar input type from the schema.
+*
+* Returns a `ScalarInput<"Name">` reference for all scalars in the schema.
+* Used for input/variable types in operations.
+*/
+const getScalarInputType = (schema, scalarName) => {
+	if (schema.scalar[scalarName]) return `ScalarInput<"${scalarName}">`;
+	return "unknown";
+};
+/**
+* Get the TypeScript type string for an enum type from the schema.
+*/
+const getEnumType = (schema, enumName) => {
+	const enumDef = schema.enum[enumName];
+	if (!enumDef) return "string";
+	const values = Object.keys(enumDef.values);
+	if (values.length === 0) return "never";
+	return values.map((v) => `"${v}"`).join(" | ");
+};
+/**
+* Default depth limit for input object type generation.
+*/
+const DEFAULT_INPUT_DEPTH = 3;
+/**
+* Generate a TypeScript type string for an input object type.
+*
+* Recursively expands fields using ScalarInput for scalars.
+* Returns `unknown` if depth is exhausted or circular reference is detected.
+*
+* @param schema - The GraphQL schema
+* @param inputName - The input object type name
+* @param options - Generation options including depth limits
+* @param seen - Set of already visited input names (for circular reference detection)
+* @param currentDepth - Current recursion depth
+*/
+const generateInputObjectType = (schema, inputName, options = {}, seen = /* @__PURE__ */ new Set(), currentDepth) => {
+	const inputDef = schema.input[inputName];
+	if (!inputDef) return "unknown";
+	const depthOverrides = options.depthOverrides ?? {};
+	const defaultDepth = options.defaultDepth ?? DEFAULT_INPUT_DEPTH;
+	const maxDepth = depthOverrides[inputName] ?? defaultDepth;
+	const depth = currentDepth ?? maxDepth;
+	if (depth <= 0) return "unknown";
+	if (seen.has(inputName)) return "unknown";
+	const newSeen = new Set(seen);
+	newSeen.add(inputName);
+	const fields = inputDef.fields;
+	const fieldEntries = Object.entries(fields);
+	if (fieldEntries.length === 0) return "{}";
+	return `{ ${fieldEntries.map(([fieldName, specifier]) => {
+		const fieldType = generateInputFieldType(schema, specifier, options, newSeen, depth - 1);
+		const isOptional = specifier.modifier === "?" || specifier.modifier.endsWith("?");
+		if (specifier.defaultValue != null || isOptional) return `readonly ${fieldName}?: ${fieldType}`;
+		return `readonly ${fieldName}: ${fieldType}`;
+	}).join("; ")} }`;
+};
+/**
+* Generate a TypeScript type string for an input field based on its specifier.
+*/
+const generateInputFieldType = (schema, specifier, options, seen, depth) => {
+	let baseType;
+	const { formatters } = options;
+	switch (specifier.kind) {
+		case "scalar":
+			baseType = formatters?.scalarInput?.(specifier.name) ?? getScalarInputType(schema, specifier.name);
+			break;
+		case "enum":
+			baseType = getEnumType(schema, specifier.name);
+			break;
+		case "input":
+			baseType = formatters?.inputObject?.(specifier.name) ?? generateInputObjectType(schema, specifier.name, options, seen, depth);
+			break;
+		default: baseType = "unknown";
+	}
+	return applyTypeModifier(baseType, specifier.modifier);
+};
+/**
+* Calculate the TypeScript type string for a single field selection.
+*
+* @param schema - The GraphQL schema
+* @param selection - The field selection to calculate type for
+* @param formatters - Optional formatters for customizing type names
+*/
+const calculateFieldType = (schema, selection, formatters) => {
+	const { type } = selection;
+	if (type.kind === "object" && selection.object) return applyTypeModifier(calculateFieldsType(schema, selection.object, formatters), type.modifier);
+	if (type.kind === "union" && selection.union) return applyTypeModifier(calculateUnionType(schema, selection.union, formatters), type.modifier);
+	if (type.kind === "typename") return applyTypeModifier(`"${type.name}"`, type.modifier);
+	if (type.kind === "scalar") return applyTypeModifier(formatters?.scalarOutput?.(type.name) ?? getScalarOutputType(schema, type.name), type.modifier);
+	if (type.kind === "enum") return applyTypeModifier(getEnumType(schema, type.name), type.modifier);
+	return "unknown";
+};
+/**
+* Calculate the TypeScript type string for a union type selection.
+*/
+const calculateUnionType = (schema, union, formatters) => {
+	const memberTypes = [];
+	for (const [_typeName, fields] of Object.entries(union)) if (fields) {
+		const memberType = calculateFieldsType(schema, fields, formatters);
+		memberTypes.push(memberType);
+	}
+	if (memberTypes.length === 0) return "never";
+	return memberTypes.join(" | ");
+};
+/**
+* Calculate the TypeScript type string for a set of field selections.
+* This is the main entry point for type calculation.
+*
+* @param schema - The GraphQL schema
+* @param fields - The field selections to calculate types for
+* @param formatters - Optional formatters for customizing type names
+*/
+const calculateFieldsType = (schema, fields, formatters) => {
+	const entries = Object.entries(fields);
+	if (entries.length === 0) return "{}";
+	return `{ ${entries.map(([alias, selection]) => {
+		return `readonly ${alias}: ${calculateFieldType(schema, selection, formatters)}`;
+	}).join("; ")} }`;
+};
+/**
+* Convert a GraphQL TypeNode to a TypeScript type string for input types.
+*
+* Handles NonNullType, ListType, and NamedType recursively.
+* Uses ScalarInput for scalar types since this is used for input/variable types.
+*
+* @param schema - The GraphQL schema
+* @param typeNode - The GraphQL type node to convert
+* @param formatters - Optional formatters for customizing type names
+*/
+const graphqlTypeToTypeScript = (schema, typeNode, formatters) => {
+	switch (typeNode.kind) {
+		case graphql.Kind.NON_NULL_TYPE: return graphqlTypeToTypeScript(schema, typeNode.type, formatters);
+		case graphql.Kind.LIST_TYPE: return `(${graphqlTypeToTypeScript(schema, typeNode.type, formatters)})[]`;
+		case graphql.Kind.NAMED_TYPE: {
+			const name = typeNode.name.value;
+			if (schema.scalar[name]) return formatters?.scalarInput?.(name) ?? getScalarInputType(schema, name);
+			if (schema.enum[name]) return getEnumType(schema, name);
+			return formatters?.inputObject?.(name) ?? name;
+		}
+	}
+};
+/**
+* Generate a TypeScript type string for operation input variables.
+*
+* Extracts variable types from GraphQL VariableDefinitionNode AST.
+*
+* @param schema - The GraphQL schema
+* @param variableDefinitions - Variable definition nodes from the operation
+* @param formatters - Optional formatters for customizing type names
+*/
+const generateInputType = (schema, variableDefinitions, formatters) => {
+	if (variableDefinitions.length === 0) return "{}";
+	return `{ ${variableDefinitions.map((varDef) => {
+		const name = varDef.variable.name.value;
+		const isRequired = varDef.type.kind === graphql.Kind.NON_NULL_TYPE;
+		const tsType = graphqlTypeToTypeScript(schema, varDef.type, formatters);
+		const finalType = isRequired ? tsType : `(${tsType} | null | undefined)`;
+		return `readonly ${name}${isRequired ? "" : "?"}: ${finalType}`;
+	}).join("; ")} }`;
+};
+/**
+* Generate TypeScript type for a single input field from its specifier.
+* Used by generateInputTypeFromSpecifiers.
+*/
+const generateInputFieldTypeFromSpecifier = (schema, specifier, options) => {
+	let baseType;
+	const { formatters } = options;
+	switch (specifier.kind) {
+		case "scalar":
+			baseType = formatters?.scalarInput?.(specifier.name) ?? getScalarInputType(schema, specifier.name);
+			break;
+		case "enum":
+			baseType = getEnumType(schema, specifier.name);
+			break;
+		case "input":
+			baseType = formatters?.inputObject?.(specifier.name) ?? generateInputObjectType(schema, specifier.name, options);
+			break;
+		default: baseType = "unknown";
+	}
+	return applyTypeModifier(baseType, specifier.modifier);
+};
+/**
+* Generate a TypeScript type string for input variables from InputTypeSpecifiers.
+*
+* Unlike generateInputType which works with GraphQL AST VariableDefinitionNode[],
+* this function works with soda-gql's internal InputTypeSpecifiers format.
+* Used for generating Fragment input types in prebuilt mode.
+*
+* @param schema - The GraphQL schema
+* @param specifiers - Input type specifiers (variable definitions)
+* @param options - Generation options including depth limits
+*/
+const generateInputTypeFromSpecifiers = (schema, specifiers, options = {}) => {
+	const entries = Object.entries(specifiers);
+	if (entries.length === 0) return "void";
+	return `{ ${entries.map(([name, specifier]) => {
+		const isOuterRequired = specifier.modifier.endsWith("!");
+		const hasDefault = specifier.defaultValue != null;
+		const baseType = generateInputFieldTypeFromSpecifier(schema, specifier, options);
+		return `readonly ${name}${!isOuterRequired || hasDefault ? "?" : ""}: ${baseType}`;
+	}).join("; ")} }`;
+};
+
 //#endregion
 exports.Fragment = Fragment;
 exports.GqlElement = GqlElement;
 exports.Operation = Operation;
+exports.VarRef = VarRef;
 exports.appendToPath = appendToPath;
+exports.applyTypeModifier = applyTypeModifier;
 exports.buildArgumentValue = buildArgumentValue;
 exports.buildConstValueNode = buildConstValueNode;
 exports.buildDocument = buildDocument;
 exports.buildOperationTypeNode = buildOperationTypeNode;
 exports.buildWithTypeModifier = buildWithTypeModifier;
+exports.calculateFieldType = calculateFieldType;
+exports.calculateFieldsType = calculateFieldsType;
 exports.createColocateHelper = createColocateHelper;
 exports.createDefaultAdapter = createDefaultAdapter;
 exports.createDirectiveBuilder = createDirectiveBuilder;
@@ -1395,22 +1714,29 @@ exports.createFieldFactories = createFieldFactories;
 exports.createGqlElementComposer = createGqlElementComposer;
 exports.createGqlFragmentComposers = createGqlFragmentComposers;
 exports.createOperationComposerFactory = createOperationComposerFactory;
+exports.createPrebuiltGqlElementComposer = createPrebuiltGqlElementComposer;
 exports.createStandardDirectives = createStandardDirectives;
 exports.createVarAssignments = createVarAssignments;
 exports.createVarBuilder = createVarBuilder;
 exports.createVarMethod = createVarMethod;
 exports.createVarMethodFactory = createVarMethodFactory;
+exports.createVarRefFromVariable = createVarRefFromVariable;
 exports.createVarRefs = createVarRefs;
 exports.defaultMetadataAdapter = defaultMetadataAdapter;
-exports.define = require_schema.define;
-exports.defineOperationRoots = require_schema.defineOperationRoots;
-exports.defineScalar = require_schema.defineScalar;
+exports.defineEnum = require_schema_builder.defineEnum;
+exports.defineOperationRoots = require_schema_builder.defineOperationRoots;
+exports.defineScalar = require_schema_builder.defineScalar;
+exports.generateInputObjectType = generateInputObjectType;
+exports.generateInputType = generateInputType;
+exports.generateInputTypeFromSpecifiers = generateInputTypeFromSpecifiers;
 exports.getCurrentFieldPath = getCurrentFieldPath;
+exports.getEnumType = getEnumType;
+exports.getScalarInputType = getScalarInputType;
+exports.getScalarOutputType = getScalarOutputType;
+exports.graphqlTypeToTypeScript = graphqlTypeToTypeScript;
 exports.isDirectiveRef = isDirectiveRef;
 exports.isListType = isListType;
 exports.recordFragmentUsage = recordFragmentUsage;
-exports.unsafeInputType = require_schema.unsafeInputType;
-exports.unsafeOutputType = require_schema.unsafeOutputType;
 exports.withFieldPath = withFieldPath;
 exports.withFragmentUsageCollection = withFragmentUsageCollection;
 //# sourceMappingURL=index.cjs.map