@subsquid/openreader 0.2.0 → 0.3.3

package/src/scalars.ts

@@ -0,0 +1,247 @@
+/**
+ * The current concept of custom scalars is as follows:
+ *
+ * Each custom scalar has a canonical string representation which is used almost everywhere:
+ *    in JSON responses
+ *    in graphql queries/schemas
+ *    in jsonb database columns
+ *    in database results
+ *
+ * Database must support 2 way coercion between underlying database type and canonical representation
+ * of a corresponding scalar.
+ *
+ * We receive from database canonical strings and use them within our resolvers as is.
+ *
+ * GraphQL parsing procedures convert canonical string representation to corresponding js type.
+ * This is for compatibility with possible extensions which would like to reuse our scalars.
+ *
+ * In GraphQL serialization procedures we accept both a canonical string representation
+ * and corresponding js type.
+ */
+
+import {GraphQLScalarType} from "graphql"
+
+
+export interface Scalar {
+    gql: GraphQLScalarType
+    fromStringCast: (sqlExp: string) => string
+    toStringCast: (sqlExp: string) => string
+    toStringArrayCast: (sqlExp: string) => string
+}
+
+
+export const scalars: Record<string, Scalar> = {
+    BigInt: {
+        gql: new GraphQLScalarType({
+            name: 'BigInt',
+            description: 'Big number integer',
+            serialize(value: number | string | bigint) {
+                return ''+value
+            },
+            parseValue(value: string) {
+                if (!isBigInt(value)) throw invalidFormat('BigInt', value)
+                return BigInt(value)
+            },
+            parseLiteral(ast) {
+                switch(ast.kind) {
+                    case "StringValue":
+                        if (isBigInt(ast.value)) {
+                            return BigInt(ast.value)
+                        } else {
+                            throw invalidFormat('BigInt', ast.value)
+                        }
+                    case "IntValue":
+                        return BigInt(ast.value)
+                    default:
+                        return null
+                }
+            }
+        }),
+        fromStringCast(exp) {
+            return `(${exp})::numeric`
+        },
+        toStringCast(exp) {
+            return `(${exp})::text`
+        },
+        toStringArrayCast(exp) {
+            return `(${exp})::text[]`
+        }
+    },
+    DateTime: {
+        gql: new GraphQLScalarType({
+            name: 'DateTime',
+            description:
+                'A date-time string in simplified extended ISO 8601 format (YYYY-MM-DDTHH:mm:ss.sssZ)',
+            serialize(value: Date | string) {
+                if (value instanceof Date) {
+                    return value.toISOString()
+                } else {
+                    if (!isIsoDateTimeString(value)) throw invalidFormat('DateTime', value)
+                    return value
+                }
+            },
+            parseValue(value: string) {
+                return parseDateTime(value)
+            },
+            parseLiteral(ast) {
+                switch(ast.kind) {
+                    case "StringValue":
+                        return parseDateTime(ast.value)
+                    default:
+                        return null
+                }
+            }
+        }),
+        fromStringCast(exp) {
+            return `(${exp})::timestamptz`
+        },
+        toStringCast(exp) {
+            return `to_char((${exp}) at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`
+        },
+        toStringArrayCast(exp) {
+            return `array(select to_char(i at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"') from unnest(${exp}) as i)`
+        }
+    },
+    Bytes: {
+        gql: new GraphQLScalarType({
+            name: 'Bytes',
+            description: 'Binary data encoded as a hex string always prefixed with 0x',
+            serialize(value: string | Buffer) {
+                if (typeof value == 'string') {
+                    if (!isBytesString(value)) throw invalidFormat('Bytes', value)
+                    return value.toLowerCase()
+                } else {
+                    return '0x' + value.toString('hex')
+                }
+            },
+            parseValue(value: string) {
+                return parseBytes(value)
+            },
+            parseLiteral(ast) {
+                switch(ast.kind) {
+                    case "StringValue":
+                        return parseBytes(ast.value)
+                    default:
+                        return null
+                }
+            }
+        }),
+        fromStringCast(exp) {
+            return `decode(substr(${exp}, 3), 'hex')`
+        },
+        toStringCast(exp) {
+            return `'0x' || encode(${exp}, 'hex')`
+        },
+        toStringArrayCast(exp) {
+            return `array(select '0x' || encode(i, 'hex') from unnest(${exp}) as i)`
+        }
+    }
+}
+
+
+function isBigInt(s: string): boolean {
+    return /^[+\-]?\d+$/.test(s)
+}
+
+
+// credit - https://github.com/Urigo/graphql-scalars/blob/91b4ea8df891be8af7904cf84751930cc0c6613d/src/scalars/iso-date/validator.ts#L122
+const RFC_3339_REGEX = /^(\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60))(\.\d{1,})?([Z])$/
+
+
+function isIsoDateTimeString(s: string): boolean {
+    return RFC_3339_REGEX.test(s)
+}
+
+
+function parseDateTime(s: string): Date {
+    if (!isIsoDateTimeString(s)) throw invalidFormat('DateTime', s)
+    let timestamp = Date.parse(s)
+    if (isNaN(timestamp)) throw invalidFormat('DateTime', s)
+    return new Date(timestamp)
+}
+
+
+function isBytesString(s: string): boolean {
+    return s.length % 2 == 0 && /^0x[a-f0-9]+$/i.test(s)
+}
+
+
+function parseBytes(s: string): Buffer {
+    if (!isBytesString(s)) throw invalidFormat('Bytes', s)
+    return Buffer.from(s.slice(2), 'hex')
+}
+
+
+function invalidFormat(type: string, value: string): Error {
+    return new TypeError(`Not a ${type}: ${value}`)
+}
+
+
+export const scalars_list = ['ID'].concat(Object.keys(scalars))
+
+
+export function getScalarResolvers(): Record<string, GraphQLScalarType> {
+    let resolvers: Record<string, GraphQLScalarType> = {}
+    for (let type in scalars) {
+        resolvers[type] = scalars[type].gql
+    }
+    return resolvers
+}
+
+
+export function toOutputCast(scalarType: string, sqlExp: string): string {
+    let s = scalars[scalarType]
+    if (s) {
+        return s.toStringCast(sqlExp)
+    } else {
+        return sqlExp
+    }
+}
+
+
+export function fromStringCast(scalarType: string, sqlExp: string): string {
+    let s = scalars[scalarType]
+    if (s) {
+        return s.fromStringCast(sqlExp)
+    } else {
+        return sqlExp
+    }
+}
+
+
+export function toOutputArrayCast(scalarType: string, sqlExp: string): string {
+    let s = scalars[scalarType]
+    if (s) {
+        return s.toStringArrayCast(sqlExp)
+    } else {
+        return sqlExp
+    }
+}
+
+
+export function fromJsonCast(scalarType: string, objSqlExp: string, prop: string): string {
+    switch(scalarType) {
+        case 'Int':
+            return `(${objSqlExp}->'${prop}')::integer`
+        case 'Float':
+            return `(${objSqlExp}->'${prop}')::numeric`
+        case 'Boolean':
+            return `(${objSqlExp}->'${prop}')::bool`
+        default:
+            return fromStringCast(scalarType, `${objSqlExp}->>'${prop}'`)
+    }
+}
+
+
+export function fromJsonToOutputCast(scalarType: string, objSqlExp: string, prop: string) {
+    switch(scalarType) {
+        case 'Int':
+            return `(${objSqlExp}->'${prop}')::integer`
+        case 'Float':
+            return `(${objSqlExp}->'${prop}')::numeric`
+        case 'Boolean':
+            return `(${objSqlExp}->'${prop}')::bool`
+        default:
+            return `${objSqlExp}->>'${prop}'`
+    }
+}

