@subsquid/openreader 0.2.0 → 0.3.3

package/src/relayConnection.ts

@@ -0,0 +1,80 @@
+import {UserInputError} from "apollo-server-core"
+
+
+export interface PageInfo {
+    hasNextPage: boolean
+    hasPreviousPage: boolean
+    startCursor: string
+    endCursor: string
+}
+
+
+export interface ConnectionEdge<T> {
+    node?: T
+    cursor?: string
+}
+
+
+export interface ConnectionResponse<T> {
+    edges?: ConnectionEdge<T>[]
+    pageInfo?: PageInfo
+}
+
+
+/**
+ * Offset value for SQL query
+ */
+export type Cursor = number
+
+
+export function encodeCursor(cursor: Cursor): string {
+    return ''+cursor
+}
+
+
+export function decodeCursor(value: string): Cursor {
+    let cursor = parseInt(value)
+    if (isFinite(cursor) && cursor >= 0) {
+        return cursor
+    } else {
+        throw new InvalidCursorValue(value)
+    }
+}
+
+
+export class InvalidCursorValue extends UserInputError {
+    constructor(value: string) {
+        super(`invalid cursor value: ${value}`)
+    }
+}
+
+
+export interface ConnectionArgs {
+    first?: number
+    after?: string
+}
+
+
+export interface ConnectionParams {
+    offset: number
+    limit: number
+}
+
+
+/**
+ * https://relay.dev/assets/files/connections-932f4f2cdffd79724ac76373deb30dc8.htm#sec-Pagination-algorithm
+ */
+export function decodeConnectionArgs(args: ConnectionArgs): ConnectionParams {
+    let offset = 0
+    let limit = 100
+    if (args.after) {
+        offset = decodeCursor(args.after)
+    }
+    if (args.first != null) {
+        if (args.first < 0) {
+            throw new UserInputError("'first' argument of connection can't be less than 0")
+        }
+        limit = args.first
+    }
+    return {offset, limit}
+}

package/src/requestedFields.ts

