@theguild/federation-composition 0.0.0-alpha-20230916192321-bb37b43

package/typings/supergraph/composition/ast.d.ts

@@ -0,0 +1,216 @@
+import { ASTNode, ConstDirectiveNode, DirectiveDefinitionNode, DocumentNode, EnumTypeDefinitionNode, EnumValueDefinitionNode, FieldDefinitionNode, InputObjectTypeDefinitionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, ObjectTypeDefinitionNode, ScalarTypeDefinitionNode, SchemaDefinitionNode, StringValueNode, UnionTypeDefinitionNode } from 'graphql';
+type inferArgument<T> = T extends (arg: infer A) => any ? A : never;
+export type DirectiveAST = inferArgument<typeof createDirectiveNode>;
+export type ObjectTypeAST = inferArgument<typeof createObjectTypeNode>;
+export type FieldAST = inferArgument<typeof createFieldNode>;
+export type FieldArgumentAST = inferArgument<typeof createFieldArgumentNode>;
+export type InputFieldAST = inferArgument<typeof createInputFieldNode>;
+export type EnumValueAST = inferArgument<typeof createEnumValueNode>;
+export type JoinTypeAST = inferArgument<typeof createJoinTypeDirectiveNode>;
+export type JoinImplementsAST = inferArgument<typeof createJoinImplementsDirectiveNode>;
+export type JoinFieldAST = inferArgument<typeof createJoinFieldDirectiveNode>;
+export type JoinUnionMemberAST = inferArgument<typeof createJoinUnionMemberDirectiveNode>;
+export type JoinEnumValueAST = inferArgument<typeof createJoinEnumValueDirectiveNode>;
+type Link = inferArgument<typeof createLinkDirectiveNode>;
+type DescriptionAST = inferArgument<typeof createDescriptionNode>;
+type Deprecated = {
+    reason?: string;
+    deprecated: true;
+};
+export declare function createSchemaNode(schema: {
+    query?: string;
+    mutation?: string;
+    subscription?: string;
+    links?: Link[];
+}): SchemaDefinitionNode;
+export declare function createDirectiveNode(directive: {
+    name: string;
+    tags?: string[];
+    arguments: FieldArgumentAST[];
+    locations: string[];
+    repeatable: boolean;
+}): DirectiveDefinitionNode;
+export declare function createObjectTypeNode(objectType: {
+    name: string;
+    fields: FieldAST[];
+    interfaces?: string[];
+    join?: {
+        type?: JoinTypeAST[];
+        implements?: JoinImplementsAST[];
+    };
+    tags?: string[];
+    inaccessible?: boolean;
+    description?: DescriptionAST;
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+}): ObjectTypeDefinitionNode;
+export declare function createInterfaceTypeNode(interfaceType: {
+    name: string;
+    fields: FieldAST[];
+    interfaces?: string[];
+    join?: {
+        type?: JoinTypeAST[];
+        implements?: JoinImplementsAST[];
+    };
+    tags?: string[];
+    inaccessible?: boolean;
+    description?: DescriptionAST;
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+}): InterfaceTypeDefinitionNode;
+export declare function createInputObjectTypeNode(inputObjectType: {
+    name: string;
+    fields: InputFieldAST[];
+    join?: {
+        type?: JoinTypeAST[];
+    };
+    tags?: string[];
+    inaccessible?: boolean;
+    description?: DescriptionAST;
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+}): InputObjectTypeDefinitionNode;
+export declare function createUnionTypeNode(unionType: {
+    name: string;
+    join?: {
+        type?: JoinTypeAST[];
+        unionMember?: JoinUnionMemberAST[];
+    };
+    members: string[];
+    inaccessible?: boolean;
+    description?: DescriptionAST;
+    tags?: string[];
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+}): UnionTypeDefinitionNode;
+export declare function createEnumTypeNode(enumType: {
+    name: string;
+    join?: {
+        type?: JoinTypeAST[];
+    };
+    tags?: string[];
+    inaccessible?: boolean;
+    description?: DescriptionAST;
+    values: EnumValueAST[];
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+}): EnumTypeDefinitionNode;
+export declare function createScalarTypeNode(scalarType: {
+    name: string;
+    join?: {
+        type?: JoinTypeAST[];
+    };
+    tags?: string[];
+    inaccessible?: boolean;
+    description?: DescriptionAST;
+    specifiedBy?: string;
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+}): ScalarTypeDefinitionNode;
+export declare function createJoinGraphEnumTypeNode(graphs: Array<{
+    name: string;
+    enumValue: string;
+    url?: string;
+}>): EnumTypeDefinitionNode;
+declare function createFieldNode(field: {
+    name: string;
+    type: string;
+    arguments?: FieldArgumentAST[];
+    join?: {
+        field?: JoinFieldAST[];
+    };
+    inaccessible?: boolean;
+    tags?: string[];
+    description?: DescriptionAST;
+    deprecated?: Deprecated;
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+}): FieldDefinitionNode;
+declare function createInputFieldNode(inputField: {
+    name: string;
+    type: string;
+    defaultValue?: string;
+    tags?: string[];
+    inaccessible?: boolean;
+    description?: DescriptionAST;
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+    join?: {
+        field?: JoinFieldAST[];
+    };
+}): InputValueDefinitionNode;
+declare function createEnumValueNode(enumValue: {
+    name: string;
+    join?: {
+        enumValue?: JoinEnumValueAST[];
+    };
+    tags?: string[];
+    inaccessible?: boolean;
+    description?: DescriptionAST;
+    deprecated?: Deprecated;
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+}): EnumValueDefinitionNode;
+declare function createFieldArgumentNode(argument: {
+    name: string;
+    type: string;
+    defaultValue?: string;
+    inaccessible?: boolean;
+    tags?: string[];
+    description?: DescriptionAST;
+    deprecated?: Deprecated;
+    ast?: {
+        directives?: ConstDirectiveNode[];
+    };
+}): InputValueDefinitionNode;
+declare function createJoinTypeDirectiveNode(join: {
+    graph: string;
+    key?: string;
+    isInterfaceObject?: boolean;
+    extension?: boolean;
+    resolvable?: boolean;
+}): ConstDirectiveNode;
+declare function createJoinImplementsDirectiveNode(join: {
+    graph: string;
+    interface: string;
+}): ConstDirectiveNode;
+declare function createJoinFieldDirectiveNode(join: {
+    graph?: string;
+    type?: string;
+    override?: string;
+    external?: boolean;
+    provides?: string;
+    requires?: string;
+}): ConstDirectiveNode;
+declare function createJoinUnionMemberDirectiveNode(join: {
+    graph: string;
+    member: string;
+}): ConstDirectiveNode;
+declare function createJoinEnumValueDirectiveNode(join: {
+    graph: string;
+}): ConstDirectiveNode;
+declare function createDescriptionNode(description: {
+    value: string;
+    block: boolean;
+}): StringValueNode;
+declare function createLinkDirectiveNode(link: {
+    url: string;
+    import?: Array<{
+        name: string;
+        alias?: string;
+    }>;
+    for?: string;
+}): ConstDirectiveNode;
+export declare function schemaCoordinate(paths: readonly (string | number)[], nodes: readonly (ASTNode | readonly ASTNode[])[]): string;
+export declare function stripFederation(supergraph: DocumentNode): DocumentNode;
+export {};
+//# sourceMappingURL=ast.d.ts.map

