@soda-gql/core 0.9.0 → 0.9.1

package/README.md

@@ -251,6 +251,73 @@ $var.getVariablePath(varRef, (p) => p.profile.name);
 // Returns: ["$user", "name"] (variable name + path after variable reference point)
 ```
 
+## Adapter
+
+Adapters customize the behavior of your GraphQL system with helpers, metadata configuration, and document transformation.
+
+### Basic Usage
+
+```typescript
+import { defineAdapter } from "@soda-gql/core/adapter";
+
+const adapter = defineAdapter({
+  helpers: {
+    auth: {
+      requiresLogin: () => ({ requiresAuth: true }),
+    },
+  },
+  metadata: {
+    aggregateFragmentMetadata: (fragments) => ({
+      count: fragments.length,
+    }),
+    schemaLevel: { apiVersion: "v2" },
+  },
+  transformDocument: ({ document, operationType }) => {
+    // Schema-wide document transformation
+    return document;
+  },
+});
+```
+
+### Document Transform
+
+Operations can also define their own transform with typed metadata:
+
+```typescript
+gql.default(({ query, $var }) =>
+  query.operation({
+    name: "GetUser",
+    metadata: () => ({ cacheHint: 300 }),
+    transformDocument: ({ document, metadata }) => {
+      // metadata is typed as { cacheHint: number }
+      return document;
+    },
+    fields: ({ f, $ }) => ({ ... }),
+  }),
+);
+```
+
+**Best Practice:** Define transform logic in helpers for reusability:
+
+```typescript
+const adapter = defineAdapter({
+  helpers: {
+    transform: {
+      addCache: (ttl: number) => ({ document }) => {
+        // Transform logic here
+        return document;
+      },
+    },
+  },
+});
+
+// Use helper in operation
+query.operation({
+  transformDocument: transform.addCache(300),
+  ...
+});
+```
+
 ## Runtime Exports
 
 The `/runtime` subpath provides utilities for operation registration and retrieval:

package/dist/adapter.cjs

@@ -2,10 +2,10 @@ const require_schema = require('./schema-D2MW4DOF.cjs');
 
 //#region packages/core/src/adapter/define-adapter.ts
 /**
-* Helper function for defining a unified adapter with helpers and metadata.
-* Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.
+* Helper function for defining a unified adapter with helpers, metadata, and document transformation.
+* Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.
 *
-* @example
+* @example Basic adapter with helpers and metadata
 * ```typescript
 * import { defineAdapter } from "@soda-gql/core/adapter";
 * import type { FragmentMetaInfo, OperationMetadata } from "@soda-gql/core";
