@subsquid/openreader 1.0.2 → 2.1.0

package/src/opencrud/tree.ts

@@ -0,0 +1,144 @@
+import {unexpectedCase} from "@subsquid/util-internal"
+import assert from "assert"
+import {GraphQLSchema} from "graphql"
+import {ResolveTree} from "graphql-parse-resolve-info"
+import {EntityListArguments} from "../ir/args"
+import {FieldRequest, OpaqueRequest} from "../ir/fields"
+import {Model} from "../model"
+import {simplifyResolveTree} from "../util/resolve-tree"
+import {ensureArray} from "../util/util"
+import {parseOrderBy} from "./orderBy"
+import {parseWhere} from "./where"
+
+
+export function parseResolveTree(
+    model: Model,
+    objectName: string,
+    schema: GraphQLSchema,
+    tree: ResolveTree
+): FieldRequest[] {
+
+    let requests: FieldRequest[] = []
+    let requestedScalars: Record<string, true> = {}
+    let object = model[objectName]
+    assert(object.kind == "entity" || object.kind == "object")
+
+    let fields = simplifyResolveTree(schema, tree, objectName).fields
+    for (let alias in fields) {
+        let f = fields[alias]
+        let prop = object.properties[f.name]
+        switch(prop.type.kind) {
+            case "scalar":
+            case "enum":
+            case "list":
+                if (requestedScalars[f.name] == null) {
+                    requestedScalars[f.name] = true
+                    requests.push({
+                        field: f.name,
+                        aliases: [f.name],
+                        kind: prop.type.kind,
+                        type: prop.type,
+                        prop,
+                        index: 0
+                    } as OpaqueRequest)
+                }
+                break
+            case "object":
+                requests.push({
+                    field: f.name,
+                    aliases: [f.alias],
+                    kind: prop.type.kind,
+                    type: prop.type,
+                    prop,
+                    index: 0,
+                    children: parseResolveTree(model, prop.type.name, schema, f)
+                })
+                break
+            case "union": {
+                let union = model[prop.type.name]
+                assert(union.kind == "union")
+                let children: FieldRequest[] = []
+                for (let variant of union.variants) {
+                    for (let req of parseResolveTree(model, variant, schema, f)) {
+                        req.ifType = variant
+                        children.push(req)
+                    }
+                }
+                requests.push({
+                    field: f.name,
+                    aliases: [f.alias],
+                    kind: prop.type.kind,
+                    type: prop.type,
+                    prop,
+                    index: 0,
+                    children
+                })
+                break
+            }
+            case "fk":
+                requests.push({
+                    field: f.name,
+                    aliases: [f.alias],
+                    kind: prop.type.kind,
+                    type: prop.type,
+                    prop,
+                    index: 0,
+                    children: parseResolveTree(model, prop.type.foreignEntity, schema, f)
+                })
+                break
+            case "lookup":
+                requests.push({
+                    field: f.name,
+                    aliases: [f.alias],
+                    kind: prop.type.kind,
+                    type: prop.type,
+                    prop,
+                    index: 0,
+                    children: parseResolveTree(model, prop.type.entity, schema, f)
+                })
+                break
+            case "list-lookup":
+                requests.push({
+                    field: f.name,
+                    aliases: [f.alias],
+                    kind: prop.type.kind,
+                    type: prop.type,
+                    prop,
+                    index: 0,
+                    args: parseEntityListArguments(model, prop.type.entity, f.args),
+                    children: parseResolveTree(model, prop.type.entity, schema, f)
+                })
+                break
+            default:
+                throw unexpectedCase()
+        }
+    }
+
+    return requests
+}
+
+
+export function parseEntityListArguments(model: Model, entityName: string, gqlArgs: any): EntityListArguments {
+    let args: EntityListArguments = {}
+
+    let where = parseWhere(gqlArgs.where)
+    if (where) {
+        args.where = where
+    }
+
+    if (gqlArgs.orderBy) {
+        args.orderBy = parseOrderBy(model, entityName, ensureArray(gqlArgs.orderBy))
+    }
+
+    if (gqlArgs.offset) {
+        assert(typeof gqlArgs.offset == "number")
+        args.offset = gqlArgs.offset
+    }
+
+    if (gqlArgs.limit != null) {
+        assert(typeof gqlArgs.limit == "number")
+        args.limit = gqlArgs.limit
+    }
+
+    return args
+}

package/src/opencrud/where.ts

