@subsquid/openreader 0.2.1 → 0.4.0

package/src/gql/schema.ts

@@ -0,0 +1,463 @@
+import {assertNotNull, unexpectedCase} from "@subsquid/util"
+import assert from "assert"
+import {
+    buildASTSchema,
+    DocumentNode,
+    extendSchema,
+    GraphQLEnumType,
+    GraphQLField,
+    GraphQLInterfaceType,
+    GraphQLList,
+    GraphQLNamedType,
+    GraphQLNonNull,
+    GraphQLObjectType,
+    GraphQLOutputType,
+    GraphQLScalarType,
+    GraphQLSchema,
+    GraphQLUnionType,
+    parse,
+    validateSchema
+} from "graphql"
+import {Index, 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 @index(fields: [String!] unique: Boolean) on OBJECT | 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: unknown): 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 indexes: Index[] = type instanceof GraphQLObjectType ? checkEntityIndexes(type) : []
+    let description = type.description || undefined
+
+    switch(kind) {
+        case 'entity':
+            model[type.name] = {kind, properties, description, interfaces, indexes}
+            break
+        case 'object':
+            model[type.name] = {kind, properties, description, interfaces}
+            break
+        case 'interface':
+            model[type.name] = {kind, properties, description}
+            break
+        default:
+            throw unexpectedCase(kind)
+    }
+
+    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]
+
+        handleFulltextDirective(model, type, f)
+
+        let propName = `${type.name}.${f.name}`
+        let fieldType = f.type
+        let nullable = true
+        let description = f.description || undefined
+        let derivedFrom = checkDerivedFrom(type, f)
+        let index = checkFieldIndex(type, f)
+        let unique = index?.unique || false
+
+        if (index) {
+            indexes.push(index)
+        }
+
+        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)) {
+                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.field
+                                },
+                                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.field
+                            },
+                            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 {
+    return asScalarField(f)?.name == 'String'
+}
+
+
+function asScalarField(f: GraphQLField<any, any>): GraphQLScalarType | undefined {
+    let type = asNonNull(f)
+    return type instanceof GraphQLScalarType ? type : undefined
+}
+
+
+function asNonNull(f: GraphQLField<any, any>): GraphQLOutputType {
+    let type = f.type
+    if (type instanceof GraphQLNonNull) {
+        type = type.ofType
+    }
+    return type
+}
+
+
+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 checkFieldIndex(type: GraphQLNamedType, f: GraphQLField<any, any>): Index | undefined {
+    let unique = false
+    let index = false
+
+    f.astNode?.directives?.forEach(d => {
+        if (d.name.value == 'unique') {
+            assertCanBeIndexed(type, f)
+            index = true
+            unique = true
+        } else if (d.name.value == 'index') {
+            assertCanBeIndexed(type, f)
+            let fieldsArg = d.arguments?.find(arg => arg.name.value == 'fields')
+            if (fieldsArg) throw new SchemaError(
+                `@index(fields: ...) where applied to ${type.name}.${f.name}, but fields argument is not allowed when @index is applied to a field`
+            )
+            let uniqueArg = d.arguments?.find(arg => arg.name.value == 'unique')
+            if (uniqueArg) {
+                assert(uniqueArg.value.kind == 'BooleanValue')
+                unique = uniqueArg.value.value
+            }
+            index = true
+        }
+    })
+
+    if (!index) return undefined
+
+    return {
+        fields: [{name: f.name}],
+        unique
+    }
+}
+
+
+function assertCanBeIndexed(type: GraphQLNamedType, f: GraphQLField<any, any>): void {
+    if (!isEntityType(type)) throw new SchemaError(
+        `${type.name}.${f.name} can't be indexed, because ${type.name} is not an entity`
+    )
+    if (!canBeIndexed(f)) throw new SchemaError(
+        `${type.name}.${f.name} can't be indexed, it is not a scalar, enum or foreign key`
+    )
+}
+
+
+function canBeIndexed(f: GraphQLField<any, any>): boolean {
+    let type = asNonNull(f)
+    if (type instanceof GraphQLScalarType || type instanceof GraphQLEnumType) return true
+    return isEntityType(type) && !f.astNode?.directives?.some(d => d.name.value == 'derivedFrom')
+}
+
+
+function checkEntityIndexes(type: GraphQLObjectType): Index[] {
+    let indexes: Index[] = []
+    type.astNode?.directives?.forEach(d => {
+        if (d.name.value != 'index') return
+        if (!isEntityType(type)) throw new SchemaError(
+            `@index was applied to ${type.name}, but only entities can have indexes`
+        )
+        let fieldsArg = d.arguments?.find(arg => arg.name.value == 'fields')
+        if (fieldsArg == null) throw new SchemaError(
+            `@index was applied to ${type.name}, but no fields were specified`
+        )
+        assert(fieldsArg.value.kind == 'ListValue')
+        if (fieldsArg.value.values.length == 0) throw new SchemaError(
+            `@index was applied to ${type.name}, but no fields were specified`
+        )
+        let fields = fieldsArg.value.values.map(arg => {
+            assert(arg.kind == 'StringValue')
+            let name = arg.value
+            let f = type.getFields()[name]
+            if (f == null) throw new SchemaError(
+                `Entity ${type.name} doesn't have a field '${name}', but it is a part of @index`
+            )
+            assertCanBeIndexed(type, f)
+            return {name}
+        })
+        indexes.push({
+            fields,
+            unique: !!d.arguments?.find(arg => arg.name.value == 'unique')?.value
+        })
+    })
+    return indexes
+}
+
+
+function checkDerivedFrom(type: GraphQLNamedType, f: GraphQLField<any, any>): {field: string} | undefined {
+    let directives = f.astNode?.directives?.filter(d => d.name.value == 'derivedFrom') || []
+    if (directives.length == 0) return undefined
+    if (!isEntityType(type)) throw new SchemaError(
+        `@derivedFrom where applied to ${type.name}.${f.name}, but only entities can have lookup fields`
+    )
+    if (directives.length > 1) throw new SchemaError(
+        `Multiple @derivedFrom where applied to ${type.name}.${f.name}`
+    )
+    let d = directives[0]
+    let fieldArg = assertNotNull(d.arguments?.find(arg => arg.name.value == 'field'))
+    assert(fieldArg.value.kind == 'StringValue')
+    return {field: fieldArg.value.value}
+}
+
+
+function unsupportedFieldTypeError(propName: string): Error {
+    return new SchemaError(`Property ${propName} has unsupported type`)
+}
+
+
+export class SchemaError extends Error {}

