@subsquid/openreader 0.3.1 → 0.4.1

package/src/test/where.test.ts

@@ -0,0 +1,135 @@
+import {useDatabase, useServer} from "./util/setup"
+
+describe('AND, OR on entity filters', function () {
+    useDatabase([
+        `create table item (id text primary key, a int, b int)`,
+        `insert into item (id, a, b) values ('1', 1, 1)`,
+        `insert into item (id, a, b) values ('2', 2, 2)`,
+        `insert into item (id, a, b) values ('3', 3, 2)`,
+        `insert into item (id, a, b) values ('4', 4, 4)`,
+        `insert into item (id, a, b) values ('5', 5, 4)`,
+        `insert into item (id, a, b) values ('6', 5, 6)`,
+    ])
+
+    const client = useServer(`
+        type Item @entity {
+            id: ID!
+            a: Int
+            b: Int
+        }
+    `)
+
+    it('{c, and: {c}}', function () {
+        return client.test(`
+            query {
+                items(where: {a_eq: 1, AND: {b_eq: 1}} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                {id: '1'}
+            ]
+        })
+    })
+
+    it('{and: {and: {c}, c}}', function () {
+        return client.test(`
+            query {
+                items(where: {AND: {b_eq: 2, AND: {a_eq: 3}}} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                {id: '3'}
+            ]
+        })
+    })
+
+    it('{and: [{c}, {c}]}', function () {
+        return client.test(`
+            query {
+                items(where: {AND: [{a_eq: 2}, {b_eq: 2}]} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                {id: '2'}
+            ]
+        })
+    })
+
+    it('{c, {or: {c}}}', function () {
+        return client.test(`
+            query {
+                items(where: {a_eq: 1, OR: {a_eq: 2}} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                {id: '1'},
+                {id: '2'}
+            ]
+        })
+    })
+
+    it('{or: [{c}, {c}]}', function () {
+        return client.test(`
+            query {
+                items(where: {OR: [{a_eq: 2}, {a_eq: 3}]} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                {id: '2'},
+                {id: '3'}
+            ]
+        })
+    })
+
+    it('{or: {or: {c}, c}}', function () {
+        return client.test(`
+            query {
+                items(where: {OR: {a_eq: 1, OR: {b_eq: 2}}} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                {id: '1'},
+                {id: '2'},
+                {id: '3'}
+            ]
+        })
+    })
+
+    it('{and: [{or: {c}, c}, {or: {c}, c}]}', function () {
+        return client.test(`
+            query {
+                items(where: {AND: [{OR: {a_eq: 5}, a_eq: 4}, {OR: {b_eq: 2}, b_eq: 4}]} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                {id: '4'},
+                {id: '5'}
+            ]
+        })
+    })
+
+    it('{c, and: {c}, or: {c}}', function () {
+        return client.test(`
+            query {
+                items(where: { a_eq: 4, AND: {b_eq: 4}, OR: {b_eq: 6} } orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                {id: '4'},
+                {id: '6'}
+            ]
+        })
+    })
+
+    it('handles empty wheres', function () {
+        return client.test(`
+            query {
+                items(where: { a_eq: 4, AND: { OR: {}, AND: {} }, OR: { OR: {AND: {} } } } orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                {id: '4'}
+            ]
+        })
+    })
+})

package/src/tools.ts

@@ -0,0 +1,33 @@
+import {mergeTypeDefs} from "@graphql-tools/merge"
+import * as fs from "fs"
+import * as path from "path"
+import {parse, Source} from "graphql"
+import {buildModel, buildSchema} from "./gql/schema"
+import type {Model} from "./model"
+
+
+export function loadModel(schemaFile: string): Model {
+    let files: string[] = []
+    if (fs.statSync(schemaFile).isDirectory()) {
+        fs.readdirSync(schemaFile, {withFileTypes: true}).forEach(item => {
+            if (item.isFile() && (item.name.endsWith('.graphql') || item.name.endsWith('.gql'))) {
+                files.push(path.join(schemaFile, item.name))
+            }
+        })
+    } else {
+        files.push(schemaFile)
+    }
+
+    let docs = files.map(f => {
+        let src = new Source(
+            fs.readFileSync(f, 'utf-8'),
+            f
+        )
+        return parse(src)
+    })
+
+    if (docs.length == 0) return {}
+    let doc = docs.length == 1 ? docs[0] : mergeTypeDefs(docs)
+    let schema = buildSchema(doc)
+    return buildModel(schema)
+}

package/src/util.ts

@@ -0,0 +1,39 @@
+import {toCamelCase, toPlural, toSnakeCase} from "@subsquid/util"
+import assert from "assert"
+
+
+export function toQueryListField(entityName: string): string {
+    return toPlural(toCamelCase(entityName))
+}
+
+
+export function toColumn(gqlFieldName: string): string {
+    return toSnakeCase(gqlFieldName)
+}
+
+
+export function toFkColumn(gqlFieldName: string): string {
+    return toSnakeCase(gqlFieldName) + '_id'
+}
+
+
+export function toTable(entityName: string): string {
+    return toSnakeCase(entityName)
+}
+
+
+export function ensureArray<T>(item: T | T[]): T[] {
+    return Array.isArray(item) ? item : [item]
+}
+
+
+export function unsupportedCase(value: string): Error {
+    return new Error(`Unsupported case: ${value}`)
+}
+
+
+export function toInt(val: number | string): number {
+    let i = parseInt(val as string)
+    assert(!isNaN(i) && isFinite(i))
+    return i
+}

package/src/where.ts

@@ -0,0 +1,110 @@
+
+export type WhereOp =
+    '-' | // no operator
+    'eq' | 'not_eq' |
+    'gt' |
+    'gte' |
+    'lt' |
+    'lte' |
+    'in' | 'not_in' |
+    'contains' | 'not_contains' |
+    'startsWith' | 'not_startsWith' |
+    'endsWith' | 'not_endsWith' |
+    'containsAll' |
+    'containsAny' |
+    'containsNone' |
+    'some' |
+    'every' |
+    'none'
+
+
+const ENDINGS = [
+    'eq',
+    'not_eq',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'in',
+    'not_in',
+    'contains',
+    'not_contains',
+    'startsWith',
+    'not_startsWith',
+    'endsWith',
+    'not_endsWith',
+    'containsAll',
+    'containsAny',
+    'containsNone',
+    'some',
+    'every',
+    'none'
+].sort((a, b) => b.length - a.length).map(e => '_' + e)
+
+
+function parseEnding(field: string): string {
+    for (let i = 0; i < ENDINGS.length; i++) {
+        if (field.endsWith(ENDINGS[i])) return ENDINGS[i].slice(1)
+    }
+    return ''
+}
+
+
+export function parseWhereField(field: string): {op: WhereOp, field: string} {
+    let ending = parseEnding(field)
+    if (!ending) return {op: '-', field}
+    let fieldName = field.slice(0, -(ending.length + 1))
+    return {
+        op: ending as WhereOp,
+        field: fieldName
+    }
+}
+
+
+export function hasConditions(where?: any): where is any {
+    if (where == null) return false
+    for (let key in where) {
+        switch(key) {
+            case 'AND':
+            case 'OR':
+                break
+            default:
+                return true
+        }
+    }
+    if (Array.isArray(where.AND)) {
+        if (where.AND.some(hasConditions)) return true
+    } else if (where.AND && hasConditions(where.AND)) {
+        return true
+    }
+    if (Array.isArray(where.OR)) {
+        if (where.OR.some(hasConditions)) return true
+    } else if (where.OR && hasConditions(where.OR)) {
+        return true
+    }
+    return false
+}
+
+
+export function whereOpToSqlOperator(op: WhereOp): string {
+    switch(op) {
+        case 'eq':
+            return '='
+        case 'not_eq':
+            return '!='
+        case 'gt':
+            return '>'
+        case 'gte':
+            return '>='
+        case 'lt':
+            return '<'
+        case 'lte':
+            return '<='
+        case 'in':
+            return 'IN'
+        case 'not_in':
+            return 'NOT IN'
+        default:
+            throw new Error(`Operator ${op} doesn't have SQL analog`)
+    }
+}