@subsquid/openreader 2.1.0 → 3.1.0

package/src/opencrud/schema.ts

@@ -1,7 +1,7 @@
-import {def, unexpectedCase} from "@subsquid/util-internal"
-import {toCamelCase, toPlural} from "@subsquid/util-naming"
-import {UserInputError} from "apollo-server-core"
-import assert from "assert"
+import {def, unexpectedCase} from '@subsquid/util-internal'
+import {toCamelCase, toPlural} from '@subsquid/util-naming'
+import {UserInputError} from 'apollo-server-core'
+import assert from 'assert'
 import {
     GraphQLBoolean,
     GraphQLEnumType,
@@ -20,27 +20,28 @@ import {
     GraphQLSchema,
     GraphQLString,
     GraphQLUnionType
-} from "graphql"
+} from 'graphql'
 import {
     GraphQLEnumValueConfigMap,
     GraphQLFieldConfigArgumentMap,
     GraphQLFieldConfigMap,
     GraphQLInputFieldConfigMap
-} from "graphql/type/definition"
-import {Context} from "../context"
-import {decodeRelayConnectionCursor, RelayConnectionRequest} from "../ir/connection"
-import {getEntityListSize, getRelaySize, getSize} from '../limit.size'
-import {Entity, Interface, JsonObject, Model, Prop} from "../model"
-import {getObject, getUnionProps} from "../model.tools"
-import {customScalars} from "../scalars"
-import {EntityByIdQuery, EntityConnectionQuery, EntityCountQuery, EntityListQuery, Query} from "../sql/query"
-import {Subscription} from "../subscription"
+} from 'graphql/type/definition'
+import {Context} from '../context'
+import {decodeRelayConnectionCursor, RelayConnectionRequest} from '../ir/connection'
+import {AnyFields} from '../ir/fields'
+import {getConnectionSize, getListSize, getObjectSize} from '../limit.size'
+import {Entity, Interface, JsonObject, Model, Prop} from '../model'
+import {getObject, getUniversalProperties} from '../model.tools'
+import {customScalars} from '../scalars'
+import {ConnectionQuery, CountQuery, EntityByIdQuery, ListQuery, Query} from '../sql/query'
+import {Subscription} from '../subscription'
 import {Limit} from '../util/limit'
-import {getResolveTree, getTreeRequest, hasTreeRequest, simplifyResolveTree} from "../util/resolve-tree"
-import {ensureArray, identity} from "../util/util"
-import {getOrderByMapping, parseOrderBy} from "./orderBy"
-import {parseEntityListArguments, parseResolveTree} from "./tree"
-import {parseWhere} from "./where"
+import {getResolveTree, getTreeRequest, hasTreeRequest, simplifyResolveTree} from '../util/resolve-tree'
+import {ensureArray, identity} from '../util/util'
+import {getOrderByMapping, parseOrderBy} from './orderBy'
+import {parseAnyTree, parseObjectTree, parseSqlArguments} from './tree'
+import {parseWhere} from './where'
 
 
 type GqlFieldMap = GraphQLFieldConfigMap<unknown, Context>