package/src/main.ts

@@ -0,0 +1,51 @@
+import {Pool} from "pg"
+import {createPoolConfig} from "./db"
+import {serve} from "./server"
+import {loadModel} from "./tools"
+
+
+module.exports = function main() {
+    let args = process.argv.slice(2)
+
+    if (args.indexOf('--help') >= 0) {
+        help()
+        process.exit(1)
+    }
+
+    if (args.length != 1) {
+        help()
+        process.exit(1)
+    }
+
+    let model = loadModel(args[0])
+    let db = new Pool(createPoolConfig())
+    let port = process.env.GRAPHQL_SERVER_PORT || 3000
+
+    serve({model, db, port}).then(
+        () => {
+            console.log('OpenReader is listening on port ' + port)
+        },
+        err => {
+            console.error(err)
+            process.exit(1)
+        }
+    )
+}
+
+
+function help() {
+    console.error(`
+Usage:  openreader SCHEMA
+
+OpenCRUD GraphQL server.
+
+Can be configured using the following environment variables:
+
+    DB_NAME
+    DB_USER
+    DB_PASS
+    DB_HOST
+    DB_PORT
+    GRAPHQL_SERVER_PORT
+`)
+}

package/src/model.tools.ts

@@ -0,0 +1,201 @@
+import assert from "assert"
+import {Entity, FTS_Query, JsonObject, Model, Prop, PropType} from "./model"
+
+
+const UNION_MAPS = new WeakMap<Model, Record<string, JsonObject>>()
+
+
+export function getUnionProps(model: Model, unionName: string): JsonObject {
+    let map = UNION_MAPS.get(model)
+    if (map == null) {
+        map = {}
+        UNION_MAPS.set(model, map)
+    }
+    if (map[unionName]) return map[unionName]
+    return map[unionName] = buildUnionProps(model, unionName)
+}
+
+
+export function buildUnionProps(model: Model, unionName: string): JsonObject {
+    let union = model[unionName]
+    assert(union.kind == 'union')
+    let properties: Record<string, Prop> = {}
+    for (let i = 0; i < union.variants.length; i++) {
+        let objectName = union.variants[i]
+        let object = model[objectName]
+        assert(object.kind == 'object')
+        Object.assign(properties, object.properties)
+    }
+    properties.isTypeOf = {
+        type: {kind: 'scalar', name: 'String'},
+        nullable: false
+    }
+    return {kind: 'object', properties}
+}
+
+
+export function validateModel(model: Model) {
+    // TODO: check all invariants we assume
+    validateNames(model)
+    validateUnionTypes(model)
+    validateLookups(model)
+    validateIndexes(model)
+}
+
+
+const TYPE_NAME_REGEX = /^[A-Z][a-zA-Z0-9]*$/
+const PROP_NAME_REGEX = /^[a-z][a-zA-Z0-9]*$/
+
+
+export function validateNames(model: Model) {
+    for (let name in model) {
+        let item = model[name]
+        if (item.kind == 'fts') {
+            if (!PROP_NAME_REGEX.test(name)) {
+                throw new Error(`Invalid fulltext search name: ${name}. It must match ${PROP_NAME_REGEX}.`)
+            }
+        } else {
+            if (!TYPE_NAME_REGEX.test(name)) {
+                throw new Error(`Invalid ${item.kind} name: ${name}. It must match ${TYPE_NAME_REGEX}`)
+            }
+        }
+        switch(item.kind) {
+            case 'entity':
+            case 'object':
+            case 'interface':
+                for (let prop in item.properties) {
+                    if (!PROP_NAME_REGEX.test(prop)) {
+                        throw new Error(`Type ${name} has a property with invalid name: ${prop}. It must match ${PROP_NAME_REGEX}.`)
+                    }
+                }
+                break
+        }
+    }
+}
+
+
+export function validateUnionTypes(model: Model): void {
+    for (let key in model) {
+        let item = model[key]
+        if (item.kind != 'union') continue
+        let properties: Record<string, { objectName: string, type: PropType }> = {}
+        item.variants.forEach(objectName => {
+            let object = model[objectName]
+            assert(object.kind == 'object')
+            for (let propName in object.properties) {
+                let rec = properties[propName]
+                if (rec && !propTypeEquals(rec.type, object.properties[propName].type)) {
+                    throw new Error(
+                        `${rec.objectName} and ${objectName} variants of union ${key} both have property '${propName}', but types of ${rec.objectName}.${propName} and ${objectName}.${propName} are different.`
+                    )
+                } else {
+                    properties[propName] = {objectName, type: object.properties[propName].type}
+                }
+            }
+        })
+    }
+}
+
+
+export function validateLookups(model: Model): void {
+    for (let name in model) {
+        let item = model[name]
+        switch(item.kind) {
+            case 'object':
+            case 'interface':
+                for (let key in item.properties) {
+                    let prop = item.properties[key]
+                    if (prop.type.kind == 'lookup' || prop.type.kind == 'list-lookup') {
+                        throw invalidProperty(name, key, `lookups are only supported on entity types`)
+                    }
+                }
+                break
+            case 'entity':
+                for (let key in item.properties) {
+                    let prop = item.properties[key]
+                    if (prop.type.kind == 'lookup' && !prop.nullable) {
+                        throw invalidProperty(name, key, 'one-to-one lookups must be nullable')
+                    }
+                    if (prop.type.kind == 'lookup' || prop.type.kind == 'list-lookup') {
+                        let lookupEntity = getEntity(model, prop.type.entity)
+                        let lookupProperty = lookupEntity.properties[prop.type.field]
+                        if (lookupProperty?.type.kind != 'fk' || lookupProperty.type.foreignEntity != name) {
+                            throw invalidProperty(name, key, `${prop.type.entity}.${prop.type.field} is not a foreign key pointing to ${name}`)
+                        }
+                        if (prop.type.kind == 'lookup' && !lookupProperty.unique) {
+                            throw invalidProperty(name, key, `${prop.type.entity}.${prop.type.field} is not @unique`)
+                        }
+                    }
+                }
+                break
+        }
+    }
+}
+
+
+export function validateIndexes(model: Model): void {
+    for (let name in model) {
+        const item = model[name]
+        if (item.kind != 'entity') continue
+        item.indexes?.forEach(index => {
+            if (index.fields.length == 0) throw new Error(`Entity ${name} has an index without fields`)
+            index.fields.forEach(f => {
+                let prop = item.properties[f.name]
+                if (prop == null) throw new Error(
+                    `Entity ${name} doesn't have a property ${f.name}, but is a part of index`
+                )
+                switch(prop.type.kind) {
+                    case "scalar":
+                    case "enum":
+                    case "fk":
+                        break
+                    default:
+                        throw new Error(
+                            `Property ${name}.${f.name} can't be a part of index`
+                        )
+                }
+            })
+        })
+    }
+}
+
+
+function invalidProperty(item: string, key: string, msg: string): Error {
+    return new Error(`Invalid property ${item}.${key}: ${msg}`)
+}
+
+
+export function propTypeEquals(a: PropType, b: PropType): boolean {
+    if (a.kind != b.kind) return false
+    if (a.kind == 'list') return propTypeEquals(a.item.type, (b as typeof a).item.type)
+    switch(a.kind) {
+        case 'fk':
+            return a.foreignEntity == (b as typeof a).foreignEntity
+        case 'lookup':
+        case 'list-lookup':
+            return a.entity == (b as typeof a).entity && a.field == (b as typeof a).field
+        default:
+            return a.name == (b as typeof a).name
+    }
+}
+
+
+export function getEntity(model: Model, name: string): Entity {
+    let entity = model[name]
+    assert(entity.kind == 'entity', `${name} expected to be an entity`)
+    return entity
+}
+
+
+export function getObject(model: Model, name: string): JsonObject {
+    let object = model[name]
+    assert(object.kind == 'object', `${name} expected to be an object`)
+    return object
+}
+
+
+export function getFtsQuery(model: Model, name: string): FTS_Query {
+    let query = model[name]
+    assert(query.kind == 'fts', `${name} expected to be FTS query`)
+    return query
+}