@subsquid/openreader 2.1.0 → 3.1.0

package/src/sql/mapping.ts

@@ -1,5 +1,5 @@
 import {unexpectedCase} from "@subsquid/util-internal"
-import {FieldRequest} from "../ir/fields"
+import {FieldRequest, FieldsByEntity} from '../ir/fields'
 
 
 export function mapRows(rows: any[][], fields: FieldRequest[]): any[] {
@@ -64,3 +64,20 @@ export function mapRow(row: any[], fields: FieldRequest[], ifType?: string): any
     }
     return rec
 }
+
+
+export function mapQueryableRows(rows: any[][], fields: FieldsByEntity): any[] {
+    let result = new Array(rows.length)
+    for (let i = 0; i < rows.length; i++) {
+        result[i] = mapQueryableRow(rows[i], fields)
+    }
+    return result
+}
+
+
+export function mapQueryableRow(row: any[], fields: FieldsByEntity): any {
+    let entity = row[0]
+    let rec = mapRow(row[1], fields[entity])
+    rec._isTypeOf = entity
+    return rec
+}

package/src/sql/printer.ts

@@ -1,14 +1,15 @@
-import {unexpectedCase} from "@subsquid/util-internal"
-import assert from "assert"
-import {Dialect} from "../dialect"
-import {EntityListArguments, OrderBy, Where} from "../ir/args"
-import {FieldRequest} from "../ir/fields"
-import {Model} from "../model"
-import {Cursor, EntityCursor} from "./cursor"
-import {AliasSet, ColumnSet, escapeIdentifier, JoinSet, printClause} from "./util"
+import {unexpectedCase} from '@subsquid/util-internal'
+import assert from 'assert'
+import {Dialect} from '../dialect'
+import {OrderBy, SortOrder, SqlArguments, Where} from '../ir/args'
+import {FieldRequest, FieldsByEntity} from '../ir/fields'
+import {Model} from '../model'
+import {getQueryableEntities} from '../model.tools'
+import {Cursor, EntityCursor} from './cursor'
+import {AliasSet, ColumnSet, escapeIdentifier, JoinSet, printClause} from './util'
 
 
-export class EntityListQueryPrinter {
+export class EntitySqlPrinter {
     private aliases: AliasSet
     private join: JoinSet
     private root: EntityCursor
@@ -19,9 +20,9 @@ export class EntityListQueryPrinter {
     constructor(
         private model: Model,
         private dialect: Dialect,
-        private entityName: string,
+        public readonly entityName: string,
         private params: unknown[],
-        private args: EntityListArguments = {},
+        private args: SqlArguments = {},
         fields?: FieldRequest[],
         aliases?: AliasSet
     ) {
@@ -43,12 +44,14 @@ export class EntityListQueryPrinter {
             this.populateWhere(this.root, args.where, this.where)
         }
         if (args.orderBy) {
-            this.populateOrderBy(this.root, args.orderBy)
+            this.traverseOrderBy(args.orderBy, (field, cursor, order) => {
+                this.orderBy.push(cursor.native(field) + ' ' + order)
+            })
         }
     }
 
-    private sub(entityName: string, args?: EntityListArguments, fields?: FieldRequest[]): EntityListQueryPrinter {
-        return new EntityListQueryPrinter(this.model, this.dialect, entityName, this.params, args, fields, this.aliases)
+    private sub(entityName: string, args?: SqlArguments, fields?: FieldRequest[]): EntitySqlPrinter {
+        return new EntitySqlPrinter(this.model, this.dialect, entityName, this.params, args, fields, this.aliases)
     }
 
     private populateColumns(cursor: Cursor, fields: FieldRequest[]): void {
@@ -128,7 +131,9 @@ export class EntityListQueryPrinter {
                 break
             }
             case "isNull": {
-                let f = cursor.ref(where.field)
+                let f = cursor.prop(where.field).type.kind == 'lookup'
+                    ? cursor.child(where.field).ref('id')
+                    : cursor.ref(where.field)
                 if (where.yes) {
                     exps.push(`${f} IS NULL`)
                 } else {
@@ -261,33 +266,45 @@ export class EntityListQueryPrinter {
         return printClause("AND", exps)
     }
 
-    private populateOrderBy(cursor: Cursor, orderBy: OrderBy): void {
+    traverseOrderBy(orderBy: OrderBy, cb: (field: string, cursor: Cursor, order: SortOrder) => void) {
+        this.visitOrderBy(this.root, orderBy, cb)
+    }
+
+    private visitOrderBy(cursor: Cursor, orderBy: OrderBy, cb: (field: string, cursor: Cursor, order: SortOrder) => void) {
         for (let field in orderBy) {
             let spec = orderBy[field]
             if (typeof spec == "string") {
-                this.orderBy.push(`${cursor.native(field)} ${spec}`)
+                cb(field, cursor, spec)
             } else {
-                this.populateOrderBy(cursor.child(field), spec)
+                this.visitOrderBy(cursor.child(field), spec, cb)
             }
         }
     }
 
     private param(value: any): string {
-        return "$" + this.params.push(value)
+        if (value && value.__is_squid_big_decimal) {
+            return "$" + this.params.push(value.toString()) + '::numeric'
+        } else {
+            return "$" + this.params.push(value)
+        }
     }
 
     private ident(name: string): string {
         return escapeIdentifier(this.dialect, name)
     }
 
-    addWhereDerivedFrom(field: string, parentIdExp: string): this {
+    private addWhereDerivedFrom(field: string, parentIdExp: string): this {
         this.where.push(`${this.root.native(field)} = ${parentIdExp}`)
         return this
     }
 
+    hasColumns(): boolean {
+        return this.columns.size() > 0
+    }
+
     printColumnList(options?: {withAliases?: boolean}): string {
+        assert(this.hasColumns())
         let names = this.columns.names()
-        assert(names.length > 0)
         if (options?.withAliases) {
             names = names.map((name, idx) => `${name} AS _c${idx}`)
         }
@@ -322,7 +339,110 @@ export class EntityListQueryPrinter {
         return `SELECT ${this.printColumnList({withAliases: true})} ${this.printFrom()}`
     }
 
-    printAsJsonRows(): string {
+    printAsCount(): string {
+        if (this.args.offset || this.args.limit) {
+            return `SELECT count(*) FROM (SELECT true ${this.printFrom()}) AS rows`
+        } else {
+            return `SELECT count(*) ${this.printFrom()}`
+        }
+    }
+
+    private printAsJsonRows(): string {
         return `SELECT ${this.printColumnListAsJsonArray()} AS row ${this.printFrom()}`
     }
 }
+
+
+export class QueryableSqlPrinter {
+    private printers: EntitySqlPrinter[] = []
+    private orders: SortOrder[] = []
+    private orderColumns: string[][] = []
+
+    constructor(
+        private model: Model,
+        private dialect: Dialect,
+        private queryableName: string,
+        private params: unknown[],
+        private args: SqlArguments = {},
+        fields?: FieldsByEntity
+    ) {
+        for (let entityName of getQueryableEntities(this.model, this.queryableName)) {
+            let entityFields = fields?.[entityName]
+
+            let printer = new EntitySqlPrinter(
+                model,
+                dialect,
+                entityName,
+                this.params,
+                {where: args.where},
+                entityFields
+            )
+
+            if (this.args.orderBy) {
+                let cols: string[] = []
+                this.orders.length = 0
+                printer.traverseOrderBy(this.args.orderBy, (field, cursor, order) => {
+                    let col = field == '_type' ? `'${entityName}'` : cursor.native(field)
+                    this.orders.push(order)
+                    cols.push(`${col} AS o${this.orders.length}`)
+                })
+                this.orderColumns.push(cols)
+            }
+
+            this.printers.push(printer)
+        }
+    }
+
+    print(): string {
+        let from = this.printers.map((printer, idx) => {
+            let cols: string[] = []
+            cols.push(`'${printer.entityName}' AS e`)
+            if (printer.hasColumns()) {
+                cols.push(printer.printColumnListAsJsonArray() + ' AS d')
+            } else {
+                cols.push('null AS d')
+            }
+            cols.push(...this.orderColumns[idx])
+            return `SELECT ${cols.join(', ')} ${printer.printFrom()}`
+        }).join('\nUNION ALL\n')
+
+        let args = this.printArgs()
+        if (args) {
+            return `SELECT e, d FROM (\n${from}\n) AS rows` + args
+        } else {
+            return from
+        }
+    }
+
+    printAsCount(): string {
+        let union = this.orders.length
+            ? this.printers.map((printer, idx) => {
+                return `SELECT ${this.orderColumns[idx].join(', ')} ${printer.printFrom()}`
+            })
+            : this.printers.map(printer => {
+                return `SELECT true ${printer.printFrom()}`
+            })
+
+        let from = union.join('\nUNION ALL\n')
+        let args = this.printArgs()
+        if (args) {
+            from = `SELECT true FROM (\n${from}\n) AS src` + args
+        }
+
+        return `SELECT count(*) FROM (\n${from}\n) AS rows`
+    }
+
+    private printArgs(): string {
+        let sql = ''
+        if (this.orders.length) {
+            sql += '\nORDER BY ' + this.orders.map((o, idx) => `o${idx + 1} ${o}`).join(', ')
+        }
+        if (this.args.offset) {
+            sql += `\nOFFSET ${this.args.offset}`
+        }
+        if (this.args.limit) {
+            sql += `\nLIMIT ${this.args.limit}`
+        }
+        return sql
+    }
+}

package/src/sql/query.ts

@@ -1,7 +1,7 @@
-import {assertNotNull} from "@subsquid/util-internal"
-import assert from "assert"
-import type {Dialect} from "../dialect"
-import type {EntityListArguments, Where} from "../ir/args"
+import {assertNotNull} from '@subsquid/util-internal'
+import assert from 'assert'
+import type {Dialect} from '../dialect'
+import type {SqlArguments, Where} from '../ir/args'
 import {
     decodeRelayConnectionCursor,
     encodeRelayConnectionCursor,
@@ -9,12 +9,12 @@ import {
     RelayConnectionPageInfo,
     RelayConnectionRequest,
     RelayConnectionResponse
-} from "../ir/connection"
-import type {FieldRequest} from "../ir/fields"
-import type {Model} from "../model"
-import {toSafeInteger} from "../util/util"
-import {mapRows} from "./mapping"
-import {EntityListQueryPrinter} from "./printer"
+} from '../ir/connection'
+import type {AnyFields, FieldRequest} from '../ir/fields'
+import type {Model} from '../model'
+import {toSafeInteger} from '../util/util'
+import {mapQueryableRows, mapRows} from './mapping'
+import {EntitySqlPrinter, QueryableSqlPrinter} from './printer'
 
 
 export interface Query<T> {
@@ -24,22 +24,32 @@ export interface Query<T> {
 }
 
 
-export class EntityListQuery implements Query<any[]> {
+export class ListQuery implements Query<any[]> {
     public readonly sql: string
     public readonly params: unknown[] = []
 
     constructor(
         model: Model,
         dialect: Dialect,
-        entityName: string,
-        private fields: FieldRequest[],
-        args: EntityListArguments
+        typeName: string,
+        private fields: AnyFields,
+        args: SqlArguments
     ) {
-        this.sql = new EntityListQueryPrinter(model, dialect, entityName, this.params, args, fields).print()
+        if (model[typeName].kind == 'entity') {
+            assert(Array.isArray(fields))
+            this.sql = new EntitySqlPrinter(model, dialect, typeName, this.params, args, fields).print()
+        } else {
+            assert(!Array.isArray(fields))
+            this.sql = new QueryableSqlPrinter(model, dialect, typeName, this.params, args, fields).print()
+        }
     }
 
     map(rows: any[][]): any[] {
-        return mapRows(rows, this.fields)
+        if (Array.isArray(this.fields)) {
+            return mapRows(rows, this.fields)
+        } else {
+            return mapQueryableRows(rows, this.fields)
+        }
     }
 }
 
@@ -55,7 +65,7 @@ export class EntityByIdQuery {
         private fields: FieldRequest[],
         id: string
     ) {
-        this.sql = new EntityListQueryPrinter(
+        this.sql = new EntitySqlPrinter(
             model,
             dialect,
             entityName,
@@ -72,17 +82,18 @@ export class EntityByIdQuery {
 }
 
 
-export class EntityCountQuery implements Query<number> {
+export class CountQuery implements Query<number> {
     public readonly sql: string
     public readonly params: unknown[] = []
 
     constructor(
         model: Model,
         dialect: Dialect,
-        entityName: string,
+        typeName: string,
         where?: Where
     ) {
-        this.sql = 'SELECT count(*) ' + new EntityListQueryPrinter(model, dialect, entityName, this.params, {where}).printFrom()
+        let Printer = model[typeName].kind == 'entity' ? EntitySqlPrinter : QueryableSqlPrinter
+        this.sql = new Printer(model, dialect, typeName, this.params, {where}).printAsCount()
     }
 
     map(rows: any[][]): number {
@@ -91,12 +102,12 @@ export class EntityCountQuery implements Query<number> {
 }
 
 
-export class EntityConnectionQuery implements Query<RelayConnectionResponse> {
+export class ConnectionQuery implements Query<RelayConnectionResponse> {
     public readonly sql: string
     public readonly params: unknown[] = []
     private offset = 0
     private limit = 100
-    private edgeNode?: FieldRequest[]
+    private edgeNode?: AnyFields
     private edgeCursor?: boolean
     private pageInfo?: boolean
     private totalCount?: boolean
@@ -104,30 +115,39 @@ export class EntityConnectionQuery implements Query<RelayConnectionResponse> {
     constructor(
         model: Model,
         dialect: Dialect,
-        entityName: string,
-        req: RelayConnectionRequest
+        typeName: string,
+        req: RelayConnectionRequest<AnyFields>
     ) {
         this.setOffsetAndLimit(req)
         this.edgeCursor = req.edgeCursor
         this.pageInfo = req.pageInfo
         this.totalCount = req.totalCount
 
-        let printer = new EntityListQueryPrinter(model, dialect, entityName, this.params, {
+        let args = {
             orderBy: req.orderBy,
             where: req.where,
             offset: this.offset,
             limit: this.limit + 1
-        }, req.edgeNode)
+        }
+
+        let printer
+        if (model[typeName].kind == 'entity') {
+            assert(req.edgeNode == null || Array.isArray(req.edgeNode))
+            printer = new EntitySqlPrinter(model, dialect, typeName, this.params, args, req.edgeNode)
+        } else {
+            assert(req.edgeNode == null || !Array.isArray(req.edgeNode))
+            printer = new QueryableSqlPrinter(model, dialect, typeName, this.params, args, req.edgeNode)
+        }
 
-        if (req.edgeNode?.length) {
+        if (req.edgeNode) {
             this.edgeNode = req.edgeNode
             this.sql = printer.print()
         } else {
-            this.sql = `SELECT count(*) FROM (SELECT true ${printer.printFrom()}) AS rows`
+            this.sql = printer.printAsCount()
         }
     }
 
-    private setOffsetAndLimit(req: RelayConnectionRequest): void {
+    private setOffsetAndLimit(req: RelayConnectionRequest<unknown>): void {
         if (req.after != null) {
             this.offset = assertNotNull(decodeRelayConnectionCursor(req.after))
         }
@@ -140,7 +160,7 @@ export class EntityConnectionQuery implements Query<RelayConnectionResponse> {
     map(rows: any[][]): RelayConnectionResponse {
         let res: RelayConnectionResponse = {}
         if (this.edgeNode) {
-            let nodes = mapRows(rows, this.edgeNode)
+            let nodes = Array.isArray(this.edgeNode) ? mapRows(rows, this.edgeNode) : mapQueryableRows(rows, this.edgeNode)
             let edges: RelayConnectionEdge[] = new Array(Math.min(this.limit, nodes.length))
             for (let i = 0; i < edges.length; i++) {
                 edges[i] = {

package/src/test/queryable.test.ts

@@ -0,0 +1,258 @@
+import {useDatabase, useServer} from './setup'
+
+describe('queryable interfaces', function() {
+    useDatabase([
+        `create table foo (id text primary key, name text, foo int)`,
+        `create table bar (id text primary key, name text, bar int)`,
+        `create table ref (id text primary key, name text, foo_id text not null unique references foo, bar_id text not null unique references bar)`,
+        `create table baz (id text primary key, name text, ref_id text references ref, baz int)`,
+        `insert into foo (id, name, foo) values ('foo-1', 'hello-foo-1', 1)`,
+        `insert into foo (id, name, foo) values ('foo-2', 'hello-foo-2', 2)`,
+        `insert into bar (id, name, bar) values ('bar-1', 'hello-bar-1', 10)`,
+        `insert into bar (id, name, bar) values ('bar-2', 'hello-bar-2', 20)`,
+        `insert into ref (id, name, foo_id, bar_id) values ('1', 'ref-1', 'foo-1', 'bar-2')`,
+        `insert into ref (id, name, foo_id, bar_id) values ('2', 'ref-2', 'foo-2', 'bar-1')`,
+        `insert into baz (id, name, baz, ref_id) values ('baz-1', 'hello-baz-1', 100, '1')`,
+        `create table one (id text primary key)`,
+        `create table two (id text primary key)`,
+        `create table relation (id text primary key, one_id text references one, two_id text references two)`,
+        `insert into one (id) values ('1-1')`,
+        `insert into one (id) values ('1-2')`,
+        `insert into two (id) values ('2-1')`,
+        `insert into two (id) values ('2-2')`,
+        `insert into relation (id, one_id, two_id) values ('r-1', '1-1', '2-1')`,
+        `insert into relation (id, one_id, two_id) values ('r-2', '1-2', '2-1')`,
+    ])
+
+    const client = useServer(`
+        interface Entity @query {
+            id: ID!
+            name: String
+            ref: Ref
+        }
+        
+        type Ref @entity {
+            id: ID!
+            name: String
+            foo: Foo! @unique
+            bar: Bar! @unique
+        } 
+    
+        type Foo implements Entity @entity {
+            id: ID!
+            name: String
+            ref: Ref @derivedFrom(field: "foo")
+            foo: Int
+        }
+        
+        type Bar implements Entity @entity {
+            id: ID!
+            name: String
+            ref: Ref @derivedFrom(field: "bar")
+            bar: Int
+        }
+        
+        type Baz implements Entity @entity {
+            id: ID!
+            name: String
+            ref: Ref
+            baz: Int
+        }
+        
+        interface Number @query {
+            id: ID!
+            relations: [Relation!]!
+        }
+        
+        type One implements Number @entity {
+            id: ID!
+            relations: [Relation!]! @derivedFrom(field: "one")
+        }
+        
+        type Two implements Number @entity {
+            id: ID!
+            relations: [Relation!]! @derivedFrom(field: "two")
+        }
+        
+        type Relation @entity {
+            id: ID!
+            one: One
+            two: Two
+        }
+    `)
+
+    it('fetching', function() {
+        return client.test(`
+            query {
+                entities(orderBy: id_ASC) {
+                    id
+                    name
+                    ref {
+                        id
+                        name
+                    }
+                    ... on Foo { foo }
+                    ... on Bar { bar }
+                    ... on Baz { baz }
+                }
+            }
+        `, {
+            entities: [
+                {
+                    id: 'bar-1',
+                    name: 'hello-bar-1',
+                    ref: {
+                        id: '2',
+                        name: 'ref-2'
+                    },
+                    bar: 10
+                },
+                {
+                    id: 'bar-2',
+                    name: 'hello-bar-2',
+                    ref: {
+                        id: '1',
+                        name: 'ref-1'
+                    },
+                    bar: 20
+                },
+                {
+                    id: 'baz-1',
+                    name: 'hello-baz-1',
+                    ref: {
+                        id: '1',
+                        name: 'ref-1'
+                    },
+                    baz: 100
+                },
+                {
+                    id: 'foo-1',
+                    name: 'hello-foo-1',
+                    ref: {
+                        id: '1',
+                        name: 'ref-1'
+                    },
+                    foo: 1
+                },
+                {
+                    id: 'foo-2',
+                    name: 'hello-foo-2',
+                    ref: {
+                        id: '2',
+                        name: 'ref-2'
+                    },
+                    foo: 2
+                }
+            ]
+        })
+    })
+
+    it('sorting by entity type', function() {
+        return client.test(`
+            query {
+                entities(orderBy: [_type_DESC, id_ASC]) {
+                    id
+                }
+            }
+        `, {
+            entities: [
+                {id: 'foo-1'},
+                {id: 'foo-2'},
+                {id: 'baz-1'},
+                {id: 'bar-1'},
+                {id: 'bar-2'}
+            ]
+        })
+    })
+
+    it('pagination', function() {
+        return client.test(`
+            query {
+                page1: entitiesConnection(orderBy: id_ASC, first: 2) {
+                    ...fields
+                }
+                page2: entitiesConnection(orderBy: id_ASC, first: 2, after: "2") {
+                    ...fields
+                }
+                page3: entitiesConnection(orderBy: id_ASC, first: 2, after: "4") {
+                    ...fields
+                }
+            }
+            
+            fragment fields on EntitiesConnection {
+                edges {
+                    cursor
+                    node { 
+                        ... on Foo { foo }
+                        ... on Bar { bar }
+                    }
+                }
+                pageInfo { 
+                    hasNextPage 
+                    hasPreviousPage 
+                    startCursor 
+                    endCursor 
+                }
+                totalCount
+            }
+        `, {
+            page1: {
+                edges: [
+                    {cursor: '1', node: {bar: 10}},
+                    {cursor: '2', node: {bar: 20}},
+                ],
+                pageInfo: {
+                    hasNextPage: true,
+                    hasPreviousPage: false,
+                    startCursor: '1',
+                    endCursor: '2'
+                },
+                totalCount: 5
+            },
+            page2: {
+                edges: [
+                    {cursor: '3', node: {}},
+                    {cursor: '4', node: {foo: 1}},
+                ],
+                pageInfo: {
+                    hasNextPage: true,
+                    hasPreviousPage: true,
+                    startCursor: '3',
+                    endCursor: '4'
+                },
+                totalCount: 5
+            },
+            page3: {
+                edges: [
+                    {cursor: '5', node: {foo: 2}},
+                ],
+                pageInfo: {
+                    hasNextPage: false,
+                    hasPreviousPage: true,
+                    startCursor: '5',
+                    endCursor: '5'
+                },
+                totalCount: 5
+            }
+        })
+    })
+
+    it('list lookup fields in interfaces', function() {
+        return client.test(`
+            query {
+                numbers(orderBy: id_ASC) {
+                    id
+                    relations { id }
+                    __typename
+                }
+            }
+        `, {
+            numbers: [
+                {__typename: 'One', id: '1-1', relations: [{id: 'r-1'}]},
+                {__typename: 'One', id: '1-2', relations: [{id: 'r-2'}]},
+                {__typename: 'Two', id: '2-1', relations: [{id: 'r-1'}, {id: 'r-2'}]},
+                {__typename: 'Two', id: '2-2', relations: []}
+            ]
+        })
+    })
+})