package/typings/supergraph/composition/common.d.cts

@@ -0,0 +1,19 @@
+import type { ConstDirectiveNode, DirectiveDefinitionNode, DirectiveNode, TypeDefinitionNode } from 'graphql';
+import type { FederationVersion } from '../../specifications/federation.cjs';
+export type MapByGraph<T> = Map<string, T>;
+export interface Key {
+    fields: string;
+    resolvable: boolean;
+}
+export interface Graph {
+    name: string;
+    id: string;
+    version: FederationVersion;
+    url?: string;
+}
+export interface TypeBuilder<T, S> {
+    visitSubgraphState(graph: Graph, state: Map<string, S>, typeName: string, type: T): void;
+    composeSupergraphNode(type: S, graphMap: Map<string, Graph>): TypeDefinitionNode | DirectiveDefinitionNode;
+}
+export declare function convertToConst(nodes: DirectiveNode[]): ConstDirectiveNode[];
+//# sourceMappingURL=common.d.ts.map

package/typings/supergraph/composition/common.d.ts

@@ -0,0 +1,19 @@
+import type { ConstDirectiveNode, DirectiveDefinitionNode, DirectiveNode, TypeDefinitionNode } from 'graphql';
+import type { FederationVersion } from '../../specifications/federation.js';
+export type MapByGraph<T> = Map<string, T>;
+export interface Key {
+    fields: string;
+    resolvable: boolean;
+}
+export interface Graph {
+    name: string;
+    id: string;
+    version: FederationVersion;
+    url?: string;
+}
+export interface TypeBuilder<T, S> {
+    visitSubgraphState(graph: Graph, state: Map<string, S>, typeName: string, type: T): void;
+    composeSupergraphNode(type: S, graphMap: Map<string, Graph>): TypeDefinitionNode | DirectiveDefinitionNode;
+}
+export declare function convertToConst(nodes: DirectiveNode[]): ConstDirectiveNode[];
+//# sourceMappingURL=common.d.ts.map

