@subsquid/openreader 0.2.0 → 0.3.3

package/src/gql/opencrud.ts

@@ -0,0 +1,328 @@
+import {Output, toCamelCase, toPlural} from "@subsquid/util"
+import assert from "assert"
+import {DocumentNode, parse, print} from "graphql"
+import {Entity, Enum, FTS_Query, Interface, JsonObject, Model, Prop, Union} from "../model"
+import {getOrderByMapping} from "../orderBy"
+import {scalars_list} from "../scalars"
+import {toQueryListField} from "../util"
+
+
+export function generateOpenCrudQueries(model: Model): string {
+    let out = new Output()
+
+    generatePageInfoType()
+
+    for (let name in model) {
+        let item = model[name]
+        switch(item.kind) {
+            case 'entity':
+                generateOrderByInput(name)
+                generateWhereUniqueInput(name)
+                generateWhereInput(name, item)
+                generateObjectType(name, item)
+                generateEntityConnection(name)
+                break
+            case 'object':
+                if (hasFilters(item)) {
+                    generateWhereInput(name, item)
+                }
+                generateObjectType(name, item)
+                break
+            case 'interface':
+                generateObjectType(name, item)
+                break
+            case 'union':
+                generateUnionWhereInput(name, item)
+                generateUnionType(name, item)
+                break
+            case 'enum':
+                generateEnumType(name, item)
+                break
+            case 'fts':
+                generateFtsTypes(name, item)
+                break
+        }
+    }
+
+    out.block('type Query', () => {
+        for (let name in model) {
+            let item = model[name]
+            if (item.kind == 'entity') {
+                out.line(`${toCamelCase(name)}ById(id: ID!): ${name}`)
+                out.line(`${toCamelCase(name)}ByUniqueInput(where: ${name}WhereUniqueInput!): ${name} @deprecated(reason: "Use \`${toCamelCase(name)}ById\`")`)
+                out.line(`${toQueryListField(name)}${manyArguments(name)}: [${name}!]!`)
+                out.line(`${toQueryListField(name)}Connection${connectionArguments(name)}: ${toPlural(name)}Connection!`)
+            }
+            if (item.kind == 'fts') {
+                generateFtsQuery(name, item)
+            }
+        }
+    })
+
+    function generateObjectType(name: string, object: Entity | JsonObject | Interface): void {
+        let head: string
+        if (object.kind == 'interface') {
+            head = `interface ${name}`
+        } else {
+            head = `type ${name}`
+            if (object.interfaces?.length) {
+                head += ` implements ${object.interfaces.join(' & ')}`
+            }
+        }
+        generateDescription(object.description)
+        out.block(head, () => {
+            for (let key in object.properties) {
+                let prop = object.properties[key]
+                let gqlType = renderPropType(prop)
+                generateDescription(prop.description)
+                if (prop.type.kind == 'list-lookup') {
+                    out.line(`${key}${manyArguments(prop.type.entity)}: ${gqlType}`)
+                } else {
+                    out.line(`${key}: ${gqlType}`)
+                }
+            }
+        })
+        out.line()
+    }
+
+    function renderPropType(prop: Prop): string {
+        switch(prop.type.kind) {
+            case "list":
+                return `[${renderPropType(prop.type.item)}]${prop.nullable ? '' : '!'}`
+            case 'fk':
+                return `${prop.type.foreignEntity}${prop.nullable ? '' : '!'}`
+            case 'lookup':
+                return prop.type.entity
+            case 'list-lookup':
+                return `[${prop.type.entity}!]!`
+            default:
+                return prop.type.name + (prop.nullable ? '' : '!')
+        }
+    }
+
+    function manyArguments(entityName: string): string {
+        return `(where: ${entityName}WhereInput orderBy: [${entityName}OrderByInput] offset: Int limit: Int)`
+    }
+
+    function connectionArguments(entityName: string): string {
+        return `(orderBy: [${entityName}OrderByInput!]! after: String first: Int where: ${entityName}WhereInput)`
+    }
+
+    function generateOrderByInput(entityName: string): void {
+        out.block(`enum ${entityName}OrderByInput`, () => {
+            let mapping = getOrderByMapping(model, entityName)
+            for (let key of mapping.keys()) {
+                out.line(key)
+            }
+        })
+        out.line()
+    }
+
+    function generateWhereUniqueInput(entityName: string): void {
+        out.block(`input ${entityName}WhereUniqueInput`, () => {
+            out.line('id: ID!')
+        })
+    }
+
+    function generateWhereInput(name: string, object: Entity | JsonObject): void {
+        out.block(`input ${name}WhereInput`, () => {
+            generatePropsFilters(object.properties)
+            if (object.kind == 'entity') {
+                out.line(`AND: [${name}WhereInput!]`)
+                out.line(`OR: [${name}WhereInput!]`)
+            }
+        })
+        out.line()
+    }
+
+    function generatePropsFilters(props: Record<string, Prop>): void {
+        for (let key in props) {
+            let prop = props[key]
+            switch(prop.type.kind) {
+                case 'scalar':
+                case 'enum':
+                    generateScalarFilters(key, prop.type.name)
+                    break
+                case 'list':
+                    if (prop.type.item.type.kind == 'scalar' || prop.type.item.type.kind == 'enum') {
+                        let item = prop.type.item.type.name
+                        out.line(`${key}_containsAll: [${item}!]`)
+                        out.line(`${key}_containsAny: [${item}!]`)
+                        out.line(`${key}_containsNone: [${item}!]`)
+                    }
+                    break
+                case 'object':
+                    if (hasFilters(getObject(prop.type.name))) {
+                        out.line(`${key}: ${prop.type.name}WhereInput`)
+                    }
+                    break
+                case 'union':
+                    out.line(`${key}: ${prop.type.name}WhereInput`)
+                    break
+                case 'fk':
+                    out.line(`${key}: ${prop.type.foreignEntity}WhereInput`)
+                    break
+                case 'lookup':
+                    out.line(`${key}: ${prop.type.entity}WhereInput`)
+                    break
+                case 'list-lookup':
+                    out.line(`${key}_every: ${prop.type.entity}WhereInput`)
+                    out.line(`${key}_some: ${prop.type.entity}WhereInput`)
+                    out.line(`${key}_none: ${prop.type.entity}WhereInput`)
+                    break
+            }
+        }
+    }
+
+    function hasFilters(obj: JsonObject): boolean {
+        for (let key in obj.properties) {
+            let propType = obj.properties[key].type
+            switch(propType.kind) {
+                case 'scalar':
+                case 'enum':
+                case 'union':
+                    return true
+                case 'object':
+                    if (hasFilters(getObject(propType.name))) {
+                        return true
+                    }
+            }
+        }
+        return false
+    }
+
+    function getObject(name: string): JsonObject {
+        let obj = model[name]
+        assert(obj.kind == 'object')
+        return obj
+    }
+
+    function generateUnionWhereInput(name: string, union: Union): void {
+        out.block(`input ${name}WhereInput`, () => {
+            // TODO: unify and use enum
+            out.line('isTypeOf_eq: String')
+            out.line('isTypeOf_not_eq: String')
+            out.line('isTypeOf_in: [String!]')
+            out.line('isTypeOf_not_in: [String!]')
+
+            let props: Record<string, Prop> = {}
+            union.variants.forEach(variant => {
+                let obj = getObject(variant)
+                Object.assign(props, obj.properties)
+            })
+
+            generatePropsFilters(props)
+        })
+    }
+
+    function generateScalarFilters(fieldName: string, graphqlType: string): void {
+        out.line(`${fieldName}_eq: ${graphqlType}`)
+        out.line(`${fieldName}_not_eq: ${graphqlType}`)
+
+        switch(graphqlType) {
+            case 'ID':
+            case 'String':
+            case 'Int':
+            case 'Float':
+            case 'DateTime':
+            case 'BigInt':
+                out.line(`${fieldName}_gt: ${graphqlType}`)
+                out.line(`${fieldName}_gte: ${graphqlType}`)
+                out.line(`${fieldName}_lt: ${graphqlType}`)
+                out.line(`${fieldName}_lte: ${graphqlType}`)
+                out.line(`${fieldName}_in: [${graphqlType}!]`)
+                out.line(`${fieldName}_not_in: [${graphqlType}!]`)
+                break
+        }
+
+        if (graphqlType == 'String' || graphqlType == 'ID') {
+            out.line(`${fieldName}_contains: ${graphqlType}`)
+            out.line(`${fieldName}_not_contains: ${graphqlType}`)
+            out.line(`${fieldName}_startsWith: ${graphqlType}`)
+            out.line(`${fieldName}_not_startsWith: ${graphqlType}`)
+            out.line(`${fieldName}_endsWith: ${graphqlType}`)
+            out.line(`${fieldName}_not_endsWith: ${graphqlType}`)
+        }
+
+        if (model[graphqlType]?.kind == 'enum') {
+            out.line(`${fieldName}_in: [${graphqlType}!]`)
+            out.line(`${fieldName}_not_in: [${graphqlType}!]`)
+        }
+    }
+
+    function generateUnionType(name: string, union: Union) {
+        generateDescription(union.description)
+        out.line(`union ${name} = ${union.variants.join(' | ')}`)
+        out.line()
+    }
+
+    function generateEnumType(name: string, e: Enum): void {
+        generateDescription(e.description)
+        out.block(`enum ${name}`, () => {
+            for (let key in e.values) {
+                out.line(key)
+            }
+        })
+    }
+
+    function generatePageInfoType(): void {
+        out.block(`type PageInfo`, () => {
+            out.line('hasNextPage: Boolean!')
+            out.line('hasPreviousPage: Boolean!')
+            out.line('startCursor: String!')
+            out.line('endCursor: String!')
+        })
+        out.line()
+    }
+
+    function generateEntityConnection(name: string): void {
+        out.block(`type ${name}Edge`, () => {
+            out.line(`node: ${name}!`)
+            out.line(`cursor: String!`)
+        })
+        out.line()
+        out.block(`type ${toPlural(name)}Connection`, () => {
+            out.line(`edges: [${name}Edge!]!`)
+            out.line(`pageInfo: PageInfo!`)
+            out.line(`totalCount: Int!`)
+        })
+        out.line()
+    }
+
+    function generateFtsTypes(name: string, query: FTS_Query): void {
+        let itemType = name + '_Item'
+        out.line(`union ${itemType} = ${query.sources.map(s => s.entity).join(' | ')}`)
+        out.line()
+        out.block(`type ${name}_Output`, () => {
+            out.line(`item: ${itemType}!`)
+            out.line(`rank: Float!`)
+            out.line(`highlight: String!`)
+        })
+        out.line()
+    }
+
+    function generateFtsQuery(name: string, query: FTS_Query): void {
+        let where = query.sources.map(src => {
+            return `where${src.entity}: ${src.entity}WhereInput`
+        })
+        out.line(`${name}(text: String! ${where.join(' ')} limit: Int offset: Int): [${name}_Output!]!`)
+    }
+
+    function generateDescription(description?: string): void {
+        if (description) {
+            out.line(print({
+                kind: 'StringValue',
+                value: description
+            }))
+        }
+    }
+
+    return out.toString()
+}
+
+
+export function buildServerSchema(model: Model): DocumentNode {
+    let scalars = scalars_list.map(name => 'scalar ' + name).join('\n')
+    let queries = generateOpenCrudQueries(model)
+    return parse(scalars  + '\n\n' + queries)
+}

