@subsquid/openreader 2.1.0 → 3.0.0

package/src/limit.size.ts

@@ -1,12 +1,13 @@
 import {unexpectedCase} from '@subsquid/util-internal'
+import assert from 'assert'
 import {Where} from './ir/args'
 import {RelayConnectionRequest} from './ir/connection'
-import {FieldRequest} from './ir/fields'
+import {AnyFields, FieldRequest} from './ir/fields'
 import {Model} from './model'
-import {getEntity} from './model.tools'
+import {getEntity, getQueryableEntities} from './model.tools'
 
 
-export function getSize(model: Model, fields: FieldRequest[]): number {
+export function getObjectSize(model: Model, fields: FieldRequest[]): number {
     let total = 0
     for (let req of fields) {
         let size = getFieldSize(model, req)
@@ -31,9 +32,9 @@ function getFieldSize(model: Model, req: FieldRequest): number {
         case "fk":
         case "lookup":
         case "union":
-            return getSize(model, req.children) + 1
+            return getObjectSize(model, req.children) + 1
         case "list-lookup":
-            return getEntityListSize(
+            return getListSize(
                 model,
                 req.type.entity,
                 req.children,
@@ -46,22 +47,55 @@ function getFieldSize(model: Model, req: FieldRequest): number {
 }
 
 
-export function getEntityListSize(
+export function getListSize(
     model: Model,
-    entityName: string,
-    fields: FieldRequest[],
+    typeName: string,
+    fields: AnyFields,
     limit?: number,
     where?: Where
 ): number {
-    let cardinality = Math.min(
-        getEntityCardinality(model, entityName),
-        limit ?? Infinity,
-        getWhereCardinality(where)
-    )
-    if (Number.isFinite(cardinality)) {
-        return cardinality * Math.max(getSize(model, fields), 1)
-    } else {
-        return Infinity
+    let cardinality = getCardinality(model, typeName, limit, where)
+    if (!Number.isFinite(cardinality)) return Infinity
+    let type = model[typeName]
+    switch(type.kind) {
+        case 'entity': {
+            assert(Array.isArray(fields))
+            return cardinality * Math.max(getObjectSize(model, fields), 1)
+        }
+        case 'interface': {
+            assert(!Array.isArray(fields))
+            let weight = 1
+            for (let entity of getQueryableEntities(model, typeName)) {
+                weight = Math.max(weight, getObjectSize(model, fields[entity] || []))
+            }
+            return cardinality * weight
+        }
+        default:
+            throw unexpectedCase(type.kind)
+    }
+}
+
+
+function getCardinality(
+    model: Model,
+    typeName: string,
+    limit?: number,
+    where?: Where
+): number  {
+    let type = model[typeName]
+    switch(type.kind) {
+        case 'entity':
+            return Math.min(type.cardinality ?? Infinity, limit ?? Infinity, getWhereCardinality(where))
+        case 'interface': {
+            let whereCardinality = getWhereCardinality(where)
+            let cardinality = 0
+            for (let entity of getQueryableEntities(model, typeName)) {
+                cardinality += Math.min(getEntity(model, entity).cardinality ?? Infinity, whereCardinality)
+            }
+            return Math.min(cardinality, limit ?? Infinity)
+        }
+        default:
+            throw unexpectedCase(type.kind)
     }
 }
 
@@ -102,18 +136,14 @@ function getWhereCardinality(where?: Where): number {
 }
 
 
-export function getRelaySize(model: Model, entityName: string, req: RelayConnectionRequest): number {
+export function getConnectionSize(model: Model, typeName: string, req: RelayConnectionRequest<AnyFields>): number {
+    let first = req.first ?? 100
     let total = 0
-    let limit = Math.min(
-        getEntityCardinality(model, entityName),
-        req.first ?? 100,
-        getWhereCardinality(req.where)
-    )
     if (req.edgeNode) {
-        total += limit * Math.max(getSize(model, req.edgeNode), 1)
+        total += getListSize(model, typeName, req.edgeNode, first, req.where)
     }
     if (req.edgeCursor) {
-        total += limit
+        total += getCardinality(model, typeName, first, req.where)
     }
     if (req.pageInfo) {
         total += 4
@@ -123,8 +153,3 @@ export function getRelaySize(model: Model, entityName: string, req: RelayConnect
     }
     return total
 }
-
-
-function getEntityCardinality(model: Model, entityName: string): number {
-    return getEntity(model, entityName).cardinality ?? Infinity
-}

package/src/main.ts

@@ -31,7 +31,6 @@ GraphQL server for postgres-compatible databases
     program.option('--sql-statement-timeout <ms>', 'sql statement timeout in ms', nat)
     program.option('--subscriptions', 'enable gql subscriptions')
     program.option('--subscription-poll-interval <ms>', 'subscription poll interval in ms', nat, 1000)
-    program.option('--subscription-sql-statement-timeout <ms>', 'sql statement timeout for polling queries', nat)
     program.option('--subscription-max-response-size <nodes>', 'max response size measured in nodes', nat)
 
     let opts = program.parse().opts() as {
@@ -45,7 +44,6 @@ GraphQL server for postgres-compatible databases
         sqlStatementTimeout?: number
         subscriptions?: boolean
         subscriptionPollInterval: number
-        subscriptionSqlStatementTimeout?: number
         subscriptionMaxResponseSize?: number
     }
 
@@ -56,14 +54,6 @@ GraphQL server for postgres-compatible databases
         statement_timeout: opts.sqlStatementTimeout || undefined
     })
 
-    let subscriptionConnection: Pool | undefined
-    if (opts.subscriptions) {
-        subscriptionConnection = new Pool({
-            connectionString: opts.dbUrl,
-            statement_timeout: opts.subscriptionSqlStatementTimeout || opts.sqlStatementTimeout || undefined
-        })
-    }
-
     let server = await serve({
         model,
         dialect: opts.dbType,
@@ -75,7 +65,6 @@ GraphQL server for postgres-compatible databases
         maxResponseNodes: opts.maxResponseSize,
         subscriptions: opts.subscriptions,
         subscriptionPollInterval: opts.subscriptionPollInterval,
-        subscriptionConnection,
         subscriptionMaxResponseNodes: opts.subscriptionMaxResponseSize
     })
 

package/src/model.schema.ts

@@ -1,5 +1,5 @@
-import {assertNotNull, unexpectedCase} from "@subsquid/util-internal"
-import assert from "assert"
+import {assertNotNull, unexpectedCase} from '@subsquid/util-internal'
+import assert from 'assert'
 import {
     buildASTSchema,
     DocumentNode,
@@ -17,14 +17,15 @@ import {
     GraphQLUnionType,
     parse,
     validateSchema
-} from "graphql"
-import {Index, Model, Prop, PropType, Scalar} from "./model"
-import {validateModel} from "./model.tools"
-import {customScalars} from "./scalars"
+} from 'graphql'
+import {Index, Model, Prop, PropType, Scalar} from './model'
+import {validateModel} from './model.tools'
+import {customScalars} from './scalars'
 
 
 const baseSchema = buildASTSchema(parse(`
     directive @entity on OBJECT
+    directive @query on INTERFACE
     directive @derivedFrom(field: String!) on FIELD_DEFINITION
     directive @unique on FIELD_DEFINITION
     directive @index(fields: [String!] unique: Boolean) on OBJECT | FIELD_DEFINITION
@@ -88,7 +89,7 @@ function addEntityOrJsonObjectOrInterface(model: Model, type: GraphQLObjectType
             model[type.name] = {kind, properties, description, interfaces}
             break
         case 'interface':
-            model[type.name] = {kind, properties, description}
+            model[type.name] = {kind, properties, description, queryable: isQueryableInterface(type)}
             break
         default:
             throw unexpectedCase(kind)
@@ -173,7 +174,7 @@ function addEntityOrJsonObjectOrInterface(model: Model, type: GraphQLObjectType
                 ...limits
             }
         } else if (fieldType instanceof GraphQLObjectType) {
-            if (isEntityType(fieldType)) {
+            if (isEntityType(fieldType) && kind != 'interface') {
                 switch(list.nulls.length) {
                     case 0:
                         if (derivedFrom) {
@@ -196,7 +197,7 @@ function addEntityOrJsonObjectOrInterface(model: Model, type: GraphQLObjectType
                             properties[key] = {
                                 type: {
                                     kind: 'fk',
-                                    foreignEntity: fieldType.name
+                                    entity: fieldType.name
                                 },
                                 nullable,
                                 unique,
@@ -519,6 +520,12 @@ function checkByteWeightDirective(type: GraphQLNamedType, f: GraphQLField<any, a
 }
 
 
+function isQueryableInterface(type: GraphQLOutputType): boolean {
+    return type instanceof GraphQLInterfaceType
+        && !!type.astNode?.directives?.find(d => d.name.value == 'query')
+}
+
+
 function unsupportedFieldTypeError(propName: string): Error {
     return new SchemaError(`Property ${propName} has unsupported type`)
 }

package/src/model.tools.ts

@@ -1,5 +1,6 @@
-import assert from "assert"
-import {Entity, FTS_Query, JsonObject, Model, Prop, PropType} from "./model"
+import {unexpectedCase} from '@subsquid/util-internal'
+import assert from 'assert'
+import {Entity, FTS_Query, Interface, JsonObject, Model, Prop, PropType} from './model'
 
 
 const UNION_MAPS = new WeakMap<Model, Record<string, JsonObject>>()
@@ -20,8 +21,7 @@ export function buildUnionProps(model: Model, unionName: string): JsonObject {
     let union = model[unionName]
     assert(union.kind == 'union')
     let properties: Record<string, Prop> = {}
-    for (let i = 0; i < union.variants.length; i++) {
-        let objectName = union.variants[i]
+    for (let objectName of union.variants) {
         let object = model[objectName]
         assert(object.kind == 'object')
         Object.assign(properties, object.properties)
@@ -34,12 +34,106 @@ export function buildUnionProps(model: Model, unionName: string): JsonObject {
 }
 
 
+const QUERYABLE_ENTITIES = new WeakMap<Model, Record<string, string[]>>()
+
+
+export function getQueryableEntities(model: Model, queryableName: string): string[] {
+    let cache = QUERYABLE_ENTITIES.get(model)
+    if (cache == null) {
+        cache = {}
+        QUERYABLE_ENTITIES.set(model, cache)
+    }
+    let entities = cache[queryableName]
+    if (entities) return entities
+    entities = cache[queryableName] = []
+    for (let name in model) {
+        let item = model[name]
+        if (item.kind == 'entity' && item.interfaces?.includes(queryableName)) {
+            entities.push(name)
+        }
+    }
+    return entities
+}
+
+
+export function getQueryableProperties(model: Model, queryableName: string): Record<string, Prop> {
+    let queryable = getInterface(model, queryableName)
+    let props: Record<string, Prop> = {}
+    for (let entityName of getQueryableEntities(model, queryableName)) {
+        let entity = getEntity(model, entityName)
+        for (let key in queryable.properties) {
+            let ep = entity.properties[key]
+            if (ep == null) throw new Error(
+                `Entity ${entityName} doesn't implement ${queryableName} properly: .${key} property is missing`
+            )
+            let prop = matchWithQueryableProp(queryable.properties[key], ep)
+            if (prop == null) throw new Error(
+                `Entity ${entityName} doesn't implement ${queryableName} properly: .${key} property types are incompatible`
+            )
+            props[key] = prop
+        }
+    }
+    return props
+}
+
+
+function matchWithQueryableProp(queryableProp: Prop, entityProp: Prop): Prop | undefined {
+    if (!queryableProp.nullable && entityProp.nullable) return undefined
+    let qt = queryableProp.type
+    let et = entityProp.type
+    switch(et.kind) {
+        case 'fk':
+        case 'lookup':
+            if (qt.kind == 'object' && qt.name == et.entity) {
+                return {
+                    type: et,
+                    nullable: queryableProp.nullable,
+                    description: queryableProp.description
+                }
+            }
+            return undefined
+        case 'list-lookup':
+            if (qt.kind == 'list' && qt.item.type.kind == 'object' && qt.item.type.name == et.entity) {
+                return {
+                    type: et,
+                    nullable: false,
+                    description: queryableProp.description
+                }
+            }
+            return undefined
+        default:
+            if (propTypeEquals(et, qt)) {
+                return queryableProp
+            }
+            return undefined
+    }
+}
+
+
+export function getUniversalProperties(model: Model, typeName: string): Record<string, Prop> {
+    let item = model[typeName]
+    switch(item.kind) {
+        case 'entity':
+        case 'object':
+            return item.properties
+        case 'union':
+            return getUnionProps(model, typeName).properties
+        case 'interface':
+            assert(item.queryable)
+            return getQueryableProperties(model, typeName)
+        default:
+            throw unexpectedCase(item.kind)
+    }
+}
+
+
 export function validateModel(model: Model) {
     // TODO: check all invariants we assume
     validateNames(model)
     validateUnionTypes(model)
     validateLookups(model)
     validateIndexes(model)
+    validateQueryableInterfaces(model)
 }
 
 
@@ -119,7 +213,7 @@ export function validateLookups(model: Model): void {
                     if (prop.type.kind == 'lookup' || prop.type.kind == 'list-lookup') {
                         let lookupEntity = getEntity(model, prop.type.entity)
                         let lookupProperty = lookupEntity.properties[prop.type.field]
-                        if (lookupProperty?.type.kind != 'fk' || lookupProperty.type.foreignEntity != name) {
+                        if (lookupProperty?.type.kind != 'fk' || lookupProperty.type.entity != name) {
                             throw invalidProperty(name, key, `${prop.type.entity}.${prop.type.field} is not a foreign key pointing to ${name}`)
                         }
                         if (prop.type.kind == 'lookup' && !lookupProperty.unique) {
@@ -142,7 +236,7 @@ export function validateIndexes(model: Model): void {
             index.fields.forEach(f => {
                 let prop = item.properties[f.name]
                 if (prop == null) throw new Error(
-                    `Entity ${name} doesn't have a property ${f.name}, but is a part of index`
+                    `Entity ${name} doesn't have a property ${f.name}, but it is a part of index`
                 )
                 switch(prop.type.kind) {
                     case "scalar":
@@ -160,6 +254,16 @@ export function validateIndexes(model: Model): void {
 }
 
 
+export function validateQueryableInterfaces(model: Model): void {
+    for (let name in model) {
+        let item = model[name]
+        if (item.kind == 'interface' && item.queryable) {
+            getQueryableProperties(model, name)
+        }
+    }
+}
+
+
 function invalidProperty(item: string, key: string, msg: string): Error {
     return new Error(`Invalid property ${item}.${key}: ${msg}`)
 }
@@ -167,10 +271,12 @@ function invalidProperty(item: string, key: string, msg: string): Error {
 
 export function propTypeEquals(a: PropType, b: PropType): boolean {
     if (a.kind != b.kind) return false
-    if (a.kind == 'list') return propTypeEquals(a.item.type, (b as typeof a).item.type)
     switch(a.kind) {
+        case 'list':
+            return a.item.nullable == (b as typeof a).item.nullable
+                && propTypeEquals(a.item.type, (b as typeof a).item.type)
         case 'fk':
-            return a.foreignEntity == (b as typeof a).foreignEntity
+            return a.entity == (b as typeof a).entity
         case 'lookup':
         case 'list-lookup':
             return a.entity == (b as typeof a).entity && a.field == (b as typeof a).field
@@ -194,6 +300,13 @@ export function getObject(model: Model, name: string): JsonObject {
 }
 
 
+export function getInterface(model: Model, name: string): Interface {
+    let i = model[name]
+    assert(i.kind == 'interface', `${name} expected to be an interface`)
+    return i
+}
+
+
 export function getFtsQuery(model: Model, name: string): FTS_Query {
     let query = model[name]
     assert(query.kind == 'fts', `${name} expected to be FTS query`)

package/src/model.ts

@@ -23,6 +23,7 @@ export interface JsonObject extends TypeMeta {
 export interface Interface extends TypeMeta {
     kind: 'interface'
     properties: Record<Name, Prop>
+    queryable?: boolean
 }
 
 
@@ -108,7 +109,7 @@ export interface ListPropType {
 
 export interface FkPropType {
     kind: 'fk'
-    foreignEntity: Name
+    entity: Name
 }
 
 

package/src/opencrud/orderBy.ts

@@ -1,6 +1,6 @@
 import assert from "assert"
 import type {Model} from "../model"
-import {getUnionProps} from "../model.tools"
+import {getUnionProps, getUniversalProperties} from '../model.tools'
 import {OrderBy} from "../ir/args"
 
 
@@ -19,27 +19,23 @@ export type OpenCrud_OrderBy_Mapping = ReadonlyMap<OpenCrudOrderByValue, OrderBy
 const MAPPING_CACHE = new WeakMap<Model, Record<string, OpenCrud_OrderBy_Mapping>>()
 
 
-export function getOrderByMapping(model: Model, entityName: string): OpenCrud_OrderBy_Mapping {
+export function getOrderByMapping(model: Model, typeName: string): OpenCrud_OrderBy_Mapping {
     let cache = MAPPING_CACHE.get(model)
     if (cache == null) {
         cache = {}
         MAPPING_CACHE.set(model, cache)
     }
-    if (cache[entityName]) return cache[entityName]
-    return cache[entityName] = buildOrderByMapping(model, entityName, 2)
+    if (cache[typeName]) return cache[typeName]
+    return cache[typeName] = buildOrderByMapping(model, typeName, 2)
 }
 
 
 function buildOrderByMapping(model: Model, typeName: string, depth: number): OpenCrud_OrderBy_Mapping {
     if (depth <= 0) return new Map()
-    let object = model[typeName]
-    if (object.kind == 'union') {
-        object = getUnionProps(model, typeName)
-    }
-    assert(object.kind == 'entity' || object.kind == 'object')
+    let properties = getUniversalProperties(model, typeName)
     let m = new Map<string, OrderBy>()
-    for (let key in object.properties) {
-        let propType = object.properties[key].type
+    for (let key in properties) {
+        let propType = properties[key].type
         switch(propType.kind) {
             case 'scalar':
             case 'enum':
@@ -55,10 +51,6 @@ function buildOrderByMapping(model: Model, typeName: string, depth: number): Ope
                 }
                 break
             case 'fk':
-                for (let [name, spec] of buildOrderByMapping(model, propType.foreignEntity, depth - 1)) {
-                    m.set(key + '_' + name, {[key]: spec})
-                }
-                break
             case 'lookup':
                 for (let [name, spec] of buildOrderByMapping(model, propType.entity, depth - 1)) {
                     m.set(key + '_' + name, {[key]: spec})
@@ -66,12 +58,16 @@ function buildOrderByMapping(model: Model, typeName: string, depth: number): Ope
                 break
         }
     }
+    if (model[typeName].kind == 'interface') {
+        m.set('_type_ASC', {_type: 'ASC'})
+        m.set('_type_DESC', {_type: 'DESC'})
+    }
     return m
 }
 
 
-export function parseOrderBy(model: Model, entityName: string, input: OpenCrudOrderByValue[]): OrderBy {
-    let mapping = getOrderByMapping(model, entityName)
+export function parseOrderBy(model: Model, typeName: string, input: OpenCrudOrderByValue[]): OrderBy {
+    let mapping = getOrderByMapping(model, typeName)
     return mergeOrderBy(
         input.map(value => {
             let spec = mapping.get(value)