@subsquid/openreader 4.6.0 → 5.0.0-beta.79fbfe

package/src/dialect/thegraph/where.ts

@@ -0,0 +1,184 @@
+import {unexpectedCase} from '@subsquid/util-internal'
+import assert from 'assert'
+import {Where} from '../../ir/args'
+import {ensureArray} from '../../util/util'
+import {toCondition} from '../common'
+
+export function parseWhere(whereArg?: any): Where | undefined {
+    if (whereArg == null) return undefined
+    let {and, or, ...fields} = whereArg
+    let conj: Where[] = []
+
+    for (let key in fields) {
+        let arg = fields[key]
+        let {field, op} = parseWhereKey(key)
+        switch (op) {
+            case 'SELF':
+                conj.push({op: 'eq', field, value: arg})
+                break
+            case '_': {
+                let where = parseWhere(arg)
+                where && conj.push({op: 'REF', field, where})
+                break
+            }
+            case '_every': {
+                let where = parseWhere(arg)
+                where && conj.push({op: 'every', field, where})
+                break
+            }
+            case '_some':
+                conj.push({op: 'some', field, where: parseWhere(arg)})
+                break
+            case '_none':
+                conj.push({op: 'none', field, where: parseWhere(arg)})
+                break
+            case '_in':
+                conj.push({op: 'in', field, values: ensureArray(arg)})
+                break
+            case '_not_in':
+                conj.push({op: 'not_in', field, values: ensureArray(arg)})
+                break
+            case '_not':
+                conj.push({op: 'not_eq', field, value: arg})
+                break
+            case '_gt':
+                conj.push({op: 'gt', field, value: arg})
+                break
+            case '_gte':
+                conj.push({op: 'gte', field, value: arg})
+                break
+            case '_lt':
+                conj.push({op: 'lt', field, value: arg})
+                break
+            case '_lte':
+                conj.push({op: 'lte', field, value: arg})
+                break
+            case '_contains':
+                conj.push({op: 'contains', field, value: arg})
+                break
+            case '_not_contains':
+                conj.push({op: 'not_contains', field, value: arg})
+                break
+            case '_contains_nocase':
+                conj.push({op: 'containsInsensitive', field, value: arg})
+                break
+            case '_not_contains_nocase':
+                conj.push({op: 'not_containsInsensitive', field, value: arg})
+                break
+            case '_starts_with':
+                conj.push({op: 'startsWith', field, value: arg})
+                break
+            case '_starts_with_nocase':
+                conj.push({op: 'startsWithInsensitive', field, value: arg})
+                break
+            case '_not_starts_with':
+                conj.push({op: 'not_startsWith', field, value: arg})
+                break
+            case '_not_starts_with_nocase':
+                conj.push({op: 'not_startsWithInsensitive', field, value: arg})
+                break
+            case '_ends_with':
+                conj.push({op: 'endsWith', field, value: arg})
+                break
+            case '_ends_with_nocase':
+                conj.push({op: 'endsWithInsensitive', field, value: arg})
+                break
+            case '_not_ends_with':
+                conj.push({op: 'not_endsWith', field, value: arg})
+                break
+            case '_not_ends_with_nocase':
+                conj.push({op: 'not_endsWithInsensitive', field, value: arg})
+                break
+            case '_json_has_key':
+                conj.push({op: 'jsonHasKey', field, value: arg})
+                break
+            case '_json_contains':
+                conj.push({op: 'jsonContains', field, value: arg})
+                break
+            case '_contains_none':
+                conj.push({op: 'containsNone', field, value: ensureArray(arg)})
+                break
+            case '_contains_all':
+                conj.push({op: 'containsAll', field, value: ensureArray(arg)})
+                break
+            case '_contains_any':
+                conj.push({op: 'containsAny', field, value: ensureArray(arg)})
+                break
+            case '_is_null':
+                assert(typeof arg == 'boolean')
+                conj.push({op: 'isNull', field, yes: arg})
+                break
+            default:
+                throw unexpectedCase(op)
+        }
+    }
+
+    if (and) {
+        for (let arg of ensureArray(and)) {
+            let where = parseWhere(arg)
+            if (where) {
+                conj.push(where)
+            }
+        }
+    }
+
+    let conjunction = toCondition('AND', conj)
+    if (or) {
+        let disjunctions: Where[] = []
+        if (conjunction) {
+            disjunctions.push(conjunction)
+        }
+        for (let arg of ensureArray(or)) {
+            let where = parseWhere(arg)
+            if (where) {
+                disjunctions.push(where)
+            }
+        }
+        return toCondition('OR', disjunctions)
+    } else {
+        return conjunction
+    }
+}
+
+export function parseWhereKey(key: string): {op: (typeof WHERE_OPS)[number] | 'SELF'; field: string} {
+    let m = WHERE_KEY_REGEX.exec(key)
+    if (m) {
+        return {op: m[2] as (typeof WHERE_OPS)[number], field: m[1]}
+    } else {
+        return {op: 'SELF', field: key}
+    }
+}
+
+const WHERE_OPS = [
+    '_',
+    '_not',
+    '_gt',
+    '_gte',
+    '_lt',
+    '_lte',
+    '_in',
+    '_not_in',
+    '_contains',
+    '_contains_nocase',
+    '_not_contains',
+    '_not_contains_nocase',
+    '_starts_with',
+    '_starts_with_nocase',
+    '_not_starts_with',
+    '_not_starts_with_nocase',
+    '_ends_with',
+    '_ends_with_nocase',
+    '_not_ends_with',
+    '_not_ends_with_nocase',
+    '_contains_all',
+    '_contains_any',
+    '_contains_none',
+    '_json_contains',
+    '_json_has_key',
+    '_is_null',
+    '_some',
+    '_every',
+    '_none',
+] as const
+
+const WHERE_KEY_REGEX = new RegExp(`^([^_]*)(${WHERE_OPS.join('|')})$`)

