@subsquid/openreader 5.4.0-beta.aa7384 → 5.5.0

package/src/main.ts

@@ -29,9 +29,11 @@ GraphQL server for postgres-compatible databases
     program.option('--max-root-fields <count>', 'max number of root fields in a query', nat)
     program.option('--max-response-size <nodes>', 'max response size measured in nodes', nat)
     program.option('--sql-statement-timeout <ms>', 'sql statement timeout in ms', nat)
+    program.option('--validation-max-errors <count>', 'max validation errors', nat)
     program.option('--subscriptions', 'enable gql subscriptions')
     program.option('--subscription-poll-interval <ms>', 'subscription poll interval in ms', nat, 1000)
     program.option('--subscription-max-response-size <nodes>', 'max response size measured in nodes', nat)
+    program.addOption(new Option('--isolation-level <level>', 'transaction isolation level').choices(['SERIALIZABLE', 'REPEATABLE READ', 'READ COMMITTED']))
 
     let opts = program.parse().opts() as {
         schema: string
@@ -42,9 +44,11 @@ GraphQL server for postgres-compatible databases
         maxRootFields?: number
         maxResponseSize?: number
         sqlStatementTimeout?: number
+        validationMaxErrors?: number
         subscriptions?: boolean
         subscriptionPollInterval: number
         subscriptionMaxResponseSize?: number
+        isolationLevel?: 'SERIALIZABLE' | 'REPEATABLE READ' | 'READ COMMITTED'
     }
 
     let model = loadModel(opts.schema)
@@ -65,7 +69,9 @@ GraphQL server for postgres-compatible databases
         maxResponseNodes: opts.maxResponseSize,
         subscriptions: opts.subscriptions,
         subscriptionPollInterval: opts.subscriptionPollInterval,
-        subscriptionMaxResponseNodes: opts.subscriptionMaxResponseSize
+        subscriptionMaxResponseNodes: opts.subscriptionMaxResponseSize,
+        validationMaxErrors: opts.validationMaxErrors,
+        isolationLevel: opts.isolationLevel
     })
 
     LOG.info(`listening on port ${server.port}`)

package/src/model.schema.ts

