graphql-relational-schema-transformer/src/RelationalDBSchemaTransformerUtils.ts

import { Kind, print, ObjectTypeDefinitionNode, NonNullTypeNode, DirectiveNode, NameNode,
    OperationTypeNode, FieldDefinitionNode, NamedTypeNode, InputValueDefinitionNode, ValueNode,
    OperationTypeDefinitionNode, SchemaDefinitionNode, ArgumentNode, ListValueNode, StringValueNode, 
    InputObjectTypeDefinitionNode, DocumentNode} from 'graphql'

const intTypes = [`INTEGER`, `INT`, `SMALLINT`, `TINYINT`, `MEDIUMINT`, `BIGINT`, `BIT`]
const floatTypes = [`FLOAT`, `DOUBLE`, `REAL`, `REAL_AS_FLOAT`, `DOUBLE PRECISION`, `DEC`, `DECIMAL`, `FIXED`, `NUMERIC`]


/**
 * Creates a non-null type, which is a node wrapped around another type that simply defines it is non-nullable.
 * 
 * @param typeNode the type to be marked as non-nullable.
 * @returns a non-null wrapper around the provided type.
 */
 export function getNonNullType(typeNode: NamedTypeNode): NonNullTypeNode {
    return {
        kind: Kind.NON_NULL_TYPE,
        type: typeNode
    }
}

/**
 * Creates a named type for the schema.
 * 
 * @param name the name of the type.
 * @returns a named type with the provided name.
 */
export function getNamedType(name: string): NamedTypeNode {
    return {
        kind: Kind.NAMED_TYPE,
        name: {
            kind: Kind.NAME,
            value: name
        }
    }
}

/**
 * Creates an input value definition for the schema.
 * 
 * @param typeNode the type of the input node.
 * @param name the name of the input.
 * @returns an input value definition node with the provided type and name.
 */
export function getInputValueDefinition(typeNode: NamedTypeNode | NonNullTypeNode, name: string): InputValueDefinitionNode {
    return {
        kind: Kind.INPUT_VALUE_DEFINITION,
        name: {
            kind: Kind.NAME,
            value: name
        },
        type: typeNode
    }
}

/**
 * Creates an operation field definition for the schema.
 * 
 * @param name the name of the operation.
 * @param args the arguments for the operation.
 * @param type the type of the operation.
 * @param directives the directives (if any) applied to this field. In this context, only subscriptions will have this.
 * @returns an operation field definition with the provided name, args, type, and optionally directives.
 */
export function getOperationFieldDefinition(name: string, args: InputValueDefinitionNode[], type: NamedTypeNode, directives: ReadonlyArray<DirectiveNode>): FieldDefinitionNode {
    return {
        kind: Kind.FIELD_DEFINITION,
        name: {
            kind: Kind.NAME,
            value: name
        },
        arguments: args,
        type: type,
        directives: directives
    }
}

/**
 * Creates a field definition node for the schema.
 * 
 * @param fieldName the name of the field to be created.
 * @param type the type of the field to be created.
 * @returns a field definition node with the provided name and type.
 */
export function getFieldDefinition(fieldName: string, type: NonNullTypeNode | NamedTypeNode): FieldDefinitionNode {
    return {
        kind: Kind.FIELD_DEFINITION,
        name: {
            kind: Kind.NAME,
            value: fieldName
        },
        type
    }
}

/**
 * Creates a type definition node for the schema.
 * 
 * @param fields the field set to be included in the type.
 * @param typeName the name of the type.
 * @returns a type definition node defined by the provided fields and name.
 */
export function getTypeDefinition(fields: ReadonlyArray<FieldDefinitionNode>, typeName: string): ObjectTypeDefinitionNode {
    return {
        kind: Kind.OBJECT_TYPE_DEFINITION,
        name: {
            kind: Kind.NAME,
            value: typeName
        },
        fields: fields
    }
}

/**
 * Creates an input type definition node for the schema.
 * 
 * @param fields the fields in the input type.
 * @param typeName the name of the input type
 * @returns an input type definition node defined by the provided fields and
 */
export function getInputTypeDefinition(fields: ReadonlyArray<InputValueDefinitionNode>, typeName: string): InputObjectTypeDefinitionNode {
    return {
        kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
        name: {
            kind: Kind.NAME,
            value: typeName
        },
        fields: fields
    }
}

/**
 * Creates a name node for the schema.
 * 
 * @param name the name of the name node.
 * @returns the name node defined by the provided name.
 */
export function getNameNode(name: string): NameNode {
    return {
        kind: Kind.NAME,
        value: name
    }        
}

/**
 * Creates a list value node for the schema.
 * 
 * @param values the list of values to be in the list node.
 * @returns a list value node containing the provided values.
 */
export function getListValueNode(values: ReadonlyArray<ValueNode>): ListValueNode {
    return {
        kind: Kind.LIST,
        values: values
    }
}

/**
 * Creates a simple string value node for the schema.
 * 
 * @param value the value to be set in the string value node.
 * @returns a fleshed-out string value node.
 */
export function getStringValueNode(value: string): StringValueNode {
    return {
        kind: Kind.STRING,
        value: value
    }
}    

/**
 * Creates a directive node for a subscription in the schema.
 * 
 * @param mutationName the name of the mutation the subscription directive is for.
 * @returns a directive node defining the subscription.
 */
export function getDirectiveNode(mutationName: string): DirectiveNode {
    return {
        kind: Kind.DIRECTIVE,
        name: this.getNameNode('aws_subscribe'),
        arguments: [this.getArgumentNode(mutationName)]
    }
}

/**
 * Creates an operation type definition (subscription, query, mutation) for the schema.
 * 
 * @param operationType the type node defining the operation type.
 * @param operation  the named type node defining the operation type.
 */
export function getOperationTypeDefinition(operationType: OperationTypeNode, operation: NamedTypeNode): OperationTypeDefinitionNode {
    return {
        kind: Kind.OPERATION_TYPE_DEFINITION,
        operation: operationType,
        type: operation
    }
}

/**
 * Creates an argument node for a subscription directive within the schema.
 * 
 * @param argument the argument string.
 * @returns the argument node.
 */
export function getArgumentNode(argument: string): ArgumentNode {
    return {
        kind: Kind.ARGUMENT,
        name: this.getNameNode('mutations'),
        value: this.getListValueNode([this.getStringValueNode(argument)])
    }
}

/**
 * Given the DB type for a column, make a best effort to select the appropriate GraphQL type for
 * the corresponding field.
 * 
 * @param dbType the SQL column type.
 * @returns the GraphQL field type.
 */
export function getGraphQLTypeFromMySQLType(dbType: string): string {
    const normalizedType = dbType.toUpperCase().split("(")[0]
    if (`BOOL` == normalizedType) {
        return `Boolean`
    } else if (`JSON` == normalizedType) {
        return `AWSJSON`
    } else if (`TIME` == normalizedType) {
        return `AWSTime`
    } else if (`DATE` == normalizedType) {
        return `AWSDate`
    } else if (`DATETIME` == normalizedType) {
        return `AWSDateTime`
    } else if (`TIMESTAMP` == normalizedType) {
        return `AWSTimestamp`
    } else if (intTypes.indexOf(normalizedType) > -1) {
        return `Int`
    } else if (floatTypes.indexOf(normalizedType) > -1) {
        return `Float`
    }
    return `String`
}