@subsquid/openreader 1.0.1 → 2.0.0

package/src/sql/query.ts

@@ -0,0 +1,194 @@
+import {assertNotNull} from "@subsquid/util-internal"
+import assert from "assert"
+import type {Dialect} from "../dialect"
+import type {EntityListArguments, Where} from "../ir/args"
+import {
+    decodeRelayConnectionCursor,
+    encodeRelayConnectionCursor,
+    RelayConnectionEdge,
+    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"
+
+
+export interface Query<T> {
+    readonly sql: string
+    readonly params: unknown[]
+    map(rows: any[][]): T
+}
+
+
+export class EntityListQuery implements Query<any[]> {
+    public readonly sql: string
+    public readonly params: unknown[] = []
+
+    constructor(
+        model: Model,
+        dialect: Dialect,
+        entityName: string,
+        private fields: FieldRequest[],
+        args: EntityListArguments
+    ) {
+        this.sql = new EntityListQueryPrinter(model, dialect, entityName, this.params, args, fields).print()
+    }
+
+    map(rows: any[][]): any[] {
+        return mapRows(rows, this.fields)
+    }
+}
+
+
+export class EntityByIdQuery {
+    public readonly sql: string
+    public readonly params: unknown[] = []
+
+    constructor(
+        model: Model,
+        dialect: Dialect,
+        entityName: string,
+        private fields: FieldRequest[],
+        id: string
+    ) {
+        this.sql = new EntityListQueryPrinter(
+            model,
+            dialect,
+            entityName,
+            this.params,
+            {where: {op: 'eq', field: 'id', value: id}},
+            fields
+        ).print()
+    }
+
+    map(rows: any[][]): any {
+        assert(rows.length < 2)
+        return mapRows(rows, this.fields)[0]
+    }
+}
+
+
+export class EntityCountQuery implements Query<number> {
+    public readonly sql: string
+    public readonly params: unknown[] = []
+
+    constructor(
+        model: Model,
+        dialect: Dialect,
+        entityName: string,
+        where?: Where
+    ) {
+        this.sql = 'SELECT count(*) ' + new EntityListQueryPrinter(model, dialect, entityName, this.params, {where}).printFrom()
+    }
+
+    map(rows: any[][]): number {
+        return toCount(rows)
+    }
+}
+
+
+export class EntityConnectionQuery implements Query<RelayConnectionResponse> {
+    public readonly sql: string
+    public readonly params: unknown[] = []
+    private offset = 0
+    private limit = 100
+    private edgeNode?: FieldRequest[]
+    private edgeCursor?: boolean
+    private pageInfo?: boolean
+    private totalCount?: boolean
+
+    constructor(
+        model: Model,
+        dialect: Dialect,
+        entityName: string,
+        req: RelayConnectionRequest
+    ) {
+        this.setOffsetAndLimit(req)
+        this.edgeCursor = req.edgeCursor
+        this.pageInfo = req.pageInfo
+        this.totalCount = req.totalCount
+
+        let printer = new EntityListQueryPrinter(model, dialect, entityName, this.params, {
+            orderBy: req.orderBy,
+            where: req.where,
+            offset: this.offset,
+            limit: this.limit + 1
+        }, req.edgeNode)
+
+        if (req.edgeNode?.length) {
+            this.edgeNode = req.edgeNode
+            this.sql = printer.print()
+        } else {
+            this.sql = `SELECT count(*) FROM (SELECT true ${printer.printFrom()}) AS rows`
+        }
+    }
+
+    private setOffsetAndLimit(req: RelayConnectionRequest): void {
+        if (req.after != null) {
+            this.offset = assertNotNull(decodeRelayConnectionCursor(req.after))
+        }
+        if (req.first != null) {
+            assert(req.first >= 0)
+            this.limit = req.first
+        }
+    }
+
+    map(rows: any[][]): RelayConnectionResponse {
+        let res: RelayConnectionResponse = {}
+        if (this.edgeNode) {
+            let nodes = mapRows(rows, this.edgeNode)
+            let edges: RelayConnectionEdge[] = new Array(Math.min(this.limit, nodes.length))
+            for (let i = 0; i < edges.length; i++) {
+                edges[i] = {
+                    node: nodes[i],
+                    cursor: this.edgeCursor ? encodeRelayConnectionCursor(this.offset + i + 1) : undefined
+                }
+            }
+            res.edges = edges
+            res.pageInfo = this.getPageInfo(nodes.length)
+            res.totalCount = this.getTotalCount(nodes.length)
+        } else {
+            let count = toCount(rows)
+            if (this.edgeCursor) {
+                res.edges = new Array(Math.min(this.limit, count))
+                for (let i = 0; i < res.edges.length; i++) {
+                    res.edges[i] = {
+                        cursor: encodeRelayConnectionCursor(this.offset + i + 1)
+                    }
+                }
+            }
+            res.pageInfo = this.getPageInfo(count)
+            res.totalCount = this.getTotalCount(count)
+        }
+        return res
+    }
+
+    private getPageInfo(count: number): Partial<RelayConnectionPageInfo> | undefined {
+        if (!this.pageInfo) return
+        return {
+            hasNextPage: count > this.limit,
+            hasPreviousPage: count > 0 && this.offset > 0,
+            startCursor: count > 0 ? encodeRelayConnectionCursor(this.offset + 1) : '',
+            endCursor: count > 0 ? encodeRelayConnectionCursor(this.offset + Math.min(this.limit, count)) : ''
+        }
+    }
+
+    private getTotalCount(count: number): number | undefined {
+        if (!this.totalCount) return
+        if (count > 0 && count <= this.limit) {
+            return this.offset + count
+        } else {
+            return undefined
+        }
+    }
+}
+
+
+function toCount(rows: any[][]): number {
+    assert(rows.length == 1)
+    return toSafeInteger(rows[0][0])
+}

package/src/sql/util.ts

@@ -0,0 +1,89 @@
+import type {Dialect} from "../dialect"
+
+
+export function escapeIdentifier(dialect: Dialect, name: string): string {
+    return `"${name.replace(/"/g, '""')}"`
+}
+
+
+export class ColumnSet {
+    private columns: Map<string, number> = new Map()
+
+    add(column: string): number {
+        let idx = this.columns.get(column)
+        if (idx == null) {
+            idx = this.columns.size
+            this.columns.set(column, idx)
+        }
+        return idx
+    }
+
+    names(): string[] {
+        return [...this.columns.keys()]
+    }
+
+    size(): number {
+        return this.columns.size
+    }
+}
+
+
+/**
+ * LEFT OUTER JOIN "{table}" "{alias}" ON "{alias}"."{column}" = {rhs}
+ */
+export interface Join {
+    table: string
+    alias: string
+    column: string
+    rhs: string
+}
+
+
+export class JoinSet {
+    private joins: Map<string, Join> = new Map()
+
+    constructor(private aliases: AliasSet) {
+    }
+
+    add(table: string, column: string, rhs: string): string {
+        let key = `${table} ${column} ${rhs}`
+        let e = this.joins.get(key)
+        if (!e) {
+            e = {
+                table,
+                alias: this.aliases.add(table),
+                column,
+                rhs
+            }
+            this.joins.set(key, e)
+        }
+        return e.alias
+    }
+
+    forEach(cb: (join: Join) => void): void {
+        this.joins.forEach(join => cb(join))
+    }
+}
+
+
+export class AliasSet {
+    private aliases: Record<string, number> = {}
+
+    add(name: string): string {
+        if (this.aliases[name]) {
+            return name + "_" + (this.aliases[name]++)
+        } else {
+            this.aliases[name] = 1
+            return name
+        }
+    }
+}
+
+
+export function printClause(op: string, exps: string[]): string {
+    switch(exps.length) {
+        case 0: return ''
+        case 1: return exps[0]
+        default: return exps.join(' ' + op + ' ')
+    }
+}

package/src/subscription.ts

@@ -0,0 +1,46 @@
+import deepEqual from "deep-equal"
+
+
+export class Subscription<T> implements AsyncIterator<T>, AsyncIterable<T> {
+    private timer?: NodeJS.Timer
+    private prev?: T
+    private hasNoVal = true
+
+    constructor(private interval: number, private poll: () => Promise<T>) {}
+
+    [Symbol.asyncIterator]() {
+        return this
+    }
+
+    async next() {
+        if (this.hasNoVal) {
+            this.prev = await this.poll()
+            this.hasNoVal = false
+        }
+        let value
+        do {
+            await new Promise(resolve => {
+                this.timer = setTimeout(resolve, this.interval)
+            })
+            value = await this.poll()
+        } while (deepEqual(this.prev, value))
+        this.prev = value
+        return {done: false, value}
+    }
+
+    async return() {
+        if (this.timer != null) {
+            clearTimeout(this.timer)
+            this.timer = undefined
+        }
+        return EOS
+    }
+}
+
+
+const EOS = {
+    done: true,
+    get value(): any {
+        throw new Error('Unexpected value access')
+    }
+}

package/src/test/fts.test.ts

@@ -6,7 +6,7 @@ function tsvector(columns: string[]) {
 }
 
 
-isCockroach() || describe('full text search', function () {
+isCockroach() || describe.skip('full text search', function () {
     useDatabase([
         `create table foo (
             id text primary key, 

package/src/test/setup.ts

@@ -1,9 +1,10 @@
 import {assertNotNull} from "@subsquid/util-internal"
+import {ListeningServer} from "@subsquid/util-internal-http-server"
 import {Client} from "gql-test-client"
 import {parse} from "graphql"
 import {Client as PgClient, ClientBase, Pool} from "pg"
-import {buildModel, buildSchema} from "../gql/schema"
-import {ListeningServer, serve} from "../server"
+import {buildModel, buildSchema} from "../model.schema"
+import {serve} from "../server"
 
 
 export function isCockroach(): boolean {
@@ -22,7 +23,7 @@ export const db_config = {
 }
 
 
-async function withClient(block: (client: ClientBase) => Promise<void>): Promise<void> {
+export async function withDatabase(block: (client: ClientBase) => Promise<void>): Promise<void> {
     let client = new PgClient(db_config)
     await client.connect()
     try {
@@ -33,8 +34,8 @@ async function withClient(block: (client: ClientBase) => Promise<void>): Promise
 }
 
 
-export function databaseInit(sql: string[]): Promise<void> {
-    return withClient(async client => {
+export function databaseExecute(sql: string[]): Promise<void> {
+    return withDatabase(async client => {
         for (let i = 0; i < sql.length; i++) {
             await client.query(sql[i])
         }
@@ -43,7 +44,7 @@ export function databaseInit(sql: string[]): Promise<void> {
 
 
 export function databaseDelete(): Promise<void> {
-    return withClient(async client => {
+    return withDatabase(async client => {
         await client.query(`DROP SCHEMA IF EXISTS root CASCADE`)
         await client.query(`CREATE SCHEMA root`)
     })
@@ -53,7 +54,7 @@ export function databaseDelete(): Promise<void> {
 export function useDatabase(sql: string[]): void {
     before(async () => {
         await databaseDelete()
-        await databaseInit(sql)
+        await databaseExecute(sql)
     })
 }
 
@@ -64,14 +65,15 @@ export function useServer(schema: string): Client {
     let info: ListeningServer | undefined
     before(async () => {
         info = await serve({
-            db,
+            connection: db,
             model: buildModel(buildSchema(parse(schema))),
             port: 0,
-            dialect: isCockroach() ? 'cockroach' : 'postgres'
+            dialect: isCockroach() ? 'cockroach' : 'postgres',
+            subscriptions: true
         })
         client.endpoint = `http://localhost:${info.port}/graphql`
     })
-    after(() => info?.stop())
+    after(() => info?.close())
     after(() => db.end())
     return client
 }

package/src/test/subscription.test.ts

@@ -0,0 +1,98 @@
+import {wait} from "@subsquid/util-internal"
+import expect from "expect"
+import {databaseExecute, useDatabase, useServer} from "./setup"
+
+
+describe("subscriptions", function() {
+    useDatabase([
+        `create table "order" (id text primary key, kind text not null, name text)`,
+        `create table item (id text primary key, order_id text, name text)`,
+    ])
+
+    const client = useServer(`
+        type Order @entity {
+            id: ID!
+            kind: String!
+            name: String
+            items: [Item!]! @derivedFrom(field: "order")
+        }
+        
+        type Item @entity {
+            id: ID!
+            order: Order
+            name: String
+        }
+    `)
+
+    it("entity list", function() {
+        return client.subscriptionTest(`
+            subscription {
+                orders(where: {kind_eq: "list"}, orderBy: id_ASC) {
+                    id
+                    name
+                    items(orderBy: id_ASC) {
+                        name
+                    }
+                }
+            }
+        `, async take => {
+            await wait(1000)
+            await databaseExecute([
+                `insert into "order" (id, kind) values ('1', 'list')`,
+                `insert into "order" (id, kind) values ('2', 'foo')`,
+            ])
+            expect(await take()).toEqual({
+                data: {
+                    orders: [{id: '1', name: null, items: []}]
+                }
+            })
+            await databaseExecute([`
+                update "order" set name = 'hello' where id in ('1', '2');
+                insert into item (id, "order_id", name) values ('1-1', '1', '123')
+            `])
+            expect(await take()).toEqual({
+                data: {
+                    orders: [
+                        {id: '1', name: 'hello', items: [{name: '123'}]}
+                    ]
+                }
+            })
+        })
+    })
+
+    it("entity by id", async function() {
+        await databaseExecute([
+            `insert into "order" (id, kind) values ('3', 'by id')`,
+            `insert into item (id, "order_id", name) values ('3-1', '3', 'hello')`
+        ])
+        await client.subscriptionTest(`
+            subscription {
+                third: orderById(id: "3") {
+                    name
+                    items(orderBy: id_ASC) {
+                        name
+                    }
+                }
+            }
+        `, async take => {
+            await wait(1000)
+            await databaseExecute([`
+                start transaction;
+                update "order" set name = 'foo' where id = '3';
+                insert into item (id, "order_id", name) values ('3-2', '3', 'world');
+                commit;
+            `])
+            expect(await take()).toEqual({
+                data: {
+                    third: {
+                        name: 'foo',
+                        items: [
+                            {name: 'hello'},
+                            {name: 'world'}
+                        ]
+                    }
+                }
+            })
+        })
+    })
+})

package/src/tools.ts

@@ -3,7 +3,7 @@ import * as fs from "fs"
 import * as path from "path"
 import {parse, Source} from "graphql"
 import process from "process"
-import {buildModel, buildSchema} from "./gql/schema"
+import {buildModel, buildSchema} from "./model.schema"
 import type {Model} from "./model"
 
 

package/src/util/error-handling.ts

@@ -0,0 +1,40 @@
+import {Logger, LogLevel} from "@subsquid/logger"
+import {GraphQLError, printError} from "graphql"
+
+
+export function logGraphQLError(log: Logger, err: GraphQLError, level: LogLevel = LogLevel.ERROR): void {
+    if (log.level > level) return
+    let msg = printError(err) + '\n'
+    log.write(level, {
+        graphqlOriginalError: err.originalError,
+        graphqlPath: err.path?.join('.'),
+        graphqlQuery: err.source?.body,
+    }, msg)
+}
+
+
+export function withErrorContext(ctx: object): (err: unknown) => never {
+    return function(err): never {
+        throw addErrorContext(err, ctx)
+    }
+}
+
+
+export function addErrorContext(error: unknown, ctx: object): Error {
+    let e = ensureError(error)
+    Object.assign(e, ctx)
+    return e
+}
+
+
+export function ensureError(err: unknown): Error {
+    if (err instanceof Error) return err
+    return new NonErrorThrown(err)
+}
+
+
+export class NonErrorThrown extends Error {
+    constructor(public readonly value: unknown) {
+        super('Non error object thrown')
+    }
+}

package/src/util/lazy-transaction.ts

@@ -0,0 +1,49 @@
+interface Tx<T> {
+    close(): void
+    ctx: T
+}
+
+
+export class LazyTransaction<T> {
+    private closed = false
+
+    private tx?: Promise<Tx<T>>
+
+    constructor(private transact: (f: (ctx: T) => Promise<void>) => Promise<void>) {
+    }
+
+    async get(): Promise<T> {
+        if (this.closed) {
+            throw new Error("Too late to request transaction")
+        }
+        this.tx = this.tx || this.startTransaction()
+        let {ctx} = await this.tx
+        return ctx
+    }
+
+    private async startTransaction(): Promise<Tx<T>> {
+        return new Promise((resolve, reject) => {
+            let promise = this.transact(ctx => {
+                return new Promise<void>(close => {
+                    resolve({
+                        ctx,
+                        close: () => {
+                            close()
+                            return promise
+                        }
+                    })
+                })
+            })
+            promise.catch(err => reject(err))
+        })
+    }
+
+    async close(): Promise<void> {
+        this.closed = true
+        if (this.tx) {
+            let tx = this.tx
+            this.tx = undefined
+            await tx.then(tx => tx.close())
+        }
+    }
+}

package/src/util/resolve-tree.ts

@@ -0,0 +1,65 @@
+import {UserInputError} from "apollo-server-core"
+import assert from "assert"
+import {GraphQLResolveInfo, GraphQLSchema} from "graphql"
+import {
+    FieldsByTypeName,
+    parseResolveInfo,
+    ResolveTree,
+    simplifyParsedResolveInfoFragmentWithType
+} from "graphql-parse-resolve-info"
+
+
+export type ResolveTreeFields = {
+    [alias: string]: ResolveTree
+}
+
+
+export interface ResolveTreeWithFields extends ResolveTree {
+    fields: ResolveTreeFields
+}
+
+
+export function simplifyResolveTree(schema: GraphQLSchema, tree: ResolveTree, typeName: string): ResolveTreeWithFields {
+    let type = schema.getType(typeName)
+    assert(type != null)
+    return simplifyParsedResolveInfoFragmentWithType(tree, type)
+}
+
+
+export function getResolveTree(info: GraphQLResolveInfo): ResolveTree
+export function getResolveTree(info: GraphQLResolveInfo, typeName: string): ResolveTreeWithFields
+export function getResolveTree(info: GraphQLResolveInfo, typeName?: string): ResolveTree {
+    let tree = parseResolveInfo(info)
+    assert(isResolveTree(tree))
+    if (typeName) {
+        return simplifyResolveTree(info.schema, tree, typeName)
+    } else {
+        return tree
+    }
+}
+
+
+function isResolveTree(resolveInfo: ResolveTree | FieldsByTypeName | null | undefined): resolveInfo is ResolveTree {
+    return resolveInfo != null && resolveInfo.fieldsByTypeName != null
+}
+
+
+export function getTreeRequest(treeFields: ResolveTreeFields, fieldName: string): ResolveTree | undefined {
+    let req: ResolveTree | undefined
+    for (let alias in treeFields) {
+        let e = treeFields[alias]
+        if (e.name != fieldName) continue
+        if (req != null) throw new UserInputError(`multiple aliases for field '${fieldName}' are not supported`)
+        req = e
+    }
+    return req
+}
+
+
+export function hasTreeRequest(treeFields: ResolveTreeFields, fieldName: string): boolean {
+    for (let alias in treeFields) {
+        let e = treeFields[alias]
+        if (e.name == fieldName) return true
+    }
+    return false
+}