package/typings/supergraph/composition/directive.d.cts

@@ -0,0 +1,32 @@
+import { DirectiveNode } from 'graphql';
+import type { Directive } from '../../subgraph/state.cjs';
+import { MapByGraph, TypeBuilder } from './common.cjs';
+export declare function directiveBuilder(): TypeBuilder<Directive, DirectiveState>;
+export type DirectiveState = {
+    name: string;
+    byGraph: MapByGraph<DirectiveStateInGraph>;
+    locations: Set<string>;
+    repeatable: boolean;
+    args: Map<string, DirectiveArgState>;
+};
+type DirectiveStateInGraph = {
+    locations: Set<string>;
+    repeatable: boolean;
+};
+export type DirectiveArgState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    defaultValue?: string;
+    byGraph: MapByGraph<ArgStateInGraph>;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+type ArgStateInGraph = {
+    type: string;
+    defaultValue?: string;
+};
+export {};
+//# sourceMappingURL=directive.d.ts.map

package/typings/supergraph/composition/directive.d.ts

@@ -0,0 +1,32 @@
+import { DirectiveNode } from 'graphql';
+import type { Directive } from '../../subgraph/state.js';
+import { MapByGraph, TypeBuilder } from './common.js';
+export declare function directiveBuilder(): TypeBuilder<Directive, DirectiveState>;
+export type DirectiveState = {
+    name: string;
+    byGraph: MapByGraph<DirectiveStateInGraph>;
+    locations: Set<string>;
+    repeatable: boolean;
+    args: Map<string, DirectiveArgState>;
+};
+type DirectiveStateInGraph = {
+    locations: Set<string>;
+    repeatable: boolean;
+};
+export type DirectiveArgState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    defaultValue?: string;
+    byGraph: MapByGraph<ArgStateInGraph>;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+type ArgStateInGraph = {
+    type: string;
+    defaultValue?: string;
+};
+export {};
+//# sourceMappingURL=directive.d.ts.map

package/typings/supergraph/composition/enum-type.d.cts

@@ -0,0 +1,32 @@
+import { Deprecated, Description, EnumType } from '../../subgraph/state.cjs';
+import type { MapByGraph, TypeBuilder } from './common.cjs';
+export declare function enumTypeBuilder(): TypeBuilder<EnumType, EnumTypeState>;
+export type EnumTypeState = {
+    name: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    hasDefinition: boolean;
+    description?: Description;
+    byGraph: MapByGraph<EnumTypeStateInGraph>;
+    referencedByInputType: boolean;
+    referencedByOutputType: boolean;
+    inputTypeReferences: Set<string>;
+    outputTypeReferences: Set<string>;
+    values: Map<string, EnumValueState>;
+};
+type EnumValueState = {
+    name: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    deprecated?: Deprecated;
+    description?: Description;
+    byGraph: MapByGraph<EnumValueStateInGraph>;
+};
+type EnumTypeStateInGraph = {
+    inaccessible: boolean;
+};
+type EnumValueStateInGraph = {
+    inaccessible: boolean;
+};
+export {};
+//# sourceMappingURL=enum-type.d.ts.map

package/typings/supergraph/composition/enum-type.d.ts