package/src/ir/args.ts

@@ -66,7 +66,9 @@ export type BinaryOp =
     'contains' | 'not_contains' |
     'containsInsensitive' | 'not_containsInsensitive' |
     'startsWith' | 'not_startsWith' |
+    'startsWithInsensitive' | 'not_startsWithInsensitive' |
     'endsWith' | 'not_endsWith' |
+    'endsWithInsensitive' | 'not_endsWithInsensitive' |
     'containsAll' |
     'containsAny' |
     'containsNone' |

package/src/main.ts

@@ -4,7 +4,7 @@ import {nat, Url} from '@subsquid/util-internal-commander'
 import {waitForInterruption} from '@subsquid/util-internal-http-server'
 import {Command, Option} from 'commander'
 import {Pool} from 'pg'
-import {Dialect} from './dialect'
+import {DbType} from './db'
 import {serve} from './server'
 import {loadModel} from './tools'
 
@@ -36,7 +36,7 @@ GraphQL server for postgres-compatible databases
     let opts = program.parse().opts() as {
         schema: string
         dbUrl: string
-        dbType: Dialect
+        dbType: DbType
         port: number
         maxRequestSize: number
         maxRootFields?: number
@@ -56,7 +56,7 @@ GraphQL server for postgres-compatible databases
 
     let server = await serve({
         model,
-        dialect: opts.dbType,
+        dbType: opts.dbType,
         connection,
         port: opts.port,
         log: LOG,

package/src/model.schema.ts

@@ -24,7 +24,7 @@ import {customScalars} from './scalars'
 
 
 const baseSchema = buildASTSchema(parse(`
-    directive @entity on OBJECT
+    directive @entity(queryName: String listQueryName: String) on OBJECT
     directive @query on INTERFACE
     directive @derivedFrom(field: String!) on FIELD_DEFINITION
     directive @unique on FIELD_DEFINITION
@@ -80,10 +80,18 @@ function addEntityOrJsonObjectOrInterface(model: Model, type: GraphQLObjectType
     let indexes: Index[] = type instanceof GraphQLObjectType ? checkEntityIndexes(type) : []
     let cardinality = checkEntityCardinality(type)
     let description = type.description || undefined
-
-    switch(kind) {
+    
+    switch (kind) {
         case 'entity':
-            model[type.name] = {kind, properties, description, interfaces, indexes, ...cardinality}
+            model[type.name] = {
+                kind,
+                properties,
+                description,
+                interfaces,
+                indexes,
+                ...cardinality,
+                ...handleEntityDirective(model, type),
+            }
             break
         case 'object':
             model[type.name] = {kind, properties, description, interfaces}
@@ -528,4 +536,29 @@ function unsupportedFieldTypeError(propName: string): Error {
 }
 
 
+function handleEntityDirective(model: Model, type: GraphQLObjectType | GraphQLInterfaceType) {
+    let directive = type.astNode?.directives?.find(d => d.name.value == 'entity')
+    if (directive == null) return
+
+    let queryNameArg = directive.arguments?.find(d => d.name.value === 'queryName')
+    let queryName: string | undefined
+    if (queryNameArg != null) {
+        assert(queryNameArg?.value.kind == 'StringValue')
+        queryName = queryNameArg.value.value
+    }
+
+    let listQueryNameArg = directive.arguments?.find(d => d.name.value === 'listQueryName')
+    let listQueryName: string | undefined
+    if (listQueryNameArg != null) {
+        assert(listQueryNameArg?.value.kind == 'StringValue')
+        listQueryName = listQueryNameArg.value.value
+    }
+
+    return {
+        queryName,
+        listQueryName,
+    }
+}
+
+
 export class SchemaError extends Error {}

package/src/model.ts

@@ -10,6 +10,8 @@ export interface Entity extends TypeMeta {
     interfaces?: Name[]
     indexes?: Index[]
     cardinality?: number
+    queryName?: string
+    listQueryName?: string
 }
 
 

package/src/server.ts

@@ -12,17 +12,18 @@ import type {Pool} from 'pg'
 import {WebSocketServer} from 'ws'
 import {Context, OpenreaderContext} from './context'
 import {PoolOpenreaderContext} from './db'
-import type {Dialect} from './dialect'
+import type {DbType} from './db'
 import type {Model} from './model'
-import {SchemaBuilder} from './opencrud/schema'
 import {openreaderExecute, openreaderSubscribe} from './util/execute'
 import {ResponseSizeLimit} from './util/limit'
+import {Dialect, getSchemaBuilder} from './dialect'
 
 
 export interface ServerOptions {
     port: number | string
     model: Model
     connection: Pool
+    dbType?: DbType
     dialect?: Dialect
     graphiqlConsole?: boolean
     log?: Logger
@@ -32,7 +33,7 @@ export interface ServerOptions {
     subscriptions?: boolean
     subscriptionPollInterval?: number
     subscriptionConnection?: Pool
-    subscriptionMaxResponseNodes?: number,
+    subscriptionMaxResponseNodes?: number
     cache?: KeyValueCache
 }
 
@@ -43,16 +44,17 @@ export async function serve(options: ServerOptions): Promise<ListeningServer> {
         subscriptionPollInterval,
         maxResponseNodes,
         subscriptionMaxResponseNodes,
-        log
+        log,
     } = options
 
-    let dialect = options.dialect ?? 'postgres'
+    let dbType = options.dbType ?? 'postgres'
 
-    let schema = new SchemaBuilder(options).build()
+    let schemaBuilder = await getSchemaBuilder(options)
+    let schema = schemaBuilder.build()
 
     let context = () => {
         let openreader: OpenreaderContext = new PoolOpenreaderContext(
-            dialect,
+            dbType,
             connection,
             subscriptionConnection,
             subscriptionPollInterval,
@@ -69,23 +71,23 @@ export async function serve(options: ServerOptions): Promise<ListeningServer> {
         }
 
         return {
-            openreader
+            openreader,
         }
     }
 
     let disposals: Dispose[] = []
 
     return addServerCleanup(disposals, runApollo({
-        port: options.port,
-        schema,
-        context,
-        disposals,
-        subscriptions: options.subscriptions,
-        log: options.log,
-        graphiqlConsole: options.graphiqlConsole,
-        maxRequestSizeBytes: options.maxRequestSizeBytes,
-        maxRootFields: options.maxRootFields,
-        cache: options.cache,
+            port: options.port,
+            schema,
+            context,
+            disposals,
+            subscriptions: options.subscriptions,
+            log: options.log,
+            graphiqlConsole: options.graphiqlConsole,
+            maxRequestSizeBytes: options.maxRequestSizeBytes,
+            maxRootFields: options.maxRootFields,
+            cache: options.cache,
     }), options.log)
 }
 
@@ -117,7 +119,7 @@ export async function runApollo(options: ApolloOptions): Promise<ListeningServer
 
     let execute = (args: ExecutionArgs) => openreaderExecute(args, {
         maxRootFields: maxRootFields
-    })
+        })
 
     if (options.subscriptions) {
         let wsServer = new WebSocketServer({

package/src/sql/cursor.ts

@@ -1,7 +1,7 @@
 import {assertNotNull, unexpectedCase} from "@subsquid/util-internal"
 import {toSnakeCase} from "@subsquid/util-naming"
 import assert from "assert"
-import {Dialect} from "../dialect"
+import {DbType} from "../db"
 import {Entity, JsonObject, Model, ObjectPropType, Prop, UnionPropType} from "../model"
 import {getEntity, getFtsQuery, getObject, getUnionProps} from "../model.tools"
 import {toColumn, toFkColumn, toTable} from "../util/util"
@@ -10,7 +10,7 @@ import {AliasSet, escapeIdentifier, JoinSet} from "./util"
 
 export interface CursorCtx {
     model: Model
-    dialect: Dialect
+    dialect: DbType
     aliases: AliasSet
     join: JoinSet
 }
@@ -62,7 +62,7 @@ export class EntityCursor implements Cursor {
     }
 
     prop(field: string): Prop {
-        return assertNotNull(this.entity.properties[field])
+        return assertNotNull(this.entity.properties[field], `property ${field} is missing`)
     }
 
     output(field: string): string {
@@ -209,7 +209,7 @@ export class ObjectCursor implements Cursor {
     }
 
     prop(field: string): Prop {
-        return assertNotNull(this.object.properties[field])
+        return assertNotNull(this.object.properties[field], `property ${field} is missing`)
     }
 
     output(field: string): string {

package/src/sql/printer.ts

@@ -1,6 +1,6 @@
 import {unexpectedCase} from '@subsquid/util-internal'
 import assert from 'assert'
-import {Dialect} from '../dialect'
+import {DbType} from '../db'
 import {OrderBy, SortOrder, SqlArguments, Where} from '../ir/args'
 import {FieldRequest, FieldsByEntity} from '../ir/fields'
 import {Model} from '../model'
@@ -19,7 +19,7 @@ export class EntitySqlPrinter {
 
     constructor(
         private model: Model,
-        private dialect: Dialect,
+        private dialect: DbType,
         public readonly entityName: string,
         private params: unknown[],
         private args: SqlArguments = {},
@@ -92,6 +92,10 @@ export class EntitySqlPrinter {
     }
 
     private populateWhere(cursor: Cursor, where: Where, exps: string[]): void {
+        function printStr(value: string) {
+            return !!where.op?.endsWith?.('Insensitive') ? `lower(${value})` : value
+        }
+
         switch(where.op) {
             case "AND":
                 for (let cond of where.args) {
@@ -178,47 +182,46 @@ export class EntitySqlPrinter {
                 break
             }
             case "startsWith":
+            case "startsWithInsensitive":
                 if (this.dialect == "cockroach") {
                     let f = cursor.native(where.field)
                     let p = this.param(where.value) + "::text"
-                    exps.push(`${f} >= ${p}`)
-                    exps.push(`left(${f}, length(${p})) = ${p}`)
+                    exps.push(`${printStr(f)} >= ${printStr(p)}`)
+                    exps.push(`left(${printStr(f)}, length(${p})) = ${printStr(p)}`)
                 } else {
-                    exps.push(`starts_with(${cursor.native(where.field)}, ${this.param(where.value)})`)
+                    exps.push(`starts_with(${printStr(cursor.native(where.field))}, ${printStr(this.param(where.value))})`)
                 }
                 break
             case "not_startsWith":
+            case "not_startsWithInsensitive":
                 if (this.dialect == "cockroach") {
                     let f = cursor.native(where.field)
                     let p = this.param(where.value) + "::text"
-                    exps.push(`(${f} < ${p} OR left(${f}, length(${p})) != ${p})`)
+                    exps.push(`(${printStr(f)} < ${printStr(p)} OR left(${printStr(f)}, length(${printStr(p)})) != ${printStr(p)})`)
                 } else {
-                    exps.push(`NOT starts_with(${cursor.native(where.field)}, ${this.param(where.value)})`)
+                    exps.push(`NOT starts_with(${printStr(cursor.native(where.field))}, ${printStr(this.param(where.value))})`)
                 }
                 break
-            case "endsWith": {
+            case "endsWith": 
+            case "not_startsWithInsensitive": {
                 let f = cursor.native(where.field)
                 let p = this.param(where.value) + "::text"
-                exps.push(`right(${f}, length(${p})) = ${p}`)
+                exps.push(`right(${printStr(f)}, length(${p})) = ${printStr(p)}`)
                 break
             }
             case "not_endsWith": {
                 let f = cursor.native(where.field)
                 let p = this.param(where.value) + "::text"
-                exps.push(`right(${f}, length(${p})) != ${p}`)
+                exps.push(`right(${printStr(f)}, length(${p})) != ${printStr(p)}`)
                 break
             }
             case "contains":
-                exps.push(`position(${this.param(where.value)} in ${cursor.native(where.field)}) > 0`)
-                break
-            case "not_contains":
-                exps.push(`position(${this.param(where.value)} in ${cursor.native(where.field)}) = 0`)
-                break
             case "containsInsensitive":
-                exps.push(`position(lower(${this.param(where.value)}) in lower(${cursor.native(where.field)})) > 0`)
+                exps.push(`position(${printStr(this.param(where.value))} in ${printStr(cursor.native(where.field))}) > 0`)
                 break
+            case "not_contains":
             case "not_containsInsensitive":
-                exps.push(`position(lower(${this.param(where.value)}) in lower(${cursor.native(where.field)})) = 0`)
+                exps.push(`position(${printStr(this.param(where.value))} in ${printStr(cursor.native(where.field))}) = 0`)
                 break
             case "every": {
                 let rel = cursor.prop(where.field)
@@ -360,7 +363,7 @@ export class QueryableSqlPrinter {
 
     constructor(
         private model: Model,
-        private dialect: Dialect,
+        private dialect: DbType,
         private queryableName: string,
         private params: unknown[],
         private args: SqlArguments = {},
@@ -446,3 +449,4 @@ export class QueryableSqlPrinter {
         return sql
     }
 }
+

package/src/sql/query.ts

@@ -1,6 +1,6 @@
 import {assertNotNull} from '@subsquid/util-internal'
 import assert from 'assert'
-import type {Dialect} from '../dialect'
+import type {DbType} from '../db'
 import type {SqlArguments, Where} from '../ir/args'
 import {
     decodeRelayConnectionCursor,
@@ -30,7 +30,7 @@ export class ListQuery implements Query<any[]> {
 
     constructor(
         model: Model,
-        dialect: Dialect,
+        dialect: DbType,
         typeName: string,
         private fields: AnyFields,
         args: SqlArguments
@@ -60,7 +60,7 @@ export class EntityByIdQuery {
 
     constructor(
         model: Model,
-        dialect: Dialect,
+        dialect: DbType,
         entityName: string,
         private fields: FieldRequest[],
         id: string
@@ -88,7 +88,7 @@ export class CountQuery implements Query<number> {
 
     constructor(
         model: Model,
-        dialect: Dialect,
+        dialect: DbType,
         typeName: string,
         where?: Where
     ) {
@@ -114,7 +114,7 @@ export class ConnectionQuery implements Query<RelayConnectionResponse> {
 
     constructor(
         model: Model,
-        dialect: Dialect,
+        dialect: DbType,
         typeName: string,
         req: RelayConnectionRequest<AnyFields>
     ) {

package/src/sql/util.ts

@@ -1,7 +1,7 @@
-import type {Dialect} from "../dialect"
+import type {DbType} from "../db"
 
 
-export function escapeIdentifier(dialect: Dialect, name: string): string {
+export function escapeIdentifier(dialect: DbType, name: string): string {
     return `"${name.replace(/"/g, '""')}"`
 }