@xyd-js/gql 0.1.0-xyd.2 → 0.1.0-xyd.4

package/examples/graphql-types/graphql-types.0.basic.graphqls

@@ -0,0 +1,28 @@
+"""
+This is a custom scalar type for Date.
+"""
+scalar Date
+
+"""
+This is a custom enum type for Role.
+"""
+enum Role {
+    ADMIN
+    OWNER
+}
+
+"""
+This is a custom input type for Book.
+"""
+input BookInput {
+    title: String!
+    author: String!
+}
+
+"""
+This is a custom type for Book.
+"""
+type Book {
+    title: String!
+    author: String!
+}

package/examples/nested/nested-arg.0.not-required.graphqls

@@ -0,0 +1,8 @@
+input BookInput {
+    title: String!
+    author: String!
+}
+
+type Mutation {
+    addBook(bookInput: BookInput): Boolean!
+}

package/examples/nested/nested-arg.0.required.graphqls

@@ -0,0 +1,8 @@
+input BookInput {
+    title: String!
+    author: String!
+}
+
+type Mutation {
+    addBook(bookInput: BookInput!): Boolean!
+}

package/examples/nested/nested-arg.1.deep.graphqls

@@ -0,0 +1,12 @@
+input BookInput {
+    title: String!
+    author: Author!
+}
+
+input Author {
+    name: String!
+}
+
+type Mutation {
+    addBook(bookInput: BookInput): Boolean!
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyd-js/gql",
-  "version": "0.1.0-xyd.2",
+  "version": "0.1.0-xyd.4",
   "description": "",
   "main": "./dist/index.js",
   "type": "module",
@@ -11,18 +11,21 @@
     "graphql-config": "^5.1.2",
     "gray-matter": "^4.0.3",
     "json-to-graphql-query": "^2.3.0",
-    "@xyd-js/core": "0.1.0-xyd.2",
-    "@xyd-js/uniform": "0.1.0-xyd.4"
+    "@xyd-js/uniform": "0.1.0-xyd.6",
+    "@xyd-js/core": "0.1.0-xyd.4"
   },
   "devDependencies": {
-    "tsup": "^8.3.0",
     "rimraf": "^3.0.2",
-    "typescript": "^4.5.5"
+    "tsup": "^8.3.0",
+    "typescript": "^4.5.5",
+    "vitest": "^2.1.1"
   },
   "scripts": {
     "clean": "rimraf build",
     "prebuild": "pnpm clean",
     "build": "tsup",
-    "build:examples": "tsup --config tsup.examples-config.ts"
+    "build:examples": "tsup --config tsup.examples-config.ts",
+    "test": "vitest",
+    "ci:test": "vitest run"
   }
 }

package/src/hydration/README.md

@@ -0,0 +1 @@
+`hydration` converts a GraphQL into XYD `uniform` format.

package/src/hydration/gql-arg.ts

@@ -0,0 +1,53 @@
+import {GraphQLArgument} from "graphql/type/definition";
+import {GraphQLInputObjectType} from "graphql/type";
+
+import {DefinitionProperty} from "@xyd-js/uniform";
+
+import {gqlInputToUniformDefinitionProperty} from "./gql-input";
+
+// gqlArgToUniformDefinitionProperty converts GraphQL arguments into xyd 'uniform' definition properties
+export function gqlArgToUniformDefinitionProperty(
+    args: readonly GraphQLArgument[]
+): DefinitionProperty[] {
+    const resp: DefinitionProperty[] = []
+
+    args.forEach(arg => {
+        let obj: GraphQLInputObjectType | null = null
+
+        switch (arg.type.constructor.name) {
+            case "GraphQLNonNull": {
+                if ("ofType" in arg.type) {
+                    const ofType = arg.type?.ofType
+
+                    if (ofType?.constructor.name === "GraphQLInputObjectType") {
+                        obj = ofType as GraphQLInputObjectType
+                    }
+                }
+                break
+            }
+
+            case "GraphQLInputObjectType" : {
+                obj = arg.type as GraphQLInputObjectType
+
+                break
+            }
+
+            default: {
+            }
+        }
+
+        if (!obj) {
+            console.error("unsupported argument type", arg.type.constructor.name)
+            return
+        }
+
+        resp.push(gqlInputToUniformDefinitionProperty(
+            arg.name,
+            arg.description || "",
+            obj
+        ))
+    })
+
+    return resp
+}
+

