@subsquid/openreader 0.3.2 → 0.3.3

package/src/test/connection.test.ts

@@ -0,0 +1,195 @@
+import {useDatabase, useServer} from "./util/setup"
+
+describe('relay connections', function () {
+    useDatabase([
+        `create table letter (id text primary key)`,
+        `insert into letter (id) values ('a')`,
+        `insert into letter (id) values ('b')`,
+        `insert into letter (id) values ('c')`,
+        `insert into letter (id) values ('d')`,
+        `insert into letter (id) values ('e')`,
+        `insert into letter (id) values ('f')`,
+        `insert into letter (id) values ('g')`,
+        `create table empty (id text primary key)`
+    ])
+
+    const client = useServer(`
+        type Letter @entity {
+            id: ID!
+        }
+        
+        type Empty @entity {
+            id: ID!
+        }
+    `)
+
+    it('pagination', function () {
+        return client.test(`
+            query { 
+                page1: lettersConnection(orderBy: id_ASC, first: 3) {
+                    ...fields
+                } 
+                page2: lettersConnection(orderBy: id_ASC, first: 3, after: "3") {
+                    ...fields
+                } 
+                page3: lettersConnection(orderBy: id_ASC, first: 3, after: "6") {
+                    ...fields
+                } 
+            }
+            fragment fields on LettersConnection {
+                edges { 
+                    node { id } 
+                    cursor
+                }
+                pageInfo { 
+                    hasNextPage 
+                    hasPreviousPage 
+                    startCursor 
+                    endCursor 
+                }
+                totalCount
+            }
+        `, {
+            page1: {
+                edges: [
+                    {node: {id: 'a'}, cursor: '1'},
+                    {node: {id: 'b'}, cursor: '2'},
+                    {node: {id: 'c'}, cursor: '3'},
+                ],
+                pageInfo: {
+                    hasNextPage: true,
+                    hasPreviousPage: false,
+                    startCursor: '1',
+                    endCursor: '3'
+                },
+                totalCount: 7
+            },
+            page2: {
+                edges: [
+                    {node: {id: 'd'}, cursor: '4'},
+                    {node: {id: 'e'}, cursor: '5'},
+                    {node: {id: 'f'}, cursor: '6'},
+                ],
+                pageInfo: {
+                    hasNextPage: true,
+                    hasPreviousPage: true,
+                    startCursor: '4',
+                    endCursor: '6'
+                },
+                totalCount: 7
+            },
+            page3: {
+                edges: [
+                    {node: {id: 'g'}, cursor: '7'},
+                ],
+                pageInfo: {
+                    hasNextPage: false,
+                    hasPreviousPage: true,
+                    startCursor: '7',
+                    endCursor: '7'
+                },
+                totalCount: 7
+            }
+        })
+    })
+
+    it('pagination without nodes', function () {
+        return client.test(`
+            query { 
+                page1: lettersConnection(orderBy: id_ASC, first: 3) {
+                    ...fields
+                } 
+                page2: lettersConnection(orderBy: id_ASC, first: 3, after: "3") {
+                    ...fields
+                } 
+                page3: lettersConnection(orderBy: id_ASC, first: 3, after: "6") {
+                    ...fields
+                } 
+            }
+            fragment fields on LettersConnection {
+                edges { 
+                    cursor
+                }
+                pageInfo { 
+                    hasNextPage 
+                    hasPreviousPage 
+                    startCursor 
+                    endCursor 
+                }
+                totalCount
+            }
+        `, {
+            page1: {
+                edges: [
+                    {cursor: '1'},
+                    {cursor: '2'},
+                    {cursor: '3'},
+                ],
+                pageInfo: {
+                    hasNextPage: true,
+                    hasPreviousPage: false,
+                    startCursor: '1',
+                    endCursor: '3'
+                },
+                totalCount: 7
+            },
+            page2: {
+                edges: [
+                    {cursor: '4'},
+                    {cursor: '5'},
+                    {cursor: '6'},
+                ],
+                pageInfo: {
+                    hasNextPage: true,
+                    hasPreviousPage: true,
+                    startCursor: '4',
+                    endCursor: '6'
+                },
+                totalCount: 7
+            },
+            page3: {
+                edges: [
+                    {cursor: '7'},
+                ],
+                pageInfo: {
+                    hasNextPage: false,
+                    hasPreviousPage: true,
+                    startCursor: '7',
+                    endCursor: '7'
+                },
+                totalCount: 7
+            }
+        })
+    })
+
+    it('request to empty table', function () {
+        return client.test(`
+            query {
+                emptiesConnection(orderBy: id_ASC) {
+                    edges { 
+                        node { id } 
+                        cursor
+                    }
+                    pageInfo { 
+                        hasNextPage 
+                        hasPreviousPage 
+                        startCursor 
+                        endCursor 
+                    }
+                    totalCount
+                }
+            }
+        `, {
+            emptiesConnection: {
+                edges: [],
+                pageInfo: {
+                    hasNextPage: false,
+                    hasPreviousPage: false,
+                    startCursor: '',
+                    endCursor: ''
+                },
+                totalCount: 0
+            }
+        })
+    })
+})