@@ -32,6 +32,7 @@ const baseSchema = buildASTSchema(parse(`
     directive @fulltext(query: String!) on FIELD_DEFINITION
     directive @cardinality(value: Int!) on OBJECT | FIELD_DEFINITION
     directive @byteWeight(value: Float!) on FIELD_DEFINITION
+    directive @disableForeignKeyConstraint on FIELD_DEFINITION
     directive @variant on OBJECT # legacy
     directive @jsonField on OBJECT # legacy
     scalar ID
@@ -132,6 +133,7 @@ function addEntityOrJsonObjectOrInterface(model: Model, type: GraphQLObjectType
         let derivedFrom = checkDerivedFrom(type, f)
         let index = checkFieldIndex(type, f)
         let unique = index?.unique || false
+        let fkConstraint = checkDisableForeignKeyConstraint(type, f)
         let limits = {
             ...checkByteWeightDirective(type, f),
             ...checkCardinalityLimitDirective(type, f)
@@ -199,10 +201,14 @@ function addEntityOrJsonObjectOrInterface(model: Model, type: GraphQLObjectType
                                 description
                             }
                         } else {
+                            if (fkConstraint.disableConstraint && !nullable) {
+                                throw new SchemaError(`Property ${propName} must be nullable when @disableForeignKeyConstraint is applied`)
+                            }
                             properties[key] = {
                                 type: {
                                     kind: 'fk',
-                                    entity: fieldType.name
+                                    entity: fieldType.name,
+                                    ...fkConstraint
                                 },
                                 nullable,
                                 unique,
@@ -509,6 +515,30 @@ function checkCardinalityLimitDirective(type: GraphQLNamedType, f: GraphQLField<
 }
 
 
+function checkDisableForeignKeyConstraint(type: GraphQLNamedType, f: GraphQLField<any, any>): {disableConstraint?: boolean} {
+    let directives = f.astNode?.directives?.filter(d => d.name.value == 'disableForeignKeyConstraint') || []
+    if (directives.length == 0) return {}
+    if (!isEntityType(type)) throw new SchemaError(
+        `@disableForeignKeyConstraint was applied to ${type.name}.${f.name}, but only entity fields can have this directive`
+    )
+    if (directives.length > 1) throw new SchemaError(
+        `Multiple @disableForeignKeyConstraint directives were applied to ${type.name}.${f.name}`
+    )
+    let fieldType = asNonNull(f)
+    let list = unwrapList(fieldType)
+    if (list.nulls.length > 0) throw new SchemaError(
+        `@disableForeignKeyConstraint was applied to ${type.name}.${f.name}, but list fields cannot have this directive`
+    )
+    if (!isEntityType(list.item)) throw new SchemaError(
+        `@disableForeignKeyConstraint was applied to ${type.name}.${f.name}, but only foreign key fields can have this directive`
+    )
+    if (f.astNode?.directives?.some(d => d.name.value == 'derivedFrom')) throw new SchemaError(
+        `@disableForeignKeyConstraint was applied to ${type.name}.${f.name}, but @derivedFrom fields cannot have this directive`
+    )
+    return {disableConstraint: true}
+}
+
+
 function checkByteWeightDirective(type: GraphQLNamedType, f: GraphQLField<any, any>): {byteWeight?: number} {
     let directives = f.astNode?.directives?.filter(d => d.name.value == 'byteWeight') || []
     if (directives.length > 1) throw new SchemaError(

package/src/model.ts

@@ -112,6 +112,7 @@ export interface ListPropType {
 export interface FkPropType {
     kind: 'fk'
     entity: Name
+    disableConstraint?: boolean
 }
 
 

package/src/server.ts

@@ -1,7 +1,7 @@
 import {Logger} from '@subsquid/logger'
 import {listen, ListeningServer} from '@subsquid/util-internal-http-server'
 import {KeyValueCache, PluginDefinition} from '@subsquid/apollo-server-core'
-import { ApolloServer } from '@subsquid/apollo-server-express';
+import {ApolloServer} from '@subsquid/apollo-server-express'
 import express from 'express'
 import fs from 'fs'
 import {ExecutionArgs, GraphQLSchema} from 'graphql'
@@ -12,7 +12,7 @@ import type {Pool} from 'pg'
 import {WebSocketServer} from 'ws'
 import {Context, OpenreaderContext} from './context'
 import {PoolOpenreaderContext} from './db'
-import type {DbType} from './db'
+import type {DbType, TransactionIsolationLevel} from './db'
 import type {Model} from './model'
 import {openreaderExecute, openreaderSubscribe} from './util/execute'
 import {ResponseSizeLimit} from './util/limit'
@@ -34,7 +34,9 @@ export interface ServerOptions {
     subscriptionPollInterval?: number
     subscriptionConnection?: Pool
     subscriptionMaxResponseNodes?: number
+    validationMaxErrors?: number
     cache?: KeyValueCache
+    isolationLevel?: TransactionIsolationLevel
 }
 
 export async function serve(options: ServerOptions): Promise<ListeningServer> {
@@ -44,6 +46,7 @@ export async function serve(options: ServerOptions): Promise<ListeningServer> {
         subscriptionPollInterval,
         maxResponseNodes,
         subscriptionMaxResponseNodes,
+        validationMaxErrors,
         log,
     } = options
 
@@ -52,12 +55,15 @@ export async function serve(options: ServerOptions): Promise<ListeningServer> {
     let schemaBuilder = await getSchemaBuilder(options)
     let schema = schemaBuilder.build()
 
+    let isolationLevel = options.isolationLevel ?? 'SERIALIZABLE'
+
     let context = () => {
         let openreader: OpenreaderContext = new PoolOpenreaderContext(
             dbType,
             connection,
             subscriptionConnection,
             subscriptionPollInterval,
+            isolationLevel,
             log
         )
 
@@ -85,6 +91,7 @@ export async function serve(options: ServerOptions): Promise<ListeningServer> {
             subscriptions: options.subscriptions,
             log: options.log,
             graphiqlConsole: options.graphiqlConsole,
+            validationMaxErrors,
             maxRequestSizeBytes: options.maxRequestSizeBytes,
             maxRootFields: options.maxRootFields,
             cache: options.cache,
@@ -105,8 +112,8 @@ export interface ApolloOptions {
     graphiqlConsole?: boolean
     log?: Logger
     maxRequestSizeBytes?: number
-    maxRootFields?: number
     validationMaxErrors?: number
+    maxRootFields?: number
     cache?: KeyValueCache
 }
 
@@ -151,6 +158,7 @@ export async function runApollo(options: ApolloOptions): Promise<ListeningServer
         cache: options.cache,
         stopOnTerminationSignals: false,
         allowBatchedHttpRequests: false,
+        dangerouslyDisableValidation: false,
         validateOptions: {
             maxErrors: validationMaxErrors
         },
@@ -161,7 +169,7 @@ export async function runApollo(options: ApolloOptions): Promise<ListeningServer
                 rootValue: {},
                 contextValue: req.context,
                 variableValues: req.request.variables,
-                operationName: req.operationName
+                operationName: req.operationName,
             })
         },
         plugins: [

package/src/sql/cursor.ts

@@ -4,7 +4,7 @@ import assert from "assert"
 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"
+import {getFkPropByIdField, toColumn, toFkColumn, toTable} from "../util/util"
 import {AliasSet, escapeIdentifier, JoinSet} from "./util"
 
 
@@ -62,7 +62,13 @@ export class EntityCursor implements Cursor {
     }
 
     prop(field: string): Prop {
-        return assertNotNull(this.entity.properties[field], `property ${field} is missing`)
+        let p = this.entity.properties[field]
+        if (p) return p
+        let fkProp = getFkPropByIdField(field, this.entity.properties)
+        if (fkProp) {
+            return {type: {kind: 'scalar', name: 'String'}, nullable: fkProp.nullable}
+        }
+        return assertNotNull(p, `property ${field} is missing`)
     }
 
     output(field: string): string {

package/src/test/basic.test.ts

@@ -314,6 +314,7 @@ describe('basic tests', function() {
                     fields: [
                         {description: 'Unique identifier'},
                         {description: 'Related account'},
+                        {description: 'Related account'},
                         {description: 'Balance'},
                     ]
                 }

package/src/test/disableForeignKeyConstraint.test.ts

@@ -0,0 +1,363 @@
+import expect from 'expect'
+import {parse} from 'graphql'
+import {buildModel, buildSchema, SchemaError} from '../model.schema'
+import {useDatabase, useServer} from './setup'
+
+
+function model(schema: string) {
+    return buildModel(buildSchema(parse(schema)))
+}
+
+
+describe('@disableForeignKeyConstraint', function () {
+    describe('schema validation', function () {
+        it('parses valid usage and sets disableConstraint flag', function () {
+            let m = model(`
+                type Account @entity {
+                    id: ID!
+                }
+                type Transfer @entity {
+                    id: ID!
+                    from: Account @disableForeignKeyConstraint
+                }
+            `)
+            expect(m.Transfer).toBeDefined()
+            expect(m.Transfer.kind).toBe('entity')
+            if (m.Transfer.kind === 'entity') {
+                let fromProp = m.Transfer.properties.from
+                expect(fromProp.type).toEqual({
+                    kind: 'fk',
+                    entity: 'Account',
+                    disableConstraint: true,
+                })
+            }
+        })
+
+        it('rejects non-nullable FK field', function () {
+            expect(() =>
+                model(`
+                    type Account @entity {
+                        id: ID!
+                    }
+                    type Transfer @entity {
+                        id: ID!
+                        from: Account! @disableForeignKeyConstraint
+                    }
+                `)
+            ).toThrow(SchemaError)
+        })
+
+        it('rejects directive on scalar field', function () {
+            expect(() =>
+                model(`
+                    type Account @entity {
+                        id: ID!
+                        name: String @disableForeignKeyConstraint
+                    }
+                `)
+            ).toThrow(SchemaError)
+        })
+
+        it('rejects directive on enum field', function () {
+            expect(() =>
+                model(`
+                    enum Status { ACTIVE INACTIVE }
+                    type Account @entity {
+                        id: ID!
+                        status: Status @disableForeignKeyConstraint
+                    }
+                `)
+            ).toThrow(SchemaError)
+        })
+
+        it('rejects directive on list (derivedFrom) field', function () {
+            expect(() =>
+                model(`
+                    type Account @entity {
+                        id: ID!
+                        transfers: [Transfer!] @derivedFrom(field: "from") @disableForeignKeyConstraint
+                    }
+                    type Transfer @entity {
+                        id: ID!
+                        from: Account
+                    }
+                `)
+            ).toThrow(SchemaError)
+        })
+
+        it('rejects directive on @derivedFrom lookup field', function () {
+            expect(() =>
+                model(`
+                    type Account @entity {
+                        id: ID!
+                        profile: Profile @derivedFrom(field: "account") @disableForeignKeyConstraint
+                    }
+                    type Profile @entity {
+                        id: ID!
+                        account: Account! @unique
+                    }
+                `)
+            ).toThrow(SchemaError)
+        })
+
+        it('rejects directive on non-entity type', function () {
+            expect(() =>
+                model(`
+                    type Account @entity {
+                        id: ID!
+                    }
+                    type Metadata {
+                        ref: Account @disableForeignKeyConstraint
+                    }
+                    type Transfer @entity {
+                        id: ID!
+                        meta: Metadata
+                    }
+                `)
+            ).toThrow(SchemaError)
+        })
+    })
+
+    describe('runtime (opencrud)', function () {
+        // Database setup: transfer table has from_id and to_id columns
+        // with NO foreign key constraints. Some IDs reference accounts
+        // that don't exist, simulating @disableForeignKeyConstraint behavior.
+        useDatabase([
+            `create table account (id text primary key, name text)`,
+            `create table transfer (id text primary key, from_id text, to_id text, amount numeric)`,
+            // account '1' exists, account '2' exists, but account 'missing' does NOT exist
+            `insert into account (id, name) values ('1', 'Alice')`,
+            `insert into account (id, name) values ('2', 'Bob')`,
+            `insert into transfer (id, from_id, to_id, amount) values ('t1', '1', '2', 100)`,
+            `insert into transfer (id, from_id, to_id, amount) values ('t2', '2', 'missing', 50)`,
+            `insert into transfer (id, from_id, to_id, amount) values ('t3', 'missing', '1', 75)`,
+            `insert into transfer (id, from_id, to_id, amount) values ('t4', null, '1', 25)`,
+        ])
+
+        const client = useServer(`
+            type Account @entity {
+                id: ID!
+                name: String
+                transfersFrom: [Transfer!] @derivedFrom(field: "from")
+                transfersTo: [Transfer!] @derivedFrom(field: "to")
+            }
+
+            type Transfer @entity {
+                id: ID!
+                from: Account @disableForeignKeyConstraint
+                to: Account @disableForeignKeyConstraint
+                amount: Int!
+            }
+        `)
+
+        it('returns null for FK relation when referenced row is missing, but exposes raw ID via {field}Id', function () {
+            return client.test(`
+                query {
+                    transfers(orderBy: [id_ASC]) {
+                        id
+                        from { id name }
+                        fromId
+                        to { id name }
+                        toId
+                        amount
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't1', from: {id: '1', name: 'Alice'}, fromId: '1', to: {id: '2', name: 'Bob'}, toId: '2', amount: 100},
+                    {id: 't2', from: {id: '2', name: 'Bob'}, fromId: '2', to: null, toId: 'missing', amount: 50},
+                    {id: 't3', from: null, fromId: 'missing', to: {id: '1', name: 'Alice'}, toId: '1', amount: 75},
+                    {id: 't4', from: null, fromId: null, to: {id: '1', name: 'Alice'}, toId: '1', amount: 25},
+                ]
+            })
+        })
+
+        it('can query only {field}Id without the relation', function () {
+            return client.test(`
+                query {
+                    transfers(orderBy: [id_ASC]) {
+                        id
+                        fromId
+                        toId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't1', fromId: '1', toId: '2'},
+                    {id: 't2', fromId: '2', toId: 'missing'},
+                    {id: 't3', fromId: 'missing', toId: '1'},
+                    {id: 't4', fromId: null, toId: '1'},
+                ]
+            })
+        })
+
+        it('supports {field}Id_eq filter', function () {
+            return client.test(`
+                query {
+                    transfers(where: {fromId_eq: "missing"}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't3', fromId: 'missing'},
+                ]
+            })
+        })
+
+        it('supports {field}Id_not_eq filter', function () {
+            return client.test(`
+                query {
+                    transfers(where: {fromId_not_eq: "missing"}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't1', fromId: '1'},
+                    {id: 't2', fromId: '2'},
+                ]
+            })
+        })
+
+        it('supports {field}Id_in filter', function () {
+            return client.test(`
+                query {
+                    transfers(where: {fromId_in: ["1", "missing"]}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't1', fromId: '1'},
+                    {id: 't3', fromId: 'missing'},
+                ]
+            })
+        })
+
+        it('supports {field}Id_not_in filter', function () {
+            return client.test(`
+                query {
+                    transfers(where: {fromId_not_in: ["1", "missing"]}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't2', fromId: '2'},
+                ]
+            })
+        })
+
+        it('supports {field}Id_isNull filter', function () {
+            return client.test(`
+                query {
+                    transfers(where: {fromId_isNull: true}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't4', fromId: null},
+                ]
+            })
+        })
+
+        it('supports {field}Id_contains filter', function () {
+            return client.test(`
+                query {
+                    transfers(where: {fromId_contains: "iss"}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't3', fromId: 'missing'},
+                ]
+            })
+        })
+
+        it('supports {field}Id_startsWith filter', function () {
+            return client.test(`
+                query {
+                    transfers(where: {fromId_startsWith: "mis"}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't3', fromId: 'missing'},
+                ]
+            })
+        })
+
+        it('supports {field}Id_endsWith filter', function () {
+            return client.test(`
+                query {
+                    transfers(where: {toId_endsWith: "2"}, orderBy: [id_ASC]) {
+                        id
+                        toId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't1', toId: '2'},
+                ]
+            })
+        })
+
+        it('supports {field}Id_gt and {field}Id_lt filters', function () {
+            return client.test(`
+                query {
+                    transfers(where: {fromId_gt: "1", fromId_lt: "missing"}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't2', fromId: '2'},
+                ]
+            })
+        })
+
+        it('can combine {field}Id filter with other filters', function () {
+            return client.test(`
+                query {
+                    transfers(where: {fromId_eq: "2", amount_gt: 40}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                        amount
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't2', fromId: '2', amount: 50},
+                ]
+            })
+        })
+
+        it('can combine {field}Id filter with relation filter in OR', function () {
+            return client.test(`
+                query {
+                    transfers(where: {OR: [{fromId_eq: "missing"}, {from: {name_eq: "Alice"}}]}, orderBy: [id_ASC]) {
+                        id
+                        fromId
+                    }
+                }
+            `, {
+                transfers: [
+                    {id: 't1', fromId: '1'},
+                    {id: 't3', fromId: 'missing'},
+                ]
+            })
+        })
+    })
+})

package/src/util/util.ts

@@ -1,5 +1,6 @@
 import {toSnakeCase} from "@subsquid/util-naming"
 import assert from "assert"
+import {Prop} from "../model"
 
 
 export function toColumn(gqlFieldName: string): string {
@@ -37,3 +38,18 @@ export function invalidFormat(type: string, value: string): Error {
 export function identity<T>(x: T): T {
     return x
 }
+
+
+export function toFkIdField(fkFieldName: string): string {
+    return fkFieldName + 'Id'
+}
+
+
+export function getFkPropByIdField(
+    idFieldName: string,
+    properties: Record<string, Prop>
+): Prop | undefined {
+    if (!idFieldName.endsWith('Id')) return undefined
+    let fkProp = properties[idFieldName.slice(0, -2)]
+    return fkProp?.type.kind == 'fk' ? fkProp : undefined
+}