@soda-gql/codegen 0.11.25 → 0.12.0

package/dist/{generator-Be7iR3TC.mjs → generator-76iJu4D4.mjs}

@@ -2164,24 +2164,6 @@ const isEnumName = (schema, name) => schema.enums.has(name);
 const _isInputName = (schema, name) => schema.inputs.has(name);
 const isUnionName = (schema, name) => schema.unions.has(name);
 const isObjectName = (schema, name) => schema.objects.has(name);
-const renderConstValue = (value) => {
-	switch (value.kind) {
-		case Kind.NULL: return "null";
-		case Kind.INT:
-		case Kind.FLOAT: return value.value;
-		case Kind.STRING:
-		case Kind.ENUM: return JSON.stringify(value.value);
-		case Kind.BOOLEAN: return value.value ? "true" : "false";
-		case Kind.LIST: return `[${value.values.map((item) => renderConstValue(item)).join(", ")}]`;
-		case Kind.OBJECT: {
-			if (value.fields.length === 0) {
-				return "{}";
-			}
-			const entries = value.fields.map((field) => `${field.name.value}: ${renderConstValue(field.value)}`);
-			return `{ ${entries.join(", ")} }`;
-		}
-	}
-};
 /**
 * Maps type kind to deferred specifier prefix character.
 */