package/src/{fields.ts → hydration/gql-field.ts}

@@ -1,4 +1,3 @@
-// overFields iterates over fields of object or input object types
 import {
     GraphQLField,
     GraphQLFieldMap,
@@ -6,15 +5,18 @@ import {
     GraphQLInputFieldMap,
     GraphQLInputObjectType
 } from "graphql/type";
-import {GraphQLObjectType} from "graphql";
+import {GraphQLObjectType, GraphQLNamedType} from "graphql";
+
 import {DefinitionProperty} from "@xyd-js/uniform";
+import {isIntrospectionType, isSpecifiedScalarType} from "graphql/index";
 
-// fieldIntoDefinitionProperty converts GraphQL fields (field or input field) into xyd 'uniform' definition property
-export function fieldIntoDefinitionProperty(
+// gqlFieldToUniformDefinitionProperty converts GraphQL fields (field or input field) into xyd 'uniform' definition property
+export function gqlFieldToUniformDefinitionProperty(
     fieldName: string,
     field: GraphQLField<any, any> | GraphQLInputField,
 ): DefinitionProperty {
     let properties;
+    let graphqlTypeFlat: GraphQLNamedType | null = null
 
     // if 'ofType' types (non-null values e.g '!<type>')
     if ("ofType" in field.type) {
@@ -25,6 +27,7 @@ export function fieldIntoDefinitionProperty(
                         const objectType = field.type.ofType as GraphQLObjectType
 
                         properties = nestedProperties(objectType)
+                        graphqlTypeFlat = objectType
 
                         break
                     }
@@ -33,12 +36,14 @@ export function fieldIntoDefinitionProperty(
                         const inputObjectType = field.type.ofType as GraphQLInputObjectType
 
                         properties = nestedProperties(inputObjectType)
+                        graphqlTypeFlat = inputObjectType
 
                         break
                     }
 
-                    case "GraphQLScalarType" : {
+                    case "GraphQLScalarType": {
                         properties = definitionPropsFromNestedObj(field) || []
+                        graphqlTypeFlat = field.type.ofType as GraphQLNamedType
 
                         break
                     }
@@ -46,6 +51,10 @@ export function fieldIntoDefinitionProperty(
                     case "GraphQLNonNull": {
                         properties = definitionPropsFromNestedObj(field) || []
 
+                        if ("ofType" in field.type.ofType) {
+                            graphqlTypeFlat = field.type.ofType.ofType as GraphQLNamedType
+                        }
+
                         break
                     }
 
@@ -61,6 +70,7 @@ export function fieldIntoDefinitionProperty(
 
             case "GraphQLNonNull": {
                 properties = definitionPropsFromNestedObj(field) || []
+                graphqlTypeFlat = field.type.ofType as GraphQLNamedType
 
                 break
             }
@@ -77,6 +87,7 @@ export function fieldIntoDefinitionProperty(
     // if regular object type
     else if (field.type.constructor.name === "GraphQLObjectType") {
         const objectType = field.type as GraphQLObjectType
+        graphqlTypeFlat = field.type
 
         // TODO: support nested & circular references - ITS JUST A FAST SOLUTION FOR TESTING PURPOSES
         // properties = [
@@ -89,18 +100,57 @@ export function fieldIntoDefinitionProperty(
 
         // TODO: comment if bug with circular references
         properties = nestedProperties(objectType)
-    }
-
-    // if input object type
-    else if (field.type.constructor.name === "GraphQLInputObjectType") {
+    } else if (field.type.constructor.name === "GraphQLInputObjectType") {
         const objectType = field.type as GraphQLInputObjectType
 
+        graphqlTypeFlat = field.type
         properties = nestedProperties(objectType)
+    } else if (field.type.constructor.name === "GraphQLScalarType") {
+        graphqlTypeFlat = field.type
+    }
+
+
+    switch (graphqlTypeFlat?.constructor?.name) {
+        case "GraphQLList": {
+            if ("ofType" in graphqlTypeFlat) {
+                graphqlTypeFlat = graphqlTypeFlat.ofType as GraphQLNamedType
+            }
+        }
+    }
+
+    const builtInType = graphqlTypeFlat ? (isSpecifiedScalarType(graphqlTypeFlat) ||
+        isIntrospectionType(graphqlTypeFlat)
+    ) : undefined
+
+    let graphqlTypeShort = ""
+
+    switch (graphqlTypeFlat?.constructor?.name) {
+        case "GraphQLObjectType": {
+            graphqlTypeShort = "object"
+
+            break
+        }
+        case "GraphQLInputObjectType": {
+            graphqlTypeShort = "input"
+
+            break
+        }
+        case "GraphQLScalarType": {
+            graphqlTypeShort = "scalar"
+
+            break
+        }
     }
 
     return {
         name: fieldName,
         type: field.type.toJSON(),
+        context: {
+            graphqlBuiltInType: builtInType,
+            graphqlName: fieldName,
+            graphqlTypeFlat: graphqlTypeFlat && graphqlTypeFlat.toJSON(),
+            graphqlTypeShort,
+        },
         description: field.description || "",
         properties,
     }
@@ -134,7 +184,7 @@ function deepFieldMap(
     const properties: DefinitionProperty[] = []
 
     for (const [name, field] of Object.entries(fieldsMap)) {
-        const prop = fieldIntoDefinitionProperty(
+        const prop = gqlFieldToUniformDefinitionProperty(
             name,
             field,
         )

package/src/hydration/gql-input.ts

@@ -0,0 +1,67 @@
+import {GraphQLInputObjectType} from "graphql/type";
+
+import {DefinitionProperty, Reference} from "@xyd-js/uniform";
+
+import {gqlFieldToUniformDefinitionProperty} from "./gql-field";
+
+// gqlInputToUniformRef is a helper function to convert a GraphQL input object type into a 'uniform' reference.
+export function gqlInputToUniformRef(gqlType: GraphQLInputObjectType): Reference {
+    const prop = gqlInputToUniformDefinitionProperty(
+        gqlType.name,
+        gqlType.description || "",
+        gqlType
+    )
+
+    return {
+        title: gqlType.name,
+        description: gqlType.description || "",
+        canonical: `input-${gqlType.name}`, // TODO: better solution
+        context: {
+            graphqlName: gqlType.name,
+            graphqlTypeShort: "input" // TODO: better solution
+        },
+        definitions: [
+            {
+                title: "Fields",
+                properties: prop.properties || []
+            }
+        ],
+        examples: {
+            groups: []
+        }
+    } as Reference
+}
+
+// gqlInputToUniformDefinitionProperty is a helper function to convert a GraphQL input object into a xyd definition property.
+export function gqlInputToUniformDefinitionProperty(
+    name: string,
+    description: string,
+    obj: GraphQLInputObjectType
+) {
+    const inputFields = obj.getFields?.()
+
+    const nestedProps: DefinitionProperty[] = []
+    const nestedDefinitionProperty: DefinitionProperty = {
+        name: name,
+        type: obj.toJSON(),
+        description: description || "",
+        context: {
+            graphqlName: name,
+            graphqlTypeShort: "input"
+        },
+        properties: nestedProps,
+    }
+
+    for (const [name, inputField] of Object.entries(inputFields)) {
+        const prop = gqlFieldToUniformDefinitionProperty(
+            name,
+            inputField,
+        )
+
+        if (prop) {
+            nestedProps.push(prop)
+        }
+    }
+
+    return nestedDefinitionProperty
+}

package/src/hydration/gql-object.ts

@@ -0,0 +1,35 @@
+import {GraphQLObjectType} from "graphql";
+
+import type {DefinitionProperty} from "@xyd-js/uniform";
+
+import {gqlFieldToUniformDefinitionProperty} from "./gql-field";
+
+// gqlObjectToUniformRef is a helper function to convert a GraphQL object type into a 'uniform' reference.
+export function gqlObjectToUniformRef(gqlType: GraphQLObjectType) {
+    const props: DefinitionProperty[] = []
+
+    for (const [name, field] of Object.entries(gqlType.getFields())) {
+        const prop = gqlFieldToUniformDefinitionProperty(name, field)
+
+        props.push(prop)
+    }
+
+    return {
+        title: gqlType.name,
+        description: gqlType.description || "",
+        canonical: `object-${gqlType.name}`, // TODO: better solution
+        context: {
+            graphqlName: gqlType.name,
+            graphqlTypeShort: "object" // TODO: better solution
+        },
+        definitions: [
+            {
+                title: "Fields",
+                properties: props
+            }
+        ],
+        examples: {
+            groups: []
+        }
+    }
+}

package/src/hydration/gql-types.ts

@@ -0,0 +1,50 @@
+import {GraphQLEnumType} from "graphql";
+
+import {GraphQLScalarType} from "@graphql-markdown/types";
+
+import type {DefinitionProperty, Reference} from "@xyd-js/uniform";
+
+// gqlEnumToUniformRef is a helper function to convert a GraphQL enum type into a 'uniform' reference.
+export function gqlEnumToUniformRef(gqlType: GraphQLEnumType): Reference {
+    const props: DefinitionProperty[] = gqlType.getValues().map(value => ({
+        name: value.name,
+        type: "string",
+        description: value.description || "",
+    }))
+
+    return {
+        title: gqlType.name,
+        description: gqlType.description || "",
+        canonical: `enum-${gqlType.name}`, // TODO: better solution
+        context: {
+            graphqlName: gqlType.name,
+            graphqlTypeShort: "enum" // TODO: better solution
+        },
+        definitions: [
+            {
+                title: "Valid values",
+                properties: props
+            }
+        ],
+        examples: {
+            groups: []
+        }
+    } as Reference
+}
+
+// gqlScalarToUniformRef is a helper function to convert a GraphQL scalar type into a 'uniform' reference.
+export function gqlScalarToUniformRef(gqlType: GraphQLScalarType): Reference {
+    return {
+        title: gqlType.name,
+        description: gqlType.description || "",
+        canonical: `scalar-${gqlType.name}`, // TODO: better solution
+        context: {
+            graphqlName: gqlType.name,
+            graphqlTypeShort: "scalar" // TODO: better solution
+        },
+        definitions: [],
+        examples: {
+            groups: []
+        }
+    } as Reference
+}

package/src/index.ts

@@ -1,3 +1,3 @@
 export {
-    gqlSchemaToReferences
+    gqlSchemaToReferences // TODO: rename to gqlSchemaToUniformRef ?
 } from "./schema"

package/src/{examples.ts → samples/index.ts}

@@ -1,10 +1,10 @@
 import {jsonToGraphQLQuery, VariableType} from "json-to-graphql-query";
+
 import {
     DefinitionProperty,
     ReferenceType
 } from "@xyd-js/uniform";
 
-// TODO: support args
 // simpleGraphqlExample is a helper function to create a simple GraphQL example query or mutation.
 export function simpleGraphqlExample(
     operationType: ReferenceType.GRAPHQL_QUERY | ReferenceType.GRAPHQL_MUTATION,
@@ -14,7 +14,6 @@ export function simpleGraphqlExample(
 ) {
     let obj: any = {}
 
-
     switch (operationType) {
         case ReferenceType.GRAPHQL_QUERY: {
             const exampleReturnProps = exampleReturns(returns)

package/src/schema.ts

@@ -1,10 +1,21 @@
-import {getDocumentLoaders, loadSchema} from "@graphql-markdown/graphql";
+import {
+    GraphQLInputObjectType,
+    GraphQLObjectType,
+    GraphQLEnumType,
+    isSpecifiedScalarType,
+    isIntrospectionType
+} from "graphql";
 import {OperationTypeNode} from "graphql/language/ast";
-import {Reference, ReferenceType} from "@xyd-js/uniform"
 
-import {
-    graphqlOperationReferences
-} from "./utils";
+import {getDocumentLoaders, loadSchema} from "@graphql-markdown/graphql";
+import {GraphQLScalarType} from "@graphql-markdown/types";
+
+import type {Reference} from "@xyd-js/uniform"
+import {ReferenceType} from "@xyd-js/uniform"
+import {gqlInputToUniformRef} from "./hydration/gql-input";
+import {gqlEnumToUniformRef, gqlScalarToUniformRef} from "./hydration/gql-types";
+import {gqlObjectToUniformRef} from "./hydration/gql-object";
+import {gqlOperationsToUniformRef} from "./utils";
 
 // TODO: support multi graphql files
 // TODO: !!! CIRCULAR_DEPENDENCY !!!
@@ -27,7 +38,7 @@ export async function gqlSchemaToReferences(
     const queryFields = queries?.getFields?.()
 
     if (queryFields) {
-        references.push(...graphqlOperationReferences(
+        references.push(...gqlOperationsToUniformRef(
             ReferenceType.GRAPHQL_QUERY,
             queryFields
         ))
@@ -37,11 +48,60 @@ export async function gqlSchemaToReferences(
     const mutationFields = mutations?.getFields?.()
 
     if (mutationFields) {
-        references.push(...graphqlOperationReferences(
+        references.push(...gqlOperationsToUniformRef(
             ReferenceType.GRAPHQL_MUTATION,
             mutationFields
         ))
     }
 
+    const typeMap = schema.getTypeMap();
+
+    for (const gqlType of Object.values(typeMap)) {
+        const builtInType = isSpecifiedScalarType(gqlType) ||
+            isIntrospectionType(gqlType) ||
+            gqlType.name === "Mutation"
+
+        if (builtInType) {
+            continue;
+        }
+
+        switch (gqlType.constructor.name) {
+            case 'GraphQLObjectType': {
+                const type = gqlType as GraphQLObjectType;
+
+                references.push(gqlObjectToUniformRef(type))
+
+                break
+            }
+
+            case 'GraphQLInputObjectType': {
+                const type = gqlType as GraphQLInputObjectType;
+
+                references.push(gqlInputToUniformRef(type))
+                break
+            }
+
+            case 'GraphQLEnumType': {
+                const type = gqlType as GraphQLEnumType;
+
+                references.push(gqlEnumToUniformRef(type))
+
+                break
+            }
+
+            case 'GraphQLScalarType': {
+                const type = gqlType as GraphQLScalarType
+
+                references.push(gqlScalarToUniformRef(type))
+
+                break
+            }
+
+            default: {
+                console.debug(`Unsupported type: ${gqlType.constructor.name}`)
+            }
+        }
+    }
+
     return references
 }

package/src/utils.ts

@@ -8,13 +8,12 @@ import {
     Example,
 } from "@xyd-js/uniform";
 
-import {argumentsIntoDefinitionProperty} from "./arguments";
-import {fieldIntoDefinitionProperty} from "./fields";
-import {simpleGraphqlExample} from "./examples";
+import {gqlArgToUniformDefinitionProperty} from "./hydration/gql-arg";
+import {gqlFieldToUniformDefinitionProperty} from "./hydration/gql-field";
+import {simpleGraphqlExample} from "./samples";
 
-// TODO: examples
-// graphqlOperationReferences is a helper function to create a list of xyd reference for a GraphQL query or mutation.
-export function graphqlOperationReferences(
+// gqlOperationsToUniformRef is a helper function to create a list of xyd reference for a GraphQL query or mutation.
+export function gqlOperationsToUniformRef(
     operationType: ReferenceType.GRAPHQL_MUTATION | ReferenceType.GRAPHQL_QUERY,
     fieldsMap: GraphQLFieldMap<any, any>
 ) {
@@ -23,8 +22,8 @@ export function graphqlOperationReferences(
     for (const [operationName, operationField] of Object.entries(fieldsMap)) {
         const definitions: Definition[] = []
 
-        const args = argumentsIntoDefinitionProperty(operationField.args)
-        const returns = fieldIntoDefinitionProperty(operationName, operationField)
+        const args = gqlArgToUniformDefinitionProperty(operationField.args)
+        const returns = gqlFieldToUniformDefinitionProperty(operationName, operationField)
         const returnProperties = returns.properties || []
 
         definitions.push({