@@ -26,6 +26,53 @@ const require_schema = require('./schema-D2MW4DOF.cjs');
 *   },
 * });
 * ```
+*
+* @example Adapter with document transformation
+* ```typescript
+* import { defineAdapter } from "@soda-gql/core/adapter";
+* import { Kind, visit } from "graphql";
+*
+* export const adapter = defineAdapter({
+*   transformDocument: ({ document, operationType }) => {
+*     // Add @auth directive to all queries
+*     if (operationType === "query") {
+*       return visit(document, {
+*         OperationDefinition: (node) => ({
+*           ...node,
+*           directives: [
+*             ...(node.directives ?? []),
+*             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: "auth" } },
+*           ],
+*         }),
+*       });
+*     }
+*     return document;
+*   },
+* });
+* ```
+*
+* @example Using helpers for operation-level transform functions (recommended)
+* ```typescript
+* // Define transform functions as helpers for reusability
+* const adapter = defineAdapter({
+*   helpers: {
+*     transform: {
+*       addCacheDirective: (ttl: number) => ({ document }) => {
+*         return visit(document, { ... });
+*       },
+*     },
+*   },
+* });
+*
+* // Use helper in operation - clean and declarative
+* gql(({ query, transform }) =>
+*   query.operation({
+*     name: "GetUser",
+*     transformDocument: transform.addCacheDirective(300),
+*     fields: ({ f }) => ({ ... }),
+*   }),
+* );
+* ```
 */
 const defineAdapter = (adapter) => adapter;
 

package/dist/adapter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.cjs","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":["import type { Adapter } from \"../types/metadata\";\n\n/**\n * Helper function for defining a unified adapter with helpers and metadata.\n * Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.\n *\n * @example\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import type { FragmentMetaInfo, OperationMetadata } from \"@soda-gql/core\";\n *\n * export const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *       adminOnly: () => ({ requiresAuth: true, role: \"admin\" }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<OperationMetadata>[]) =>\n *       fragments.map((m) => m.metadata),\n *     schemaLevel: {\n *       apiVersion: \"v2\",\n *     },\n *   },\n * });\n * ```\n */\nexport const defineAdapter = <\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n>(\n  adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n): Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel> => adapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,iBAMX,YACoF"}
+{"version":3,"file":"adapter.cjs","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":["import type { Adapter } from \"../types/metadata\";\n\n/**\n * Helper function for defining a unified adapter with helpers, metadata, and document transformation.\n * Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.\n *\n * @example Basic adapter with helpers and metadata\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import type { FragmentMetaInfo, OperationMetadata } from \"@soda-gql/core\";\n *\n * export const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *       adminOnly: () => ({ requiresAuth: true, role: \"admin\" }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<OperationMetadata>[]) =>\n *       fragments.map((m) => m.metadata),\n *     schemaLevel: {\n *       apiVersion: \"v2\",\n *     },\n *   },\n * });\n * ```\n *\n * @example Adapter with document transformation\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import { Kind, visit } from \"graphql\";\n *\n * export const adapter = defineAdapter({\n *   transformDocument: ({ document, operationType }) => {\n *     // Add @auth directive to all queries\n *     if (operationType === \"query\") {\n *       return visit(document, {\n *         OperationDefinition: (node) => ({\n *           ...node,\n *           directives: [\n *             ...(node.directives ?? []),\n *             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: \"auth\" } },\n *           ],\n *         }),\n *       });\n *     }\n *     return document;\n *   },\n * });\n * ```\n *\n * @example Using helpers for operation-level transform functions (recommended)\n * ```typescript\n * // Define transform functions as helpers for reusability\n * const adapter = defineAdapter({\n *   helpers: {\n *     transform: {\n *       addCacheDirective: (ttl: number) => ({ document }) => {\n *         return visit(document, { ... });\n *       },\n *     },\n *   },\n * });\n *\n * // Use helper in operation - clean and declarative\n * gql(({ query, transform }) =>\n *   query.operation({\n *     name: \"GetUser\",\n *     transformDocument: transform.addCacheDirective(300),\n *     fields: ({ f }) => ({ ... }),\n *   }),\n * );\n * ```\n */\nexport const defineAdapter = <\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n>(\n  adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n): Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel> => adapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,MAAa,iBAMX,YACoF"}

package/dist/adapter.d.cts

@@ -1,13 +1,13 @@
-import { N as Adapter } from "./schema-CPTxQbTv.cjs";
-import { r as defineScalar } from "./schema-builder-BYJd50o2.cjs";
+import { t as Adapter } from "./index-zCOsREx0.cjs";
+import { r as defineScalar } from "./schema-builder-BI5PQkH7.cjs";
 
 //#region packages/core/src/adapter/define-adapter.d.ts
 
 /**
- * Helper function for defining a unified adapter with helpers and metadata.
- * Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.
+ * Helper function for defining a unified adapter with helpers, metadata, and document transformation.
+ * Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.
  *
- * @example
+ * @example Basic adapter with helpers and metadata
  * ```typescript
  * import { defineAdapter } from "@soda-gql/core/adapter";
  * import type { FragmentMetaInfo, OperationMetadata } from "@soda-gql/core";
@@ -28,6 +28,53 @@ import { r as defineScalar } from "./schema-builder-BYJd50o2.cjs";
  *   },
  * });
  * ```
+ *
+ * @example Adapter with document transformation
+ * ```typescript
+ * import { defineAdapter } from "@soda-gql/core/adapter";
+ * import { Kind, visit } from "graphql";
+ *
+ * export const adapter = defineAdapter({
+ *   transformDocument: ({ document, operationType }) => {
+ *     // Add @auth directive to all queries
+ *     if (operationType === "query") {
+ *       return visit(document, {
+ *         OperationDefinition: (node) => ({
+ *           ...node,
+ *           directives: [
+ *             ...(node.directives ?? []),
+ *             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: "auth" } },
+ *           ],
+ *         }),
+ *       });
+ *     }
+ *     return document;
+ *   },
+ * });
+ * ```
+ *
+ * @example Using helpers for operation-level transform functions (recommended)
+ * ```typescript
+ * // Define transform functions as helpers for reusability
+ * const adapter = defineAdapter({
+ *   helpers: {
+ *     transform: {
+ *       addCacheDirective: (ttl: number) => ({ document }) => {
+ *         return visit(document, { ... });
+ *       },
+ *     },
+ *   },
+ * });
+ *
+ * // Use helper in operation - clean and declarative
+ * gql(({ query, transform }) =>
+ *   query.operation({
+ *     name: "GetUser",
+ *     transformDocument: transform.addCacheDirective(300),
+ *     fields: ({ f }) => ({ ... }),
+ *   }),
+ * );
+ * ```
  */
 declare const defineAdapter: <THelpers extends object = object, TFragmentMetadata = unknown, TAggregatedFragmentMetadata = unknown, TSchemaLevel = unknown>(adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>) => Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;
 //#endregion

package/dist/adapter.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.cts","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;;cAAa,uJAMF,QAAQ,UAAU,mBAAmB,6BAA6B,kBAC1E,QAAQ,UAAU,mBAAmB,6BAA6B"}
+{"version":3,"file":"adapter.d.cts","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA2EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,uJAMF,QAAQ,UAAU,mBAAmB,6BAA6B,kBAC1E,QAAQ,UAAU,mBAAmB,6BAA6B"}

package/dist/adapter.d.ts

@@ -1,13 +1,13 @@
-import { N as Adapter } from "./schema-2qqtKss4.js";
-import { r as defineScalar } from "./schema-builder-Dhss2O1I.js";
+import { t as Adapter } from "./index-BlVgxrXb.js";
+import { r as defineScalar } from "./schema-builder-CF_AwsOM.js";
 
 //#region packages/core/src/adapter/define-adapter.d.ts
 
 /**
- * Helper function for defining a unified adapter with helpers and metadata.
- * Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.
+ * Helper function for defining a unified adapter with helpers, metadata, and document transformation.
+ * Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.
  *
- * @example
+ * @example Basic adapter with helpers and metadata
  * ```typescript
  * import { defineAdapter } from "@soda-gql/core/adapter";
  * import type { FragmentMetaInfo, OperationMetadata } from "@soda-gql/core";
@@ -28,6 +28,53 @@ import { r as defineScalar } from "./schema-builder-Dhss2O1I.js";
  *   },
  * });
  * ```
+ *
+ * @example Adapter with document transformation
+ * ```typescript
+ * import { defineAdapter } from "@soda-gql/core/adapter";
+ * import { Kind, visit } from "graphql";
+ *
+ * export const adapter = defineAdapter({
+ *   transformDocument: ({ document, operationType }) => {
+ *     // Add @auth directive to all queries
+ *     if (operationType === "query") {
+ *       return visit(document, {
+ *         OperationDefinition: (node) => ({
+ *           ...node,
+ *           directives: [
+ *             ...(node.directives ?? []),
+ *             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: "auth" } },
+ *           ],
+ *         }),
+ *       });
+ *     }
+ *     return document;
+ *   },
+ * });
+ * ```
+ *
+ * @example Using helpers for operation-level transform functions (recommended)
+ * ```typescript
+ * // Define transform functions as helpers for reusability
+ * const adapter = defineAdapter({
+ *   helpers: {
+ *     transform: {
+ *       addCacheDirective: (ttl: number) => ({ document }) => {
+ *         return visit(document, { ... });
+ *       },
+ *     },
+ *   },
+ * });
+ *
+ * // Use helper in operation - clean and declarative
+ * gql(({ query, transform }) =>
+ *   query.operation({
+ *     name: "GetUser",
+ *     transformDocument: transform.addCacheDirective(300),
+ *     fields: ({ f }) => ({ ... }),
+ *   }),
+ * );
+ * ```
  */
 declare const defineAdapter: <THelpers extends object = object, TFragmentMetadata = unknown, TAggregatedFragmentMetadata = unknown, TSchemaLevel = unknown>(adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>) => Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;
 //#endregion

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;;cAAa,uJAMF,QAAQ,UAAU,mBAAmB,6BAA6B,kBAC1E,QAAQ,UAAU,mBAAmB,6BAA6B"}
+{"version":3,"file":"adapter.d.ts","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA2EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,uJAMF,QAAQ,UAAU,mBAAmB,6BAA6B,kBAC1E,QAAQ,UAAU,mBAAmB,6BAA6B"}

package/dist/adapter.js

@@ -2,10 +2,10 @@ import { r as defineScalar } from "./schema-BiYcVVvm.js";
 
 //#region packages/core/src/adapter/define-adapter.ts
 /**
-* Helper function for defining a unified adapter with helpers and metadata.
-* Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.
+* Helper function for defining a unified adapter with helpers, metadata, and document transformation.
+* Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.
 *
-* @example
+* @example Basic adapter with helpers and metadata
 * ```typescript
 * import { defineAdapter } from "@soda-gql/core/adapter";
 * import type { FragmentMetaInfo, OperationMetadata } from "@soda-gql/core";
@@ -26,6 +26,53 @@ import { r as defineScalar } from "./schema-BiYcVVvm.js";
 *   },
 * });
 * ```
+*
+* @example Adapter with document transformation
+* ```typescript
+* import { defineAdapter } from "@soda-gql/core/adapter";
+* import { Kind, visit } from "graphql";
+*
+* export const adapter = defineAdapter({
+*   transformDocument: ({ document, operationType }) => {
+*     // Add @auth directive to all queries
+*     if (operationType === "query") {
+*       return visit(document, {
+*         OperationDefinition: (node) => ({
+*           ...node,
+*           directives: [
+*             ...(node.directives ?? []),
+*             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: "auth" } },
+*           ],
+*         }),
+*       });
+*     }
+*     return document;
+*   },
+* });
+* ```
+*
+* @example Using helpers for operation-level transform functions (recommended)
+* ```typescript
+* // Define transform functions as helpers for reusability
+* const adapter = defineAdapter({
+*   helpers: {
+*     transform: {
+*       addCacheDirective: (ttl: number) => ({ document }) => {
+*         return visit(document, { ... });
+*       },
+*     },
+*   },
+* });
+*
+* // Use helper in operation - clean and declarative
+* gql(({ query, transform }) =>
+*   query.operation({
+*     name: "GetUser",
+*     transformDocument: transform.addCacheDirective(300),
+*     fields: ({ f }) => ({ ... }),
+*   }),
+* );
+* ```
 */
 const defineAdapter = (adapter) => adapter;
 

package/dist/adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.js","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":["import type { Adapter } from \"../types/metadata\";\n\n/**\n * Helper function for defining a unified adapter with helpers and metadata.\n * Provides type inference for helpers, aggregateFragmentMetadata and schemaLevel.\n *\n * @example\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import type { FragmentMetaInfo, OperationMetadata } from \"@soda-gql/core\";\n *\n * export const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *       adminOnly: () => ({ requiresAuth: true, role: \"admin\" }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<OperationMetadata>[]) =>\n *       fragments.map((m) => m.metadata),\n *     schemaLevel: {\n *       apiVersion: \"v2\",\n *     },\n *   },\n * });\n * ```\n */\nexport const defineAdapter = <\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n>(\n  adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n): Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel> => adapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,iBAMX,YACoF"}
+{"version":3,"file":"adapter.js","names":[],"sources":["../src/adapter/define-adapter.ts"],"sourcesContent":["import type { Adapter } from \"../types/metadata\";\n\n/**\n * Helper function for defining a unified adapter with helpers, metadata, and document transformation.\n * Provides type inference for helpers, aggregateFragmentMetadata, schemaLevel, and transformDocument.\n *\n * @example Basic adapter with helpers and metadata\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import type { FragmentMetaInfo, OperationMetadata } from \"@soda-gql/core\";\n *\n * export const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *       adminOnly: () => ({ requiresAuth: true, role: \"admin\" }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<OperationMetadata>[]) =>\n *       fragments.map((m) => m.metadata),\n *     schemaLevel: {\n *       apiVersion: \"v2\",\n *     },\n *   },\n * });\n * ```\n *\n * @example Adapter with document transformation\n * ```typescript\n * import { defineAdapter } from \"@soda-gql/core/adapter\";\n * import { Kind, visit } from \"graphql\";\n *\n * export const adapter = defineAdapter({\n *   transformDocument: ({ document, operationType }) => {\n *     // Add @auth directive to all queries\n *     if (operationType === \"query\") {\n *       return visit(document, {\n *         OperationDefinition: (node) => ({\n *           ...node,\n *           directives: [\n *             ...(node.directives ?? []),\n *             { kind: Kind.DIRECTIVE, name: { kind: Kind.NAME, value: \"auth\" } },\n *           ],\n *         }),\n *       });\n *     }\n *     return document;\n *   },\n * });\n * ```\n *\n * @example Using helpers for operation-level transform functions (recommended)\n * ```typescript\n * // Define transform functions as helpers for reusability\n * const adapter = defineAdapter({\n *   helpers: {\n *     transform: {\n *       addCacheDirective: (ttl: number) => ({ document }) => {\n *         return visit(document, { ... });\n *       },\n *     },\n *   },\n * });\n *\n * // Use helper in operation - clean and declarative\n * gql(({ query, transform }) =>\n *   query.operation({\n *     name: \"GetUser\",\n *     transformDocument: transform.addCacheDirective(300),\n *     fields: ({ f }) => ({ ... }),\n *   }),\n * );\n * ```\n */\nexport const defineAdapter = <\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n>(\n  adapter: Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n): Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel> => adapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2EA,MAAa,iBAMX,YACoF"}

package/dist/{index-Ib9pb2Si.d.cts → index-B_TU5U2U.d.ts}

@@ -1,4 +1,4 @@
-import { C as ObjectTypeProfile, Ct as GetSignature, Et as ConstValue, F as AnyMetadataAdapter, G as FragmentMetadataBuilder, I as DefaultAdapter, L as DefaultMetadataAdapter, N as Adapter, Ot as FieldPath, P as AnyAdapter, R as ExtractAdapterTypes, S as GetModifiedType, St as ApplyTypeModifier, T as TypeProfile, X as AnyVarRef, Z as AnyVarRefBrand, bt as OutputTypenameSpecifier, c as InferOutputProfile, dt as InputTypeSpecifier, et as VarRef, f as ObjectFieldRecord, ft as InputTypeSpecifiers, g as ResolveInputProfileFromMeta, gt as OutputScalarSpecifier, h as PickTypeSpecifierByFieldName, ht as OutputObjectSpecifier, i as AnyTypeName, it as AnyDefaultValue, m as OperationType, mt as OutputInferrableTypeSpecifier, n as AnyFieldName, o as InferInputKind, pt as OutputEnumSpecifier, q as MetadataBuilder, r as AnyGraphqlSchema, s as InferInputProfile, t as AllInputTypeNames, ut as InputTypeKind, vt as OutputTypeSpecifier, w as PrimitiveTypeProfile, wt as TypeModifier, x as GetConstAssignableType, xt as OutputUnionSpecifier, y as UnionMemberName } from "./schema-CPTxQbTv.cjs";
+import { At as ConstValue, B as UnionMemberName, C as AnyFieldName, D as InferInputKind, F as OperationType, H as AnyVarRef, I as PickTypeSpecifierByFieldName, K as VarRef, L as ResolveInputProfileFromMeta, Mt as FieldPath, N as ObjectFieldRecord, O as InferInputProfile, S as AllInputTypeNames, T as AnyTypeName, U as AnyVarRefBrand, X as AnyDefaultValue, _ as FragmentMetadataBuilder, _t as PrimitiveTypeProfile, a as DefaultMetadataAdapter, at as OutputEnumSpecifier, bt as GetSignature, c as ExtractAdapterTypes, ct as OutputScalarSpecifier, ft as OutputTypenameSpecifier, gt as ObjectTypeProfile, ht as GetModifiedType, i as DefaultAdapter, it as InputTypeSpecifiers, k as InferOutputProfile, mt as GetConstAssignableType, n as AnyAdapter, nt as InputTypeKind, ot as OutputInferrableTypeSpecifier, p as OperationDocumentTransformer, pt as OutputUnionSpecifier, r as AnyMetadataAdapter, rt as InputTypeSpecifier, s as DocumentTransformer, st as OutputObjectSpecifier, t as Adapter, ut as OutputTypeSpecifier, vt as TypeProfile, w as AnyGraphqlSchema, xt as TypeModifier, y as MetadataBuilder, yt as ApplyTypeModifier } from "./index-BlVgxrXb.js";
 import { ConstValueNode, NamedTypeNode, OperationTypeNode, TypeNode, ValueNode } from "graphql";
 import { TypedDocumentNode } from "@graphql-typed-document-node/core";
 
@@ -1074,8 +1074,10 @@ declare const createVarBuilder: <TSchema extends AnyGraphqlSchema>(inputTypeMeth
 type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation>(composeElement: (context: TContext) => TResult) => TResult;
 /**
  * Extracts the helpers type from an adapter.
+ * Uses `any` for non-target type parameters to avoid contravariance issues
+ * with the `aggregateFragmentMetadata` function parameter type.
  */
-type ExtractHelpers<TAdapter extends AnyAdapter> = TAdapter extends Adapter<infer THelpers, unknown, unknown, unknown> ? THelpers : object;
+type ExtractHelpers<TAdapter extends AnyAdapter> = TAdapter extends Adapter<infer THelpers, any, any, any> ? THelpers : object;
 /**
  * Extracts the metadata adapter type from an adapter.
  * Handles optional metadata property correctly.
@@ -1140,6 +1142,7 @@ declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TFrag
       variables?: TVarDefinitions | undefined;
       metadata?: MetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
       fields: FieldsBuilder<TSchema, TSchema["operations"]["query"] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
+      transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
     }) => Operation<"query", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
   };
   mutation: {
@@ -1148,6 +1151,7 @@ declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TFrag
       variables?: TVarDefinitions | undefined;
       metadata?: MetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
       fields: FieldsBuilder<TSchema, TSchema["operations"]["mutation"] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
+      transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
     }) => Operation<"mutation", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
   };
   subscription: {
@@ -1156,6 +1160,7 @@ declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TFrag
       variables?: TVarDefinitions | undefined;
       metadata?: MetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
       fields: FieldsBuilder<TSchema, TSchema["operations"]["subscription"] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
+      transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
     }) => Operation<"subscription", TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
   };
   $var: VarBuilder<TSchema>;
@@ -1175,15 +1180,17 @@ declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TFrag
  *
  * @param schema - The GraphQL schema definition
  * @param adapter - Optional metadata adapter for custom metadata handling
+ * @param transformDocument - Optional document transformer called after building
  * @returns Operation type selector function
  *
  * @internal Used by `createGqlElementComposer`
  */
-declare const createOperationComposerFactory: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, adapter?: TAdapter) => <TOperationType extends OperationType>(operationType: TOperationType) => <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
+declare const createOperationComposerFactory: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, adapter?: TAdapter, transformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>) => <TOperationType extends OperationType>(operationType: TOperationType) => <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}, TOperationMetadata = unknown>(options: {
   name: TOperationName;
   variables?: TVarDefinitions;
   metadata?: MetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
   fields: FieldsBuilder<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, TVarDefinitions, TFields>;
+  transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
 }) => Operation<TOperationType, TOperationName, (keyof TVarDefinitions & string)[], ConstAssignableInput<TSchema, TVarDefinitions>, TFields, InferFields<TSchema, TFields>>;
 //#endregion
 //#region packages/core/src/utils/hidden.d.ts
