@subsquid/openreader 0.3.2 → 0.3.3

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 {}

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,173 @@
+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)
+}
+
+
+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
+        }
+    }
+}
+
+
+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
+}

package/src/model.ts

@@ -0,0 +1,125 @@
+export type Name = string
+
+
+export type Model = Record<Name, Entity | JsonObject | Interface | Union | Enum | FTS_Query>
+
+
+export interface Entity extends TypeMeta {
+    kind: 'entity'
+    properties: Record<Name, Prop>
+    interfaces?: Name[]
+}
+
+
+export interface JsonObject extends TypeMeta {
+    kind: 'object'
+    properties: Record<Name, Prop>
+    interfaces?: Name[]
+}
+
+
+export interface Interface extends TypeMeta {
+    kind: 'interface'
+    properties: Record<Name, Prop>
+}
+
+
+export interface Union extends TypeMeta {
+    kind: 'union'
+    variants: Name[]
+}
+
+
+export interface Enum extends TypeMeta {
+    kind: 'enum'
+    values: Record<string, {}>
+}
+
+
+export interface TypeMeta {
+    description?: string
+}
+
+
+export interface Prop {
+    type: PropType
+    nullable: boolean
+    description?: string
+    /**
+     * Whether the values in the column must be unique. Applicable only to entities.
+     */
+    unique?: boolean
+}
+
+
+export type PropType =
+    ScalarPropType |
+    EnumPropType |
+    ListPropType |
+    ObjectPropType |
+    UnionPropType |
+    FkPropType |
+    LookupPropType |
+    ListLookupPropType
+
+
+export interface ScalarPropType {
+    kind: 'scalar'
+    name: Name
+}
+
+
+export interface EnumPropType {
+    kind: 'enum'
+    name: Name
+}
+
+
+export interface ObjectPropType {
+    kind: 'object'
+    name: Name
+}
+
+
+export interface UnionPropType {
+    kind: 'union'
+    name: Name
+}
+
+
+export interface ListPropType {
+    kind: 'list'
+    item: Prop
+}
+
+
+export interface FkPropType {
+    kind: 'fk'
+    foreignEntity: Name
+}
+
+
+export interface LookupPropType {
+    kind: 'lookup'
+    entity: Name
+    field: Name
+}
+
+
+export interface ListLookupPropType {
+    kind: 'list-lookup'
+    entity: Name
+    field: Name
+}
+
+
+export interface FTS_Query {
+    kind: 'fts'
+    sources: FTS_Source[]
+}
+
+
+export interface FTS_Source {
+    entity: Name
+    fields: Name[]
+}