@soda-gql/core 0.8.0 → 0.9.0

package/dist/index.cjs

@@ -1,6 +1,37 @@
-const require_schema = require('./schema-DuWaRhdp.cjs');
+const require_schema = require('./schema-D2MW4DOF.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) {
@@ -33,6 +64,12 @@ function createVarRefFromNestedValue(value) {
 
 //#endregion
 //#region packages/core/src/composer/build-document.ts
+/**
+* Converts an assignable input value to a GraphQL AST ValueNode.
+*
+* Handles primitives, arrays, objects, and variable references.
+* Returns null for undefined values (field is omitted).
+*/
 const buildArgumentValue = (value) => {
 	if (value === void 0) return null;
 	if (value === null) return { kind: graphql.Kind.NULL };
@@ -91,6 +128,41 @@ const buildArguments = (args) => Object.entries(args ?? {}).map(([name, value])
 		value: valueNode
 	} : null;
 }).filter((item) => item !== null);
+/**
+* Validates that a directive can be used at the specified location.
+*
+* @param directive - The directive reference to validate
+* @param expectedLocation - The location where the directive is being used
+* @throws Error if the directive is not valid at the specified location
+*/
+const validateDirectiveLocation = (directive, expectedLocation) => {
+	const inner = DirectiveRef.getInner(directive);
+	if (!inner.locations.includes(expectedLocation)) throw new Error(`Directive @${inner.name} cannot be used on ${expectedLocation}. Valid locations: ${inner.locations.join(", ")}`);
+};
+/**
+* Builds DirectiveNode array from field directives.
+*
+* Filters for DirectiveRef instances, validates their locations,
+* and converts them to GraphQL AST DirectiveNode objects.
+*
+* @param directives - Array of directive references (or unknown values)
+* @param location - The location context for validation
+* @returns Array of DirectiveNode for the GraphQL AST
+*/
+const buildDirectives = (directives, location) => {
+	return directives.filter((d) => d instanceof DirectiveRef).map((directive) => {
+		validateDirectiveLocation(directive, location);
+		const inner = DirectiveRef.getInner(directive);
+		return {
+			kind: graphql.Kind.DIRECTIVE,
+			name: {
+				kind: graphql.Kind.NAME,
+				value: inner.name
+			},
+			arguments: buildArguments(inner.arguments)
+		};
+	});
+};
 const buildUnionSelection = (union) => Object.entries(union).map(([typeName, object]) => {
 	return object ? {
 		kind: graphql.Kind.INLINE_FRAGMENT,
@@ -107,25 +179,35 @@ const buildUnionSelection = (union) => Object.entries(union).map(([typeName, obj
 		}
 	} : null;
 }).filter((item) => item !== null);
-const buildField = (field) => Object.entries(field).map(([alias, { args, field: field$1, object, union }]) => ({
-	kind: graphql.Kind.FIELD,
-	name: {
-		kind: graphql.Kind.NAME,
-		value: field$1
-	},
-	alias: alias !== field$1 ? {
-		kind: graphql.Kind.NAME,
-		value: alias
-	} : void 0,
-	arguments: buildArguments(args),
-	selectionSet: object ? {
-		kind: graphql.Kind.SELECTION_SET,
-		selections: buildField(object)
-	} : union ? {
-		kind: graphql.Kind.SELECTION_SET,
-		selections: buildUnionSelection(union)
-	} : void 0
-}));
+const buildField = (field) => Object.entries(field).map(([alias, { args, field: field$1, object, union, directives }]) => {
+	const builtDirectives = buildDirectives(directives, "FIELD");
+	return {
+		kind: graphql.Kind.FIELD,
+		name: {
+			kind: graphql.Kind.NAME,
+			value: field$1
+		},
+		alias: alias !== field$1 ? {
+			kind: graphql.Kind.NAME,
+			value: alias
+		} : void 0,
+		arguments: buildArguments(args),
+		directives: builtDirectives.length > 0 ? builtDirectives : void 0,
+		selectionSet: object ? {
+			kind: graphql.Kind.SELECTION_SET,
+			selections: buildField(object)
+		} : union ? {
+			kind: graphql.Kind.SELECTION_SET,
+			selections: buildUnionSelection(union)
+		} : void 0
+	};
+});
+/**
+* Converts a constant value to a GraphQL AST ConstValueNode.
+*
+* Unlike `buildArgumentValue`, this only handles literal values
+* (no variable references). Used for default values.
+*/
 const buildConstValueNode = (value) => {
 	if (value === void 0) return null;
 	if (value === null) return { kind: graphql.Kind.NULL };
@@ -161,6 +243,18 @@ const buildConstValueNode = (value) => {
 	};
 	throw new Error(`Unknown value type: ${typeof value}`);
 };
+/**
+* Wraps a named type with modifiers (non-null, list).
+*
+* Modifier format: starts with `?` (nullable) or `!` (non-null),
+* followed by `[]?` or `[]!` pairs for lists.
+*
+* @example
+* - `"!"` → `String!`
+* - `"?"` → `String`
+* - `"![]!"` → `[String!]!`
+* - `"?[]?"` → `[String]`
+*/
 const buildWithTypeModifier = (modifier, buildType) => {
 	const baseType = buildType();
 	if (modifier === "?") return baseType;
@@ -238,6 +332,9 @@ const buildVariables = (variables) => {
 		}))
 	}));
 };
