@subsquid/openreader 2.0.0 → 3.0.0

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/limits.test.ts

@@ -0,0 +1,163 @@
+import expect from 'expect'
+import {useDatabase, useServer} from './setup'
+
+
+describe('response size limits', function() {
+    useDatabase([
+        `create table "order1" (id text primary key)`,
+        `create table item1 (id text primary key, order_id text, name text)`,
+        `create table "order2" (id text primary key)`,
+        `create table item2 (id text primary key, order_id text, name text)`,
+        `create table "order3" (id text primary key)`,
+        `create table item3 (id text primary key, order_id text, name text)`,
+    ])
+
+    const client = useServer(`
+        type Order1 @entity {
+            id: ID!
+            items: [Item1!]! @derivedFrom(field: "order")
+        }
+        
+        type Item1 @entity {
+            id: ID!
+            order: Order1!
+            name: String
+        }
+        
+        type Order2 @entity @cardinality(value: 10) {
+            id: ID!
+            items: [Item2!]! @derivedFrom(field: "order")
+        }
+        
+        type Item2 @entity {
+            id: ID!
+            order: Order2!
+            name: String
+        }
+        
+        type Order3 @entity {
+            id: ID!
+            items: [Item3!]! @derivedFrom(field: "order") @cardinality(value: 10)
+        }
+        
+        type Item3 @entity {
+            id: ID!
+            order: Order3!
+            name: String @byteWeight(value: 10.0)
+        }
+    `, {
+        maxResponseNodes: 50,
+        maxRootFields: 3
+    })
+
+    it('unlimited requests fail', async function() {
+        let result = await client.query(`
+            query {
+                order1s {
+                    id
+                }
+            }
+        `)
+        expect(result).toMatchObject({
+            data: null,
+            errors: [
+                expect.objectContaining({message: 'response might exceed the size limit', path: ['order1s']})
+            ]
+        })
+    })
+
+    it('limited requests work', function() {
+        return client.test(`
+            query {
+                order1s(limit: 10) {
+                    items(limit: 2) {
+                        id
+                    }
+                }
+            }
+        `, {
+            order1s: []
+        })
+    })
+
+    it('entity level cardinalities are respected', function() {
+        return client.test(`
+            query {
+                order2s {
+                    id
+                }
+            }
+        `, {
+            order2s: []
+        })
+    })
+
+    it('item cardinalities are respected', function() {
+        return client.test(`
+            query {
+                order3s(limit: 1) {
+                    items { id }
+                }
+            }
+        `, {
+            order3s: []
+        })
+    })
+
+    it('@byteWeight annotations are respected', async function() {
+        let result = await client.query(`
+            query {
+                order3s(limit: 1) {
+                    items(limit: 8) { name }
+                }
+            }
+        `)
+        expect(result).toEqual({
+            data: null,
+            errors: [
+                expect.objectContaining({
+                    message: 'response might exceed the size limit',
+                    path: ['order3s']
+                })
+            ]
+        })
+        await client.test(`
+            query {
+                order3s(limit: 1) {
+                    items(limit: 4) { name }
+                }
+            }
+        `, {
+            order3s: []
+        })
+    })
+
+    it('id_in conditions are understood', function() {
+        return client.test(`
+            query {
+                order1s(where: {id_in: ["1", "2", "3"]}) {
+                    id
+                }
+            }
+        `, {
+            order1s: []
+        })
+    })
+
+    it('root query fields limit', async function() {
+        return client.errorTest(`
+            query {
+                a: order1ById(id: "1") { id }
+                b: order1ById(id: "1") { id }
+                c: order1ById(id: "1") { id }
+                d: order1ById(id: "1") { id }
+            }
+        `, {
+            errors: [
+                expect.objectContaining({
+                    message: 'only 3 root query fields allowed, but got 4'
+                })
+            ]
+        })
+    })
+})

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

package/src/test/setup.ts

@@ -4,7 +4,7 @@ import {Client} from "gql-test-client"
 import {parse} from "graphql"
 import {Client as PgClient, ClientBase, Pool} from "pg"
 import {buildModel, buildSchema} from "../model.schema"
-import {serve} from "../server"
+import {serve, ServerOptions} from '../server'
 
 
 export function isCockroach(): boolean {
@@ -59,7 +59,7 @@ export function useDatabase(sql: string[]): void {
 }
 
 
-export function useServer(schema: string): Client {
+export function useServer(schema: string, options?: Partial<ServerOptions>): Client {
     let client = new Client('not defined')
     let db = new Pool(db_config)
     let info: ListeningServer | undefined
@@ -69,7 +69,10 @@ export function useServer(schema: string): Client {
             model: buildModel(buildSchema(parse(schema))),
             port: 0,
             dialect: isCockroach() ? 'cockroach' : 'postgres',
-            subscriptions: true
+            subscriptions: true,
+            subscriptionPollInterval: 500,
+            maxRootFields: 10,
+            ...options
         })
         client.endpoint = `http://localhost:${info.port}/graphql`
     })

package/src/util/execute.ts

@@ -0,0 +1,53 @@
+import {getOperationRootType, GraphQLError} from 'graphql'
+import {ExecutionResult} from 'graphql-ws'
+import {
+    assertValidExecutionArguments,
+    buildExecutionContext,
+    collectFields,
+    execute as graphqlExecute,
+    ExecutionArgs,
+    ExecutionContext
+} from 'graphql/execution/execute'
+import {PromiseOrValue} from 'graphql/jsutils/PromiseOrValue'
+
+
+export function executeWithLimit(maxQueries: number, args: ExecutionArgs): PromiseOrValue<ExecutionResult> {
+    assertValidExecutionArguments(args.schema, args.document, args.variableValues)
+
+    let xtx = buildExecutionContext(
+        args.schema,
+        args.document,
+        args.rootValue,
+        args.contextValue,
+        args.variableValues,
+        args.operationName,
+        args.fieldResolver,
+        args.typeResolver
+    )
+
+    if (Array.isArray(xtx)) {
+        return {errors: xtx}
+    }
+
+    let etx = xtx as ExecutionContext
+    if (etx.operation.operation == 'query') {
+        let query = getOperationRootType(etx.schema, etx.operation)
+        let fields = collectFields(
+            etx,
+            query,
+            etx.operation.selectionSet,
+            Object.create(null),
+            Object.create(null)
+        )
+        let fieldsCount = Object.keys(fields).length
+        if (fieldsCount > maxQueries) {
+            return {
+                errors: [
+                    new GraphQLError(`only ${maxQueries} root query fields allowed, but got ${fieldsCount}`)
+                ]
+            }
+        }
+    }
+
+    return graphqlExecute(args)
+}