@xyd-js/gql 0.1.0-build.170

package/src/converters/gql-interface.ts

@@ -0,0 +1,35 @@
+import {GraphQLInterfaceType, GraphQLField} from "graphql";
+
+import {Definition, DefinitionProperty, Reference} from "@xyd-js/uniform";
+
+import {gqlFieldToUniformDefinitionProperty} from "./gql-field";
+import {uniformify} from "../gql-core";
+import {NestedGraphqlType} from "../types";
+import {Context} from "../context";
+
+export function gqlInterfaceToUniformRef(ctx: Context, interfaceType: GraphQLInterfaceType): Reference {
+    const properties = gqlInterfaceToUniformDefinitionProperties(ctx, interfaceType)
+
+    const definitions: Definition[] = [
+        {
+            title: "Fields",
+            properties,
+        }
+    ]
+
+    return uniformify(
+        ctx,
+        interfaceType,
+        definitions,
+        []
+    )
+}
+
+export function gqlInterfaceToUniformDefinitionProperties(ctx: Context, interfaceType: GraphQLInterfaceType): DefinitionProperty[] {
+    return Object.values(interfaceType.getFields()).map((field: GraphQLField<any, any>) => {
+        return gqlFieldToUniformDefinitionProperty(
+            ctx,
+            field,
+        )
+    })
+} 

package/src/converters/gql-mutation.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 graphqlMutationsToUniformReferences(
+    schema: GraphQLSchema,
+    options?: GQLSchemaToReferencesOptions,
+) {
+    const references: Reference[] = []
+
+    const mutations = schema.getRootType(OperationTypeNode.MUTATION)
+    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_MUTATION,
+            filteredMutationFields,
+            schema,
+            options,
+        ))
+    }
+
+    return references;
+}

package/src/converters/gql-object.ts

@@ -0,0 +1,83 @@
+import {GraphQLObjectType} from "graphql";
+
+import {Definition, DefinitionProperty, DefinitionVariant} from "@xyd-js/uniform";
+
+import {gqlFieldToUniformDefinitionProperty} from "./gql-field";
+import {gqlObjectPropsUniformify, uniformify} from "../gql-core";
+import {Context} from "../context";
+import {gqlArgToUniformDefinitionProperty} from "./gql-arg";
+
+// gqlObjectToUniformRef is a helper function to convert a GraphQL object type into a 'uniform' reference.
+export function gqlObjectToUniformRef(
+    ctx: Context,
+    gqlType: GraphQLObjectType
+) {
+    const definitions: Definition[] = []
+    const graphqlFields: DefinitionProperty[] = []
+
+    const variants: DefinitionVariant[] = []
+
+    const argumentDefinition: Definition = {
+        title: "Arguments",
+        properties: [],
+        variants,
+        meta: [
+            {
+                name: "type",
+                value: "arguments",
+            },
+        ]
+    }
+
+    for (const [name, field] of Object.entries(gqlType.getFields())) {
+        if (!field?.args?.length) {
+         continue;
+        }
+
+        const args = gqlArgToUniformDefinitionProperty(ctx, field.args)
+
+        variants.push({
+            title: "",
+            properties: args,
+            meta: [
+                {
+                    name: "symbolName",
+                    value: name,
+                }
+            ]
+        })
+    }
+    definitions.push(argumentDefinition)
+
+    for (const [name, field] of Object.entries(gqlType.getFields())) {
+        const prop = gqlFieldToUniformDefinitionProperty(ctx, field)
+
+        graphqlFields.push(prop)
+    }
+
+    definitions.push({
+        title: "Fields",
+        properties: graphqlFields,
+        meta: [
+            {
+                name: "type",
+                value: "fields",
+            }
+        ]
+    })
+
+    return uniformify(
+        ctx,
+        gqlType,
+        definitions,
+        []
+    )
+}
+
+// gqlObjectToUniformDefinitionProperty is a helper function to convert a GraphQL object type into a xyd definition property.
+export function gqlObjectToUniformDefinitionProperty(
+    ctx: Context,
+    obj: GraphQLObjectType,
+) {
+    return gqlObjectPropsUniformify(ctx, obj)
+}

