@subsquid/openreader 5.4.0-beta.11e779 → 5.4.0

package/src/server.ts

@@ -1,9 +1,8 @@
 import {Logger} from '@subsquid/logger'
 import {listen, ListeningServer} from '@subsquid/util-internal-http-server'
-import {KeyValueCache, PluginDefinition} from 'apollo-server-core'
-import {ApolloServer} from 'apollo-server-express'
+import {KeyValueCache, PluginDefinition} from '@subsquid/apollo-server-core'
+import {ApolloServer} from '@subsquid/apollo-server-express'
 import express from 'express'
-import { validate } from 'graphql'
 import fs from 'fs'
 import {ExecutionArgs, GraphQLSchema} from 'graphql'
 import {useServer as useWsServer} from 'graphql-ws/lib/use/ws'
@@ -156,7 +155,9 @@ export async function runApollo(options: ApolloOptions): Promise<ListeningServer
         stopOnTerminationSignals: false,
         allowBatchedHttpRequests: false,
         dangerouslyDisableValidation: false,
-        validationMaxErrors,
+        validateOptions: {
+            maxErrors: validationMaxErrors
+        },
         executor: async req => {
             return execute({
                 schema,

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/execute.ts

@@ -1,6 +1,6 @@
 import {Logger, LogLevel} from '@subsquid/logger'
 import {addErrorContext} from '@subsquid/util-internal'
-import {UserInputError} from 'apollo-server-core'
+import {UserInputError} from '@subsquid/apollo-server-core'
 import {getOperationRootType, GraphQLError, subscribe as graphqlSubscribe} from 'graphql'
 import {ExecutionResult} from 'graphql-ws'
 import {

package/src/util/limit.ts

@@ -1,4 +1,4 @@
-import {UserInputError} from 'apollo-server-core'
+import {UserInputError} from '@subsquid/apollo-server-core'
 import assert from 'assert'
 
 

package/src/util/resolve-tree.ts

@@ -1,4 +1,4 @@
-import {UserInputError} from "apollo-server-core"
+import {UserInputError} from "@subsquid/apollo-server-core"
 import assert from "assert"
 import {GraphQLResolveInfo, GraphQLSchema} from "graphql"
 import {

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
+}