@subsquid/openreader 0.4.1 → 0.6.0

package/src/gql/opencrud.ts

@@ -1,13 +1,14 @@
 import {Output, toCamelCase, toPlural} from "@subsquid/util"
 import assert from "assert"
 import {DocumentNode, parse, print} from "graphql"
-import {Entity, Enum, FTS_Query, Interface, JsonObject, Model, Prop, Union} from "../model"
+import type {Dialect} from "../dialect"
+import type {Entity, Enum, FTS_Query, Interface, JsonObject, Model, Prop, Union} from "../model"
 import {getOrderByMapping} from "../orderBy"
-import {scalars_list} from "../scalars"
 import {toQueryListField} from "../util"
+import {customScalars} from "./scalars"
 
 
-export function generateOpenCrudQueries(model: Model): string {
+export function generateOpenCrudQueries(model: Model, dialect: Dialect): string {
     let out = new Output()
 
     generatePageInfoType()
@@ -39,6 +40,7 @@ export function generateOpenCrudQueries(model: Model): string {
                 generateEnumType(name, item)
                 break
             case 'fts':
+                assert(dialect == 'postgres', `Full-text search queries are not supported by ${dialect}`)
                 generateFtsTypes(name, item)
                 break
         }
@@ -141,9 +143,11 @@ export function generateOpenCrudQueries(model: Model): string {
             switch(prop.type.kind) {
                 case 'scalar':
                 case 'enum':
+                    generateIsNullFilter(key, prop)
                     generateScalarFilters(key, prop.type.name)
                     break
                 case 'list':
+                    generateIsNullFilter(key, prop)
                     if (prop.type.item.type.kind == 'scalar' || prop.type.item.type.kind == 'enum') {
                         let item = prop.type.item.type.name
                         out.line(`${key}_containsAll: [${item}!]`)
@@ -152,14 +156,17 @@ export function generateOpenCrudQueries(model: Model): string {
                     }
                     break
                 case 'object':
+                    generateIsNullFilter(key, prop)
                     if (hasFilters(getObject(prop.type.name))) {
                         out.line(`${key}: ${prop.type.name}WhereInput`)
                     }
                     break
                 case 'union':
+                    generateIsNullFilter(key, prop)
                     out.line(`${key}: ${prop.type.name}WhereInput`)
                     break
                 case 'fk':
+                    generateIsNullFilter(key, prop)
                     out.line(`${key}: ${prop.type.foreignEntity}WhereInput`)
                     break
                 case 'lookup':
@@ -174,6 +181,11 @@ export function generateOpenCrudQueries(model: Model): string {
         }
     }
 
+    function generateIsNullFilter(key: string, prop: Prop): void {
+        if (!prop.nullable) return
+        out.line(`${key}_isNull: Boolean`)
+    }
+
     function hasFilters(obj: JsonObject): boolean {
         for (let key in obj.properties) {
             let propType = obj.properties[key].type
@@ -182,10 +194,12 @@ export function generateOpenCrudQueries(model: Model): string {
                 case 'enum':
                 case 'union':
                     return true
-                case 'object':
-                    if (hasFilters(getObject(propType.name))) {
+                case 'object': {
+                    let ref = getObject(propType.name)
+                    if (ref !== obj && hasFilters(ref)) {
                         return true
                     }
+                }
             }
         }
         return false
@@ -238,6 +252,8 @@ export function generateOpenCrudQueries(model: Model): string {
         if (graphqlType == 'String' || graphqlType == 'ID') {
             out.line(`${fieldName}_contains: ${graphqlType}`)
             out.line(`${fieldName}_not_contains: ${graphqlType}`)
+            out.line(`${fieldName}_containsInsensitive: ${graphqlType}`)
+            out.line(`${fieldName}_not_containsInsensitive: ${graphqlType}`)
             out.line(`${fieldName}_startsWith: ${graphqlType}`)
             out.line(`${fieldName}_not_startsWith: ${graphqlType}`)
             out.line(`${fieldName}_endsWith: ${graphqlType}`)
@@ -321,8 +337,8 @@ export function generateOpenCrudQueries(model: Model): string {
 }
 
 
-export function buildServerSchema(model: Model): DocumentNode {
-    let scalars = scalars_list.map(name => 'scalar ' + name).join('\n')
-    let queries = generateOpenCrudQueries(model)
+export function buildServerSchema(model: Model, dialect: Dialect): DocumentNode {
+    let scalars = ['ID'].concat(Object.keys(customScalars)).map(name => 'scalar ' + name).join('\n')
+    let queries = generateOpenCrudQueries(model, dialect)
     return parse(scalars  + '\n\n' + queries)
 }

package/src/gql/scalars/BigInt.ts

@@ -0,0 +1,34 @@
+import {GraphQLScalarType} from "graphql"
+import {invalidFormat} from "../../util"
+
+
+export const BigIntScalar = 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
+        }
+    }
+})
+
+
+function isBigInt(s: string): boolean {
+    return /^[+\-]?\d+$/.test(s)
+}

package/src/gql/scalars/Bytes.ts

@@ -0,0 +1,28 @@
+import {decodeHex, isHex} from "@subsquid/util"
+import {GraphQLScalarType} from "graphql"
+import {invalidFormat} from "../../util"
+
+
+export const BytesScalar = 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 (!isHex(value)) throw invalidFormat('Bytes', value)
+            return value.toLowerCase()
+        } else {
+            return '0x' + value.toString('hex')
+        }
+    },
+    parseValue(value: string) {
+        return decodeHex(value)
+    },
+    parseLiteral(ast) {
+        switch(ast.kind) {
+            case "StringValue":
+                return decodeHex(ast.value)
+            default:
+                return null
+        }
+    }
+})

package/src/gql/scalars/DateTime.ts

@@ -0,0 +1,45 @@
+import {GraphQLScalarType} from "graphql"
+import {invalidFormat} from "../../util"
+
+
+export const DateTimeScalar = 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
+        }
+    }
+})
+
+
+// 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)
+}