package/src/server.ts

@@ -0,0 +1,115 @@
+import {ApolloServerPluginDrainHttpServer} from "apollo-server-core"
+import {ApolloServer} from "apollo-server-express"
+import assert from "assert"
+import express from "express"
+import fs from "fs"
+import http from "http"
+import path from "path"
+import type {Pool} from "pg"
+import {PoolTransaction} from "./db"
+import {buildServerSchema} from "./gql/opencrud"
+import type {Model} from "./model"
+import {buildResolvers} from "./resolver"
+
+
+export interface ListeningServer {
+    readonly port: number
+    stop(): Promise<void>
+}
+
+
+export interface ServerOptions {
+    model: Model
+    db: Pool
+    port: number | string
+    graphiqlConsole?: boolean
+}
+
+
+export async function serve(options: ServerOptions): Promise<ListeningServer> {
+    let {model, db} = options
+    let resolvers = buildResolvers(model)
+    let typeDefs = buildServerSchema(model)
+    let app = express()
+    let server = http.createServer(app)
+
+    let apollo = new ApolloServer({
+        typeDefs,
+        resolvers,
+        context: () => ({openReaderTransaction: new PoolTransaction(db)}),
+        plugins: [
+            {
+                async requestDidStart() {
+                    return {
+                        willSendResponse(req: any) {
+                            return req.context.openReaderTransaction.close()
+                        }
+                    }
+                }
+            },
+            ApolloServerPluginDrainHttpServer({httpServer: server})
+        ]
+    })
+
+    if (options.graphiqlConsole !== false) {
+        setupGraphiqlConsole(app)
+    }
+
+    await apollo.start()
+    apollo.applyMiddleware({app})
+    return listen(apollo, server, options.port)
+}
+
+
+export function listen(apollo: ApolloServer, server: http.Server, port: number | string): Promise<ListeningServer> {
+    return new Promise((resolve, reject) => {
+        function onerror(err: Error) {
+            cleanup()
+            reject(err)
+        }
+
+        function onlistening() {
+            cleanup()
+            let address = server.address()
+            assert(address != null && typeof address == 'object')
+            resolve({
+                port: address.port,
+                stop: () => apollo.stop()
+            })
+        }
+
+        function cleanup() {
+            server.removeListener('error', onerror)
+            server.removeListener('listening', onlistening)
+        }
+
+        server.on('error', onerror)
+        server.on('listening', onlistening)
+        server.listen(port)
+    })
+}
+
+
+export function setupGraphiqlConsole(app: express.Application): void {
+    let assets = path.join(
+        require.resolve('@subsquid/graphiql-console/package.json'),
+        '../build'
+    )
+
+    let indexHtml = fs.readFileSync(path.join(assets, 'index.html'), 'utf-8')
+        .replace(/\/static\//g, 'console/static/')
+        .replace('/manifest.json', 'console/manifest.json')
+        .replace('${GRAPHQL_API}', 'graphql')
+        .replace('${APP_TITLE}', 'Query node playground')
+
+    app.use('/console', express.static(assets))
+
+    app.use('/graphql', (req, res, next) => {
+        if (req.path != '/') return next()
+        if (req.method != 'GET' && req.method != 'HEAD') return next()
+        if (req.query['query']) return next()
+        res.vary('Accept')
+        if (!req.accepts('html')) return next()
+        res.type('html').send(indexHtml)
+    })
+}

package/src/test/basic.test.ts

@@ -0,0 +1,339 @@
+import {useDatabase, useServer} from "./util/setup"
+
+
+describe('basic tests', function() {
+    useDatabase([
+        `create table account (id text primary key, wallet text, balance numeric)`,
+        `create table historical_balance (id text primary key, account_id text references account(id), balance numeric)`,
+        `insert into account (id, wallet, balance) values ('1', 'a', 100)`,
+        `insert into account (id, wallet, balance) values ('2', 'b', 200)`,
+        `insert into account (id, wallet, balance) values ('3', 'c', 300)`,
+        `insert into historical_balance (id, account_id, balance) values ('1-1', '1', 20)`,
+        `insert into historical_balance (id, account_id, balance) values ('1-2', '1', 80)`,
+        `insert into historical_balance (id, account_id, balance) values ('2-1', '2', 50)`,
+        `insert into historical_balance (id, account_id, balance) values ('2-2', '2', 90)`,
+        `insert into historical_balance (id, account_id, balance) values ('2-3', '2', 60)`,
+        `insert into historical_balance (id, account_id, balance) values ('3-1', '3', 300)`,
+    ])
+
+    const client = useServer(`
+        interface HasBalance {
+            balance: Int!
+        }
+    
+        type Account implements HasBalance @entity {
+            id: ID!
+            wallet: String!
+            balance: Int!
+            history: [HistoricalBalance!] @derivedFrom(field: "account")
+        }
+
+        "Historical record of account balance"
+        type HistoricalBalance implements HasBalance @entity {
+            "Unique identifier"
+            id: ID!
+            
+            "Related account"
+            account: Account!
+            
+            "Balance"
+            balance: Int!
+        }
+    `)
+
+    it('can fetch all accounts', function() {
+        return client.test(
+            `query {
+                accounts {
+                    id
+                    wallet
+                    balance
+                    history { balance }
+                }
+            }`,
+            {
+                accounts: [
+                    {id: '1', wallet: 'a', balance: 100, history: [{balance: 20}, {balance: 80}]},
+                    {id: '2', wallet: 'b', balance: 200, history: [{balance: 50}, {balance: 90}, {balance: 60}]},
+                    {id: '3', wallet: 'c', balance: 300, history: [{balance: 300}]},
+                ]
+            }
+        )
+    })
+
+    it('supports filtering by id', function () {
+        return client.test(
+            `query {
+                accounts(where: {id_eq: "3"}) {
+                    id
+                    wallet
+                }
+            }`,
+            {
+                accounts: [{id: '3', wallet: 'c'}]
+            }
+        )
+    })
+
+    it('supports by id query', function () {
+        return client.test(
+            `query {
+                a3: accountById(id: "3") {
+                    id
+                    wallet
+                }
+                nonexistent: accountById(id: "foo") {
+                    id
+                    wallet
+                }
+            }`,
+            {
+                a3: {id: '3', wallet: 'c'},
+                nonexistent: null
+            }
+        )
+    })
+
+    it('supports by unique input query', function () {
+        return client.test(
+            `query {
+                a2: accountByUniqueInput(where: {id: "2"}) {
+                    id
+                    wallet
+                }
+                nonexistent: accountByUniqueInput(where: {id: "foo"}) {
+                    id
+                    wallet
+                }
+            }`,
+            {
+                a2: {id: '2', wallet: 'b'},
+                nonexistent: null
+            }
+        )
+    })
+
+    it('can fetch deep relations', function () {
+        return client.test(
+            `query {
+                accounts(where: {id_eq: "3"}) {
+                    id
+                    history {
+                        id
+                        account {
+                            wallet
+                            history {
+                                balance
+                                account {
+                                    id
+                                }
+                            }
+                        }
+                    }
+                }
+            }`,
+            {
+                accounts: [{
+                    id: '3',
+                    history: [{
+                        id: '3-1',
+                        account: {
+                            wallet: 'c',
+                            history: [{
+                                balance: 300,
+                                account: {
+                                    id: '3'
+                                }
+                            }]
+                        }
+                    }]
+                }]
+            }
+        )
+    })
+
+    it('supports *_some filter', function () {
+        return client.test(
+            `query {
+                accounts(where: {history_some: {balance_lt: 50}}) {
+                    id
+                }
+            }`,
+            {
+                accounts: [{id: '1'}]
+            }
+        )
+    })
+
+    it('supports *_every filter', function () {
+        return client.test(
+            `query {
+                accounts(where: {history_every: {balance_gt: 20}}) {
+                    wallet
+                }
+            }`,
+            {
+                accounts: [{wallet: 'b'}, {wallet: 'c'}]
+            }
+        )
+    })
+
+    it('supports *_none filter', function () {
+        return client.test(
+            `query {
+                accounts(where: {history_none: {balance_lt: 60}}) {
+                    wallet
+                }
+            }`,
+            {
+                accounts: [{wallet: 'c'}]
+            }
+        )
+    })
+
+    it('supports gql aliases', function () {
+        return client.test(
+            `query {
+                accounts(where: {id_eq: "1"}) {
+                    balance
+                    bag: wallet
+                    purse: wallet
+                    payment1: history(where: {id_eq: "1-1"}) {
+                        balance
+                    }
+                    payment2: history(where: {id_eq: "1-2"}) {
+                        balance
+                    }
+                }
+            }`,
+            {
+                accounts: [{
+                    balance: 100,
+                    bag: 'a',
+                    purse: 'a',
+                    payment1: [{balance: 20}],
+                    payment2: [{balance: 80}]
+                }]
+            }
+        )
+    })
+
+    it('supports gql fragments', function () {
+        return client.test(
+            `query {
+                accounts(where: {id_eq: "1"}) {
+                    ...accountFields
+                    history {
+                        ...historicalBalance
+                    }
+                }
+            }
+            
+            fragment accountFields on Account {
+                id
+                wallet
+            }
+            
+            fragment historicalBalance on HistoricalBalance {
+                balance
+            }`,
+            {
+                accounts: [{
+                    id: '1',
+                    wallet: 'a',
+                    history: [{balance: 20}, {balance: 80}]
+                }]
+            }
+        )
+    })
+
+    it('supports gql fragments on interfaces', function () {
+        return client.test(
+            `query {
+                accounts(where: {id_eq: "1"}) {
+                    ...balance
+                    history {
+                        ...balance
+                    }
+                }
+            }
+            
+            fragment balance on HasBalance {
+                ... on Account {
+                    accountBalance: balance
+                }
+                ... on HistoricalBalance {
+                    payment: balance
+                }
+            }`,
+            {
+                accounts: [{
+                    accountBalance: 100,
+                    history: [{payment: 20}, {payment: 80}]
+                }]
+            }
+        )
+    })
+
+    it('supports sorting', function () {
+        return client.test(
+            `query {
+                historicalBalances(orderBy: balance_ASC) {
+                    balance
+                }
+            }`,
+            {
+                historicalBalances: [
+                    {balance: 20},
+                    {balance: 50},
+                    {balance: 60},
+                    {balance: 80},
+                    {balance: 90},
+                    {balance: 300}
+                ]
+            }
+        )
+    })
+
+    it('supports sorting by referenced entity field', function () {
+        return client.test(
+            `query {
+                historicalBalances(orderBy: [account_wallet_ASC, balance_DESC]) {
+                    balance
+                }
+            }`,
+            {
+                historicalBalances: [
+                    {balance: 80},
+                    {balance: 20},
+                    {balance: 90},
+                    {balance: 60},
+                    {balance: 50},
+                    {balance: 300}
+                ]
+            }
+        )
+    })
+
+    it('supports descriptions', function () {
+        return client.test(`
+            query {
+                HistoricalBalance: __type(name: "HistoricalBalance") {
+                    description
+                    fields {
+                        description
+                    }
+                }
+            }
+        `, {
+            HistoricalBalance: {
+                description: 'Historical record of account balance',
+                fields: [
+                    {description: 'Unique identifier'},
+                    {description: 'Related account'},
+                    {description: 'Balance'},
+                ]
+            }
+        })
+    })
+})