@@ -0,0 +1,32 @@
+import { Deprecated, Description, EnumType } from '../../subgraph/state.js';
+import type { MapByGraph, TypeBuilder } from './common.js';
+export declare function enumTypeBuilder(): TypeBuilder<EnumType, EnumTypeState>;
+export type EnumTypeState = {
+    name: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    hasDefinition: boolean;
+    description?: Description;
+    byGraph: MapByGraph<EnumTypeStateInGraph>;
+    referencedByInputType: boolean;
+    referencedByOutputType: boolean;
+    inputTypeReferences: Set<string>;
+    outputTypeReferences: Set<string>;
+    values: Map<string, EnumValueState>;
+};
+type EnumValueState = {
+    name: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    deprecated?: Deprecated;
+    description?: Description;
+    byGraph: MapByGraph<EnumValueStateInGraph>;
+};
+type EnumTypeStateInGraph = {
+    inaccessible: boolean;
+};
+type EnumValueStateInGraph = {
+    inaccessible: boolean;
+};
+export {};
+//# sourceMappingURL=enum-type.d.ts.map

package/typings/supergraph/composition/input-object-type.d.cts

@@ -0,0 +1,32 @@
+import { Deprecated, Description, InputObjectType } from '../../subgraph/state.cjs';
+import type { MapByGraph, TypeBuilder } from './common.cjs';
+export declare function inputObjectTypeBuilder(): TypeBuilder<InputObjectType, InputObjectTypeState>;
+export interface InputObjectTypeState {
+    name: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    hasDefinition: boolean;
+    description?: Description;
+    byGraph: MapByGraph<InputObjectTypeStateInGraph>;
+    fields: Map<string, InputObjectTypeFieldState>;
+}
+export type InputObjectTypeFieldState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    defaultValue?: string;
+    description?: Description;
+    deprecated?: Deprecated;
+    byGraph: MapByGraph<InputObjectFieldStateInGraph>;
+};
+type InputObjectTypeStateInGraph = {
+    inaccessible: boolean;
+};
+type InputObjectFieldStateInGraph = {
+    type: string;
+    inaccessible: boolean;
+    defaultValue?: string;
+};
+export {};
+//# sourceMappingURL=input-object-type.d.ts.map

package/typings/supergraph/composition/input-object-type.d.ts

@@ -0,0 +1,32 @@
+import { Deprecated, Description, InputObjectType } from '../../subgraph/state.js';
+import type { MapByGraph, TypeBuilder } from './common.js';
+export declare function inputObjectTypeBuilder(): TypeBuilder<InputObjectType, InputObjectTypeState>;
+export interface InputObjectTypeState {
+    name: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    hasDefinition: boolean;
+    description?: Description;
+    byGraph: MapByGraph<InputObjectTypeStateInGraph>;
+    fields: Map<string, InputObjectTypeFieldState>;
+}
+export type InputObjectTypeFieldState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    defaultValue?: string;
+    description?: Description;
+    deprecated?: Deprecated;
+    byGraph: MapByGraph<InputObjectFieldStateInGraph>;
+};
+type InputObjectTypeStateInGraph = {
+    inaccessible: boolean;
+};
+type InputObjectFieldStateInGraph = {
+    type: string;
+    inaccessible: boolean;
+    defaultValue?: string;
+};
+export {};
+//# sourceMappingURL=input-object-type.d.ts.map

package/typings/supergraph/composition/interface-type.d.cts

