import { inspect } from '../jsutils/inspect.js';
import { instanceOf } from '../jsutils/instanceOf.js';
import type { Maybe } from '../jsutils/Maybe.js';
import { toObjMap } from '../jsutils/toObjMap.js';
import type { DirectiveDefinitionNode } from '../language/ast.js';
import { DirectiveLocation } from '../language/directiveLocation.js';
import { assertName } from './assertName.js';
import type {
GraphQLArgument,
GraphQLFieldConfigArgumentMap,
} from './definition.js';
import {
argsToArgsConfig,
defineArguments,
GraphQLNonNull,
} from './definition.js';
import { GraphQLBoolean, GraphQLInt, GraphQLString } from './scalars.js';
export function isDirective(directive: unknown): directive is GraphQLDirective {
return instanceOf(directive, GraphQLDirective);
}
export function assertDirective(directive: unknown): GraphQLDirective {
if (!isDirective(directive)) {
throw new Error(
`Expected ${inspect(directive)} to be a GraphQL directive.`,
);
}
return directive;
}
export interface GraphQLDirectiveExtensions {
[attributeName: string]: unknown;
}
export class GraphQLDirective {
name: string;
description: Maybe<string>;
locations: ReadonlyArray<DirectiveLocation>;
args: ReadonlyArray<GraphQLArgument>;
isRepeatable: boolean;
extensions: Readonly<GraphQLDirectiveExtensions>;
astNode: Maybe<DirectiveDefinitionNode>;
constructor(config: Readonly<GraphQLDirectiveConfig>) {
this.name = assertName(config.name);
this.description = config.description;
this.locations = config.locations;
this.isRepeatable = config.isRepeatable ?? false;
this.extensions = toObjMap(config.extensions);
this.astNode = config.astNode;
const args = config.args ?? {};
this.args = defineArguments(args);
}
get [Symbol.toStringTag]() {
return 'GraphQLDirective';
}
toConfig(): GraphQLDirectiveNormalizedConfig {
return {
name: this.name,
description: this.description,
locations: this.locations,
args: argsToArgsConfig(this.args),
isRepeatable: this.isRepeatable,
extensions: this.extensions,
astNode: this.astNode,
};
}
toString(): string {
return '@' + this.name;
}
toJSON(): string {
return this.toString();
}
}
export interface GraphQLDirectiveConfig {
name: string;
description?: Maybe<string>;
locations: ReadonlyArray<DirectiveLocation>;
args?: Maybe<GraphQLFieldConfigArgumentMap>;
isRepeatable?: Maybe<boolean>;
extensions?: Maybe<Readonly<GraphQLDirectiveExtensions>>;
astNode?: Maybe<DirectiveDefinitionNode>;
}
interface GraphQLDirectiveNormalizedConfig extends GraphQLDirectiveConfig {
args: GraphQLFieldConfigArgumentMap;
isRepeatable: boolean;
extensions: Readonly<GraphQLDirectiveExtensions>;
}
export const GraphQLIncludeDirective: GraphQLDirective = new GraphQLDirective({
name: 'include',
description:
'Directs the executor to include this field or fragment only when the `if` argument is true.',
locations: [
DirectiveLocation.FIELD,
DirectiveLocation.FRAGMENT_SPREAD,
DirectiveLocation.INLINE_FRAGMENT,
],
args: {
if: {
type: new GraphQLNonNull(GraphQLBoolean),
description: 'Included when true.',
},
},
});
export const GraphQLSkipDirective: GraphQLDirective = new GraphQLDirective({
name: 'skip',
description:
'Directs the executor to skip this field or fragment when the `if` argument is true.',
locations: [
DirectiveLocation.FIELD,
DirectiveLocation.FRAGMENT_SPREAD,
DirectiveLocation.INLINE_FRAGMENT,
],
args: {
if: {
type: new GraphQLNonNull(GraphQLBoolean),
description: 'Skipped when true.',
},
},
});
export const GraphQLDeferDirective = new GraphQLDirective({
name: 'defer',
description:
'Directs the executor to defer this fragment when the `if` argument is true or undefined.',
locations: [
DirectiveLocation.FRAGMENT_SPREAD,
DirectiveLocation.INLINE_FRAGMENT,
],
args: {
if: {
type: new GraphQLNonNull(GraphQLBoolean),
description: 'Deferred when true or undefined.',
defaultValue: true,
},
label: {
type: GraphQLString,
description: 'Unique name',
},
},
});
export const GraphQLStreamDirective = new GraphQLDirective({
name: 'stream',
description:
'Directs the executor to stream plural fields when the `if` argument is true or undefined.',
locations: [DirectiveLocation.FIELD],
args: {
if: {
type: new GraphQLNonNull(GraphQLBoolean),
description: 'Stream when true or undefined.',
defaultValue: true,
},
label: {
type: GraphQLString,
description: 'Unique name',
},
initialCount: {
defaultValue: 0,
type: GraphQLInt,
description: 'Number of items to return immediately',
},
},
});
export const DEFAULT_DEPRECATION_REASON = 'No longer supported';
export const GraphQLDeprecatedDirective: GraphQLDirective =
new GraphQLDirective({
name: 'deprecated',
description: 'Marks an element of a GraphQL schema as no longer supported.',
locations: [
DirectiveLocation.FIELD_DEFINITION,
DirectiveLocation.ARGUMENT_DEFINITION,
DirectiveLocation.INPUT_FIELD_DEFINITION,
DirectiveLocation.ENUM_VALUE,
],
args: {
reason: {
type: GraphQLString,
description:
'Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted using the Markdown syntax, as specified by [CommonMark](https://commonmark.org/).',
defaultValue: DEFAULT_DEPRECATION_REASON,
},
},
});
export const GraphQLSpecifiedByDirective: GraphQLDirective =
new GraphQLDirective({
name: 'specifiedBy',
description: 'Exposes a URL that specifies the behavior of this scalar.',
locations: [DirectiveLocation.SCALAR],
args: {
url: {
type: new GraphQLNonNull(GraphQLString),
description: 'The URL that specifies the behavior of this scalar.',
},
},
});
export const specifiedDirectives: ReadonlyArray<GraphQLDirective> =
Object.freeze([
GraphQLIncludeDirective,
GraphQLSkipDirective,
GraphQLDeprecatedDirective,
GraphQLSpecifiedByDirective,
]);
export function isSpecifiedDirective(directive: GraphQLDirective): boolean {
return specifiedDirectives.some(({ name }) => name === directive.name);
}