@@ -1194,4 +1201,4 @@ type Hidden<T> = () => T;
 declare function wrapByKey<TName$1 extends string, TValue$1>(name: TName$1, value: TValue$1): { [K in TName$1]: TValue$1 };
 //#endregion
 export { NestedUnionFieldsBuilder as $, AnyDirectiveRefBrand as $t, AnyOperationOf as A, AbstractFieldSelection as At, AnyFieldSelectionFactory as B, AnyAssignableInputValue as Bt, withFragmentUsageCollection as C, Tuple as Ct, createVarRefs as D, buildDocument as Dt, createVarAssignments as E, buildConstValueNode as Et, FragmentInferMeta as F, FieldSelectionTemplateOf as Ft, FieldSelectionFactoryObjectReturn as G, FieldArgumentValue as Gt, FieldSelectionFactories as H, AssignableInput as Ht, GqlElement as I, InferField as It, FieldSelectionFactoryUnionReturn as J, AnyConstAssignableInputValue as Jt, FieldSelectionFactoryPrimitiveReturn as K, AnyConstDirectiveAttachments as Kt, GqlElementAttachment as L, InferFields as Lt, OperationInferMeta as M, AnyFields as Mt, AnyFragment as N, AnyNestedObject as Nt, createFieldFactories as O, buildOperationTypeNode as Ot, Fragment as P, AnyNestedUnion as Pt, NestedObjectFieldsBuilderTools as Q, AnyDirectiveRef as Qt, GqlElementContext as R, AnyDirectiveAttachments as Rt, recordFragmentUsage as S, StripSymbols as St, createGqlFragmentComposers as T, buildArgumentValue as Tt, FieldSelectionFactory as U, AssignableInputByFieldName as Ut, AnyFieldSelectionFactoryReturn as V, AnyAssigningInput as Vt, FieldSelectionFactoryFieldArguments as W, DeclaredVariables as Wt, FieldsBuilderTools as X, ConstAssignableInputValue as Xt, FieldsBuilder as Y, ConstAssignableInput as Yt, NestedObjectFieldsBuilder as Z, GetAssignableType as Zt, VarSpecifier as _, ColocateHelper as _t, ExtractMetadataAdapter as a, AttachmentShape as at, createVarMethodFactory as b, createColocateHelper as bt, GqlElementComposerOptions as c, AnyDirectiveMethod as ct, InputTypeMethods as d, DirectiveMethod as dt, DirectiveLocation as en, EmptyObject as et, ResolveTypeFromMeta as f, StandardDirectives as ft, VarBuilderMethods as g, isDirectiveRef as gt, VarBuilder as h, createStandardDirectives as ht, createOperationComposerFactory as i, empty as it, Operation as j, AnyFieldSelection as jt, AnyOperation as k, buildWithTypeModifier as kt, createGqlElementComposer as l, DirectiveArgValue as lt, SchemaAwareGetValueAt as m, createDirectiveMethod as mt, Hidden as n, DirectiveRefInner as nn, OptionalArg as nt, FragmentBuildersAll as o, AttachmentToProperty as ot, SchemaAwareGetNameAt as p, createDirectiveBuilder as pt, FieldSelectionFactoryReturn as q, AnyConstAssignableInput as qt, hidden as r, SwitchIfOmittable as rt, GqlElementComposer as s, AttachmentsTupleToIntersection as st, wrapByKey as t, DirectiveRef as tn, IfOmittable as tt, InputTypeMethod as u, DirectiveBuilder as ut, createVarBuilder as v, ColocatedEntries as vt, FragmentBuilderFor as w, UnionToIntersection as wt, FragmentUsageRecord as x, StripFunctions as xt, createVarMethod as y, ColocatedFields as yt, GqlElementDefinitionFactory as z, AnyAssignableInput as zt };
-//# sourceMappingURL=index-Ib9pb2Si.d.cts.map
+//# sourceMappingURL=index-B_TU5U2U.d.ts.map