package/src/gql/scalars/index.ts

@@ -0,0 +1,10 @@
+import {BigIntScalar} from "./BigInt"
+import {BytesScalar} from "./Bytes"
+import {DateTimeScalar} from "./DateTime"
+
+
+export const customScalars = {
+    BigInt: BigIntScalar,
+    Bytes: BytesScalar,
+    DateTime: DateTimeScalar
+}

package/src/gql/schema.ts

@@ -20,7 +20,7 @@ import {
 } from "graphql"
 import {Index, Model, Prop, PropType} from "../model"
 import {validateModel} from "../model.tools"
-import {scalars_list} from "../scalars"
+import {customScalars} from "./scalars"
 
 
 const baseSchema = buildASTSchema(parse(`
@@ -31,7 +31,8 @@ const baseSchema = buildASTSchema(parse(`
     directive @fulltext(query: String!) on FIELD_DEFINITION
     directive @variant on OBJECT # legacy
     directive @jsonField on OBJECT # legacy
-    ${scalars_list.map(name => 'scalar ' + name).join('\n')}
+    scalar ID
+    ${Object.keys(customScalars).map(name => 'scalar ' + name).join('\n')}
 `))
 
 

package/src/queryBuilder.ts

@@ -1,12 +1,11 @@
 import {toSnakeCase} from "@subsquid/util"
 import assert from "assert"
-import type {ClientBase, QueryArrayResult} from "pg"
 import {Database} from "./db"
+import type {Dialect} from "./dialect"
 import type {Entity, JsonObject, Model} from "./model"
 import {getEntity, getFtsQuery, getObject, getUnionProps} from "./model.tools"
 import {OpenCrudOrderByValue, OrderBy, parseOrderBy} from "./orderBy"
 import type {FtsRequestedFields, RequestedFields} from "./requestedFields"
-import {fromJsonCast, fromJsonToOutputCast, toOutputArrayCast, toOutputCast} from "./scalars"
 import {ensureArray, toColumn, toFkColumn, toInt, toTable, unsupportedCase} from "./util"
 import {hasConditions, parseWhereField, WhereOp, whereOpToSqlOperator} from "./where"
 
@@ -25,6 +24,7 @@ export class QueryBuilder {
 
     constructor(
         private model: Model,
+        private dialect: Dialect,
         private db: Database
     ) {}
 
@@ -44,6 +44,7 @@ export class QueryBuilder {
 
         let cursor = new Cursor(
             this.model,
+            this.dialect,
             this.ident.bind(this),
             this.aliases,
             join,
@@ -76,12 +77,12 @@ export class QueryBuilder {
                 break
             case 'list-subquery':
                 if (columns.size()) {
-                    out += `SELECT json_build_array(${columns.render()}) `
+                    out += `SELECT json_build_array(${columns.render()}) AS row `
                 }
                 break
             default:
                 if (columns.size()) {
-                    out += `SELECT ${columns.render()}\n`
+                    out += `SELECT ${columns.render(true)}\n`
                 }
         }
 
@@ -178,7 +179,7 @@ export class QueryBuilder {
                     case 'scalar':
                     case 'enum':
                     case 'list':
-                        req.index = columns.add(cursor.transport(fieldName))
+                        req.index = columns.add(cursor.output(fieldName))
                         break
                     case 'object':
                         req.index = columns.add(cursor.field(fieldName) + ' IS NULL')
@@ -190,7 +191,7 @@ export class QueryBuilder {
                         break
                     case 'union':
                         let cu = cursor.child(fieldName)
-                        req.index = columns.add(cu.transport('isTypeOf'))
+                        req.index = columns.add(cu.output('isTypeOf'))
                         this.populateColumns(
                             columns,
                             cu,
@@ -200,7 +201,7 @@ export class QueryBuilder {
                     case 'fk':
                     case 'lookup': {
                         let cu = cursor.child(fieldName)
-                        req.index = columns.add(cu.transport('id'))
+                        req.index = columns.add(cu.output('id'))
                         this.populateColumns(
                             columns,
                             cu,
@@ -210,11 +211,11 @@ export class QueryBuilder {
                     }
                     case 'list-lookup':
                         req.index = columns.add(
-                            'array(' + this.select(field.propType.entity, req.args, req.children, {
+                            '(SELECT jsonb_agg(row) FROM (' + this.select(field.propType.entity, req.args, req.children, {
                                 kind: 'list-subquery',
                                 field: field.propType.field,
                                 parent: cursor.native('id')
-                            }) + ')'
+                            }) + ') as rows)'
                         )
                         break
                     default:
@@ -304,6 +305,15 @@ export class QueryBuilder {
 
     private addPropCondition(exps: string[], cursor: Cursor, field: string, op: WhereOp, arg: any): void {
         let propType = cursor.object.properties[field].type
+        if (op == 'isNull') {
+            let lhs = propType.kind == 'fk' ? cursor.fk(field) : cursor.field(field)
+            if (arg) {
+                exps.push(`${lhs} IS NULL`)
+            } else {
+                exps.push(`${lhs} IS NOT NULL`)
+            }
+            return
+        }
         switch(propType.kind) {
             case 'scalar':
             case 'enum': {
@@ -321,18 +331,29 @@ export class QueryBuilder {
                         break
                     }
                     case 'startsWith':
-                        exps.push(`starts_with(${lhs}, ${this.param(arg)})`)
+                        if (this.dialect == 'cockroach') {
+                            let p = this.param(arg) + '::text'
+                            exps.push(`${lhs} >= ${p}`)
+                            exps.push(`left(${lhs}, length(${p})) = ${p}`)
+                        } else {
+                            exps.push(`starts_with(${lhs}, ${this.param(arg)})`)
+                        }
                         break
                     case 'not_startsWith':
-                        exps.push(`NOT starts_with(${lhs}, ${this.param(arg)})`)
+                        if (this.dialect == 'cockroach') {
+                            let p = this.param(arg) + '::text'
+                            exps.push(`(${lhs} < ${p} OR left(${lhs}, length(${p})) != ${p})`)
+                        } else {
+                            exps.push(`NOT starts_with(${lhs}, ${this.param(arg)})`)
+                        }
                         break
                     case 'endsWith': {
-                        let param = this.param(arg)
+                        let param = this.param(arg) + '::text'
                         exps.push(`right(${lhs}, length(${param})) = ${param}`)
                         break
                     }
                     case 'not_endsWith': {
-                        let param = this.param(arg)
+                        let param = this.param(arg) + '::text'
                         exps.push(`right(${lhs}, length(${param})) != ${param}`)
                         break
                     }
@@ -342,6 +363,12 @@ export class QueryBuilder {
                     case 'not_contains':
                         exps.push(`position(${this.param(arg)} in ${lhs}) = 0`)
                         break
+                    case 'containsInsensitive':
+                        exps.push(`position(lower(${this.param(arg)}) in lower(${lhs})) > 0`)
+                        break
+                    case 'not_containsInsensitive':
+                        exps.push(`position(lower(${this.param(arg)}) in lower(${lhs})) = 0`)
+                        break
                     default: {
                         exps.push(`${lhs} ${whereOpToSqlOperator(op)} ${this.param(arg)}`)
                     }
@@ -570,11 +597,12 @@ interface ListSubquery {
  * A pointer to an entity or nested json object within SQL query.
  *
  * It has convenience methods for building various SQL expressions
- * related to individual properties of an entity or an object it points to.
+ * related to individual properties of an entity or of an object it points to.
  */
 class Cursor {
     constructor(
         private model: Model,
+        private dialect: Dialect,
         private ident: (name: string) => string,
         private aliases: AliasSet,
         private join: JoinSet,
@@ -584,15 +612,43 @@ class Cursor {
         private prefix: string
     ) {}
 
-    transport(propName: string): string {
+    output(propName: string): string {
         let prop = this.object.properties[propName]
         switch(prop.type.kind) {
             case 'scalar':
+                if (this.object.kind == 'object') {
+                    switch(prop.type.name) {
+                        case 'Int':
+                            return `(${this.prefix}->'${propName}')::integer`
+                        case 'Float':
+                            return `(${this.prefix}->'${propName}')::numeric`
+                        case 'Boolean':
+                            return `(${this.prefix}->>'${propName}')::bool`
+                        default:
+                            return `${this.prefix}->>'${propName}'`
+                    }
+                } else {
+                    let exp = this.column(propName)
+                    switch(prop.type.name) {
+                        case 'BigInt':
+                            return `(${exp})::text`
+                        case 'Bytes':
+                            return `'0x' || encode(${exp}, 'hex')`
+                        case 'DateTime':
+                            if (this.dialect == 'cockroach') {
+                                return `experimental_strftime((${exp}) at time zone 'UTC', '%Y-%m-%dT%H:%M:%S.%fZ')`
+                            } else {
+                                return `to_char((${exp}) at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"')`
+                            }
+                        default:
+                            return exp
+                    }
+                }
             case 'enum':
                 if (this.object.kind == 'object') {
-                    return fromJsonToOutputCast(prop.type.name, this.prefix, propName)
+                    return `${this.prefix}->>'${propName}'`
                 } else {
-                    return toOutputCast(prop.type.name, this.column(propName))
+                    return this.column(propName)
                 }
             case 'list':
                 let itemType = prop.type.item.type
