@xyd-js/gql 0.1.0-xyd.6 → 0.1.0-xyd.66

package/src/converters/gql-query.ts

@@ -0,0 +1,36 @@
+import type {GraphQLSchema} from "graphql";
+import {OperationTypeNode} from "graphql";
+
+import {Reference, ReferenceType} from "@xyd-js/uniform";
+
+import type {GQLSchemaToReferencesOptions} from "../types";
+import {filterFieldsByRegions} from "../utils";
+import {gqlOperationToUniformRef} from "./gql-operation";
+
+export function graphqlQueriesToUniformReferences(
+    schema: GraphQLSchema,
+    options?: GQLSchemaToReferencesOptions,
+): Reference[] {
+    const references: Reference[] = []
+
+    const queries = schema.getRootType(OperationTypeNode.QUERY)
+    const queryFields = queries?.getFields?.()
+
+    if (queryFields) {
+        // Filter query fields based on regions if provided
+        const filteredQueryFields = filterFieldsByRegions(
+            queryFields,
+            "query",
+            options?.regions
+        );
+
+        references.push(...gqlOperationToUniformRef(
+            ReferenceType.GRAPHQL_QUERY,
+            filteredQueryFields,
+            schema,
+            options
+        ))
+    }
+
+    return references;
+}

package/src/converters/gql-sample.ts