package/src/converters/gql-operation.ts

@@ -0,0 +1,128 @@
+import { GraphQLFieldMap, GraphQLSchema, OperationTypeNode } from "graphql";
+import { Definition, Example, Reference, ReferenceType, } from "@xyd-js/uniform";
+
+import { type GQLSchemaToReferencesOptions, GQLOperation } from "../types";
+import { gqlArgToUniformDefinitionProperty } from "./gql-arg";
+import { gqlFieldToUniformDefinitionProperty } from "./gql-field";
+import { simpleGraphqlExample } from "./gql-sample";
+import { uniformify } from "../gql-core";
+import { Context } from "../context";
+
+// gqlOperationToUniformRef is a helper function to create a list of xyd reference for a GraphQL operation (query or mutation).
+export function gqlOperationToUniformRef(
+    operationType: ReferenceType.GRAPHQL_MUTATION | ReferenceType.GRAPHQL_QUERY | ReferenceType.GRAPHQL_SUBSCRIPTION,
+    fieldsMap: GraphQLFieldMap<any, any>,
+    schema: GraphQLSchema,
+    options?: GQLSchemaToReferencesOptions,
+) {
+    const references: Reference[] = []
+
+    for (const [operationName, operationField] of Object.entries(fieldsMap)) {
+        const definitions: Definition[] = []
+        let flatReturn = false
+        let flat = false
+        let argFlat = false
+
+        if (options?.flat) {
+            flatReturn = true
+            flat = true
+            argFlat = true
+        }
+
+        const args = gqlArgToUniformDefinitionProperty(new Context(
+            new Set(),
+            options,
+            {
+                flat,
+                flatArg: argFlat,
+            },
+            schema
+        ), operationField.args)
+
+
+        const returns = gqlFieldToUniformDefinitionProperty(new Context(
+            new Set(),
+            options,
+            {
+                flatReturn
+            },
+            schema
+        ), operationField)
+        let returnProperties = returns.properties || []
+        if (options?.flat) {
+            returnProperties = [returns]
+        }
+
+        definitions.push({
+            title: "Arguments",
+            properties: args,
+        })
+        definitions.push({
+            title: "Returns",
+            properties: returnProperties,
+        })
+
+        const exampleQuery = simpleGraphqlExample(
+            operationType,
+            operationName,
+            args,
+            returnProperties
+        )
+
+        const examples: Example[] = [
+            {
+                codeblock: {
+                    tabs: [
+                        {
+                            title: "",
+                            language: "graphql",
+                            code: exampleQuery,
+                        }
+                    ]
+                }
+            }
+        ]
+
+        const exampleGroup = {
+            description: "",
+            examples,
+        }
+
+        const operation = new GQLOperation(operationField)
+        switch (operationType) {
+            case ReferenceType.GRAPHQL_QUERY: {
+                operation.__operationType = OperationTypeNode.QUERY;
+                break;
+            }
+            case ReferenceType.GRAPHQL_MUTATION: {
+                operation.__operationType = OperationTypeNode.MUTATION;
+                break;
+            }
+            case ReferenceType.GRAPHQL_SUBSCRIPTION: {
+                operation.__operationType = OperationTypeNode.SUBSCRIPTION;
+                break;
+            }
+            default: {
+                console.error(`Invalid operation type: ${operationType}`);
+            }
+        }
+
+        const ref = uniformify(
+            new Context(
+                new Set(),
+                options,
+                {},
+                schema
+            ),
+            operation,
+            definitions,
+            [exampleGroup]
+        )
+        
+        if (ref) {
+            references.push(ref)
+        }
+    }
+
+    return references
+}

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;
+}