@subsquid/openreader 0.2.0 → 0.3.3

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[]
+}

package/src/orderBy.ts

@@ -0,0 +1,105 @@
+import assert from "assert"
+import type {Model} from "./model"
+import {getUnionProps} from "./model.tools"
+
+
+export type SortOrder = 'ASC' | 'DESC'
+
+
+export interface OrderBy {
+    [field: string]: SortOrder | OrderBy
+}
+
+
+/**
+ * OpenCRUD orderBy enum value (e.g. foo_ASC)
+ */
+export type OpenCrudOrderByValue = string
+
+
+/**
+ * A mapping between OpenCRUD enum variants and OrderBy specs
+ */
+export type OpenCrud_OrderBy_Mapping = ReadonlyMap<OpenCrudOrderByValue, OrderBy>
+
+
+const MAPPING_CACHE = new WeakMap<Model, Record<string, OpenCrud_OrderBy_Mapping>>()
+
+
+export function getOrderByMapping(model: Model, entityName: string): OpenCrud_OrderBy_Mapping {
+    let cache = MAPPING_CACHE.get(model)
+    if (cache == null) {
+        cache = {}
+        MAPPING_CACHE.set(model, cache)
+    }
+    if (cache[entityName]) return cache[entityName]
+    return cache[entityName] = buildOrderByMapping(model, entityName, 2)
+}
+
+
+function buildOrderByMapping(model: Model, typeName: string, depth: number): OpenCrud_OrderBy_Mapping {
+    if (depth <= 0) return new Map()
+    let object = model[typeName]
+    if (object.kind == 'union') {
+        object = getUnionProps(model, typeName)
+    }
+    assert(object.kind == 'entity' || object.kind == 'object')
+    let m = new Map<string, OrderBy>()
+    for (let key in object.properties) {
+        let propType = object.properties[key].type
+        switch(propType.kind) {
+            case 'scalar':
+            case 'enum':
+                m.set(key + '_ASC', {[key]: 'ASC'})
+                m.set(key + '_DESC', {[key]: 'DESC'})
+                break
+            case 'object':
+            case 'union':
+                for (let [name, spec] of buildOrderByMapping(model, propType.name, depth - 1)) {
+                    m.set(key + '_' + name, {[key]: spec})
+                }
+                break
+            case 'fk':
+                for (let [name, spec] of buildOrderByMapping(model, propType.foreignEntity, depth - 1)) {
+                    m.set(key + '_' + name, {[key]: spec})
+                }
+                break
+            case 'lookup':
+                for (let [name, spec] of buildOrderByMapping(model, propType.entity, depth - 1)) {
+                    m.set(key + '_' + name, {[key]: spec})
+                }
+                break
+        }
+    }
+    return m
+}
+
+
+export function parseOrderBy(model: Model, entityName: string, input: OpenCrudOrderByValue[]): OrderBy {
+    let mapping = getOrderByMapping(model, entityName)
+    return mergeOrderBy(
+        input.map(value => {
+            let spec = mapping.get(value)
+            assert(spec != null)
+            return spec
+        })
+    )
+}
+
+
+export function mergeOrderBy(list: OrderBy[]): OrderBy {
+    let result: OrderBy = {}
+    list.forEach(item => {
+        for (let key in item) {
+            let current = result[key]
+            if (current == null ) {
+                result[key] = item[key]
+            } else if (typeof current != 'string') {
+                let it = item[key]
+                assert(typeof it == 'object')
+                result[key] = mergeOrderBy([current, it])
+            }
+        }
+    })
+    return result
+}