@@ -0,0 +1,61 @@
+import { DirectiveNode } from 'graphql';
+import { Deprecated, Description, InterfaceType } from '../../subgraph/state.cjs';
+import type { Key, MapByGraph, TypeBuilder } from './common.cjs';
+export declare function interfaceTypeBuilder(): TypeBuilder<InterfaceType, InterfaceTypeState>;
+export type InterfaceTypeState = {
+    name: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    hasDefinition: boolean;
+    description?: Description;
+    byGraph: MapByGraph<InterfaceTypeInGraph>;
+    interfaces: Set<string>;
+    implementedBy: Set<string>;
+    fields: Map<string, InterfaceTypeFieldState>;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+type InterfaceTypeFieldState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    deprecated?: Deprecated;
+    description?: Description;
+    byGraph: MapByGraph<FieldStateInGraph>;
+    args: Map<string, InterfaceTypeFieldArgState>;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+export type InterfaceTypeFieldArgState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    defaultValue?: string;
+    description?: Description;
+    deprecated?: Deprecated;
+    byGraph: MapByGraph<ArgStateInGraph>;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+type InterfaceTypeInGraph = {
+    extension: boolean;
+    keys: Key[];
+    interfaces: Set<string>;
+    implementedBy: Set<string>;
+};
+type FieldStateInGraph = {
+    type: string;
+    override: string | null;
+    provides: string | null;
+    requires: string | null;
+};
+type ArgStateInGraph = {
+    type: string;
+    defaultValue?: string;
+};
+export {};
+//# sourceMappingURL=interface-type.d.ts.map

package/typings/supergraph/composition/interface-type.d.ts

@@ -0,0 +1,61 @@
+import { DirectiveNode } from 'graphql';
+import { Deprecated, Description, InterfaceType } from '../../subgraph/state.js';
+import type { Key, MapByGraph, TypeBuilder } from './common.js';
+export declare function interfaceTypeBuilder(): TypeBuilder<InterfaceType, InterfaceTypeState>;
+export type InterfaceTypeState = {
+    name: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    hasDefinition: boolean;
+    description?: Description;
+    byGraph: MapByGraph<InterfaceTypeInGraph>;
+    interfaces: Set<string>;
+    implementedBy: Set<string>;
+    fields: Map<string, InterfaceTypeFieldState>;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+type InterfaceTypeFieldState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    deprecated?: Deprecated;
+    description?: Description;
+    byGraph: MapByGraph<FieldStateInGraph>;
+    args: Map<string, InterfaceTypeFieldArgState>;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+export type InterfaceTypeFieldArgState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    defaultValue?: string;
+    description?: Description;
+    deprecated?: Deprecated;
+    byGraph: MapByGraph<ArgStateInGraph>;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+type InterfaceTypeInGraph = {
+    extension: boolean;
+    keys: Key[];
+    interfaces: Set<string>;
+    implementedBy: Set<string>;
+};
+type FieldStateInGraph = {
+    type: string;
+    override: string | null;
+    provides: string | null;
+    requires: string | null;
+};
+type ArgStateInGraph = {
+    type: string;
+    defaultValue?: string;
+};
+export {};
+//# sourceMappingURL=interface-type.d.ts.map

package/typings/supergraph/composition/object-type.d.cts

@@ -0,0 +1,79 @@
+import { DirectiveNode } from 'graphql';
+import type { FederationVersion } from '../../specifications/federation.cjs';
+import { Deprecated, Description, ObjectType } from '../../subgraph/state.cjs';
+import type { Key, MapByGraph, TypeBuilder } from './common.cjs';
+export declare function isRealExtension(meta: ObjectTypeStateInGraph, version: FederationVersion): boolean;
+export declare function objectTypeBuilder(): TypeBuilder<ObjectType, ObjectTypeState>;
+export type ObjectTypeState = {
+    name: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    hasDefinition: boolean;
+    byGraph: MapByGraph<ObjectTypeStateInGraph>;
+    interfaces: Set<string>;
+    fields: Map<string, ObjectTypeFieldState>;
+    description?: Description;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+export type ObjectTypeFieldState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    usedAsKey: boolean;
+    override: string | null;
+    byGraph: MapByGraph<FieldStateInGraph>;
+    args: Map<string, ObjectTypeFieldArgState>;
+    description?: Description;
+    deprecated?: Deprecated;
+    ast: {
+        directives: DirectiveNode[];
+    };
+    internal: {
+        seenNonExternal: boolean;
+    };
+};
+export type ObjectTypeFieldArgState = {
+    name: string;
+    type: string;
+    tags: Set<string>;
+    inaccessible: boolean;
+    defaultValue?: string;
+    byGraph: MapByGraph<ArgStateInGraph>;
+    description?: Description;
+    deprecated?: Deprecated;
+    ast: {
+        directives: DirectiveNode[];
+    };
+};
+export type ObjectTypeStateInGraph = {
+    extension: boolean;
+    extensionType?: '@extends' | 'extend';
+    external: boolean;
+    keys: Key[];
+    interfaces: Set<string>;
+    inaccessible: boolean;
+    shareable: boolean;
+};
+type FieldStateInGraph = {
+    type: string;
+    external: boolean;
+    inaccessible: boolean;
+    used: boolean;
+    override: string | null;
+    provides: string | null;
+    requires: string | null;
+    provided: boolean;
+    required: boolean;
+    shareable: boolean;
+    usedAsKey: boolean;
+};
+type ArgStateInGraph = {
+    type: string;
+    inaccessible: boolean;
+    defaultValue?: string;
+};
+export {};
+//# sourceMappingURL=object-type.d.ts.map