@@ -0,0 +1,159 @@
+import {
+    Kind,
+    print,
+    OperationTypeNode,
+    ASTNode,
+    ArgumentNode,
+    TypeNode,
+    ValueNode,
+    VariableDefinitionNode,
+} from 'graphql';
+
+import {
+    DefinitionProperty,
+    ReferenceType
+} from "@xyd-js/uniform";
+
+const operationTypeToTypeNode = {
+    [ReferenceType.GRAPHQL_QUERY]: OperationTypeNode.QUERY,
+    [ReferenceType.GRAPHQL_MUTATION]: OperationTypeNode.MUTATION,
+    [ReferenceType.GRAPHQL_SUBSCRIPTION]: OperationTypeNode.SUBSCRIPTION,
+}
+
+// simpleGraphqlExample is a helper function to create a simple GraphQL example query or mutation.
+export function simpleGraphqlExample(
+    operationType: ReferenceType.GRAPHQL_QUERY | ReferenceType.GRAPHQL_MUTATION | ReferenceType.GRAPHQL_SUBSCRIPTION,
+    operationName: string,
+    args: DefinitionProperty[],
+    returns: DefinitionProperty[],
+) {
+    // Filter required arguments or take first one if no required args
+    const requiredArgs = args.filter(arg => arg.meta?.some(m => m.name === 'required' && m.value === 'true'));
+    const selectedArgs = requiredArgs.length > 0 ? requiredArgs : args.slice(0, 1);
+
+    let hasArgVars = false
+
+    const argDefaults = selectedArgs.reduce<Record<string, ArgumentNode>>((acc, arg) => {
+        if (operationType != ReferenceType.GRAPHQL_QUERY) {
+            return acc; // Skip for mutations, as we use variables
+        }
+
+        let defaultValue: string = ""
+
+        const getDefaultValue = arg.meta?.find(m => m.name === 'defaults')?.value
+        if (getDefaultValue && typeof getDefaultValue !== 'string') {
+            defaultValue = JSON.stringify(getDefaultValue)
+        }
+
+        let sampleValue: ValueNode | undefined = undefined;
+
+        switch (arg.context?.graphqlTypeFlat) {
+            case 'String':
+                sampleValue = {kind: Kind.STRING, value: defaultValue || `example-${arg.name}`};
+                break;
+            case 'Int':
+            case 'Float':
+                sampleValue = {kind: Kind.INT, value: defaultValue || '0'};
+                break;
+            case 'Boolean':
+                sampleValue = {kind: Kind.BOOLEAN, value: defaultValue === 'true'};
+                break;
+        }
+
+        // For queries, use direct values; for mutations, use variables
+        if (sampleValue) {
+            return {
+                ...acc,
+                [arg.name]: {
+                    kind: Kind.ARGUMENT,
+                    name: {kind: Kind.NAME, value: arg.name},
+                    value: sampleValue
+                }
+            };
+        }
+
+        return acc;
+    }, {});
+
+    const allDefaultArgs = Object.keys(argDefaults).length === selectedArgs.length
+
+    const argumentsList: ArgumentNode[] = selectedArgs.map(arg => {
+        if (allDefaultArgs) {
+            return argDefaults[arg.name]
+        }
+
+        hasArgVars = true
+
+        return {
+            kind: Kind.ARGUMENT,
+            name: {kind: Kind.NAME, value: arg.name},
+            value: {
+                kind: Kind.VARIABLE,
+                name: {kind: Kind.NAME, value: arg.name}
+            }
+        };
+    });
+
+    const queryAST: ASTNode = {
+        kind: Kind.DOCUMENT,
+        definitions: [
+            {
+                kind: Kind.OPERATION_DEFINITION,
+                operation: operationTypeToTypeNode[operationType],
+                name: hasArgVars ? {
+                    kind: Kind.NAME,
+                    value: operationName
+                } : undefined,
+                variableDefinitions: hasArgVars ? selectedArgs.map(variableDefinitions) : [],
+                selectionSet: {
+                    kind: Kind.SELECTION_SET,
+                    selections: [
+                        {
+                            kind: Kind.FIELD,
+                            name: {kind: Kind.NAME, value: operationName},
+                            arguments: argumentsList,
+                            selectionSet: {
+                                kind: Kind.SELECTION_SET,
+                                selections: [
+                                    {kind: Kind.FIELD, name: {kind: Kind.NAME, value: `# ${operationName} fields`}}
+                                ]
+                            }
+                        }
+                    ]
+                }
+            }
+        ]
+    } as const;
+
+    const sampleText = print(queryAST);
+
+    return sampleText;
+}
+
+function variableDefinitions(arg: DefinitionProperty): VariableDefinitionNode {
+    const hasDefault = arg.meta?.some(m => m.name === 'defaults');
+    let defaultValue: string = ""
+
+    const getDefaultValue = arg.meta?.find(m => m.name === 'defaults')?.value
+    if (getDefaultValue && typeof getDefaultValue !== 'string') {
+        defaultValue = JSON.stringify(getDefaultValue)
+    }
+
+    return {
+        kind: Kind.VARIABLE_DEFINITION,
+        variable: {
+            kind: Kind.VARIABLE,
+            name: {kind: Kind.NAME, value: arg.name}
+        },
+        type: {
+            kind: Kind.NAMED_TYPE,
+            name: {kind: Kind.NAME, value: arg.type}
+        },
+        ...(hasDefault && defaultValue ? {
+            defaultValue: {
+                kind: Kind.STRING,
+                value: defaultValue
+            }
+        } : {})
+    };
+}

package/src/converters/gql-scalar.ts

@@ -0,0 +1,16 @@
+import {GraphQLScalarType} from "@graphql-markdown/types";
+
+import type {Reference} from "@xyd-js/uniform";
+
+import {uniformify} from "../gql-core";
+import {Context} from "../context";
+
+// gqlScalarToUniformRef is a helper function to convert a GraphQL scalar type into a 'uniform' reference.
+export function gqlScalarToUniformRef(ctx: Context, gqlType: GraphQLScalarType): Reference {
+    return uniformify(
+        ctx,
+        gqlType,
+        [],
+        []
+    )
+}

package/src/converters/gql-subscription.ts