+/**
+* Converts an operation type string to a GraphQL AST OperationTypeNode.
+*/
 const buildOperationTypeNode = (operation) => {
 	switch (operation) {
 		case "query": return graphql.OperationTypeNode.QUERY;
@@ -246,6 +343,16 @@ const buildOperationTypeNode = (operation) => {
 		default: throw new Error(`Unknown operation type: ${operation}`);
 	}
 };
+/**
+* Builds a TypedDocumentNode from operation options.
+*
+* This is the main entry point for converting field selections into
+* a GraphQL document AST. The result can be used with any GraphQL
+* client that supports TypedDocumentNode.
+*
+* @param options - Operation configuration (name, type, variables, fields)
+* @returns TypedDocumentNode with inferred input/output types
+*/
 const buildDocument = (options) => {
 	const { operationName, operationType, variables, fields } = options;
 	return {
@@ -304,6 +411,85 @@ const createColocateHelper = () => {
 	return $colocate;
 };
 
+//#endregion
+//#region packages/core/src/composer/directive-builder.ts
+/**
+* Directive builder utilities for creating field-level directives.
+*
+* Provides type-safe methods for creating directive references that can be
+* applied to field selections. The builder follows a similar pattern to
+* the variable builder ($var).
+*
+* @module
+*/
+/**
+* Creates a directive method factory for a specific directive.
+*
+* @param name - The directive name (without @)
+* @param locations - Valid locations where the directive can be applied
+* @returns A function that creates DirectiveRef instances
+*
+* @example
+* ```typescript
+* const skipMethod = createDirectiveMethod("skip", ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"] as const);
+* const skipDirective = skipMethod({ if: true });
+* ```
+*/
+const createDirectiveMethod = (name, locations) => {
+	return (args) => new DirectiveRef({
+		name,
+		arguments: args,
+		locations
+	});
+};
+/**
+* Standard directive locations for @skip and @include.
+*/
+const CONDITIONAL_DIRECTIVE_LOCATIONS = [
+	"FIELD",
+	"FRAGMENT_SPREAD",
+	"INLINE_FRAGMENT"
+];
+/**
+* Creates the standard GraphQL directives (@skip, @include).
+* These are always available regardless of schema definition.
+*
+* @returns Object containing skip and include directive methods
+*
+* @example
+* ```typescript
+* const $dir = createStandardDirectives();
+* const skipDirective = $dir.skip({ if: true });
+* ```
+*/
+const createStandardDirectives = () => ({
+	skip: createDirectiveMethod("skip", CONDITIONAL_DIRECTIVE_LOCATIONS),
+	include: createDirectiveMethod("include", CONDITIONAL_DIRECTIVE_LOCATIONS)
+});
+/**
+* Creates a directive builder with standard directives and optional custom directives.
+*
+* @param customDirectives - Additional directive methods from schema (generated by codegen)
+* @returns Combined directive builder with all available directives
+*
+* @internal Used by codegen to create schema-specific directive builders
+*/
+const createDirectiveBuilder = (customDirectives) => {
+	return {
+		...createStandardDirectives(),
+		...customDirectives ?? {}
+	};
+};
+/**
+* Type guard to check if a value is a DirectiveRef.
+*
+* @param value - Value to check
+* @returns True if value is a DirectiveRef instance
+*/
+const isDirectiveRef = (value) => {
+	return value instanceof DirectiveRef;
+};
+
 //#endregion
 //#region packages/core/src/composer/field-path-context.ts
 /**
@@ -387,6 +573,18 @@ const ensureCacheMapBySchema = (schema) => {
 	cacheMapBySchema.set(schema, cacheMap);
 	return cacheMap;
 };
+/**
+* Creates field selection factories for a given object type.
+*
+* Returns an object with a factory for each field defined on the type.
+* Factories are cached per schema+type to avoid recreation.
+*
+* @param schema - The GraphQL schema definition
+* @param typeName - The object type name to create factories for
+* @returns Object mapping field names to their selection factories
+*
+* @internal Used by operation and fragment composers
+*/
 const createFieldFactories = (schema, typeName) => {
 	const cacheMap = ensureCacheMapBySchema(schema);
 	const cached = cacheMap.get(typeName);
@@ -401,6 +599,7 @@ const createFieldFactoriesInner = (schema, typeName) => {
 	const entries = Object.entries(typeDef.fields).map(([fieldName, type]) => {
 		const factory = (fieldArgs, extras) => {
 			const wrap = (value) => require_schema.wrapByKey(extras?.alias ?? fieldName, value);
+			const directives = extras?.directives ?? [];
 			if (type.kind === "object") {
 				const factoryReturn = ((nest) => {
 					const nestedFields = withFieldPath(appendToPath(getCurrentFieldPath(), {
@@ -413,7 +612,7 @@ const createFieldFactoriesInner = (schema, typeName) => {
 						field: fieldName,
 						type,
 						args: fieldArgs ?? {},
-						directives: extras?.directives ?? {},
+						directives,
 						object: nestedFields,
 						union: null
 					});
@@ -435,7 +634,7 @@ const createFieldFactoriesInner = (schema, typeName) => {
 						field: fieldName,
 						type,
 						args: fieldArgs ?? {},
-						directives: extras?.directives ?? {},
+						directives,
 						object: null,
 						union: nestedUnion
 					});
@@ -447,7 +646,7 @@ const createFieldFactoriesInner = (schema, typeName) => {
 				field: fieldName,
 				type,
 				args: fieldArgs ?? {},
-				directives: extras?.directives ?? {},
+				directives,
 				object: null,
 				union: null
 			});
@@ -509,6 +708,15 @@ const evaluateSync = (executor, context) => {
 //#region packages/core/src/types/element/gql-element.ts
 const GQL_ELEMENT_FACTORY = Symbol("GQL_ELEMENT_FACTORY");
 const GQL_ELEMENT_CONTEXT = Symbol("GQL_ELEMENT_CONTEXT");
+/**
+* Abstract base class for all GraphQL elements (Fragment, Operation).
+*
+* Uses lazy evaluation with caching - definition is computed on first access.
+* Subclasses should not be instantiated directly; use static `create` methods.
+*
+* @template TDefinition - The shape of the evaluated definition
+* @template TInfer - Type inference metadata (access via `$infer`)
+*/
 var GqlElement = class GqlElement {
 	[GQL_ELEMENT_FACTORY];
 	[GQL_ELEMENT_CONTEXT] = null;
@@ -518,30 +726,55 @@ var GqlElement = class GqlElement {
 			throw new Error("This property is only for type meta. Do not access this property directly.");
 		} });
 	}
-	attach(attachment) {
-		let cache = null;
-		Object.defineProperty(this, attachment.name, { get() {
-			if (cache) return cache;
-			GqlElement.evaluateInstantly(this);
-			return cache = attachment.createValue(this);
-		} });
+	attach(attachmentOrAttachments) {
+		const attachments = Array.isArray(attachmentOrAttachments) ? attachmentOrAttachments : [attachmentOrAttachments];
+		for (const attachment of attachments) {
+			let cache = null;
+			const self = this;
+			Object.defineProperty(this, attachment.name, { get() {
+				if (cache) return cache;
+				GqlElement.evaluateInstantly(self);
+				return cache = attachment.createValue(self);
+			} });
+		}
 		return this;
 	}
+	/**
+	* Sets the canonical context for an element. Used by the builder.
+	* @internal
+	*/
 	static setContext(element, context) {
 		element[GQL_ELEMENT_CONTEXT] = context;
 	}
+	/**
+	* Gets the canonical context of an element, if set.
+	* @internal
+	*/
 	static getContext(element) {
 		return element[GQL_ELEMENT_CONTEXT];
 	}
+	/**
+	* Creates a generator for async evaluation. Used by the builder.
+	* @internal
+	*/
 	static createEvaluationGenerator(element) {
 		return createEvaluationGenerator(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);
 	}
 	static evaluateInstantly(element) {
 		return evaluateSync(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);
 	}
+	/**
+	* Forces synchronous evaluation. Throws if async operation is needed.
+	* @internal
+	*/
 	static evaluateSync(element) {
 		GqlElement.evaluateInstantly(element);
 	}
+	/**
+	* Evaluates and returns the element's definition.
+	* Throws if async operation is needed.
+	* @internal
+	*/
 	static get(element) {
 		return GqlElement.evaluateInstantly(element);
 	}
@@ -549,16 +782,37 @@ var GqlElement = class GqlElement {
 
 //#endregion
 //#region packages/core/src/types/element/fragment.ts
+/**
+* Represents a reusable GraphQL field selection on a specific type.
+*
+* Fragments are created via `gql(({ fragment }) => fragment.TypeName({ ... }))`.
+* Use `spread()` to include the fragment's fields in an operation.
+*
+* @template TTypeName - The GraphQL type this fragment selects from
+* @template TVariables - Variables required when spreading
+* @template TFields - The selected fields structure
+* @template TOutput - Inferred output type from selected fields
+*/
 var Fragment = class Fragment extends GqlElement {
 	constructor(define$1) {
 		super(define$1);
 	}
+	/** The GraphQL type name this fragment selects from. */
 	get typename() {
 		return GqlElement.get(this).typename;
 	}
+	/**
+	* Spreads this fragment's fields into a parent selection.
+	* Pass variables if the fragment defines any.
+	*/
 	get spread() {
 		return GqlElement.get(this).spread;
 	}
+	/**
+	* Creates a new Fragment instance.
+	* Prefer using the `gql(({ fragment }) => ...)` API instead.
+	* @internal
+	*/
 	static create(define$1) {
 		return new Fragment(define$1);
 	}
@@ -566,28 +820,55 @@ var Fragment = class Fragment extends GqlElement {
 
 //#endregion
 //#region packages/core/src/types/element/operation.ts
+/**
+* Represents a GraphQL operation (query, mutation, or subscription).
+*
+* Operations are created via `gql(({ query }) => query.operation({ ... }))`.
+* Produces a TypedDocumentNode for type-safe execution with GraphQL clients.
+*
+* @template TOperationType - 'query' | 'mutation' | 'subscription'
+* @template TOperationName - The unique operation name
+* @template TVariableNames - Tuple of variable names
+* @template TVariables - Variable types for the operation
+* @template TFields - Selected fields structure
+* @template TData - Inferred response data type
+*/
 var Operation = class Operation extends GqlElement {
 	constructor(define$1) {
 		super(define$1);
 	}
+	/** The operation type: 'query', 'mutation', or 'subscription'. */
 	get operationType() {
 		return GqlElement.get(this).operationType;
 	}
+	/** The unique name of this operation. */
 	get operationName() {
 		return GqlElement.get(this).operationName;
 	}
+	/** List of variable names defined for this operation. */
 	get variableNames() {
 		return GqlElement.get(this).variableNames;
 	}
+	/**
+	* Returns the field selections. Used for document reconstruction.
+	* @internal
+	*/
 	get documentSource() {
 		return GqlElement.get(this).documentSource;
 	}
+	/** The TypedDocumentNode for use with GraphQL clients. */
 	get document() {
 		return GqlElement.get(this).document;
 	}
+	/** Custom metadata attached to this operation, if any. */
 	get metadata() {
 		return GqlElement.get(this).metadata;
 	}
+	/**
+	* Creates a new Operation instance.
+	* Prefer using the `gql(({ query }) => ...)` API instead.
+	* @internal
+	*/
 	static create(define$1) {
 		return new Operation(define$1);
 	}
@@ -631,6 +912,21 @@ const recordFragmentUsage = (record) => {
 
 //#endregion
 //#region packages/core/src/composer/input.ts
+/**
+* Utilities for creating variable assignments and references.
+* @module
+*/
+/**
+* Creates variable assignments from provided values.
+*
+* Maps variable definitions to VarRefs. If a value is provided,
+* wraps it as a nested-value VarRef. If not provided, creates
+* an undefined VarRef (field will be omitted).
+*
+* Used when spreading fragments with partial variable values.
+*
+* @internal
+*/
 const createVarAssignments = (definitions, providedValues) => {
 	return mapValues(definitions, (_, key) => {
 		const varName = key;
@@ -640,10 +936,34 @@ const createVarAssignments = (definitions, providedValues) => {
 		return createVarRefFromNestedValue(provided);
 	});
 };
+/**
+* Creates variable references from variable definitions.
+*
+* Maps each variable definition to a VarRef pointing to that variable.
+* Used in operation builders to create the `$` context object.
+*
+* @internal
+*/
 const createVarRefs = (definitions) => mapValues(definitions, (_, name) => createVarRefFromVariable(name));
 
 //#endregion
 //#region packages/core/src/composer/fragment.ts
+/**
+* Fragment composer factory for creating reusable field selections.
+* @module
+*/
+/**
+* Creates fragment builder functions for all object types in the schema.
+*
+* Returns an object with a builder for each type (e.g., `fragment.User`, `fragment.Post`).
+* Each builder creates a `Fragment` that can be spread into operations.
+*
+* @param schema - The GraphQL schema definition
+* @param _adapter - Optional metadata adapter (for fragment metadata)
+* @returns Object mapping type names to fragment builder functions
+*
+* @internal Used by `createGqlElementComposer`
+*/
 const createGqlFragmentComposers = (schema, _adapter) => {
 	const createFragmentComposer = (typename) => {
 		return (options) => {
@@ -683,6 +1003,25 @@ const defaultMetadataAdapter = createDefaultAdapter();
 
 //#endregion
 //#region packages/core/src/composer/operation.ts
+/**
+* Operation composer factory for creating typed GraphQL operations.
+* @module
+*/
+/**
+* Creates a factory for composing GraphQL operations.
+*
+* Returns a curried function: first select operation type (query/mutation/subscription),
+* then define the operation with name, variables, and fields.
+*
+* Handles metadata aggregation from fragments (sync or async) and builds
+* the TypedDocumentNode automatically.
+*
+* @param schema - The GraphQL schema definition
+* @param adapter - Optional metadata adapter for custom metadata handling
+* @returns Operation type selector function
+*
+* @internal Used by `createGqlElementComposer`
+*/
 const createOperationComposerFactory = (schema, adapter) => {
 	const resolvedAdapter = adapter ?? defaultMetadataAdapter;
 	return (operationType) => {
@@ -744,7 +1083,9 @@ const createOperationComposerFactory = (schema, adapter) => {
 //#region packages/core/src/composer/var-ref-tools.ts
 /**
 * Recursively checks if a NestedValue contains any VarRef.
+*
 * Used by getVarRefValue to determine if it's safe to return as ConstValue.
+* @internal
 */
 const hasVarRefInside = (value) => {
 	if (value instanceof VarRef) return true;
@@ -856,6 +1197,18 @@ const getValueAt = (varRef, selector) => {
 	if (hasVarRefInside(inner.varInner.value)) throw new Error(`Value at path [${inner.segments.join(".")}] contains nested VarRef`);
 	return inner.varInner.value;
 };
+/**
+* Gets the full path to a variable within a nested structure.
+*
+* Returns path segments starting with `$variableName` followed by
+* property accesses within that variable's value.
+*
+* @example
+* ```typescript
+* getVariablePath($.filter, p => p.user.id)
+* // Returns: ["$filter", "user", "id"]
+* ```
+*/
 const getVariablePath = (varRef, selector) => {
 	const inner = getSelectableProxyInner(selector(createSelectableProxy({
 		varInner: VarRef.getInner(varRef),
@@ -908,7 +1261,16 @@ const createVarMethodFactory = () => {
 	};
 };
 /**
-* Creates a variable builder that uses injected input type methods.
+* Creates a variable builder using injected input type methods.
+*
+* The returned builder provides type-safe variable definition methods
+* for all input types in the schema. Also includes utilities for
+* extracting variable names and values from VarRefs.
+*
+* @param inputTypeMethods - Methods for each input type (from codegen)
+* @returns Variable builder with methods for all input types
+*
+* @internal Used by `createGqlElementComposer`
 */
 const createVarBuilder = (inputTypeMethods) => {
 	const varBuilder = (varName) => {
@@ -933,12 +1295,38 @@ const createVarBuilder = (inputTypeMethods) => {
 /**
 * Creates a GQL element composer for a given schema.
 *
-* @typeParam TSchema - The GraphQL schema type
-* @typeParam TAdapter - The adapter type (optional)
-* @typeParam TFragmentBuilders - Pre-computed fragment builders type (optional, for codegen optimization)
+* This is the main entry point for defining GraphQL operations and fragments.
+* The returned function provides a context with:
+* - `fragment`: Builders for each object type
+* - `query/mutation/subscription`: Operation builders
+* - `$var`: Variable definition helpers
+* - `$dir`: Field directive helpers (@skip, @include)
+* - `$colocate`: Fragment colocation utilities
+*
+* @param schema - The GraphQL schema definition
+* @param options - Configuration including input type methods and optional adapter
+* @returns Element composer function
+*
+* @example
+* ```typescript
+* const gql = createGqlElementComposer(schema, { inputTypeMethods });
+*
+* const GetUser = gql(({ query, $var, $dir }) =>
+*   query.operation({
+*     name: "GetUser",
+*     variables: { showEmail: $var("showEmail").Boolean("!") },
+*     fields: ({ f, $ }) => ({
+*       ...f.user({ id: "1" })(({ f }) => ({
+*         ...f.name(),
+*         ...f.email({}, { directives: [$dir.skip({ if: $.showEmail })] }),
+*       })),
+*     }),
+*   })
+* );
+* ```
 */
 const createGqlElementComposer = (schema, options) => {
-	const { adapter, inputTypeMethods } = options;
+	const { adapter, inputTypeMethods, directiveMethods } = options;
 	const helpers = adapter?.helpers;
 	const metadataAdapter = adapter?.metadata;
 	const fragment = createGqlFragmentComposers(schema, metadataAdapter);
@@ -949,6 +1337,7 @@ const createGqlElementComposer = (schema, options) => {
 		mutation: { operation: createOperationComposer("mutation") },
 		subscription: { operation: createOperationComposer("subscription") },
 		$var: createVarBuilder(inputTypeMethods),
+		$dir: directiveMethods ?? createStandardDirectives(),
 		$colocate: createColocateHelper(),
 		...helpers ?? {}
 	};
@@ -968,10 +1357,13 @@ exports.buildOperationTypeNode = buildOperationTypeNode;
 exports.buildWithTypeModifier = buildWithTypeModifier;
 exports.createColocateHelper = createColocateHelper;
 exports.createDefaultAdapter = createDefaultAdapter;
+exports.createDirectiveBuilder = createDirectiveBuilder;
+exports.createDirectiveMethod = createDirectiveMethod;
 exports.createFieldFactories = createFieldFactories;
 exports.createGqlElementComposer = createGqlElementComposer;
 exports.createGqlFragmentComposers = createGqlFragmentComposers;
 exports.createOperationComposerFactory = createOperationComposerFactory;
+exports.createStandardDirectives = createStandardDirectives;
 exports.createVarAssignments = createVarAssignments;
 exports.createVarBuilder = createVarBuilder;
 exports.createVarMethod = createVarMethod;
@@ -982,6 +1374,7 @@ exports.define = require_schema.define;
 exports.defineOperationRoots = require_schema.defineOperationRoots;
 exports.defineScalar = require_schema.defineScalar;
 exports.getCurrentFieldPath = getCurrentFieldPath;
+exports.isDirectiveRef = isDirectiveRef;
 exports.isListType = isListType;
 exports.recordFragmentUsage = recordFragmentUsage;
 exports.unsafeInputType = require_schema.unsafeInputType;