@@ -0,0 +1,141 @@
+import {unexpectedCase} from "@subsquid/util-internal"
+import assert from "assert"
+import {Where} from "../ir/args"
+import {ensureArray} from "../util/util"
+
+
+export function parseWhere(whereArg?: any): Where | undefined {
+    if (whereArg == null) return undefined
+    let {AND, OR, ...fields} = whereArg
+    let conj: Where[] = []
+
+    for (let key in fields) {
+        let arg = fields[key]
+        let {field, op} = parseWhereKey(key)
+        switch(op) {
+            case "REF":
+            case "every": {
+                let where = parseWhere(arg)
+                where && conj.push({op, field, where})
+                break
+            }
+            case "some":
+            case "none":
+                conj.push({op, field, where: parseWhere(arg)})
+                break
+            case "in":
+            case "not_in":
+                conj.push({op, field, values: ensureArray(arg)})
+                break
+            case "eq":
+            case "not_eq":
+            case "gt":
+            case "gte":
+            case "lt":
+            case "lte":
+            case "contains":
+            case "not_contains":
+            case "containsInsensitive":
+            case "not_containsInsensitive":
+            case "startsWith":
+            case "not_startsWith":
+            case "endsWith":
+            case "not_endsWith":
+            case "jsonHasKey":
+            case "jsonContains":
+                conj.push({op, field, value: arg})
+                break
+            case "containsNone":
+            case "containsAll":
+            case "containsAny":
+                conj.push({op, field, value: ensureArray(arg)})
+                break
+            case "isNull":
+                assert(typeof arg == 'boolean')
+                conj.push({op, field, yes: arg})
+                break
+            default:
+                throw unexpectedCase(op)
+        }
+    }
+
+    if (AND) {
+        for (let arg of ensureArray(AND)) {
+            let where = parseWhere(arg)
+            if (where) {
+                conj.push(where)
+            }
+        }
+    }
+
+    let conjunction = toCondition('AND', conj)
+    if (OR) {
+        let disjunctions: Where[] = []
+        if (conjunction) {
+            disjunctions.push(conjunction)
+        }
+        for (let arg of ensureArray(OR)) {
+            let where = parseWhere(arg)
+            if (where) {
+                disjunctions.push(where)
+            }
+        }
+        return toCondition('OR', disjunctions)
+    } else {
+        return conjunction
+    }
+}
+
+
+function toCondition(op: 'AND' | 'OR', operands: Where[]): Where | undefined {
+    switch(operands.length) {
+        case 0:
+            return undefined
+        case 1:
+            return operands[0]
+        default:
+            return {op, args: operands}
+    }
+}
+
+
+export function parseWhereKey(key: string): {op: Where['op'], field: string} {
+    let m = WHERE_KEY_REGEX.exec(key)
+    if (m) {
+        return {op: m[2] as Where['op'], field: m[1]}
+    } else {
+        return {op: 'REF', field: key}
+    }
+}
+
+
+const WHERE_KEY_REGEX = (() => {
+    let ops: Where['op'][] = [
+        "eq",
+        "not_eq",
+        "gt",
+        "gte",
+        "lt",
+        "lte",
+        "contains",
+        "not_contains",
+        "containsInsensitive",
+        "not_containsInsensitive",
+        "startsWith",
+        "not_startsWith",
+        "endsWith",
+        "not_endsWith",
+        "containsAll",
+        "containsAny",
+        "containsNone",
+        "jsonContains",
+        "jsonHasKey",
+        "isNull",
+        "some",
+        "every",
+        "none",
+        "in",
+        "not_in",
+    ]
+    return new RegExp(`^([^_]*)_(${ops.join('|')})$`)
+})()

package/src/{gql/scalars → scalars}/BigInt.ts

@@ -1,5 +1,5 @@
 import {GraphQLScalarType} from "graphql"