@@ -0,0 +1,36 @@
+import type {GraphQLSchema} from "graphql";
+import {OperationTypeNode} from "graphql";
+
+import {Reference, ReferenceType} from "@xyd-js/uniform";
+
+import type {GQLSchemaToReferencesOptions} from "../types";
+import {filterFieldsByRegions} from "../utils";
+import {gqlOperationToUniformRef} from "./gql-operation";
+
+export function graphqlSubscriptionsToUniformReferences(
+    schema: GraphQLSchema,
+    options?: GQLSchemaToReferencesOptions,
+) {
+    const references: Reference[] = []
+
+    const mutations = schema.getRootType(OperationTypeNode.SUBSCRIPTION)
+    const mutationFields = mutations?.getFields?.()
+
+    if (mutationFields) {
+        // Filter mutation fields based on regions if provided
+        const filteredMutationFields = filterFieldsByRegions(
+            mutationFields,
+            "mutation",
+            options?.regions
+        );
+
+        references.push(...gqlOperationToUniformRef(
+            ReferenceType.GRAPHQL_SUBSCRIPTION,
+            filteredMutationFields,
+            schema,
+            options,
+        ))
+    }
+
+    return references;
+}

package/src/converters/gql-types.ts

@@ -0,0 +1,195 @@
+import type {
+    GraphQLEnumType,
+    GraphQLInputObjectType,
+    GraphQLInterfaceType,
+    GraphQLObjectType,
+    GraphQLScalarType,
+    GraphQLSchema,
+    GraphQLUnionType,
+    GraphQLNamedType,
+} from "graphql";
+import {
+    isIntrospectionType,
+    isSpecifiedScalarType
+} from "graphql";
+
+import {Reference} from "@xyd-js/uniform";
+
+import {GQLSchemaToReferencesOptions, NestedGraphqlType} from "../types";
+import {gqlObjectToUniformRef} from "./gql-object";
+import {gqlInputToUniformRef} from "./gql-input";
+import {gqlEnumToUniformRef} from "./gql-enum";
+import {gqlScalarToUniformRef} from "./gql-scalar";
+import {gqlUnionToUniformRef} from "./gql-union";
+import {gqlInterfaceToUniformRef} from "./gql-interface";
+import {Context} from "../context";
+
+// TODO: missing types like interfaces, fragments.
+export function graphqlTypesToUniformReferences(
+    schema: GraphQLSchema,
+    options?: GQLSchemaToReferencesOptions,
+): Reference[] {
+    const references: Reference[] = []
+    const typeMap = schema.getTypeMap();
+
+    const sharedProcessedTypes = new Set<NestedGraphqlType>();
+
+    for (const gqlType of Object.values(typeMap)) {
+        const builtInType = isSpecifiedScalarType(gqlType) ||
+            isIntrospectionType(gqlType) ||
+            gqlType.name === "Mutation" ||
+            gqlType.name === "Query" ||
+            gqlType.name === "Subscription" ||
+            isInternalOpenDocsType(gqlType)
+
+        if (builtInType) {
+            continue;
+        }
+
+        let ref: Reference | null = null
+
+        let flat = false;
+        if (options?.flat) {
+            flat = true;
+        }
+
+        switch (gqlType.constructor.name) {
+            case 'GraphQLObjectType': {
+                const type = gqlType as GraphQLObjectType;
+                const regionKey = `object.${type.name}`;
+                if (!options?.regions || !options?.regions?.length || options.regions.includes(regionKey)) {
+
+                    ref = gqlObjectToUniformRef(
+                        new Context(
+                            sharedProcessedTypes,
+                            options,
+                            {
+                                flat,
+                            },
+                            schema
+                        ),
+                        type,
+                        
+                    )
+                }
+                break
+            }
+
+            case 'GraphQLInputObjectType': {
+                const type = gqlType as GraphQLInputObjectType;
+                const regionKey = `input.${type.name}`;
+                if (!options?.regions || !options?.regions?.length || options.regions.includes(regionKey)) {
+                    ref = gqlInputToUniformRef(
+                        new Context(
+                            sharedProcessedTypes,
+                            options,
+                            {
+                                flat,
+                            },
+                            schema
+                        ),
+                        type
+                    )
+                }
+                break
+            }
+
+            case 'GraphQLEnumType': {
+                const type = gqlType as GraphQLEnumType;
+                const regionKey = `enum.${type.name}`;
+                if (!options?.regions || !options?.regions?.length || options.regions.includes(regionKey)) {
+                    ref = gqlEnumToUniformRef(
+                        new Context(
+                            new Set(),
+                            options,
+                            {},
+                            schema
+                        ),
+                        type
+                    )
+                }
+                break
+            }
+
+            case 'GraphQLScalarType': {
+                const type = gqlType as GraphQLScalarType;
+                const regionKey = `scalar.${type.name}`;
+                if (!options?.regions || !options?.regions?.length || options.regions.includes(regionKey)) {
+                    ref = gqlScalarToUniformRef(
+                        new Context(
+                            new Set(),
+                            options,
+                            {},
+                            schema
+                        ),
+                        type
+                    )
+                }
+                break
+            }
+
+            case 'GraphQLUnionType': {
+                const type = gqlType as GraphQLUnionType;
+                const regionKey = `union.${type.name}`;
+                if (!options?.regions || !options?.regions?.length || options.regions.includes(regionKey)) {
+                    ref = gqlUnionToUniformRef(
+                        new Context(
+                            sharedProcessedTypes,
+                            options,
+                            {
+                                flat,
+                                flatArg: flat || false
+                            },
+                            schema
+                        ),
+                        type,
+                    )
+                }
+
+                break
+            }
+
+            case 'GraphQLInterfaceType': {
+                const type = gqlType as GraphQLInterfaceType;
+                const regionKey = `interface.${type.name}`;
+                if (!options?.regions || !options?.regions?.length || options.regions.includes(regionKey)) {
+                    ref = gqlInterfaceToUniformRef(
+                        new Context(
+                            new Set(),
+                            options,
+                            {
+                                flat
+                            },
+                            schema
+                        ),
+                        type,
+                    )
+                }
+                break
+            }
+
+            default: {
+                console.debug(`Unsupported type: ${gqlType.constructor.name}`)
+            }
+        }
+
+        if (ref) {
+            references.push(ref);
+        }
+    }
+
+    return references;
+}
+
+function isInternalOpenDocsType(type: GraphQLNamedType): boolean {
+    const internalTypes = [
+        'OpenDocsScope',
+        'OpenDocsSidebarItemType',
+        'OpenDocsPage',
+        'OpenDocsExampleInput',
+        'OpenDocsSortInput',
+        'OpenDocsSortStackInput'
+
+    ]
+    return internalTypes.includes(type.name)
+}

package/src/converters/gql-union.ts

@@ -0,0 +1,40 @@
+import {GraphQLUnionType} from "graphql";
+
+import {Definition, DefinitionProperty, Reference} from "@xyd-js/uniform";
+
+import {gqlObjectToUniformDefinitionProperty} from "./gql-object";
+import {uniformify} from "../gql-core";
+import {Context} from "../context";
+
+export function gqlUnionToUniformRef(ctx: Context, unionType: GraphQLUnionType): Reference {
+    const properties = gqlUnionToUniformDefinitionProperties(ctx, unionType)
+
+    const definitions: Definition[] = [
+        {
+            title: "Possible types",
+            properties,
+        }
+    ]
+
+    return uniformify(
+        ctx,
+        unionType,
+        definitions,
+        []
+    )
+}
+
+export function gqlUnionToUniformDefinitionProperties(
+    ctx: Context,
+    unionType: GraphQLUnionType
+): DefinitionProperty[] {
+    return unionType.getTypes().map(type => {
+        if (type.constructor.name === "GraphQLObjectType") {
+            return gqlObjectToUniformDefinitionProperty(
+                ctx,
+                type,
+            )
+        }
+        return []
+    }).flat()
+}