package/src/gql/schema.ts

@@ -0,0 +1,337 @@
+import assert from "assert"
+import {
+    buildASTSchema,
+    DocumentNode,
+    extendSchema,
+    GraphQLEnumType,
+    GraphQLField,
+    GraphQLInterfaceType,
+    GraphQLList,
+    GraphQLNamedType,
+    GraphQLNonNull,
+    GraphQLObjectType,
+    GraphQLOutputType,
+    GraphQLScalarType,
+    GraphQLSchema,
+    GraphQLUnionType,
+    parse,
+    validateSchema
+} from "graphql"
+import {Model, Prop, PropType} from "../model"
+import {validateModel} from "../model.tools"
+import {scalars_list} from "../scalars"
+
+
+const baseSchema = buildASTSchema(parse(`
+    directive @entity on OBJECT
+    directive @derivedFrom(field: String!) on FIELD_DEFINITION
+    directive @unique on FIELD_DEFINITION
+    directive @fulltext(query: String!) on FIELD_DEFINITION
+    directive @variant on OBJECT # legacy
+    directive @jsonField on OBJECT # legacy
+    ${scalars_list.map(name => 'scalar ' + name).join('\n')}
+`))
+
+
+export function buildSchema(doc: DocumentNode): GraphQLSchema {
+    let schema = extendSchema(baseSchema, doc)
+    let errors = validateSchema(schema).filter(err => !/query root/i.test(err.message))
+    if (errors.length > 0) {
+        throw errors[0]
+    }
+    return schema
+}
+
+
+export function buildModel(schema: GraphQLSchema): Model {
+    let types = schema.getTypeMap()
+    let model: Model = {}
+    for (let key in types) {
+        let type = types[key]
+        if (isEntityType(type)) {
+            addEntityOrJsonObjectOrInterface(model, type as GraphQLObjectType)
+        }
+    }
+    validateModel(model)
+    return model
+}
+
+
+function isEntityType(type: GraphQLNamedType): boolean {
+    return type instanceof GraphQLObjectType && !!type.astNode?.directives?.some(d => d.name.value == 'entity')
+}
+
+
+function addEntityOrJsonObjectOrInterface(model: Model, type: GraphQLObjectType | GraphQLInterfaceType): void {
+    if (model[type.name]) return
+
+    let kind: 'entity' | 'object' | 'interface' = isEntityType(type)
+        ? 'entity'
+        :  type instanceof GraphQLInterfaceType ? 'interface' : 'object'
+
+    let properties: Record<string, Prop> = {}
+    let interfaces: string[] = []
+    let description = type.description || undefined
+
+    if (kind != 'interface') {
+        model[type.name] = {kind, properties, interfaces, description}
+    } else {
+        model[type.name] = {kind, properties, description}
+    }
+
+    let fields = type.getFields()
+    if (kind == 'entity') {
+        if (fields.id == null) {
+            properties.id = {
+                type: {kind: 'scalar', name: 'ID'},
+                nullable: false
+            }
+        } else {
+            let correctIdType = fields.id.type instanceof GraphQLNonNull
+                && fields.id.type.ofType instanceof GraphQLScalarType
+                && fields.id.type.ofType.name === 'ID'
+            if (!correctIdType) {
+                throw unsupportedFieldTypeError(type.name + '.id')
+            }
+        }
+    }
+
+    for (let key in fields) {
+        let f: GraphQLField<any, any> = fields[key]
+        let fieldType = f.type
+        let nullable = true
+        let description = f.description || undefined
+        let propName = `${type.name}.${f.name}`
+        let unique = f.astNode?.directives?.some(d => d.name.value == 'unique')
+        handleFulltextDirective(model, type, f)
+        if (fieldType instanceof GraphQLNonNull) {
+            nullable = false
+            fieldType = fieldType.ofType
+        }
+        let list = unwrapList(fieldType)
+        fieldType = list.item
+        if (fieldType instanceof GraphQLScalarType) {
+            properties[key] = {
+                type: wrapWithList(list.nulls, {
+                    kind: 'scalar',
+                    name: fieldType.name
+                }),
+                nullable,
+                description
+            }
+        } else if (fieldType instanceof GraphQLEnumType) {
+            addEnum(model, fieldType)
+            properties[key] = {
+                type: wrapWithList(list.nulls, {
+                    kind: 'enum',
+                    name: fieldType.name
+                }),
+                nullable,
+                description
+            }
+        } else if (fieldType instanceof GraphQLUnionType) {
+            addUnion(model, fieldType)
+            properties[key] = {
+                type: wrapWithList(list.nulls, {
+                    kind: 'union',
+                    name: fieldType.name
+                }),
+                nullable,
+                description
+            }
+        } else if (fieldType instanceof GraphQLObjectType) {
+            if (isEntityType(fieldType)) {
+                let derivedFrom = f.astNode?.directives?.filter(d => d.name.value == 'derivedFrom').map(d => {
+                    let valueNode = d.arguments?.[0].value
+                    assert(valueNode != null)
+                    assert(valueNode.kind == 'StringValue')
+                    return valueNode.value
+                })[0]
+
+                switch(list.nulls.length) {
+                    case 0:
+                        if (derivedFrom) {
+                            if (!nullable) {
+                                throw new SchemaError(`Property ${propName} must be nullable`)
+                            }
+                            properties[key] = {
+                                type: {
+                                    kind: 'lookup',
+                                    entity: fieldType.name,
+                                    field: derivedFrom
+                                },
+                                nullable,
+                                description
+                            }
+                        } else {
+                            if (unique && nullable) {
+                                throw new SchemaError(`Unique property ${propName} must be non-nullable`)
+                            }
+                            properties[key] = {
+                                type: {
+                                    kind: 'fk',
+                                    foreignEntity: fieldType.name
+                                },
+                                nullable,
+                                unique,
+                                description
+                            }
+                        }
+                        break
+                    case 1:
+                        if (derivedFrom == null) {
+                            throw new SchemaError(`@derivedFrom directive is required on ${propName} declaration`)
+                        }
+                        properties[key] = {
+                            type: {
+                                kind: 'list-lookup',
+                                entity: fieldType.name,
+                                field: derivedFrom
+                            },
+                            nullable: false,
+                            description
+                        }
+                        break
+                    default:
+                        throw unsupportedFieldTypeError(propName)
+                }
+            } else {
+                addEntityOrJsonObjectOrInterface(model, fieldType)
+                properties[key] = {
+                    type: wrapWithList(list.nulls, {
+                        kind: 'object',
+                        name: fieldType.name
+                    }),
+                    nullable,
+                    description
+                }
+            }
+        } else {
+            throw unsupportedFieldTypeError(propName)
+        }
+    }
+
+    if (kind != 'interface') {
+        type.getInterfaces().forEach(i => {
+            addEntityOrJsonObjectOrInterface(model, i)
+            interfaces.push(i.name)
+        })
+    }
+}
+
+
+function addUnion(model: Model, type: GraphQLUnionType): void {
+    if (model[type.name]) return
+    let variants: string[] = []
+
+    model[type.name] = {
+        kind: 'union',
+        variants,
+        description: type.description || undefined
+    }
+
+    type.getTypes().forEach(obj => {
+        if (isEntityType(obj)) {
+            throw new Error(`union ${type.name} has entity ${obj.name} as a variant. Entities in union types are not supported`)
+        }
+        addEntityOrJsonObjectOrInterface(model, obj)
+        variants.push(obj.name)
+    })
+}
+
+
+function addEnum(model: Model, type: GraphQLEnumType): void {
+    if (model[type.name]) return
+    let values: Record<string, {}> = {}
+
+    model[type.name] = {
+        kind: 'enum',
+        values,
+        description: type.description || undefined
+    }
+
+    type.getValues().forEach(item => {
+        values[item.name] = {}
+    })
+}
+
+
+function handleFulltextDirective(model: Model, object: GraphQLNamedType, f: GraphQLField<any, any>): void {
+    f.astNode?.directives?.forEach(d => {
+        if (d.name.value != 'fulltext') return
+        if (!isEntityType(object) || !isStringField(f)) {
+            throw new Error(`@fulltext directive can be only applied to String entity fields, but was applied to ${object.name}.${f.name}`)
+        }
+        let queryArgument = d.arguments?.find(arg => arg.name.value == 'query')
+        assert(queryArgument != null)
+        assert(queryArgument.value.kind == 'StringValue')
+        let queryName = queryArgument.value.value
+        let query = model[queryName]
+        if (query == null) {
+            query = model[queryName] = {
+                kind: 'fts',
+                sources: []
+            }
+        }
+        assert(query.kind == 'fts')
+        let src = query.sources.find(s => s.entity == object.name)
+        if (src == null) {
+            query.sources.push({
+                entity: object.name,
+                fields: [f.name]
+            })
+        } else {
+            src.fields.push(f.name)
+        }
+    })
+}
+
+
+function isStringField(f: GraphQLField<any, any>): boolean {
+    let type = f.type
+    if (type instanceof GraphQLNonNull) {
+        type = type.ofType
+    }
+    return type instanceof GraphQLScalarType && type.name == 'String'
+}
+
+
+function unwrapList(type: GraphQLOutputType): DeepList {
+    let nulls: boolean[] = []
+    while (type instanceof GraphQLList) {
+        type = type.ofType
+        if (type instanceof GraphQLNonNull) {
+            nulls.push(false)
+            type = type.ofType
+        } else {
+            nulls.push(true)
+        }
+    }
+    return {item: type, nulls}
+}
+
+
+interface DeepList {
+    item: GraphQLOutputType
+    nulls: boolean[]
+}
+
+
+function wrapWithList(nulls: boolean[], dataType: PropType): PropType {
+    if (nulls.length == 0) return dataType
+    return {
+        kind: 'list',
+        item: {
+            type: wrapWithList(nulls.slice(1), dataType),
+            nullable: nulls[0]
+        }
+    }
+}
+
+
+function unsupportedFieldTypeError(propName: string): Error {
+    return new SchemaError(`Property ${propName} has unsupported type`)
+}
+
+
+export class SchemaError extends Error {}