package/src/test/fts.test.ts

@@ -0,0 +1,114 @@
+import {useDatabase, useServer} from "./util/setup"
+
+function tsvector(columns: string[]) {
+    return columns.map(col => `setweight(to_tsvector('english', coalesce(${col}, '')), 'A')`).join(' || ')
+}
+
+describe('full text search', function () {
+    useDatabase([
+        `create table foo (
+            id text primary key, 
+            foo int, 
+            comment text, 
+            search_tsv tsvector generated always as ( ${tsvector(['comment'])} ) stored
+        )`,
+        `create table bar (
+            id text primary key, 
+            bar text, 
+            description text, 
+            search_tsv tsvector generated always as ( ${tsvector(['bar', 'description'])} ) stored
+        )`,
+        `insert into foo (id, foo, comment) values ('1', 1, 'Some man greeted me with hello')`,
+        `insert into foo (id, foo, comment) values ('2', 2, 'Deeply buried lorem ipsum dolor sit amet, then comes baz')`,
+        `insert into foo (id, foo, comment) values ('3', 3, 'Lorem ipsum dolor sit amet')`,
+        `insert into bar (id, bar, description) values ('1', 'every bar is followed by baz. Baz!', 'Absolutely!')`,
+        `insert into bar (id, bar, description) values ('2', 'qux', 'Baz should be here! Baz! Baz! Baz!')`,
+    ])
+
+    const client = useServer(`
+        type Foo @entity {
+            id: ID!
+            foo: Int
+            comment: String @fulltext(query: "search")
+        }
+        
+        type Bar @entity {
+            id: ID!
+            bar: String @fulltext(query: "search")
+            description: String @fulltext(query: "search")
+        }
+    `)
+
+    it('finds "hello" across entities in Foo.comment and highlights it', function () {
+        return client.test(`
+            query {
+                search(text: "hello") {
+                    item {
+                        ... on Foo { id, foo }
+                    }
+                    highlight
+                }
+            }
+        `, {
+            search: [{
+                item: {id: '1', foo: 1},
+                highlight: 'Some man greeted me with <b>hello</b>'
+            }]
+        })
+    })
+
+    it('finds "absolute" across entities in Bar.description and highlights it', function () {
+        return client.test(`
+            query {
+                search(text: "absolute") {
+                    item {
+                        ... on Bar { id, bar }
+                    }
+                    highlight
+                }
+            }
+        `, {
+            search: [{
+                item: {id: '1', bar: 'every bar is followed by baz. Baz!'},
+                highlight: 'every bar is followed by baz. Baz!\n\n<b>Absolutely</b>!'
+            }]
+        })
+    })
+
+    it('finds and arranges "Baz"', function () {
+        return client.test(`
+            query {
+                search(text: "baz") {
+                    item {
+                        ... on Foo { id foo }
+                        ... on Bar { id bar }
+                    }
+                }
+            }
+        `, {
+            search: [
+                {item: {id: '2', bar: 'qux'}},
+                {item: {id: '1', bar: 'every bar is followed by baz. Baz!'}},
+                {item: {id: '2', foo: 2}},
+            ]
+        })
+    })
+
+    it('supports where conditions', function () {
+        return client.test(`
+            query {
+                search(text: "baz" whereBar: {bar_eq: "qux"}) {
+                    item {
+                        ... on Foo { id foo }
+                        ... on Bar { id bar }
+                    }
+                }
+            }
+        `, {
+            search: [
+                {item: {id: '2', bar: 'qux'}},
+                {item: {id: '2', foo: 2}}
+            ]
+        })
+    })
+})

package/src/test/lists.test.ts

@@ -0,0 +1,278 @@
+import {useDatabase, useServer} from "./util/setup"
+
+
+describe('lists', function () {
+    useDatabase([
+        `create table lists (
+            id text primary key, 
+            int_array integer[], 
+            bigint_array numeric[], 
+            enum_array text[],
+            datetime_array timestamptz[],
+            bytes_array bytea[],
+            list_of_list_of_int jsonb, 
+            list_of_json_objects jsonb
+        )`,
+        `insert into lists (id, int_array) values ('1', '{1, 2, 3}')`,
+        `insert into lists (id, int_array) values ('2', '{4, 5, 6}')`,
+        `insert into lists (id, int_array) values ('20', '{7, 8}')`,
+        `insert into lists (id, bigint_array) values ('3', '{1000000000000000000000000000, 2000000000000000000000000000}')`,
+        `insert into lists (id, bigint_array) values ('4', '{3000000000000000000000000000, 4000000000000000000000000000}')`,
+        `insert into lists (id, list_of_list_of_int) values ('5', '[[1, 2], [3, 4], [5]]'::jsonb)`,
+        `insert into lists (id, list_of_json_objects) values ('6', '[{"foo": 1, "bar": 2}, {"foo": 3, "bar": 4}]'::jsonb)`,
+        `insert into lists (id, datetime_array) values ('7', array['2020-01-01T00:00:00Z', '2021-01-01T00:00:00Z']::timestamptz[])`,
+        `insert into lists (id, datetime_array) values ('70', array['2020-01-01T00:00:00Z', '2022-01-01T00:00:00Z']::timestamptz[])`,
+        `insert into lists (id, bytes_array) values ('8', array['hello', 'world']::bytea[])`,
+        `insert into lists (id, bytes_array) values ('9', array['hello', 'big', 'world']::bytea[])`,
+        `insert into lists (id, enum_array) values ('10', array['A', 'B', 'C'])`,
+        `insert into lists (id, enum_array) values ('11', array['C',  'D'])`,
+        `insert into lists (id, enum_array) values ('12', array['A',  'D'])`,
+    ])
+
+    const client = useServer(`    
+        type Lists @entity {
+            intArray: [Int!]
+            enumArray: [Enum!]
+            bigintArray: [BigInt!]
+            datetimeArray: [DateTime!]
+            bytesArray: [Bytes!]
+            listOfListOfInt: [[Int]]
+            listOfJsonObjects: [Foo!]
+        }
+        
+        enum Enum {
+            A B C D E F
+        }
+        
+        type Foo {
+            foo: Int
+            bar: Int
+        }
+    `)
+
+    describe('integer arrays', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    lists(where: {id_in: ["1", "2"]} orderBy: id_ASC) {
+                        intArray
+                    }
+                }
+            `, {
+                lists: [
+                    {intArray: [1, 2, 3]},
+                    {intArray: [4, 5, 6]}
+                ]
+            })
+        })
+
+        it('support where conditions', function () {
+            return client.test(`
+                query {
+                    all: lists(where: {intArray_containsAll: [1, 3]} orderBy: id_ASC) {
+                        id
+                    }
+                    any: lists(where: {intArray_containsAny: [4, 7]} orderBy: id_ASC) {
+                        id
+                    }
+                    none: lists(where: {intArray_containsNone: 5} orderBy: id_ASC) {
+                        id
+                    }
+                    nothing: lists(where: {intArray_containsNone: [1, 4, 7]} orderBy: id_ASC) {
+                        id
+                    }
+                }
+            `, {
+                all: [{id: '1'}],
+                any: [{id: '2'}, {id: '20'}],
+                none: [{id: '1'}, {id: '20'}],
+                nothing: []
+            })
+        })
+    })
+
+    describe('enum arrays', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    lists(where: {id_in: ["10", "11", "12"]} orderBy: id_ASC) {
+                        id
+                        enumArray
+                    }
+                }
+            `, {
+                lists: [
+                    {id: '10', enumArray: ['A', 'B', 'C']},
+                    {id: '11', enumArray: ['C', 'D']},
+                    {id: '12', enumArray: ['A', 'D']}
+                ]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    all : lists(where: {enumArray_containsAll: [A, B]} orderBy: id_ASC) { id }
+                    any : lists(where: {enumArray_containsAny: D} orderBy: id_ASC) { id }
+                    none: lists(where: {enumArray_containsNone: A} orderBy: id_ASC) { id }
+                }
+            `, {
+                all: [{id: '10'}],
+                any: [{id: '11'}, {id: '12'}],
+                none: [{id: '11'}],
+            })
+        })
+    })
+
+    describe('big integer arrays', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    lists(where: {id_in: ["3", "4"]} orderBy: id_ASC) {
+                        bigintArray
+                    }
+                }
+            `, {
+                lists: [
+                    {bigintArray: ['1000000000000000000000000000', '2000000000000000000000000000']},
+                    {bigintArray: ['3000000000000000000000000000', '4000000000000000000000000000']}
+                ]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    all: lists(where: {bigintArray_containsAll: 1000000000000000000000000000} orderBy: id_ASC) {
+                        id
+                    }
+                    any: lists(where: {bigintArray_containsAny: [3000000000000000000000000000, 2000000000000000000000000000]} orderBy: id_ASC) {
+                        id
+                    }
+                    none: lists(where: {bigintArray_containsNone: "2000000000000000000000000000"} orderBy: id_ASC) {
+                        id
+                    }
+                }
+            `, {
+                all: [{id: '3'}],
+                any: [{id: '3'}, {id: '4'}],
+                none: [{id: '4'}]
+            })
+        })
+    })
+
+    describe('date-time arrays', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    lists(where: {id_eq: "7"}) {
+                        datetimeArray
+                    }
+                }
+            `, {
+                lists: [{
+                    datetimeArray: [
+                        '2020-01-01T00:00:00.000Z',
+                        '2021-01-01T00:00:00.000Z'
+                    ]
+                }]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    all: lists(where: {datetimeArray_containsAll: ["2020-01-01T00:00:00Z", "2022-01-01T00:00:00Z"]} orderBy: id_ASC) {
+                        id
+                    }
+                    any: lists(where: {datetimeArray_containsAny: ["2020-01-01T00:00:00Z", "2022-01-01T00:00:00Z"]} orderBy: id_ASC) {
+                        id
+                    }
+                    none: lists(where: {datetimeArray_containsNone: ["2024-01-01T00:00:00Z", "2022-01-01T00:00:00Z"]} orderBy: id_ASC) {
+                        id
+                    }
+                }
+            `, {
+                all: [{id: '70'}],
+                any: [{id: '7'}, {id: '70'}],
+                none: [{id: '7'}]
+            })
+        })
+    })
+
+    describe('bytes array', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    lists(where: {id_eq: "8"}) {
+                        bytesArray
+                    }
+                }
+            `, {
+                lists: [{
+                    bytesArray: [
+                        '0x68656c6c6f',
+                        '0x776f726c64'
+                    ]
+                }]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    all: lists(where: {bytesArray_containsAll: ["0x68656c6c6f", "0x626967"]} orderBy: id_ASC) {
+                        id
+                    }
+                    any: lists(where: {bytesArray_containsAny: "0x776f726c64"} orderBy: id_ASC) {
+                        id
+                    }
+                    none: lists(where: {bytesArray_containsNone: ["0x626967", "0xaa"]} orderBy: id_ASC) {
+                        id
+                    }
+                }
+            `, {
+                all: [{id: '9'}],
+                any: [{id: '8'}, {id: '9'}],
+                none: [{id: '8'}],
+            })
+        })
+    })
+
+    describe('json lists', function () {
+        it('outputs list of list of integers', function () {
+            return client.test(`
+                query {
+                    lists(where: {id_eq: "5"}) {
+                        listOfListOfInt
+                    }
+                }
+            `, {
+                lists: [
+                    {listOfListOfInt: [[1, 2], [3, 4], [5]]}
+                ]
+            })
+        })
+
+        it('outputs list of json objects', function () {
+            return client.test(`
+                query {
+                    lists(where: {id_eq: "6"}) {
+                        listOfJsonObjects {
+                            foo
+                        }
+                    }
+                }
+            `, {
+                lists: [
+                    {
+                        listOfJsonObjects: [
+                            {foo: 1},
+                            {foo: 3}
+                        ]
+                    }
+                ]
+            })
+        })
+    })
+})

package/src/test/lookup.test.ts

@@ -0,0 +1,111 @@
+import {useDatabase, useServer} from "./util/setup"
+
+describe('lookup test', function () {
+    useDatabase([
+        `create table issue (id text primary key)`,
+        `create table issue_payment (id text primary key, issue_id text not null unique, amount numeric)`,
+        `create table issue_cancellation (id text primary key, issue_id text not null unique, height int)`,
+        `insert into issue (id) values ('1')`,
+        `insert into issue (id) values ('2')`,
+        `insert into issue (id) values ('3')`,
+        `insert into issue_payment (id, issue_id, amount) values ('1', '1', 2)`,
+        `insert into issue_payment (id, issue_id, amount) values ('2', '2', 1)`,
+        `insert into issue_cancellation (id, issue_id, height) values ('3', '3', 10)`,
+    ])
+
+    const client = useServer(`
+        type Issue @entity {
+            id: ID!
+            payment: IssuePayment @derivedFrom(field: "issue")
+            cancellation: IssueCancellation @derivedFrom(field: "issue")
+        }
+        
+        type IssuePayment @entity {
+            id: ID!
+            issue: Issue! @unique
+            amount: Int!
+        }
+        
+        type IssueCancellation @entity {
+            id: ID!
+            issue: Issue! @unique
+            height: Int!
+        }
+    `)
+
+    it('fetches correctly', function () {
+        return client.test(`
+            query {
+                issues(orderBy: [id_ASC]) {
+                    id
+                    payment {
+                        amount
+                    }
+                    cancellation {
+                        height
+                        issue {
+                            cancellation {
+                                id
+                            }
+                        }
+                    }
+                }
+            }
+        `, {
+            issues: [
+                {
+                    id: '1',
+                    payment: {amount: 2},
+                    cancellation: null
+                },
+                {
+                    id: '2',
+                    payment: {amount: 1},
+                    cancellation: null
+                },
+                {
+                    id: '3',
+                    payment: null,
+                    cancellation: {
+                        height: 10,
+                        issue: {
+                            cancellation: {
+                                id: '3'
+                            }
+                        }
+                    }
+                }
+            ]
+        })
+    })
+
+    it('supports sorting on lookup fields', function () {
+        return client.test(`
+            query {
+                issues(orderBy: [payment_amount_DESC]) {
+                    id
+                }
+            }
+        `, {
+            issues: [
+                {id: '3'},
+                {id: '1'},
+                {id: '2'}
+            ]
+        })
+    })
+
+    it('supports where conditions', function () {
+        return client.test(`
+            query {
+                issues(where: {payment: {amount_gt: 1}}) {
+                    id
+                }
+            }
+        `, {
+            issues: [
+                {id: '1'}
+            ]
+        })
+    })
+})