@@ -0,0 +1,246 @@
+import {toPlural} from "@subsquid/util"
+import {UserInputError} from "apollo-server-core"
+import assert from "assert"
+import {GraphQLResolveInfo, GraphQLSchema} from "graphql"
+import {
+    FieldsByTypeName,
+    parseResolveInfo,
+    ResolveTree,
+    simplifyParsedResolveInfoFragmentWithType
+} from "graphql-parse-resolve-info"
+import {Model, PropType} from "./model"
+
+
+export interface RequestedFields {
+    [name: string]: RequestedField
+}
+
+
+export interface RequestedField {
+    propType: PropType
+    requests: FieldRequest[]
+}
+
+
+export interface FieldRequest {
+    alias: string
+    children?: RequestedFields
+    args?: any
+    ifType?: string
+    index: number
+}
+
+
+export function requestedFields(model: Model, entityName: string, info: GraphQLResolveInfo): RequestedFields {
+    let tree = getResolveTree(info)
+    return collectRequestedFields(model, entityName, info.schema, tree)
+}
+
+
+function collectRequestedFields(model: Model, objectName: string, schema: GraphQLSchema, tree: ResolveTree): RequestedFields {
+    let requested: RequestedFields = {}
+    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]
+        let propType = prop.type
+        switch(propType.kind) {
+            case 'scalar':
+            case 'enum':
+            case 'list':
+                requested[f.name] = {
+                    propType,
+                    requests: [{alias: f.name, index: 0}]
+                }
+                break
+            case 'object':
+                addRequest(requested, f.name, propType, {
+                    alias,
+                    children: collectRequestedFields(model, propType.name, schema, f),
+                    index: 0
+                })
+                break
+            case 'fk':
+                addRequest(requested, f.name, propType, {
+                    alias,
+                    children: collectRequestedFields(model, propType.foreignEntity, schema, f),
+                    index: 0
+                })
+                break
+            case 'lookup':
+                addRequest(requested, f.name, propType, {
+                    alias,
+                    children: collectRequestedFields(model, propType.entity, schema, f),
+                    index: 0
+                })
+                break
+            case 'list-lookup':
+                addRequest(requested, f.name, propType, {
+                    alias,
+                    args: f.args,
+                    children: collectRequestedFields(model, propType.entity, schema, f),
+                    index: 0
+                })
+                break
+            case 'union':{
+                let union = model[propType.name]
+                assert(union.kind == 'union')
+                let children: RequestedFields = {}
+                union.variants.forEach(name => {
+                    let variantFields = collectRequestedFields(model, name, schema, f)
+                    for (let key in variantFields) {
+                        let field = variantFields[key]
+                        field.requests.forEach(req => {
+                            addRequest(children, key, field.propType, {...req, ifType: name})
+                        })
+                    }
+                })
+                addRequest(requested, f.name, propType, {
+                    alias,
+                    children,
+                    index: 0
+                })
+                break
+            }
+            default:
+                throw new Error(`Field ${objectName}.${f.name} has unsupported type and can't be requested`)
+        }
+    }
+
+    return requested
+}
+
+
+function addRequest(requested: RequestedFields, name: string, propType: PropType, req: FieldRequest): void {
+    let field = requested[name]
+    if (field == null) {
+        requested[name] = {
+            propType,
+            requests: [req]
+        }
+    } else {
+        field.requests.push(req)
+    }
+}
+
+
+export interface ConnectionRequestedFields {
+    totalCount?: boolean
+    pageInfo?: boolean
+    edges?: {
+        node?: RequestedFields
+        cursor?: boolean
+    }
+}
+
+
+export function connectionRequestedFields(model: Model, entityName: string, info: GraphQLResolveInfo): ConnectionRequestedFields {
+    let requested: ConnectionRequestedFields = {}
+    let tree = getResolveTree(info, toPlural(entityName) + 'Connection')
+    requested.totalCount = hasTreeRequest(tree.fields, 'totalCount')
+    requested.pageInfo = hasTreeRequest(tree.fields, 'pageInfo')
+    let edgesTree = getTreeRequest(tree.fields, 'edges')
+    if (edgesTree) {
+        let edgeFields = simplifyResolveTree(info.schema, edgesTree, entityName + 'Edge').fields
+        requested.edges = {}
+        requested.edges.cursor = hasTreeRequest(edgeFields, 'cursor')
+        let nodeTree = getTreeRequest(edgeFields, 'node')
+        if (nodeTree) {
+            requested.edges.node = collectRequestedFields(model, entityName, info.schema, nodeTree)
+        }
+    }
+    return requested
+}
+
+
+export interface FtsRequestedFields {
+    item?: Record<string, RequestedFields>
+    highlight?: boolean
+    rank?: boolean
+}
+
+
+export function ftsRequestedFields(model: Model, queryName: string, info: GraphQLResolveInfo): FtsRequestedFields {
+    let query = model[queryName]
+    assert(query.kind == 'fts')
+
+    let requested: FtsRequestedFields = {}
+    let tree = getResolveTree(info, queryName + '_Output')
+
+    requested.rank = hasTreeRequest(tree.fields, 'rank')
+    requested.highlight = hasTreeRequest(tree.fields, 'highlight')
+
+    let itemTree = getTreeRequest(tree.fields, 'item')
+    if (itemTree) {
+        requested.item = {}
+        for (let i = 0; i < query.sources.length; i++) {
+            let entity = query.sources[i].entity
+            let fields = collectRequestedFields(model, entity, info.schema, itemTree)
+            for (let key in fields) {
+                requested.item[entity] = fields
+                break
+            }
+        }
+    }
+
+    return requested
+}
+
+
+function getTreeRequest(treeFields: ResolveTreeFields, fieldName: string): ResolveTree | undefined {
+    let req: ResolveTree | undefined
+    for (let alias in treeFields) {
+        let e = treeFields[alias]
+        if (e.name != fieldName) continue
+        if (req != null) throw new UserInputError(`multiple aliases for field '${fieldName}' are not supported`)
+        req = e
+    }
+    return req
+}
+
+
+function hasTreeRequest(treeFields: ResolveTreeFields, fieldName: string): boolean {
+    for (let alias in treeFields) {
+        let e = treeFields[alias]
+        if (e.name == fieldName) return true
+    }
+    return false
+}
+
+
+type ResolveTreeFields = {
+    [alias: string]: ResolveTree
+}
+
+
+interface ResolveTreeWithFields extends ResolveTree {
+    fields: ResolveTreeFields
+}
+
+
+function getResolveTree(info: GraphQLResolveInfo): ResolveTree
+function getResolveTree(info: GraphQLResolveInfo, typeName: string): ResolveTreeWithFields
+function getResolveTree(info: GraphQLResolveInfo, typeName?: string): ResolveTree {
+    let tree = parseResolveInfo(info)
+    assert(isResolveTree(tree))
+    if (typeName) {
+        return simplifyResolveTree(info.schema, tree, typeName)
+    } else {
+        return tree
+    }
+}
+
+
+function simplifyResolveTree(schema: GraphQLSchema, tree: ResolveTree, typeName: string): ResolveTreeWithFields {
+    let type = schema.getType(typeName)
+    assert(type != null)
+    return simplifyParsedResolveInfoFragmentWithType(tree, type)
+}
+
+
+function isResolveTree(resolveInfo: ResolveTree | FieldsByTypeName | null | undefined): resolveInfo is ResolveTree {
+    return resolveInfo != null && resolveInfo.fieldsByTypeName != null
+}