-import {invalidFormat} from "../../util"
+import {invalidFormat} from "../util/util"
 
 
 export const BigIntScalar = new GraphQLScalarType({

package/src/{gql/scalars → scalars}/Bytes.ts

@@ -1,17 +1,17 @@
-import {decodeHex, isHex} from "@subsquid/util-internal-hex"
+import {decodeHex, isHex, toHex} from "@subsquid/util-internal-hex"
 import {GraphQLScalarType} from "graphql"
-import {invalidFormat} from "../../util"
+import {invalidFormat} from "../util/util"
 
 
 export const BytesScalar = new GraphQLScalarType({
     name: 'Bytes',
     description: 'Binary data encoded as a hex string always prefixed with 0x',
-    serialize(value: string | Buffer) {
+    serialize(value: string | Uint8Array) {
         if (typeof value == 'string') {
             if (!isHex(value)) throw invalidFormat('Bytes', value)
             return value.toLowerCase()
         } else {
-            return '0x' + value.toString('hex')
+            return toHex(value)
         }
     },
     parseValue(value: string) {

package/src/{gql/scalars → scalars}/DateTime.ts

@@ -1,5 +1,5 @@
 import {GraphQLScalarType} from "graphql"
-import {invalidFormat} from "../../util"
+import {invalidFormat} from "../util/util"
 
 
 export const DateTimeScalar = new GraphQLScalarType({

package/src/server.ts

@@ -1,56 +1,175 @@
-import {ApolloServerPluginDrainHttpServer} from "apollo-server-core"
-import {ApolloServer} from "apollo-server-express"
-import assert from "assert"
-import express from "express"
-import fs from "fs"
-import http from "http"
-import path from "path"
-import type {Pool} from "pg"
-import {PoolTransaction} from "./db"
-import {Dialect} from "./dialect"
-import {buildServerSchema} from "./gql/opencrud"
-import type {Model} from "./model"
-import {buildResolvers} from "./resolver"
-
-
-export interface ListeningServer {
-    readonly port: number
-    stop(): Promise<void>
-}
+import type {Logger} from '@subsquid/logger'
+import {listen, ListeningServer} from '@subsquid/util-internal-http-server'
+import {PluginDefinition} from 'apollo-server-core'
+import {ApolloServer} from 'apollo-server-express'
+import express from 'express'
+import fs from 'fs'
+import {ExecutionArgs, GraphQLSchema} from 'graphql'
+import {useServer as useWsServer} from 'graphql-ws/lib/use/ws'
+import http from 'http'
+import path from 'path'
+import type {Pool} from 'pg'
+import {WebSocketServer} from 'ws'
+import {Context, OpenreaderContext} from './context'
+import {PoolOpenreaderContext} from './db'
+import type {Dialect} from './dialect'
+import type {Model} from './model'
+import {SchemaBuilder} from './opencrud/schema'
+import {logGraphQLError} from './util/error-handling'
+import {executeWithLimit} from './util/execute'
+import {ResponseSizeLimit} from './util/limit'
 
 
 export interface ServerOptions {
-    model: Model
-    db: Pool
     port: number | string
+    model: Model
+    connection: Pool
     dialect?: Dialect
     graphiqlConsole?: boolean
+    log?: Logger
+    maxRequestSizeBytes?: number
+    maxRootFields?: number
+    maxResponseNodes?: number
+    subscriptions?: boolean
+    subscriptionPollInterval?: number
+    subscriptionConnection?: Pool
+    subscriptionMaxResponseNodes?: number
 }
 
 
 export async function serve(options: ServerOptions): Promise<ListeningServer> {
-    let {model, db} = options
+    let {connection, subscriptionConnection, subscriptionPollInterval, maxResponseNodes, subscriptionMaxResponseNodes} = options
     let dialect = options.dialect ?? 'postgres'
-    let resolvers = buildResolvers(model, dialect)
-    let typeDefs = buildServerSchema(model, dialect)
+
+    let schema = new SchemaBuilder(options).build()
+
+    let context = () => {
+        let openreader: OpenreaderContext = new PoolOpenreaderContext(
+            dialect,
+            connection,
+            subscriptionConnection,
+            subscriptionPollInterval
+        )
+
+        if (maxResponseNodes) {
+            openreader.responseSizeLimit = new ResponseSizeLimit(maxResponseNodes)
+            openreader.subscriptionResponseSizeLimit = new ResponseSizeLimit(maxResponseNodes)
+        }
+
+        if (subscriptionMaxResponseNodes) {
+            openreader.subscriptionResponseSizeLimit = new ResponseSizeLimit(subscriptionMaxResponseNodes)
+        }
+
+        return {
+            openreader
+        }
+    }
+
+    let disposals: Dispose[] = []
+
+    return addServerCleanup(disposals, runApollo({
+        port: options.port,
+        schema,
+        context,
+        disposals,
+        subscriptions: options.subscriptions,
+        log: options.log,
+        graphiqlConsole: options.graphiqlConsole,
+        maxRequestSizeBytes: options.maxRequestSizeBytes,
+        maxRootFields: options.maxRootFields
+    }), options.log)
+}
+
+
+export type Dispose = () => Promise<void>
+
+
+export interface ApolloOptions {
+    port: number | string
+    disposals: Dispose[]
+    context: () => Context
+    schema: GraphQLSchema
+    plugins?: PluginDefinition[]
+    subscriptions?: boolean
+    graphiqlConsole?: boolean
+    log?: Logger
+    maxRequestSizeBytes?: number
+    maxRootFields?: number
+}
+
+
+export async function runApollo(options: ApolloOptions): Promise<ListeningServer> {
+    const {disposals, context, schema, log, maxRootFields} = options
+
+    let maxRequestSizeBytes = options.maxRequestSizeBytes ?? 256 * 1024
     let app = express()
     let server = http.createServer(app)
 
+    const execute = maxRootFields
+            ? (args: ExecutionArgs) => executeWithLimit(maxRootFields, args)
+            : undefined
+
+    if (options.subscriptions) {
+        let wsServer = new WebSocketServer({
+            server,
+            path: '/graphql',
+            maxPayload: maxRequestSizeBytes
+        })
+        let wsServerCleanup = useWsServer(
+            {
+                schema,
+                context,
+                execute,
+                onError(ctx, message, errors) {
+                    if (log) {
+                        // FIXME: we don't want to log client errors
+                        for (let err of errors) {
+                            logGraphQLError(log, err)
+                        }
+                    }
+                },
+                onNext(_ctx, _message, args, result) {
+                    args.contextValue.openreader.close()
+                    return result
+                }
+            },
+            wsServer
+        )
+        disposals.push(async () => wsServerCleanup.dispose())
+    }
+
     let apollo = new ApolloServer({
-        typeDefs,
-        resolvers,
-        context: () => ({openReaderTransaction: new PoolTransaction(db)}),
+        schema,
+        context,
+        stopOnTerminationSignals: false,
+        executor: execute && (async req => {
+            return execute({
+                schema,
+                document: req.document,
+                rootValue: {},
+                contextValue: req.context,
+                variableValues: req.request.variables,
+                operationName: req.operationName
+            })
+        }),
         plugins: [
+            ...options.plugins || [],
             {
                 async requestDidStart() {
                     return {
                         willSendResponse(req: any) {
-                            return req.context.openReaderTransaction.close()
+                            return req.context.openreader.close()
+                        },
+                        async didEncounterErrors(req) {
+                            if (req.operation && log) {
+                                for (let err of req.errors) {
+                                    logGraphQLError(log, err)
+                                }
+                            }
                         }
                     }
                 }
-            },
-            ApolloServerPluginDrainHttpServer({httpServer: server})
+            }
         ]
     })
 
@@ -59,37 +178,38 @@ export async function serve(options: ServerOptions): Promise<ListeningServer> {
     }
 
     await apollo.start()
-    apollo.applyMiddleware({app})
-    return listen(apollo, server, options.port)
-}
-
+    disposals.push(() => apollo.stop())
 
-export function listen(apollo: ApolloServer, server: http.Server, port: number | string): Promise<ListeningServer> {
-    return new Promise((resolve, reject) => {
-        function onerror(err: Error) {
-            cleanup()
-            reject(err)
+    apollo.applyMiddleware({
+        app,
+        bodyParserConfig: {
+            limit: maxRequestSizeBytes
         }
+    })
 
-        function onlistening() {
-            cleanup()
-            let address = server.address()
-            assert(address != null && typeof address == 'object')
-            resolve({
-                port: address.port,
-                stop: () => apollo.stop()
-            })
-        }
+    return listen(server, options.port)
+}
 
-        function cleanup() {
-            server.removeListener('error', onerror)
-            server.removeListener('listening', onlistening)
+
+export function addServerCleanup(disposals: Dispose[], server: Promise<ListeningServer>, log?: Logger): Promise<ListeningServer> {
+    async function cleanup() {
+        for (let i = disposals.length - 1; i >= 0; i--) {
+            await disposals[i]().catch(err => log?.error(err))
         }
+    }
 
-        server.on('error', onerror)
-        server.on('listening', onlistening)
-        server.listen(port)
-    })
+    return server.then(
+        s => {
+            return {
+                port: s.port,
+                close: () => s.close().finally(cleanup)
+            }
+        },
+        async err => {
+            await cleanup()
+            throw err
+        }
+    )
 }