@@ -79,6 +80,8 @@ export class SchemaBuilder {
                 return customScalars.DateTime
             case 'BigInt':
                 return customScalars.BigInt
+            case 'BigDecimal':
+                return customScalars.BigDecimal
             case 'Bytes':
                 return customScalars.Bytes
             case 'JSON':
@@ -111,7 +114,8 @@ export class SchemaBuilder {
                 return new GraphQLInterfaceType({
                     name,
                     description: item.description,
-                    fields: () => this.buildObjectFields(item)
+                    fields: () => this.buildObjectFields(item),
+                    resolveType: item.queryable ? (value: any) => value._isTypeOf : undefined
                 })
             case "enum":
                 return new GraphQLEnumType({
@@ -145,7 +149,7 @@ export class SchemaBuilder {
                 type: this.getPropType(prop)
             }
             if (prop.type.kind == 'list-lookup') {
-                field.args = this.entityListArguments(prop.type.entity)
+                field.args = this.listArguments(prop.type.entity)
             }
             if (object.kind == 'entity' || object.kind == 'object') {
                 switch(prop.type.kind) {
@@ -170,7 +174,7 @@ export class SchemaBuilder {
                 type = new GraphQLList(this.getPropType(prop.type.item))
                 break
             case "fk":
-                type = this.get(prop.type.foreignEntity)
+                type = this.get(prop.type.entity)
                 break
             case "lookup":
                 return this.get(prop.type.entity)
@@ -191,46 +195,33 @@ export class SchemaBuilder {
         return type
     }
 
-    private entityListArguments(entityName: string): GraphQLFieldConfigArgumentMap {
+    private listArguments(typeName: string): GraphQLFieldConfigArgumentMap {
         return {
-            where: {type: this.getWhere(entityName)},
-            orderBy: {type: this.getOrderBy(entityName)},
+            where: {type: this.getWhere(typeName)},
+            orderBy: {type: this.getOrderBy(typeName)},
             offset: {type: GraphQLInt},
             limit: {type: GraphQLInt}
         }
     }
 
-    private getWhere(name: string): GraphQLInputType {
-        let where = this.where.get(name)
+    private getWhere(typeName: string): GraphQLInputType {
+        let where = this.where.get(typeName)
         if (where) return where
 
-        const object = this.model[name]
-        switch(object.kind) {
-            case "entity":
-            case "object":
-            case "union":
-                break
-            default:
-                throw unexpectedCase(object.kind)
-        }
+        let object = this.model[typeName]
+        let properties = getUniversalProperties(this.model, typeName)
 
         where = new GraphQLInputObjectType({
-            name: `${name}WhereInput`,
+            name: `${typeName}WhereInput`,
             fields: () => {
                 let fields: GraphQLInputFieldConfigMap = {}
-                let properties
-                if (object.kind == 'union') {
-                    properties = getUnionProps(this.model, name).properties
-                } else {
-                    properties = object.properties
-                }
 
                 for (let key in properties) {
                     this.buildPropWhereFilters(key, properties[key], fields)
                 }
 
-                if (object.kind == 'entity') {
-                    let whereList = new GraphQLList(new GraphQLNonNull(this.getWhere(name)))
+                if (object.kind == 'entity' || object.kind == 'interface') {
+                    let whereList = new GraphQLList(new GraphQLNonNull(this.getWhere(typeName)))
                     fields['AND'] = {
                         type: whereList
                     }
@@ -242,7 +233,8 @@ export class SchemaBuilder {
                 return fields
             }
         })
-        this.where.set(name, where)
+
+        this.where.set(typeName, where)
         return where
     }
 
@@ -263,6 +255,7 @@ export class SchemaBuilder {
                     case 'Float':
                     case 'DateTime':
                     case 'BigInt':
+                    case 'BigDecimal':
                         fields[`${key}_gt`] = {type}
                         fields[`${key}_gte`] = {type}
                         fields[`${key}_lt`] = {type}
@@ -320,10 +313,8 @@ export class SchemaBuilder {
                 fields[key] = {type: this.getWhere(prop.type.name)}
                 break
             case "fk":
-                fields[`${key}_isNull`] = {type: GraphQLBoolean}
-                fields[key] = {type: this.getWhere(prop.type.foreignEntity)}
-                break
             case "lookup":
+                fields[`${key}_isNull`] = {type: GraphQLBoolean}
                 fields[key] = {type: this.getWhere(prop.type.entity)}
                 break
             case "list-lookup": {
@@ -355,24 +346,24 @@ export class SchemaBuilder {
         return false
     }
 
-    private getOrderBy(entityName: string): GraphQLInputType {
-        let orderBy = this.orderBy.get(entityName)
+    private getOrderBy(typeName: string): GraphQLInputType {
+        let orderBy = this.orderBy.get(typeName)
         if (orderBy) return orderBy
 
         let values: GraphQLEnumValueConfigMap = {}
-        for (let variant of getOrderByMapping(this.model, entityName).keys()) {
+        for (let variant of getOrderByMapping(this.model, typeName).keys()) {
             values[variant] = {}
         }
 
         orderBy = new GraphQLList(
             new GraphQLNonNull(
                 new GraphQLEnumType({
-                    name: `${entityName}OrderByInput`,
+                    name: `${typeName}OrderByInput`,
                     values
                 })
             )
         )
-        this.orderBy.set(entityName, orderBy)
+        this.orderBy.set(typeName, orderBy)
         return orderBy
     }
 
@@ -385,11 +376,17 @@ export class SchemaBuilder {
             let item = this.model[name]
             switch(item.kind) {
                 case "entity":
-                    this.installEntityList(name, query, subscription)
+                    this.installListQuery(name, query, subscription)
                     this.installEntityById(name, query, subscription)
                     this.installEntityByUniqueInput(name, query)
                     this.installRelayConnection(name, query)
                     break
+                case 'interface':
+                    if (item.queryable) {
+                        this.installListQuery(name, query, subscription)
+                        this.installRelayConnection(name, query)
+                    }
+                    break
             }
         }
 
@@ -405,21 +402,21 @@ export class SchemaBuilder {
         })
     }
 
-    private installEntityList(entityName: string, query: GqlFieldMap, subscription: GqlFieldMap): void {
+    private installListQuery(typeName: string, query: GqlFieldMap, subscription: GqlFieldMap): void {
         let model = this.model
-        let queryName = toPlural(toCamelCase(entityName))
-        let outputType = new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(this.get(entityName))))
-        let argsType = this.entityListArguments(entityName)
+        let queryName = toPlural(toCamelCase(typeName))
+        let outputType = new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(this.get(typeName))))
+        let argsType = this.listArguments(typeName)
 
         function createQuery(context: Context, info: GraphQLResolveInfo, limit?: Limit) {
             let tree = getResolveTree(info)
-            let fields = parseResolveTree(model, entityName, info.schema, tree)
-            let args = parseEntityListArguments(model, entityName, tree.args)
-            limit?.check(() => getEntityListSize(model, entityName, fields, args.limit, args.where) + 1)
-            return new EntityListQuery(
+            let args = parseSqlArguments(model, typeName, tree.args)
+            let fields = parseAnyTree(model, typeName, info.schema, tree)
+            limit?.check(() => getListSize(model, typeName, fields, args.limit, args.where) + 1)
+            return new ListQuery(
                 model,
                 context.openreader.dialect,
-                entityName,
+                typeName,
                 fields,
                 args
             )
@@ -454,8 +451,8 @@ export class SchemaBuilder {
 
         function createQuery(context: Context, info: GraphQLResolveInfo, limit?: Limit) {
             let tree = getResolveTree(info)
-            let fields = parseResolveTree(model, entityName, info.schema, tree)
-            limit?.check(() => getSize(model, fields) + 1)
+            let fields = parseObjectTree(model, entityName, info.schema, tree)
+            limit?.check(() => getObjectSize(model, fields) + 1)
             return new EntityByIdQuery(
                 model,
                 context.openreader.dialect,
@@ -496,9 +493,9 @@ export class SchemaBuilder {
             },
             async resolve(source, args, context, info) {
                 let tree = getResolveTree(info)
-                let fields = parseResolveTree(model, entityName, info.schema, tree)
-                context.openreader.responseSizeLimit?.check(() => getSize(model, fields) + 1)
-                let query = new EntityListQuery(
+                let fields = parseObjectTree(model, entityName, info.schema, tree)
+                context.openreader.responseSizeLimit?.check(() => getObjectSize(model, fields) + 1)
+                let query = new ListQuery(
                     model,
                     context.openreader.dialect,
                     entityName,
@@ -512,12 +509,12 @@ export class SchemaBuilder {
         }
     }
 
-    private installRelayConnection(entityName: string, query: GqlFieldMap): void {
+    private installRelayConnection(typeName: string, query: GqlFieldMap): void {
         let model = this.model
-        let outputType = toPlural(entityName) + 'Connection'
-        let edgeType = `${entityName}Edge`
+        let outputType = toPlural(typeName) + 'Connection'
+        let edgeType = `${typeName}Edge`
 
-        query[`${toPlural(toCamelCase(entityName))}Connection`] = {
+        query[`${toPlural(toCamelCase(typeName))}Connection`] = {
             type: new GraphQLNonNull(new GraphQLObjectType({
                 name: outputType,
                 fields: {
@@ -525,7 +522,7 @@ export class SchemaBuilder {
                         type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(new GraphQLObjectType({
                             name: edgeType,
                             fields: {
-                                node: {type: new GraphQLNonNull(this.get(entityName))},
+                                node: {type: new GraphQLNonNull(this.get(typeName))},
                                 cursor: {type: new GraphQLNonNull(GraphQLString)}
                             }
                         }))))
@@ -535,10 +532,10 @@ export class SchemaBuilder {
                 }
             })),
             args: {
-                orderBy: {type: new GraphQLNonNull(this.getOrderBy(entityName))},
+                orderBy: {type: new GraphQLNonNull(this.getOrderBy(typeName))},
                 after: {type: GraphQLString},
                 first: {type: GraphQLInt},
-                where: {type: this.getWhere(entityName)}
+                where: {type: this.getWhere(typeName)}
             },
             async resolve(source, args, context, info) {
                 let orderByArg = ensureArray(args.orderBy)
@@ -546,8 +543,8 @@ export class SchemaBuilder {
                     throw new UserInputError('orderBy argument is required for connection')
                 }
 
-                let req: RelayConnectionRequest = {
-                    orderBy: parseOrderBy(model, entityName, orderByArg),
+                let req: RelayConnectionRequest<AnyFields> = {
+                    orderBy: parseOrderBy(model, typeName, orderByArg),
                     where: parseWhere(args.where)
                 }
 
@@ -578,24 +575,24 @@ export class SchemaBuilder {
                     req.edgeCursor = hasTreeRequest(edgeFields, 'cursor')
                     let nodeTree = getTreeRequest(edgeFields, 'node')
                     if (nodeTree) {
-                        req.edgeNode = parseResolveTree(model, entityName, info.schema, nodeTree)
+                        req.edgeNode = parseAnyTree(model, typeName, info.schema, nodeTree)
                     }
                 }
 
-                context.openreader.responseSizeLimit?.check(() => getRelaySize(model, entityName, req) + 1)
+                context.openreader.responseSizeLimit?.check(() => getConnectionSize(model, typeName, req) + 1)
 
-                let result = await context.openreader.executeQuery(new EntityConnectionQuery(
+                let result = await context.openreader.executeQuery(new ConnectionQuery(
                     model,
                     context.openreader.dialect,
-                    entityName,
+                    typeName,
                     req
                 ))
 
                 if (req.totalCount && result.totalCount == null) {
-                    result.totalCount = await context.openreader.executeQuery(new EntityCountQuery(
+                    result.totalCount = await context.openreader.executeQuery(new CountQuery(
                         model,
                         context.openreader.dialect,
-                        entityName,
+                        typeName,
                         req.where
                     ))
                 }

package/src/opencrud/tree.ts

@@ -1,29 +1,30 @@
-import {unexpectedCase} from "@subsquid/util-internal"
-import assert from "assert"
-import {GraphQLSchema} from "graphql"
-import {ResolveTree} from "graphql-parse-resolve-info"
-import {EntityListArguments} from "../ir/args"
-import {FieldRequest, OpaqueRequest} from "../ir/fields"
-import {Model} from "../model"
-import {simplifyResolveTree} from "../util/resolve-tree"
-import {ensureArray} from "../util/util"
-import {parseOrderBy} from "./orderBy"
-import {parseWhere} from "./where"
-
-
-export function parseResolveTree(
+import {unexpectedCase} from '@subsquid/util-internal'
+import assert from 'assert'
+import {GraphQLSchema} from 'graphql'
+import {ResolveTree} from 'graphql-parse-resolve-info'
+import {SqlArguments} from '../ir/args'
+import {AnyFields, FieldRequest, FieldsByEntity, OpaqueRequest} from '../ir/fields'
+import {Model} from '../model'
+import {getQueryableEntities} from '../model.tools'
+import {simplifyResolveTree} from '../util/resolve-tree'
+import {ensureArray} from '../util/util'
+import {parseOrderBy} from './orderBy'
+import {parseWhere} from './where'
+
+
+export function parseObjectTree(
     model: Model,
-    objectName: string,
+    typeName: string,
     schema: GraphQLSchema,
     tree: ResolveTree
 ): FieldRequest[] {
 
     let requests: FieldRequest[] = []
     let requestedScalars: Record<string, true> = {}
-    let object = model[objectName]
+    let object = model[typeName]
     assert(object.kind == "entity" || object.kind == "object")
 
-    let fields = simplifyResolveTree(schema, tree, objectName).fields
+    let fields = simplifyResolveTree(schema, tree, typeName).fields
     for (let alias in fields) {
         let f = fields[alias]
         let prop = object.properties[f.name]
@@ -51,7 +52,7 @@ export function parseResolveTree(
                     type: prop.type,
                     prop,
                     index: 0,
-                    children: parseResolveTree(model, prop.type.name, schema, f)
+                    children: parseObjectTree(model, prop.type.name, schema, f)
                 })
                 break
             case "union": {
@@ -59,7 +60,7 @@ export function parseResolveTree(
                 assert(union.kind == "union")
                 let children: FieldRequest[] = []
                 for (let variant of union.variants) {
-                    for (let req of parseResolveTree(model, variant, schema, f)) {
+                    for (let req of parseObjectTree(model, variant, schema, f)) {
                         req.ifType = variant
                         children.push(req)
                     }
@@ -83,7 +84,7 @@ export function parseResolveTree(
                     type: prop.type,
                     prop,
                     index: 0,
-                    children: parseResolveTree(model, prop.type.foreignEntity, schema, f)
+                    children: parseObjectTree(model, prop.type.entity, schema, f)
                 })
                 break
             case "lookup":
@@ -94,7 +95,7 @@ export function parseResolveTree(
                     type: prop.type,
                     prop,
                     index: 0,
-                    children: parseResolveTree(model, prop.type.entity, schema, f)
+                    children: parseObjectTree(model, prop.type.entity, schema, f)
                 })
                 break
             case "list-lookup":
@@ -105,8 +106,8 @@ export function parseResolveTree(
                     type: prop.type,
                     prop,
                     index: 0,
-                    args: parseEntityListArguments(model, prop.type.entity, f.args),
-                    children: parseResolveTree(model, prop.type.entity, schema, f)
+                    args: parseSqlArguments(model, prop.type.entity, f.args),
+                    children: parseObjectTree(model, prop.type.entity, schema, f)
                 })
                 break
             default:
@@ -118,8 +119,8 @@ export function parseResolveTree(
 }
 
 
-export function parseEntityListArguments(model: Model, entityName: string, gqlArgs: any): EntityListArguments {
-    let args: EntityListArguments = {}
+export function parseSqlArguments(model: Model, typeName: string, gqlArgs: any): SqlArguments {
+    let args: SqlArguments = {}
 
     let where = parseWhere(gqlArgs.where)
     if (where) {
@@ -127,7 +128,7 @@ export function parseEntityListArguments(model: Model, entityName: string, gqlAr
     }
 
     if (gqlArgs.orderBy) {
-        args.orderBy = parseOrderBy(model, entityName, ensureArray(gqlArgs.orderBy))
+        args.orderBy = parseOrderBy(model, typeName, ensureArray(gqlArgs.orderBy))
     }
 
     if (gqlArgs.offset) {
@@ -142,3 +143,31 @@ export function parseEntityListArguments(model: Model, entityName: string, gqlAr
 
     return args
 }
+
+
+export function parseQueryableTree(
+    model: Model,
+    queryableName: string,
+    schema: GraphQLSchema,
+    tree: ResolveTree
+): FieldsByEntity {
+    let fields: FieldsByEntity = {}
+    for (let entity of getQueryableEntities(model, queryableName)) {
+        fields[entity] = parseObjectTree(model, entity, schema, tree)
+    }
+    return fields
+}
+
+
+export function parseAnyTree(
+    model: Model,
+    typeName: string,
+    schema: GraphQLSchema,
+    tree: ResolveTree
+): AnyFields {
+    if (model[typeName].kind == 'interface') {
+        return parseQueryableTree(model, typeName, schema, tree)
+    } else {
+        return parseObjectTree(model, typeName, schema, tree)
+    }
+}

package/src/scalars/BigDecimal.ts

@@ -0,0 +1,37 @@
+import type {BigDecimal, BigDecimalSource} from '@subsquid/big-decimal'
+import {GraphQLScalarType} from 'graphql'
+import {bigDecimal} from '../util/big-decimal'
+import {invalidFormat} from '../util/util'
+
+
+export const BigDecimalScalar = new GraphQLScalarType({
+    name: 'BigDecimal',
+    description: 'Big number decimal',
+    serialize(value: BigDecimalSource) {
+        return bigDecimal.BigDecimal(value).toString()
+    },
+    parseValue(value: string) {
+        if (!isDecimal(value)) throw invalidFormat('BigDecimal', value)
+        return bigDecimal.BigDecimal(value)
+    },
+    parseLiteral(ast) {
+        switch (ast.kind) {
+            case "StringValue":
+                if (isDecimal(ast.value)) {
+                    return bigDecimal.BigDecimal(ast.value)
+                } else {
+                    throw invalidFormat('BigDecimal', ast.value)
+                }
+            case "IntValue":
+            case "FloatValue":
+                return bigDecimal.BigDecimal(ast.value)
+            default:
+                return null
+        }
+    }
+})
+
+
+function isDecimal(s: string): boolean {
+    return /^[+\-]?\d+\.?(\d+)?(e[+\-]?\d+)?$/.test(s)
+}

package/src/scalars/index.ts

@@ -1,4 +1,5 @@
 import {BigIntScalar} from "./BigInt"
+import {BigDecimalScalar} from "./BigDecimal"
 import {BytesScalar} from "./Bytes"
 import {DateTimeScalar} from "./DateTime"
 import {JSONScalar} from "./JSON"
@@ -6,6 +7,7 @@ import {JSONScalar} from "./JSON"
 
 export const customScalars = {
     BigInt: BigIntScalar,
+    BigDecimal: BigDecimalScalar,
     Bytes: BytesScalar,
     DateTime: DateTimeScalar,
     JSON: JSONScalar,

package/src/server.ts

@@ -1,6 +1,6 @@
-import type {Logger} from '@subsquid/logger'
+import {Logger} from '@subsquid/logger'
 import {listen, ListeningServer} from '@subsquid/util-internal-http-server'
-import {PluginDefinition} from 'apollo-server-core'
+import {KeyValueCache, PluginDefinition} from 'apollo-server-core'
 import {ApolloServer} from 'apollo-server-express'
 import express from 'express'
 import fs from 'fs'
@@ -33,10 +33,10 @@ export interface ServerOptions {
     subscriptions?: boolean
     subscriptionPollInterval?: number
     subscriptionConnection?: Pool
-    subscriptionMaxResponseNodes?: number
+    subscriptionMaxResponseNodes?: number,
+    cache?: KeyValueCache
 }
 
-
 export async function serve(options: ServerOptions): Promise<ListeningServer> {
     let {connection, subscriptionConnection, subscriptionPollInterval, maxResponseNodes, subscriptionMaxResponseNodes} = options
     let dialect = options.dialect ?? 'postgres'
@@ -76,7 +76,8 @@ export async function serve(options: ServerOptions): Promise<ListeningServer> {
         log: options.log,
         graphiqlConsole: options.graphiqlConsole,
         maxRequestSizeBytes: options.maxRequestSizeBytes,
-        maxRootFields: options.maxRootFields
+        maxRootFields: options.maxRootFields,
+        cache: options.cache,
     }), options.log)
 }
 
@@ -95,6 +96,7 @@ export interface ApolloOptions {
     log?: Logger
     maxRequestSizeBytes?: number
     maxRootFields?: number
+    cache?: KeyValueCache
 }
 
 
@@ -138,9 +140,11 @@ export async function runApollo(options: ApolloOptions): Promise<ListeningServer
         disposals.push(async () => wsServerCleanup.dispose())
     }
 
+
     let apollo = new ApolloServer({
         schema,
         context,
+        cache: options.cache,
         stopOnTerminationSignals: false,
         executor: execute && (async req => {
             return execute({
@@ -169,7 +173,7 @@ export async function runApollo(options: ApolloOptions): Promise<ListeningServer
                         }
                     }
                 }
-            }
+            },
         ]
     })
 
@@ -190,7 +194,6 @@ export async function runApollo(options: ApolloOptions): Promise<ListeningServer
     return listen(server, options.port)
 }
 
-
 export function addServerCleanup(disposals: Dispose[], server: Promise<ListeningServer>, log?: Logger): Promise<ListeningServer> {
     async function cleanup() {
         for (let i = disposals.length - 1; i >= 0; i--) {

package/src/sql/cursor.ts

@@ -154,7 +154,7 @@ export class EntityCursor implements Cursor {
             case "fk":
                 return new EntityCursor(
                     this.ctx,
-                    prop.type.foreignEntity,
+                    prop.type.entity,
                     {on: 'id', rhs: this.native(field)}
                 )
             case "lookup":
@@ -252,6 +252,8 @@ export class ObjectCursor implements Cursor {
                         return `(${this.string(field)})::bool`
                     case 'BigInt':
                         return `(${this.string(field)})::numeric`
+                    case 'BigDecimal':
+                        return `(${this.string(field)})::numeric`
                     case 'Bytes':
                         return `decode(substr(${this.string(field)}, 3), 'hex')`
                     case 'DateTime':
@@ -281,7 +283,7 @@ export class ObjectCursor implements Cursor {
             case "fk":
                 return new EntityCursor(
                     this.ctx,
-                    prop.type.foreignEntity,
+                    prop.type.entity,
                     {on: 'id', rhs: this.string(field)}
                 )
             default: