@subsquid/openreader 0.2.1 → 0.4.0

package/src/test/scalars.test.ts

@@ -0,0 +1,316 @@
+import {useDatabase, useServer} from "./util/setup"
+
+describe('scalars', function() {
+    useDatabase([
+        `create table scalar (id text primary key, "boolean" bool, "bigint" numeric, "string" text, enum text, date_time timestamptz, "bytes" bytea, deep jsonb)`,
+        `insert into scalar (id, "boolean") values ('1', true)`,
+        `insert into scalar (id, "boolean", deep) values ('2', false, '{"boolean": true}'::jsonb)`,
+        `insert into scalar (id, "bigint", deep) values ('3', 1000000000000000000000000000000000000, '{"bigint": "1000000000000000000000000000000000000"}'::jsonb)`,
+        `insert into scalar (id, "bigint", deep) values ('4', 2000000000000000000000000000000000000, '{"bigint": "2000000000000000000000000000000000000"}'::jsonb)`,
+        `insert into scalar (id, "bigint", deep) values ('5', 5, '{"bigint": "5"}'::jsonb)`,
+        `insert into scalar (id, "string") values ('6', 'foo bar baz')`,
+        `insert into scalar (id, "string") values ('7', 'bar baz foo')`,
+        `insert into scalar (id, "string") values ('8', 'baz foo bar')`,
+        `insert into scalar (id, "string") values ('9', 'hello')`,
+        `insert into scalar (id, "date_time", deep) values ('10', '2021-09-24T15:43:13.400Z', '{"dateTime": "2021-09-24T00:00:00.120Z"}'::jsonb)`,
+        `insert into scalar (id, "date_time", deep) values ('11', '2021-09-24T00:00:00.000Z', '{"dateTime": "2021-09-24T00:00:00Z"}'::jsonb)`,
+        `insert into scalar (id, "date_time", deep) values ('12', '2021-09-24 02:00:00.001 +01:00', '{"dateTime": "2021-09-24T00:00:00.1Z"}'::jsonb)`,
+        `insert into scalar (id, "bytes", deep) values ('13', decode('aa', 'hex'), '{"bytes": "0xaa"}'::jsonb)`,
+        `insert into scalar (id, "bytes", deep) values ('14', decode('bb', 'hex'), '{"bytes": "0xCCDD"}'::jsonb)`,
+        `insert into scalar (id, "enum") values ('15', 'A')`,
+        `insert into scalar (id, "enum") values ('16', 'B')`,
+        `insert into scalar (id, "enum") values ('17', 'C')`,
+    ])
+
+    const client = useServer(`
+        type Scalar @entity {
+            id: ID!
+            boolean: Boolean
+            string: String
+            enum: Enum
+            bigint: BigInt
+            dateTime: DateTime
+            bytes: Bytes
+            deep: DeepScalar
+        }
+        
+        type DeepScalar {
+            bigint: BigInt
+            dateTime: DateTime
+            bytes: Bytes
+            boolean: Boolean
+        }
+        
+        enum Enum {
+            A B C
+        }
+    `)
+
+    describe('Boolean', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    scalars(where: {id_in: ["1", "2"]} orderBy: id_ASC) {
+                        id
+                        boolean
+                    }
+                }
+            `, {
+                scalars: [
+                    {id: '1', boolean: true},
+                    {id: '2', boolean: false}
+                ]
+            })
+        })
+
+        it('output from nested object', function () {
+            return client.test(`
+                query {
+                    scalars(where: {id_eq: "2"}) {
+                       deep {
+                            boolean
+                       } 
+                    }
+                }
+            `, {
+                scalars: [
+                    {deep: {boolean: true}}
+                ]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    t: scalars(where: {boolean_eq: true}) { id }
+                    f: scalars(where: {boolean_eq: false}) { id }
+                    nt: scalars(where: {boolean_not_eq: true}) { id }
+                    nf: scalars(where: {boolean_not_eq: false}) { id }
+                }
+            `, {
+                t: [{id: '1'}],
+                f: [{id: '2'}],
+                nt: [{id: '2'}],
+                nf: [{id: '1'}]
+            })
+        })
+    })
+
+    describe('String', function () {
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    starts_with: scalars(where: {string_startsWith: "foo"} orderBy: id_ASC) { id }
+                    not_starts_with: scalars(where: {string_not_startsWith: "foo"} orderBy: id_ASC) { id }
+                    ends_with: scalars(where: {string_endsWith: "foo"} orderBy: id_ASC) { id }
+                    not_ends_with: scalars(where: {string_not_endsWith: "foo"} orderBy: id_ASC) { id }
+                    contains: scalars(where: {string_contains: "foo"} orderBy: id_ASC) { id }
+                    not_contains: scalars(where: {string_not_contains: "foo"} orderBy: id_ASC) { id }
+                    case_sensitive: scalars(where: {string_contains: "Foo"} orderBy: id_ASC) { id }
+                }
+            `, {
+                starts_with: [{id: '6'}],
+                not_starts_with: [{id: '7'}, {id: '8'}, {id: '9'}],
+                ends_with: [{id: '7'}],
+                not_ends_with: [{id: '6'}, {id: '8'}, {id: '9'}],
+                contains: [{id: '6'}, {id: '7'}, {id: '8'}],
+                not_contains: [{id: '9'}],
+                case_sensitive: []
+            })
+        })
+    })
+
+    describe('Enum', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    scalars(where: {id_in: ["15", "16", "17"]} orderBy: id_ASC) {
+                        id
+                        enum
+                    }
+                }
+            `, {
+                scalars: [
+                    {id: '15', enum: 'A'},
+                    {id: '16', enum: 'B'},
+                    {id: '17', enum: 'C'},
+                ]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    eq: scalars(where: {enum_eq: A} orderBy: id_ASC) { id }
+                    not_eq: scalars(where: {enum_not_eq: A} orderBy: id_ASC) { id }
+                    in: scalars(where: {enum_in: [A, B]} orderBy: id_ASC) { id }
+                    not_in: scalars(where: {enum_not_in: B} orderBy: id_ASC) { id }
+                }
+            `, {
+                eq: [{id: '15'}],
+                not_eq: [{id: '16'}, {id: '17'}],
+                in: [{id: '15'}, {id: '16'}],
+                not_in: [{id: '15'}, {id: '17'}],
+            })
+        })
+    })
+
+    describe('BigInt', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    scalars(where: {id_in: ["3", "4", "5"]} orderBy: id_ASC) {
+                        id
+                        bigint
+                        deep { bigint }
+                    }
+                }
+            `, {
+                scalars: [
+                    {
+                        id: '3',
+                        bigint: '1000000000000000000000000000000000000',
+                        deep: {bigint: '1000000000000000000000000000000000000'}
+                    },
+                    {
+                        id: '4',
+                        bigint: '2000000000000000000000000000000000000',
+                        deep: {bigint: '2000000000000000000000000000000000000'}
+                    },
+                    {
+                        id: '5',
+                        bigint: '5',
+                        deep: {bigint: '5'}
+                    }
+                ]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    eq: scalars(where: {bigint_eq: 2000000000000000000000000000000000000} orderBy: id_ASC) { id }
+                    not_eq: scalars(where: {bigint_not_eq: 2000000000000000000000000000000000000} orderBy: id_ASC) { id }
+                    gt: scalars(where: {bigint_gt: 1000000000000000000000000000000000000} orderBy: id_ASC) { id }
+                    gte: scalars(where: {bigint_gte: 1000000000000000000000000000000000000} orderBy: id_ASC) { id }
+                    lt: scalars(where: {bigint_lt: 1000000000000000000000000000000000000} orderBy: id_ASC) { id }
+                    lte: scalars(where: {bigint_lte: 1000000000000000000000000000000000000} orderBy: id_ASC) { id }
+                    in: scalars(where: {bigint_in: [1000000000000000000000000000000000000, 5]} orderBy: id_ASC) { id }
+                    not_in: scalars(where: {bigint_not_in: [1000000000000000000000000000000000000, 5]} orderBy: id_ASC) { id }
+                }
+            `, {
+                eq: [{id: '4'}],
+                not_eq: [{id: '3'}, {id: '5'}],
+                gt: [{id: '4'}],
+                gte: [{id: '3'}, {id: '4'}],
+                lt: [{id: '5'}],
+                lte: [{id: '3'}, {id: '5'}],
+                in: [{id: '3'}, {id: '5'}],
+                not_in: [{id: '4'}]
+            })
+        })
+
+        it('json sort', function () {
+            return client.test(`
+                query {
+                    scalars(orderBy: deep_bigint_ASC where: {id_in: ["3", "4", "5"]}) {
+                        id
+                    }
+                }
+            `, {
+                scalars: [
+                    {id: '5'},
+                    {id: '3'},
+                    {id: '4'}
+                ]
+            })
+        })
+    })
+
+    describe('DateTime', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    scalars(where: {id_in: ["10", "11", "12"]} orderBy: id_ASC) {
+                        id
+                        dateTime
+                        deep { dateTime }
+                    }
+                }
+            `, {
+                scalars: [
+                    {id: '10', dateTime: '2021-09-24T15:43:13.400Z', deep: {dateTime: '2021-09-24T00:00:00.120Z'}},
+                    {id: '11', dateTime: '2021-09-24T00:00:00.000Z', deep: {dateTime: '2021-09-24T00:00:00Z'}},
+                    {id: '12', dateTime: '2021-09-24T01:00:00.001Z', deep: {dateTime: '2021-09-24T00:00:00.1Z'}}
+                ]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    gt: scalars(orderBy: id_ASC, where: {dateTime_gt: "2021-09-24T00:00:00Z"}) { id }
+                    gte: scalars(orderBy: id_ASC, where: {dateTime_gte: "2021-09-24T00:00:00Z"}) { id }
+                    lt: scalars(orderBy: id_ASC, where: {dateTime_lt: "2021-09-24T00:00:00Z"}) { id }
+                    lte: scalars(orderBy: id_ASC, where: {dateTime_lte: "2021-09-24T00:00:00Z"}) { id }
+                    in: scalars(orderBy: id_ASC, where: {dateTime_in: ["2021-09-24T00:00:00Z", "2021-09-24T15:43:13.400Z"]}) { id }
+                    not_in: scalars(orderBy: id_ASC, where: {dateTime_not_in: ["2021-09-24T00:00:00Z", "2021-09-24T15:43:13.400Z"]}) { id }
+                }
+            `, {
+                gt: [{id: '10'}, {id: '12'}],
+                gte: [{id: '10'}, {id: '11'}, {id: '12'}],
+                lt: [],
+                lte: [{id: '11'}],
+                in: [{id: '10'}, {'id': '11'}],
+                not_in: [{'id': '12'}]
+            })
+        })
+
+        it('json sort', function () {
+            return client.test(`
+                query {
+                    scalars(orderBy: deep_dateTime_ASC where: {id_in: ["10", "11", "12"]}) {
+                        id
+                    }
+                }
+            `, {
+                scalars: [
+                    {id: '11'},
+                    {id: '12'},
+                    {id: '10'}
+                ]
+            })
+        })
+    })
+
+    describe('Bytes', function () {
+        it('outputs correctly', function () {
+            return client.test(`
+                query {
+                    scalars(where: {id_in: ["13", "14"]} orderBy: id_ASC) {
+                        id
+                        bytes
+                        deep { bytes }
+                    }
+                }
+            `, {
+                scalars: [
+                    {id: '13', bytes: '0xaa', deep: {bytes: '0xaa'}},
+                    {id: '14', bytes: '0xbb', deep: {bytes: '0xccdd'}},
+                ]
+            })
+        })
+
+        it('supports where conditions', function () {
+            return client.test(`
+                query {
+                    eq: scalars(where: {bytes_eq: "0xaa"} orderBy: id_ASC) { id }
+                    deep_eq: scalars(where: {deep: {bytes_eq: "0xccdd"}} orderBy: id_ASC) { id }
+                }
+            `, {
+                eq: [{id: '13'}],
+                deep_eq: [{id: '14'}]
+            })
+        })
+    })
+})

package/src/test/tools.test.ts

@@ -0,0 +1,27 @@
+import * as path from "path"
+import expect from "expect"
+import {loadModel} from "../tools"
+
+function fixture(name: string): string {
+    return path.join(__dirname, '../../fixtures', name)
+}
+
+describe('tools', function () {
+    describe('loadModel()', function () {
+        it('loads model from a single file', function () {
+            let model = loadModel(fixture('schema.graphql'))
+            expect(model).toMatchObject({
+                Account: {kind: 'entity'},
+                HistoricalBalance: {kind: 'entity'}
+            })
+        })
+
+        it('loads model from a directory', function () {
+            let model = loadModel(fixture('schema'))
+            expect(model).toMatchObject({
+                Account: {kind: 'entity'},
+                HistoricalBalance: {kind: 'entity'}
+            })
+        })
+    })
+})

package/src/test/typed-json.test.ts

@@ -0,0 +1,76 @@
+import {useDatabase, useServer} from "./util/setup"
+
+describe('typed json fields', function () {
+    useDatabase([
+        `create table entity (id text primary key, a jsonb)`,
+        `insert into entity (id, a) values ('1', '{"a": "a", "b": {"b": "b", "e": "1"}}'::jsonb)`,
+        `insert into entity (id, a) values ('2', '{"a": "A", "b": {"b": "B", "e": "1"}}'::jsonb)`,
+        `insert into entity (id, a) values ('3', '{}'::jsonb)`,
+        `insert into entity (id) values ('4')`,
+    ])
+
+    const client = useServer(`
+        type Entity @entity {
+            a: A
+        }
+        
+        type A {
+            a: String
+            b: B
+        }
+        
+        type B {
+            a: A
+            b: String
+            e: Entity
+        }
+    `)
+
+    it('maps nulls correctly', function () {
+        return client.test(`
+            query {
+                entities(orderBy: id_ASC) { 
+                    id 
+                    a { a } 
+                }
+            }
+        `, {
+            entities: [
+                {id: '1', a: {a: 'a'}},
+                {id: '2', a: {a: 'A'}},
+                {id: '3', a: {a: null}},
+                {id: '4', a: null}
+            ]
+        })
+    })
+
+    it('can fetch deep entities', function () {
+        return client.test(`
+            query {
+                entities(orderBy: id_ASC) { 
+                    id 
+                    a { 
+                        b {
+                            e {
+                                id
+                                a {
+                                    b {
+                                        b
+                                        e { id }
+                                    }
+                                }
+                            }
+                        }
+                    } 
+                }
+            }
+        `, {
+            entities: [
+                {id: '1', a: {b: {e: {id: '1', a: {b: {b: 'b', e: {id: '1'}}}}}}},
+                {id: '2', a: {b: {e: {id: '1', a: {b: {b: 'b', e: {id: '1'}}}}}}},
+                {id: '3', a: {b: null}},
+                {id: '4', a: null}
+            ]
+        })
+    })
+})

package/src/test/unions.test.ts

@@ -0,0 +1,85 @@
+import {useDatabase, useServer} from "./util/setup"
+
+describe('unions', function () {
+    useDatabase([
+        `create table "user" (id text primary key, login text)`,
+        `create table equipment (id text primary key, name text, owner jsonb)`,
+        `insert into "user" (id, login) values ('1', 'farmer')`,
+        `insert into "user" (id, login) values ('2', 'programmer')`,
+        `insert into equipment (id, name, owner) values ('1', 'combine', '{"isTypeOf": "Farmer", "user": "1", "crop": 100}'::jsonb)`,
+        `insert into equipment (id, name, owner) values ('2', 'computer', '{"isTypeOf": "Programmer", "user": "2", "stack": "Python"}'::jsonb)`
+    ])
+
+    const client = useServer(`
+        type User @entity {
+            id: ID!
+            login: String!
+        }
+        
+        type Farmer {
+            user: User!
+            crop: Int
+        }
+        
+        type Programmer {
+            user: User!
+            stack: String
+        }
+        
+        union Owner = Farmer | Programmer
+        
+        type Equipment @entity {
+            name: String!
+            owner: Owner!
+        }
+    `)
+
+    it('output', function () {
+        return client.test(`
+            query {
+                equipment(orderBy: id_ASC) {
+                    name
+                    owner {
+                        ... on Farmer {
+                            user { login }
+                            crop
+                        }
+                        ... on Programmer {
+                            user { login }
+                            stack
+                        }
+                    }
+                }
+            }
+        `, {
+            equipment: [
+                {
+                    name: 'combine',
+                    owner: {
+                        user: {login: 'farmer'},
+                        crop: 100
+                    }
+                },
+                {
+                    name: 'computer',
+                    owner: {
+                        user: {login: 'programmer'},
+                        stack: 'Python'
+                    }
+                }
+            ]
+        })
+    })
+
+    it('filtering', function () {
+        return client.test(`
+            query {
+                type_farmer:  equipment(where: {owner: {isTypeOf_eq: "Farmer"}}) { id }
+                stack_Python: equipment(where: {owner: {stack_eq:    "Python"}}) { id }
+            }
+        `, {
+            type_farmer: [{id: '1'}],
+            stack_Python: [{id: '2'}]
+        })
+    })
+})

package/src/test/util/setup.ts

@@ -0,0 +1,63 @@
+import {Client} from "gql-test-client"
+import {parse} from "graphql"
+import {Client as PgClient, ClientBase, Pool} from "pg"
+import {createPoolConfig} from "../../db"
+import {buildModel, buildSchema} from "../../gql/schema"
+import {ListeningServer, serve} from "../../server"
+
+
+export const db_config = createPoolConfig()
+
+
+async function withClient(block: (client: ClientBase) => Promise<void>): Promise<void> {
+    let client = new PgClient(db_config)
+    await client.connect()
+    try {
+        await block(client)
+    } finally {
+        await client.end()
+    }
+}
+
+
+export function databaseInit(sql: string[]): Promise<void> {
+    return withClient(async client => {
+        for (let i = 0; i < sql.length; i++) {
+            await client.query(sql[i])
+        }
+    })
+}
+
+
+export function databaseDelete(): Promise<void> {
+    return withClient(async client => {
+        await client.query(`DROP SCHEMA IF EXISTS public CASCADE`)
+        await client.query(`CREATE SCHEMA public`)
+    })
+}
+
+
+export function useDatabase(sql: string[]): void {
+    before(async () => {
+        await databaseDelete()
+        await databaseInit(sql)
+    })
+}
+
+
+export function useServer(schema: string): Client {
+    let client = new Client('not defined')
+    let db = new Pool(db_config)
+    let info: ListeningServer | undefined
+    before(async () => {
+        info = await serve({
+            db,
+            model: buildModel(buildSchema(parse(schema))),
+            port: 0
+        })
+        client.endpoint = `http://localhost:${info.port}/graphql`
+    })
+    after(() => info?.stop())
+    after(() => db.end())
+    return client
+}