@@ -600,7 +656,21 @@ class Cursor {
                     // this is json
                     return this.field(propName)
                 } else {
-                    return toOutputArrayCast(itemType.name, this.column(propName))
+                    let exp = this.column(propName)
+                    switch(itemType.name) {
+                        case 'BigInt':
+                            return `(${exp})::text[]`
+                        case 'Bytes':
+                            return `array(select '0x' || encode(i, 'hex') from unnest(${exp}) as i)`
+                        case 'DateTime':
+                            if (this.dialect == 'cockroach') {
+                                return `array(select experimental_strftime(i at time zone 'UTC', '%Y-%m-%dT%H:%M:%S.%fZ') from unnest(${exp}) as i)`
+                            } else {
+                                return `array(select to_char(i at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"') from unnest(${exp}) as i)`
+                            }
+                        default:
+                            return exp
+                    }
                 }
             default:
                 throw unsupportedCase(prop.type.kind)
@@ -616,7 +686,24 @@ class Cursor {
         }
         assert(prop.type.kind == 'scalar' || prop.type.kind == 'enum')
         if (this.object.kind == 'object') {
-            return fromJsonCast(prop.type.name, this.prefix, propName)
+            let js = `${this.prefix}->'${propName}'`
+            let str = `${this.prefix}->>'${propName}'`
+            switch(prop.type.name) {
+                case 'Int':
+                    return `(${js})::integer`
+                case 'Float':
+                    return `(${js})::numeric`
+                case 'Boolean':
+                    return `(${str})::bool`
+                case 'BigInt':
+                    return `(${str})::numeric`
+                case 'Bytes':
+                    return `decode(substr(${str}, 3), 'hex')`
+                case 'DateTime':
+                    return `(${str})::timestamptz`
+                default:
+                    return str
+            }
         } else {
             return this.column(propName)
         }