package/src/resolver.ts

@@ -0,0 +1,199 @@
+import type {IFieldResolver, IResolvers} from "@graphql-tools/utils"
+import {toCamelCase} from "@subsquid/util"
+import {UserInputError} from "apollo-server-core"
+import assert from "assert"
+import type {GraphQLResolveInfo} from "graphql"
+import type {Database, Transaction} from "./db"
+import type {Entity, JsonObject, Model} from "./model"
+import {QueryBuilder} from "./queryBuilder"
+import {
+    ConnectionArgs as RelayConnectionArgs,
+    ConnectionEdge,
+    ConnectionResponse as RelayConnectionResponse,
+    decodeConnectionArgs,
+    encodeCursor,
+    PageInfo
+} from "./relayConnection"
+import {connectionRequestedFields, ftsRequestedFields, requestedFields} from "./requestedFields"
+import {getScalarResolvers} from "./scalars"
+import {ensureArray, toQueryListField, unsupportedCase} from "./util"
+
+
+export interface ResolverContext {
+    openReaderTransaction: Transaction
+}
+
+
+export function buildResolvers(model: Model): IResolvers<unknown, ResolverContext> {
+    let Query: Record<string, IFieldResolver<unknown, ResolverContext>> = {}
+    let resolvers: IResolvers = {Query, ...getScalarResolvers()}
+
+    for (let name in model) {
+        let item = model[name]
+        switch(item.kind) {
+            case 'entity':
+                Query[toQueryListField(name)] = async (source, args, context, info) => {
+                    let fields = requestedFields(model, name, info)
+                    let db = await context.openReaderTransaction.get()
+                    return new QueryBuilder(model, db).executeSelect(name, args, fields)
+                }
+                Query[toQueryListField(name) + 'Connection'] = async (source, args, context, info) => {
+                    let db = await context.openReaderTransaction.get()
+                    return resolveEntityConnection(model, name, args, info, db)
+                }
+                Query[`${toCamelCase(name)}ById`] = async (source, args, context, info) => {
+                    let fields = requestedFields(model, name, info)
+                    let db = await context.openReaderTransaction.get()
+                    let result = await new QueryBuilder(model, db)
+                        .executeSelect(name, {where: {id_eq: args.id}}, fields)
+                    assert(result.length < 2)
+                    return result[0]
+                }
+                Query[`${toCamelCase(name)}ByUniqueInput`] = async (source, args, context, info) => {
+                    let fields = requestedFields(model, name, info)
+                    let db = await context.openReaderTransaction.get()
+                    let result = await new QueryBuilder(model, db)
+                        .executeSelect(name, {where: {id_eq: args.where.id}}, fields)
+                    assert(result.length < 2)
+                    return result[0]
+                }
+                installFieldResolvers(name, item)
+                break
+            case 'object':
+                installFieldResolvers(name, item)
+                break
+            case 'union':
+                resolvers[name] = {
+                    __resolveType: resolveUnionType
+                }
+                break
+            case 'fts':
+                Query[name] = async (source, args, context, info) => {
+                    let fields = ftsRequestedFields(model, name, info)
+                    let db = await context.openReaderTransaction.get()
+                    return new QueryBuilder(model, db).executeFulltextSearch(name, args, fields)
+                }
+                resolvers[`${name}_Item`] = {
+                    __resolveType: resolveUnionType
+                }
+                break
+        }
+    }
+
+    function installFieldResolvers(name: string, object: Entity | JsonObject): void {
+        let fields: Record<string, IFieldResolver<any, any>> = {}
+        for (let key in object.properties) {
+            let kind = object.properties[key].type.kind
+            switch(kind) {
+                case 'object':
+                case 'union':
+                case 'fk':
+                case 'lookup':
+                case 'list-lookup':
+                    fields[key] = aliasResolver
+                    break
+                case 'scalar':
+                case 'enum':
+                case 'list':
+                    break
+                default:
+                    throw unsupportedCase(kind)
+            }
+        }
+        resolvers[name] = fields
+    }
+
+    return resolvers
+}
+
+
+function resolveUnionType(source: any): string {
+    return source.isTypeOf
+}
+
+
+function aliasResolver(source: any, args: unknown, ctx: unknown, info: GraphQLResolveInfo): any {
+    return source[info.path.key]
+}
+
+
+interface ConnectionArgs extends RelayConnectionArgs {
+    orderBy?: string[]
+    where?: any
+}
+
+
+interface ConnectionResponse extends RelayConnectionResponse<any> {
+    totalCount?: number
+}
+
+
+async function resolveEntityConnection(
+    model: Model,
+    entityName: string,
+    args: ConnectionArgs,
+    info: GraphQLResolveInfo,
+    db: Database
+): Promise<ConnectionResponse> {
+    let response: ConnectionResponse = {}
+
+    let orderBy = args.orderBy && ensureArray(args.orderBy)
+    if (!orderBy?.length) {
+        throw new UserInputError('orderBy argument is required for connection')
+    }
+
+    let {offset, limit} = decodeConnectionArgs(args)
+    let listArgs = {
+        where: args.where,
+        orderBy,
+        offset,
+        limit: limit + 1
+    }
+
+    // https://relay.dev/assets/files/connections-932f4f2cdffd79724ac76373deb30dc8.htm#sec-undefined.PageInfo.Fields
+    function pageInfo(listLength: number): PageInfo {
+        return {
+            hasNextPage: listLength > limit,
+            hasPreviousPage: listLength > 0 && offset > 0,
+            startCursor: listLength > 0 ? encodeCursor(offset + 1) : '',
+            endCursor: listLength > 0 ? encodeCursor(offset + Math.min(limit, listLength)) : ''
+        }
+    }
+
+    let fields = connectionRequestedFields(model, entityName, info)
+    if (fields.edges?.node) {
+        let nodes = await new QueryBuilder(model, db).executeSelect(entityName, listArgs, fields.edges.node)
+        let edges: ConnectionEdge<any>[] = new Array(Math.min(limit, nodes.length))
+        for (let i = 0; i < edges.length; i++) {
+            edges[i] = {
+                node: nodes[i],
+                cursor: encodeCursor(offset + i + 1)
+            }
+        }
+        response.edges = edges
+        response.pageInfo = pageInfo(nodes.length)
+        if (nodes.length > 0 && nodes.length <= limit) {
+            response.totalCount = offset + nodes.length
+        }
+    } else if (fields.edges?.cursor || fields.pageInfo) {
+        let listLength = await new QueryBuilder(model, db).executeListCount(entityName, listArgs)
+        response.pageInfo = pageInfo(listLength)
+        if (fields.edges?.cursor) {
+            response.edges = []
+            for (let i = 0; i < Math.min(limit, listLength); i++) {
+                response.edges.push({
+                    cursor: encodeCursor(offset + i + 1)
+                })
+            }
+        }
+        if (listLength > 0 && listLength <= limit) {
+            response.totalCount = offset + listLength
+        }
+    }
+
+    if (fields.totalCount && response.totalCount == null) {
+        response.totalCount = await new QueryBuilder(model, db).executeSelectCount(entityName, listArgs.where)
+    }
+
+    return response
+}