@subsquid/openreader 1.0.2 → 2.1.0

package/src/relayConnection.ts

@@ -1,80 +0,0 @@
-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

@@ -1,246 +0,0 @@
-import {toPlural} from "@subsquid/util-naming"
-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

@@ -1,201 +0,0 @@
-import type {IFieldResolver, IResolvers} from "@graphql-tools/utils"
-import {toCamelCase} from "@subsquid/util-naming"
-import {UserInputError} from "apollo-server-core"
-import assert from "assert"
-import type {GraphQLResolveInfo} from "graphql"
-import type {Database, Transaction} from "./db"
-import type {Dialect} from "./dialect"
-import {customScalars} from "./gql/scalars"
-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 {ensureArray, toQueryListField, unsupportedCase} from "./util"
-
-
-export interface ResolverContext {
-    openReaderTransaction: Transaction
-}
-
-
-export function buildResolvers(model: Model, dialect: Dialect): IResolvers<unknown, ResolverContext> {
-    let Query: Record<string, IFieldResolver<unknown, ResolverContext>> = {}
-    let resolvers: IResolvers = {Query, ...customScalars}
-
-    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, dialect, db).executeSelect(name, args, fields)
-                }
-                Query[toQueryListField(name) + 'Connection'] = async (source, args, context, info) => {
-                    let db = await context.openReaderTransaction.get()
-                    return resolveEntityConnection(model, dialect, 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, dialect, 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, dialect, 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, dialect, 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,
-    dialect: Dialect,
-    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, dialect, 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, dialect, 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, dialect, db).executeSelectCount(entityName, listArgs.where)
-    }
-
-    return response
-}

package/src/where.ts

@@ -1,119 +0,0 @@
-
-export type WhereOp =
-    '-' | // no operator
-    'isNull' |
-    'eq' | 'not_eq' |
-    'gt' |
-    'gte' |
-    'lt' |
-    'lte' |
-    'in' | 'not_in' |
-    'contains' | 'not_contains' |
-    'containsInsensitive' | 'not_containsInsensitive' |
-    'startsWith' | 'not_startsWith' |
-    'endsWith' | 'not_endsWith' |
-    'containsAll' |
-    'containsAny' |
-    'containsNone' |
-    'some' |
-    'every' |
-    'none' |
-    'jsonContains' |
-    'jsonHasKey'
-
-
-const ENDINGS = [
-    'isNull',
-    'eq',
-    'not_eq',
-    'gt',
-    'gte',
-    'lt',
-    'lte',
-    'in',
-    'not_in',
-    'contains',
-    'not_contains',
-    'containsInsensitive',
-    'not_containsInsensitive',
-    'startsWith',
-    'not_startsWith',
-    'endsWith',
-    'not_endsWith',
-    'containsAll',
-    'containsAny',
-    'containsNone',
-    'some',
-    'every',
-    'none',
-    'jsonContains',
-    'jsonHasKey',
-].sort((a, b) => b.length - a.length).map(e => '_' + e)
-
-
-function parseEnding(field: string): string {
-    for (let i = 0; i < ENDINGS.length; i++) {
-        if (field.endsWith(ENDINGS[i])) return ENDINGS[i].slice(1)
-    }
-    return ''
-}
-
-
-export function parseWhereField(field: string): {op: WhereOp, field: string} {
-    let ending = parseEnding(field)
-    if (!ending) return {op: '-', field}
-    let fieldName = field.slice(0, -(ending.length + 1))
-    return {
-        op: ending as WhereOp,
-        field: fieldName
-    }
-}
-
-
-export function hasConditions(where?: any): where is any {
-    if (where == null) return false
-    for (let key in where) {
-        switch(key) {
-            case 'AND':
-            case 'OR':
-                break
-            default:
-                return true
-        }
-    }
-    if (Array.isArray(where.AND)) {
-        if (where.AND.some(hasConditions)) return true
-    } else if (where.AND && hasConditions(where.AND)) {
-        return true
-    }
-    if (Array.isArray(where.OR)) {
-        if (where.OR.some(hasConditions)) return true
-    } else if (where.OR && hasConditions(where.OR)) {
-        return true
-    }
-    return false
-}
-
-
-export function whereOpToSqlOperator(op: WhereOp): string {
-    switch(op) {
-        case 'eq':
-            return '='
-        case 'not_eq':
-            return '!='
-        case 'gt':
-            return '>'
-        case 'gte':
-            return '>='
-        case 'lt':
-            return '<'
-        case 'lte':
-            return '<='
-        case 'in':
-            return 'IN'
-        case 'not_in':
-            return 'NOT IN'
-        default:
-            throw new Error(`Operator ${op} doesn't have SQL analog`)
-    }
-}