@subsquid/openreader 0.5.1 → 0.6.0

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,11 +1,11 @@
 import {toSnakeCase} from "@subsquid/util"
 import assert from "assert"
 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"
 
@@ -24,6 +24,7 @@ export class QueryBuilder {
 
     constructor(
         private model: Model,
+        private dialect: Dialect,
         private db: Database
     ) {}
 
@@ -43,6 +44,7 @@ export class QueryBuilder {
 
         let cursor = new Cursor(
             this.model,
+            this.dialect,
             this.ident.bind(this),
             this.aliases,
             join,
@@ -75,7 +77,7 @@ 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:
@@ -177,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')
@@ -189,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,
@@ -199,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,
@@ -209,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:
@@ -329,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
                     }
@@ -350,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)}`)
                     }
@@ -578,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,
@@ -592,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
@@ -608,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)
@@ -624,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)
         }
@@ -676,6 +755,7 @@ class Cursor {
 
         return new Cursor(
             this.model,
+            this.dialect,
             this.ident,
             this.aliases,
             this.join,
@@ -702,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 {

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 }
                 }
             }`,
             {

package/src/test/connection.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 describe('relay connections', function () {
     useDatabase([

package/src/test/fts.test.ts

@@ -1,10 +1,12 @@
-import {useDatabase, useServer} from "./util/setup"
+import {isCockroach, useDatabase, useServer} from "./setup"
+
 
 function tsvector(columns: string[]) {
     return columns.map(col => `setweight(to_tsvector('english', coalesce(${col}, '')), 'A')`).join(' || ')
 }
 
-describe('full text search', function () {
+
+isCockroach() || describe('full text search', function () {
     useDatabase([
         `create table foo (
             id text primary key, 

package/src/test/isNull.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 
 describe('isNull operator', function() {

package/src/test/lists.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 
 describe('lists', function () {
@@ -172,8 +172,8 @@ describe('lists', function () {
             `, {
                 lists: [{
                     datetimeArray: [
-                        '2020-01-01T00:00:00.000Z',
-                        '2021-01-01T00:00:00.000Z'
+                        '2020-01-01T00:00:00.000000Z',
+                        '2021-01-01T00:00:00.000000Z'
                     ]
                 }]
             })

package/src/test/lookup.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {isCockroach, useDatabase, useServer} from "./setup"
 
 describe('lookup test', function () {
     useDatabase([
@@ -82,16 +82,22 @@ describe('lookup test', function () {
     it('supports sorting on lookup fields', function () {
         return client.test(`
             query {
-                issues(orderBy: [payment_amount_DESC]) {
+                issues(orderBy: [payment_amount_ASC]) {
                     id
                 }
             }
         `, {
-            issues: [
-                {id: '3'},
-                {id: '1'},
-                {id: '2'}
-            ]
+            issues: isCockroach()
+                ? [
+                    {id: '3'},
+                    {id: '2'},
+                    {id: '1'}
+                ]
+                : [
+                    {id: '2'},
+                    {id: '1'},
+                    {id: '3'}
+                ]
         })
     })
 

package/src/test/scalars.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 describe('scalars', function() {
     useDatabase([
@@ -12,6 +12,7 @@ describe('scalars', function() {
         `insert into scalar (id, "string") values ('7', 'bar baz foo')`,
         `insert into scalar (id, "string") values ('8', 'baz foo bar')`,
         `insert into scalar (id, "string") values ('9', 'hello')`,
+        `insert into scalar (id, "string") values ('9-1', 'A fOo B')`,
         `insert into scalar (id, "date_time", deep) values ('10', '2021-09-24T15:43:13.400Z', '{"dateTime": "2021-09-24T00:00:00.120Z"}'::jsonb)`,
         `insert into scalar (id, "date_time", deep) values ('11', '2021-09-24T00:00:00.000Z', '{"dateTime": "2021-09-24T00:00:00Z"}'::jsonb)`,
         `insert into scalar (id, "date_time", deep) values ('12', '2021-09-24 02:00:00.001 +01:00', '{"dateTime": "2021-09-24T00:00:00.1Z"}'::jsonb)`,
@@ -106,16 +107,18 @@ describe('scalars', function() {
                     not_ends_with: scalars(where: {string_not_endsWith: "foo"} orderBy: id_ASC) { id }
                     contains: scalars(where: {string_contains: "foo"} orderBy: id_ASC) { id }
                     not_contains: scalars(where: {string_not_contains: "foo"} orderBy: id_ASC) { id }
-                    case_sensitive: scalars(where: {string_contains: "Foo"} orderBy: id_ASC) { id }
+                    contains_insensitive: scalars(where: {string_containsInsensitive: "FoO"} orderBy: id_ASC) { id }
+                    not_contains_insensitive: scalars(where: {string_not_containsInsensitive: "FoO"} orderBy: id_ASC) { id }
                 }
             `, {
                 starts_with: [{id: '6'}],
-                not_starts_with: [{id: '7'}, {id: '8'}, {id: '9'}],
+                not_starts_with: [{id: '7'}, {id: '8'}, {id: '9'}, {id: '9-1'}],
                 ends_with: [{id: '7'}],
-                not_ends_with: [{id: '6'}, {id: '8'}, {id: '9'}],
+                not_ends_with: [{id: '6'}, {id: '8'}, {id: '9'}, {id: '9-1'}],
                 contains: [{id: '6'}, {id: '7'}, {id: '8'}],
-                not_contains: [{id: '9'}],
-                case_sensitive: []
+                not_contains: [{id: '9'}, {id: '9-1'}],
+                contains_insensitive: [{id: '6'}, {id: '7'}, {id: '8'}, {id: '9-1'}],
+                not_contains_insensitive: [{id: '9'}]
             })
         })
     })
@@ -239,9 +242,9 @@ describe('scalars', function() {
                 }
             `, {
                 scalars: [
-                    {id: '10', dateTime: '2021-09-24T15:43:13.400Z', deep: {dateTime: '2021-09-24T00:00:00.120Z'}},
-                    {id: '11', dateTime: '2021-09-24T00:00:00.000Z', deep: {dateTime: '2021-09-24T00:00:00Z'}},
-                    {id: '12', dateTime: '2021-09-24T01:00:00.001Z', deep: {dateTime: '2021-09-24T00:00:00.1Z'}}
+                    {id: '10', dateTime: '2021-09-24T15:43:13.400000Z', deep: {dateTime: '2021-09-24T00:00:00.120Z'}},
+                    {id: '11', dateTime: '2021-09-24T00:00:00.000000Z', deep: {dateTime: '2021-09-24T00:00:00Z'}},
+                    {id: '12', dateTime: '2021-09-24T01:00:00.001000Z', deep: {dateTime: '2021-09-24T00:00:00.1Z'}}
                 ]
             })
         })

package/src/test/{util/setup.ts → setup.ts}

@@ -1,12 +1,25 @@
+import {assertNotNull} from "@subsquid/util"
 import {Client} from "gql-test-client"
 import {parse} from "graphql"
 import {Client as PgClient, ClientBase, Pool} from "pg"
-import {createPoolConfig} from "../../db"
-import {buildModel, buildSchema} from "../../gql/schema"
-import {ListeningServer, serve} from "../../server"
+import {buildModel, buildSchema} from "../gql/schema"
+import {ListeningServer, serve} from "../server"
 
 
-export const db_config = createPoolConfig()
+export function isCockroach(): boolean {
+    return process.env.DB_TYPE == 'cockroach'
+}
+
+
+export const db_config = {
+    host: 'localhost',
+    port: parseInt(assertNotNull(
+        isCockroach() ? process.env.DB_PORT_COCKROACH : process.env.DB_PORT_PG
+    )),
+    user: 'root',
+    password: 'root',
+    database: 'defaultdb'
+}
 
 
 async function withClient(block: (client: ClientBase) => Promise<void>): Promise<void> {
@@ -31,8 +44,8 @@ export function databaseInit(sql: string[]): Promise<void> {
 
 export function databaseDelete(): Promise<void> {
     return withClient(async client => {
-        await client.query(`DROP SCHEMA IF EXISTS public CASCADE`)
-        await client.query(`CREATE SCHEMA public`)
+        await client.query(`DROP SCHEMA IF EXISTS root CASCADE`)
+        await client.query(`CREATE SCHEMA root`)
     })
 }
 
@@ -53,7 +66,8 @@ export function useServer(schema: string): Client {
         info = await serve({
             db,
             model: buildModel(buildSchema(parse(schema))),
-            port: 0
+            port: 0,
+            dialect: isCockroach() ? 'cockroach' : 'postgres'
         })
         client.endpoint = `http://localhost:${info.port}/graphql`
     })

package/src/test/typed-json.test.ts

@@ -1,4 +1,4 @@
-import {useDatabase, useServer} from "./util/setup"
+import {useDatabase, useServer} from "./setup"
 
 describe('typed json fields', function () {
     useDatabase([