@@ -2197,10 +2179,8 @@ const renderInputRef = (schema, definition, excluded) => {
 	const { name, modifier } = parseTypeReference(definition.type);
 	const defaultValue = definition.defaultValue;
 	if (excluded.has(name)) {
-		if (defaultValue) {
-			return `{ kind: "excluded", name: "${name}", modifier: "${modifier}", defaultValue: { default: ${renderConstValue(defaultValue)} } }`;
-		}
-		return `{ kind: "excluded", name: "${name}", modifier: "${modifier}" }`;
+		const defaultSuffix$1 = defaultValue ? "|D" : "";
+		return `"x|${name}|${modifier}${defaultSuffix$1}"`;
 	}
 	let kind;
 	if (isScalarName(schema, name)) {
@@ -2260,7 +2240,7 @@ const renderOutputRef = (schema, type, args, excluded) => {
 	const { name, modifier } = parseTypeReference(type);
 	if (excluded.has(name)) {
 		const argumentMap = renderArgumentMap(schema, args, excluded);
-		return `{ kind: "excluded", name: "${name}", modifier: "${modifier}", arguments: ${argumentMap} }`;
+		return `{ spec: "x|${name}|${modifier}", arguments: ${argumentMap} }`;
 	}
 	let kind;
 	if (isScalarName(schema, name)) {
@@ -2337,14 +2317,6 @@ const renderUnionVar = (schemaName, record, excluded) => {
 	return `const union_${schemaName}_${record.name} = { name: "${record.name}", types: ${typesObj} } as const;`;
 };
 const collectObjectTypeNames = (schema) => Array.from(schema.objects.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
-const renderFragmentBuildersType = (objectTypeNames, schemaName, adapterTypeName) => {
-	if (objectTypeNames.length === 0) {
-		return `type FragmentBuilders_${schemaName} = Record<string, never>;`;
-	}
-	const adapterPart = adapterTypeName ? `, ExtractMetadataAdapter<${adapterTypeName}>` : "";
-	const entries = objectTypeNames.map((name) => `  readonly ${name}: FragmentBuilderFor<Schema_${schemaName}, "${name}"${adapterPart}>`);
-	return `type FragmentBuilders_${schemaName} = {\n${entries.join(";\n")};\n};`;
-};
 const collectInputTypeNames = (schema) => Array.from(schema.inputs.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
 const collectEnumTypeNames = (schema) => Array.from(schema.enums.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
 const collectUnionTypeNames = (schema) => Array.from(schema.unions.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
@@ -2522,7 +2494,7 @@ const multiRuntimeTemplate = ($$) => {
 	}
 	const extraImports = imports.length > 0 ? `${imports.join("\n")}\n` : "";
 	const schemaBlocks = [];
-	const gqlEntries = [];
+	const gqlExports = [];
 	for (const [name, config] of Object.entries($$.schemas)) {
 		const schemaVar = `${name}Schema`;
 		const adapterVar = adapterAliases.get(name);
@@ -2530,7 +2502,6 @@ const multiRuntimeTemplate = ($$) => {
 		if (adapterVar) {
 			typeExports.push(`export type Adapter_${name} = typeof ${adapterVar} & { _?: never };`);
 		}
-		typeExports.push(config.fragmentBuildersTypeBlock);
 		const inputTypeMethodsVar = `inputTypeMethods_${name}`;
 		const factoryVar = `createMethod_${name}`;
 		const customDirectivesVar = `customDirectives_${name}`;
@@ -2591,10 +2562,10 @@ const ${customDirectivesVar} = { ...createStandardDirectives(), ...${config.dire
 ${typeExports.join("\n")}`);
 		const gqlVarName = `gql_${name}`;
 		if (adapterVar) {
-			const typeParams = `<Schema_${name}, FragmentBuilders_${name}, typeof ${customDirectivesVar}, Adapter_${name}>`;
+			const typeParams = `<Schema_${name}, typeof ${customDirectivesVar}, Adapter_${name}>`;
 			schemaBlocks.push(`const ${gqlVarName} = createGqlElementComposer${typeParams}(${schemaVar}, { adapter: ${adapterVar}, inputTypeMethods: ${inputTypeMethodsVar}, directiveMethods: ${customDirectivesVar} });`);
 		} else {
-			const typeParams = `<Schema_${name}, FragmentBuilders_${name}, typeof ${customDirectivesVar}>`;
+			const typeParams = `<Schema_${name}, typeof ${customDirectivesVar}>`;
 			schemaBlocks.push(`const ${gqlVarName} = createGqlElementComposer${typeParams}(${schemaVar}, { inputTypeMethods: ${inputTypeMethodsVar}, directiveMethods: ${customDirectivesVar} });`);
 		}
 		schemaBlocks.push(`export type Context_${name} = Parameters<typeof ${gqlVarName}>[0] extends (ctx: infer C) => unknown ? C : never;`);
@@ -2607,13 +2578,11 @@ ${typeExports.join("\n")}`);
 			prebuiltExports.push(`export { ${adapterVar} as __adapter_${name} }`);
 		}
 		schemaBlocks.push(`${prebuiltExports.join(";\n")};`);
-		gqlEntries.push(`  ${name}: ${gqlVarName}`);
+		gqlExports.push(`export { ${gqlVarName} as __gql_${name} }`);
 	}
 	const needsDefineEnum = false;
 	return `\
 import {${needsDefineEnum ? "\n  defineEnum," : ""}
-  type ExtractMetadataAdapter,
-  type FragmentBuilderFor,
   type AnyGraphqlSchema,
   createDirectiveMethod,
   createTypedDirectiveMethod,
@@ -2624,9 +2593,7 @@ import {${needsDefineEnum ? "\n  defineEnum," : ""}
 ${extraImports}
 ${schemaBlocks.join("\n")}
 
-export const gql = {
-${gqlEntries.join(",\n")}
-};
+${gqlExports.join(";\n")};
 `;
 };
 const generateMultiSchemaModule = (schemas, options) => {
@@ -2700,8 +2667,6 @@ const generateMultiSchemaModule = (schemas, options) => {
 		const factoryVar = `createMethod_${name}`;
 		const inputTypeMethodsBlock = renderInputTypeMethods(schema, factoryVar, excluded);
 		const directiveMethodsBlock = renderDirectiveMethods(schema, excluded);
-		const adapterTypeName = options?.injection?.get(name)?.adapterImportPath ? `Adapter_${name}` : undefined;
-		const fragmentBuildersTypeBlock = renderFragmentBuildersType(objectTypeNames, name, adapterTypeName);
 		const queryType = schema.operationTypes.query ?? "Query";
 		const mutationType = schema.operationTypes.mutation ?? "Mutation";
 		const subscriptionType = schema.operationTypes.subscription ?? "Subscription";
@@ -2721,7 +2686,6 @@ const generateMultiSchemaModule = (schemas, options) => {
 			unionNames: unionTypeNames,
 			inputTypeMethodsBlock,
 			directiveMethodsBlock,
-			fragmentBuildersTypeBlock,
 			defaultInputDepth: options?.defaultInputDepth?.get(name),
 			inputDepthOverrides: options?.inputDepthOverrides?.get(name)
 		};
@@ -2769,7 +2733,138 @@ const generateMultiSchemaModule = (schemas, options) => {
 		stats: allStats
 	};
 };
+/**
+* Generate a stub `types.prebuilt.ts` file with empty PrebuiltTypes registries.
+* This stub is only written when `types.prebuilt.ts` does not already exist.
+* Typegen will later overwrite it with the real type registry.
+*/
+const generatePrebuiltStub = (schemaNames) => {
+	const typeDeclarations = schemaNames.map((name) => `export type PrebuiltTypes_${name} = {
+  readonly fragments: {};
+  readonly operations: {};
+};`).join("\n\n");
+	return `\
+/**
+ * Prebuilt type registry stub.
+ *
+ * This file was generated by @soda-gql/codegen as an empty stub.
+ * Run 'soda-gql typegen' to populate with real prebuilt types.
+ *
+ * @module
+ * @generated
+ */
+
+${typeDeclarations}
+`;
+};
+/**
+* Generate the `index.ts` module that re-exports from `_internal`
+* and constructs the `gql` object from individual `__gql_*` exports.
+*
+* The `gql` object preserves the original inferred types from schema inference.
+* PrebuiltContext types will be integrated once the type resolution strategy
+* is redesigned to match the tagged template runtime API.
+*/
+const generateIndexModule = (schemaNames) => {
+	const gqlImports = schemaNames.map((name) => `__gql_${name}`).join(", ");
+	const prebuiltImports = schemaNames.map((name) => `PrebuiltTypes_${name}`).join(", ");
+	const schemaTypeImports = schemaNames.map((name) => `Schema_${name}`).join(", ");
+	const directiveImports = schemaNames.map((name) => `__directiveMethods_${name}`).join(", ");
+	const perSchemaTypes = schemaNames.map((name) => `
+type ResolveFragmentAtBuilder_${name}<TKey extends string> =
+  TKey extends keyof PrebuiltTypes_${name}["fragments"]
+    ? Fragment<
+        PrebuiltTypes_${name}["fragments"][TKey]["typename"],
+        PrebuiltTypes_${name}["fragments"][TKey]["input"] extends void
+          ? void
+          : Partial<PrebuiltTypes_${name}["fragments"][TKey]["input"] & AnyConstAssignableInput>,
+        Partial<AnyFields>,
+        PrebuiltTypes_${name}["fragments"][TKey]["output"] & object
+      >
+    : Fragment<"(unknown)", PrebuiltEntryNotFound<TKey, "fragment">, Partial<AnyFields>, PrebuiltEntryNotFound<TKey, "fragment">>;
+
+type ResolveOperationAtBuilder_${name}<TOperationType extends OperationType, TName extends string> =
+  TName extends keyof PrebuiltTypes_${name}["operations"]
+    ? Operation<
+        TOperationType,
+        TName,
+        string[],
+        PrebuiltTypes_${name}["operations"][TName]["input"] & AnyConstAssignableInput,
+        Partial<AnyFields>,
+        PrebuiltTypes_${name}["operations"][TName]["output"] & object
+      >
+    : Operation<
+        TOperationType,
+        TName,
+        string[],
+        PrebuiltEntryNotFound<TName, "operation">,
+        Partial<AnyFields>,
+        PrebuiltEntryNotFound<TName, "operation">
+      >;
+
+type PrebuiltCurriedFragment_${name} = <TKey extends string>(
+  name: TKey,
+  typeName: string,
+) => (...args: unknown[]) => (...args: unknown[]) => ResolveFragmentAtBuilder_${name}<TKey>;
+
+type PrebuiltCurriedOperation_${name}<TOperationType extends OperationType> = <TName extends string>(
+  operationName: TName,
+) => (...args: unknown[]) => (...args: unknown[]) => ResolveOperationAtBuilder_${name}<TOperationType, TName>;
+
+type GenericFieldFactory_${name} = Record<string, (...args: unknown[]) => Record<string, unknown> & ((callback: (tools: GenericFieldsBuilderTools_${name}) => Record<string, unknown>) => Record<string, unknown>)>;
+type GenericFieldsBuilderTools_${name} = { readonly f: GenericFieldFactory_${name}; readonly $: Readonly<Record<string, never>> };
+
+type PrebuiltCallbackOperation_${name}<TOperationType extends OperationType> = <TName extends string>(
+  options: { name: TName; fields: (tools: GenericFieldsBuilderTools_${name}) => Record<string, unknown>; variables?: Record<string, unknown>; metadata?: (tools: { readonly $: Readonly<Record<string, never>>; readonly fragmentMetadata: unknown[] | undefined }) => Record<string, unknown> },
+) => ResolveOperationAtBuilder_${name}<TOperationType, TName>;
+
+export type PrebuiltContext_${name} = {
+  readonly fragment: PrebuiltCurriedFragment_${name};
+  readonly query: PrebuiltCurriedOperation_${name}<"query"> & {
+    readonly operation: PrebuiltCallbackOperation_${name}<"query">;
+    readonly compat: (operationName: string) => (strings: TemplateStringsArray, ...values: never[]) => GqlDefine<unknown>;
+  };
+  readonly mutation: PrebuiltCurriedOperation_${name}<"mutation"> & {
+    readonly operation: PrebuiltCallbackOperation_${name}<"mutation">;
+    readonly compat: (operationName: string) => (strings: TemplateStringsArray, ...values: never[]) => GqlDefine<unknown>;
+  };
+  readonly subscription: PrebuiltCurriedOperation_${name}<"subscription"> & {
+    readonly operation: PrebuiltCallbackOperation_${name}<"subscription">;
+    readonly compat: (operationName: string) => (strings: TemplateStringsArray, ...values: never[]) => GqlDefine<unknown>;
+  };
+  readonly define: <TValue>(factory: () => TValue | Promise<TValue>) => GqlDefine<TValue>;
+  readonly extend: (...args: unknown[]) => AnyOperation;
+  readonly $var: VarBuilder<Schema_${name}>;
+  readonly $dir: typeof __directiveMethods_${name};
+  readonly $colocate: <T extends Record<string, unknown>>(projections: T) => T;
+};
+
+type GqlComposer_${name} = {
+  <TResult>(composeElement: (context: PrebuiltContext_${name}) => TResult): TResult;
+  readonly $schema: AnyGraphqlSchema;
+};`).join("\n");
+	const gqlEntries = schemaNames.map((name) => `  ${name}: __gql_${name} as unknown as GqlComposer_${name}`).join(",\n");
+	return `\
+/**
+ * Generated by @soda-gql/codegen
+ * @module
+ * @generated
+ */
+
+export * from "./_internal";
+import { ${gqlImports} } from "./_internal";
+import type { ${schemaTypeImports} } from "./_internal";
+import type { ${directiveImports} } from "./_internal";
+import type { ${prebuiltImports} } from "./types.prebuilt";
+import type { Fragment, Operation, OperationType, PrebuiltEntryNotFound, AnyConstAssignableInput, AnyFields, AnyGraphqlSchema, AnyOperation, VarBuilder, GqlDefine } from "@soda-gql/core";
+${perSchemaTypes}
+
+export const gql = {
+${gqlEntries}
+};
+`;
+};
 
 //#endregion
-export { generateMultiSchemaModule as n, createSchemaIndex as t };
-//# sourceMappingURL=generator-Be7iR3TC.mjs.map
+export { compileTypeFilter as a, generatePrebuiltStub as i, generateIndexModule as n, generateMultiSchemaModule as r, createSchemaIndex as t };
+//# sourceMappingURL=generator-76iJu4D4.mjs.map