@@ -668,6 +755,7 @@ class Cursor {
 
         return new Cursor(
             this.model,
+            this.dialect,
             this.ident,
             this.aliases,
             this.join,
@@ -694,7 +782,7 @@ class Cursor {
     fk(propName: string): string {
         return this.object.kind == 'entity'
             ? this.ident(this.alias) + '.' + this.ident(toFkColumn(propName))
-            : fromJsonCast('ID', this.prefix, propName)
+            : `${this.prefix}->>'${propName}'`
     }
 
     tsv(queryName: string): string {
@@ -724,8 +812,12 @@ class ColumnSet {
         return idx
     }
 
-    render(): string {
-        return Array.from(this.columns.keys()).join(', ')
+    render(withAliases?: boolean): string {
+        let cols = Array.from(this.columns.keys())
+        if (withAliases) {
+            cols = cols.map((col, idx) => `${col} AS _c${idx}`)
+        }
+        return cols.join(', ')
     }
 
     size(): number {

package/src/resolver.ts

@@ -4,6 +4,8 @@ import {UserInputError} from "apollo-server-core"
 import assert from "assert"
 import type {GraphQLResolveInfo} from "graphql"
 import type {Database, Transaction} from "./db"
+import type {Dialect} from "./dialect"
+import {customScalars} from "./gql/scalars"
 import type {Entity, JsonObject, Model} from "./model"
 import {QueryBuilder} from "./queryBuilder"
 import {
@@ -15,7 +17,6 @@ import {
     PageInfo
 } from "./relayConnection"
 import {connectionRequestedFields, ftsRequestedFields, requestedFields} from "./requestedFields"
-import {getScalarResolvers} from "./scalars"
 import {ensureArray, toQueryListField, unsupportedCase} from "./util"
 
 
@@ -24,9 +25,9 @@ export interface ResolverContext {
 }
 
 
-export function buildResolvers(model: Model): IResolvers<unknown, ResolverContext> {
+export function buildResolvers(model: Model, dialect: Dialect): IResolvers<unknown, ResolverContext> {
     let Query: Record<string, IFieldResolver<unknown, ResolverContext>> = {}
-    let resolvers: IResolvers = {Query, ...getScalarResolvers()}
+    let resolvers: IResolvers = {Query, ...customScalars}
 
     for (let name in model) {
         let item = model[name]
@@ -35,16 +36,16 @@ export function buildResolvers(model: Model): IResolvers<unknown, ResolverContex
                 Query[toQueryListField(name)] = async (source, args, context, info) => {
                     let fields = requestedFields(model, name, info)
                     let db = await context.openReaderTransaction.get()
-                    return new QueryBuilder(model, db).executeSelect(name, args, fields)
+                    return new QueryBuilder(model, dialect, db).executeSelect(name, args, fields)
                 }
                 Query[toQueryListField(name) + 'Connection'] = async (source, args, context, info) => {
                     let db = await context.openReaderTransaction.get()
-                    return resolveEntityConnection(model, name, args, info, db)
+                    return resolveEntityConnection(model, dialect, name, args, info, db)
                 }
                 Query[`${toCamelCase(name)}ById`] = async (source, args, context, info) => {
                     let fields = requestedFields(model, name, info)
                     let db = await context.openReaderTransaction.get()
-                    let result = await new QueryBuilder(model, db)
+                    let result = await new QueryBuilder(model, dialect, db)
                         .executeSelect(name, {where: {id_eq: args.id}}, fields)
                     assert(result.length < 2)
                     return result[0]
@@ -52,7 +53,7 @@ export function buildResolvers(model: Model): IResolvers<unknown, ResolverContex
                 Query[`${toCamelCase(name)}ByUniqueInput`] = async (source, args, context, info) => {
                     let fields = requestedFields(model, name, info)
                     let db = await context.openReaderTransaction.get()
-                    let result = await new QueryBuilder(model, db)
+                    let result = await new QueryBuilder(model, dialect, db)
                         .executeSelect(name, {where: {id_eq: args.where.id}}, fields)
                     assert(result.length < 2)
                     return result[0]
@@ -71,7 +72,7 @@ export function buildResolvers(model: Model): IResolvers<unknown, ResolverContex
                 Query[name] = async (source, args, context, info) => {
                     let fields = ftsRequestedFields(model, name, info)
                     let db = await context.openReaderTransaction.get()
-                    return new QueryBuilder(model, db).executeFulltextSearch(name, args, fields)
+                    return new QueryBuilder(model, dialect, db).executeFulltextSearch(name, args, fields)
                 }
                 resolvers[`${name}_Item`] = {
                     __resolveType: resolveUnionType
@@ -130,6 +131,7 @@ interface ConnectionResponse extends RelayConnectionResponse<any> {
 
 async function resolveEntityConnection(
     model: Model,
+    dialect: Dialect,
     entityName: string,
     args: ConnectionArgs,
     info: GraphQLResolveInfo,
@@ -162,7 +164,7 @@ async function resolveEntityConnection(
 
     let fields = connectionRequestedFields(model, entityName, info)
     if (fields.edges?.node) {
-        let nodes = await new QueryBuilder(model, db).executeSelect(entityName, listArgs, fields.edges.node)
+        let nodes = await new QueryBuilder(model, dialect, db).executeSelect(entityName, listArgs, fields.edges.node)
         let edges: ConnectionEdge<any>[] = new Array(Math.min(limit, nodes.length))
         for (let i = 0; i < edges.length; i++) {
             edges[i] = {
@@ -176,7 +178,7 @@ async function resolveEntityConnection(
             response.totalCount = offset + nodes.length
         }
     } else if (fields.edges?.cursor || fields.pageInfo) {
-        let listLength = await new QueryBuilder(model, db).executeListCount(entityName, listArgs)
+        let listLength = await new QueryBuilder(model, dialect, db).executeListCount(entityName, listArgs)
         response.pageInfo = pageInfo(listLength)
         if (fields.edges?.cursor) {
             response.edges = []
@@ -192,7 +194,7 @@ async function resolveEntityConnection(
     }
 
     if (fields.totalCount && response.totalCount == null) {
-        response.totalCount = await new QueryBuilder(model, db).executeSelectCount(entityName, listArgs.where)
+        response.totalCount = await new QueryBuilder(model, dialect, db).executeSelectCount(entityName, listArgs.where)
     }
 
     return response

package/src/server.ts

@@ -7,6 +7,7 @@ import http from "http"
 import path from "path"
 import type {Pool} from "pg"
 import {PoolTransaction} from "./db"
+import {Dialect} from "./dialect"
 import {buildServerSchema} from "./gql/opencrud"
 import type {Model} from "./model"
 import {buildResolvers} from "./resolver"
@@ -22,14 +23,16 @@ export interface ServerOptions {
     model: Model
     db: Pool
     port: number | string
+    dialect?: Dialect
     graphiqlConsole?: boolean
 }
 
 
 export async function serve(options: ServerOptions): Promise<ListeningServer> {
     let {model, db} = options
-    let resolvers = buildResolvers(model)
-    let typeDefs = buildServerSchema(model)
+    let dialect = options.dialect ?? 'postgres'
+    let resolvers = buildResolvers(model, dialect)
+    let typeDefs = buildServerSchema(model, dialect)
     let app = express()
     let server = http.createServer(app)
 

package/src/test/basic.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 
 describe('basic tests', function() {
@@ -44,11 +44,11 @@ describe('basic tests', function() {
     it('can fetch all accounts', function() {
         return client.test(
             `query {
-                accounts {
+                accounts(orderBy: id_ASC) {
                     id
                     wallet
                     balance
-                    history { balance }
+                    history(orderBy: id_ASC) { balance }
                 }
             }`,
             {