@subsquid/openreader 2.0.0 → 3.0.0

package/lib/util/execute.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWithLimit = void 0;
+const graphql_1 = require("graphql");
+const execute_1 = require("graphql/execution/execute");
+function executeWithLimit(maxQueries, args) {
+    (0, execute_1.assertValidExecutionArguments)(args.schema, args.document, args.variableValues);
+    let xtx = (0, execute_1.buildExecutionContext)(args.schema, args.document, args.rootValue, args.contextValue, args.variableValues, args.operationName, args.fieldResolver, args.typeResolver);
+    if (Array.isArray(xtx)) {
+        return { errors: xtx };
+    }
+    let etx = xtx;
+    if (etx.operation.operation == 'query') {
+        let query = (0, graphql_1.getOperationRootType)(etx.schema, etx.operation);
+        let fields = (0, execute_1.collectFields)(etx, query, etx.operation.selectionSet, Object.create(null), Object.create(null));
+        let fieldsCount = Object.keys(fields).length;
+        if (fieldsCount > maxQueries) {
+            return {
+                errors: [
+                    new graphql_1.GraphQLError(`only ${maxQueries} root query fields allowed, but got ${fieldsCount}`)
+                ]
+            };
+        }
+    }
+    return (0, execute_1.execute)(args);
+}
+exports.executeWithLimit = executeWithLimit;
+//# sourceMappingURL=execute.js.map

package/lib/util/execute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.js","sourceRoot":"","sources":["../../src/util/execute.ts"],"names":[],"mappings":";;;AAAA,qCAA0D;AAE1D,uDAOkC;AAIlC,SAAgB,gBAAgB,CAAC,UAAkB,EAAE,IAAmB;IACpE,IAAA,uCAA6B,EAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,CAAA;IAE9E,IAAI,GAAG,GAAG,IAAA,+BAAqB,EAC3B,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,QAAQ,EACb,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,YAAY,EACjB,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,YAAY,CACpB,CAAA;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;QACpB,OAAO,EAAC,MAAM,EAAE,GAAG,EAAC,CAAA;KACvB;IAED,IAAI,GAAG,GAAG,GAAuB,CAAA;IACjC,IAAI,GAAG,CAAC,SAAS,CAAC,SAAS,IAAI,OAAO,EAAE;QACpC,IAAI,KAAK,GAAG,IAAA,8BAAoB,EAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,CAAA;QAC3D,IAAI,MAAM,GAAG,IAAA,uBAAa,EACtB,GAAG,EACH,KAAK,EACL,GAAG,CAAC,SAAS,CAAC,YAAY,EAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EACnB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CACtB,CAAA;QACD,IAAI,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAA;QAC5C,IAAI,WAAW,GAAG,UAAU,EAAE;YAC1B,OAAO;gBACH,MAAM,EAAE;oBACJ,IAAI,sBAAY,CAAC,QAAQ,UAAU,uCAAuC,WAAW,EAAE,CAAC;iBAC3F;aACJ,CAAA;SACJ;KACJ;IAED,OAAO,IAAA,iBAAc,EAAC,IAAI,CAAC,CAAA;AAC/B,CAAC;AAvCD,4CAuCC"}

package/lib/util/limit.d.ts

@@ -0,0 +1,11 @@
+export declare class Limit {
+    private error;
+    private value;
+    constructor(error: Error, value: number);
+    get left(): number;
+    check(cb: (left: number) => number): void;
+}
+export declare class ResponseSizeLimit extends Limit {
+    constructor(maxNodes: number);
+}
+//# sourceMappingURL=limit.d.ts.map

package/lib/util/limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limit.d.ts","sourceRoot":"","sources":["../../src/util/limit.ts"],"names":[],"mappings":"AAIA,qBAAa,KAAK;IACF,OAAO,CAAC,KAAK;IAAS,OAAO,CAAC,KAAK;gBAA3B,KAAK,EAAE,KAAK,EAAU,KAAK,EAAE,MAAM;IAIvD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,KAAK,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI;CAS5C;AAOD,qBAAa,iBAAkB,SAAQ,KAAK;gBAC5B,QAAQ,EAAE,MAAM;CAG/B"}

package/lib/util/limit.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseSizeLimit = exports.Limit = void 0;
+const assert_1 = __importDefault(require("assert"));
+const graphql_1 = require("graphql");
+class Limit {
+    constructor(error, value) {
+        this.error = error;
+        this.value = value;
+        (0, assert_1.default)(this.value > 0);
+    }
+    get left() {
+        return Math.max(this.value, 0);
+    }
+    check(cb) {
+        if (this.value < 0)
+            throw this.error;
+        let left = this.value - cb(this.value);
+        if (left < 0) {
+            throw this.error;
+        }
+        else {
+            this.value = left;
+        }
+    }
+}
+exports.Limit = Limit;
+const SIZE_LIMIT = new graphql_1.GraphQLError('response might exceed the size limit');
+SIZE_LIMIT.stack = undefined;
+class ResponseSizeLimit extends Limit {
+    constructor(maxNodes) {
+        super(SIZE_LIMIT, maxNodes);
+    }
+}
+exports.ResponseSizeLimit = ResponseSizeLimit;
+//# sourceMappingURL=limit.js.map

package/lib/util/limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limit.js","sourceRoot":"","sources":["../../src/util/limit.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA2B;AAC3B,qCAAoC;AAGpC,MAAa,KAAK;IACd,YAAoB,KAAY,EAAU,KAAa;QAAnC,UAAK,GAAL,KAAK,CAAO;QAAU,UAAK,GAAL,KAAK,CAAQ;QACnD,IAAA,gBAAM,EAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAA;IAC1B,CAAC;IAED,IAAI,IAAI;QACJ,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IAClC,CAAC;IAED,KAAK,CAAC,EAA4B;QAC9B,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC;YAAE,MAAM,IAAI,CAAC,KAAK,CAAA;QACpC,IAAI,IAAI,GAAG,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACtC,IAAI,IAAI,GAAG,CAAC,EAAE;YACV,MAAM,IAAI,CAAC,KAAK,CAAA;SACnB;aAAM;YACH,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;SACpB;IACL,CAAC;CACJ;AAlBD,sBAkBC;AAGD,MAAM,UAAU,GAAG,IAAI,sBAAY,CAAC,sCAAsC,CAAC,CAAA;AAC3E,UAAU,CAAC,KAAK,GAAG,SAAS,CAAA;AAG5B,MAAa,iBAAkB,SAAQ,KAAK;IACxC,YAAY,QAAgB;QACxB,KAAK,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;IAC/B,CAAC;CACJ;AAJD,8CAIC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@subsquid/openreader",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "GraphQL server for postgres-compatible databases",
   "keywords": [
     "graphql",
@@ -22,7 +22,7 @@
   ],
   "dependencies": {
     "@graphql-tools/merge": "^8",
-    "@subsquid/graphiql-console": "^0.2.0",
+    "@subsquid/graphiql-console": "^0.3.0",
     "@subsquid/logger": "^0.1.0",
     "@subsquid/util-internal": "^0.0.1",
     "@subsquid/util-internal-commander": "^0.0.0",
@@ -54,7 +54,7 @@
     "typescript": "~4.7.4"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc",
+    "build": "rm -rf lib && tsc",
     "test": "make up && sleep 2 && make test test-cockroach && make down || (make down && exit 1)"
   },
   "readme": "# OpenReader\n\nGraphQL server for squid framework. Given [data schema](https://docs.subsquid.io/reference/openreader-schema) \nand compatible Postgres database it serves \"read part\" of [OpenCRUD spec](https://www.opencrud.org).\n\n## Usage\n\n```bash\nopenreader schema.graphql\n```\n\nDatabase connection and server port are configured via environment variables:\n\n```\nDB_NAME\nDB_USER\nDB_PASS\nDB_HOST\nDB_PORT\nGRAPHQL_SERVER_PORT\n```\n"

package/src/context.ts

@@ -1,5 +1,6 @@
-import {Dialect} from "./dialect"
-import {Query} from "./sql/query"
+import {Dialect} from './dialect'
+import {Query} from './sql/query'
+import {Limit} from './util/limit'
 
 
 export interface Context {
@@ -11,4 +12,6 @@ export interface OpenreaderContext {
     dialect: Dialect
     executeQuery<T>(query: Query<T>): Promise<T>
     subscription<T>(query: Query<T>): AsyncIterable<T>
+    responseSizeLimit?: Limit
+    subscriptionResponseSizeLimit?: Limit
 }

package/src/ir/args.ts

@@ -1,4 +1,4 @@
-export interface EntityListArguments {
+export interface SqlArguments {
     offset?: number
     limit?: number
     orderBy?: OrderBy

package/src/ir/connection.ts

@@ -1,13 +1,12 @@
-import {OrderBy, Where} from "./args"
-import {FieldRequest} from "./fields"
+import {OrderBy, Where} from './args'
 
 
-export interface RelayConnectionRequest {
+export interface RelayConnectionRequest<R> {
     orderBy: OrderBy
     where?: Where
     first?: number
     after?: string
-    edgeNode?: FieldRequest[]
+    edgeNode?: R
     edgeCursor?: boolean
     pageInfo?: boolean
     totalCount?: boolean

package/src/ir/fields.ts

@@ -1,3 +1,4 @@
+import assert from 'assert'
 import {
     EnumPropType,
     FkPropType,
@@ -9,7 +10,7 @@ import {
     ScalarPropType,
     UnionPropType
 } from "../model"
-import {EntityListArguments} from "./args"
+import {SqlArguments} from "./args"
 
 
 export type FieldRequest = EntityListRequest | ObjectRequest | OpaqueRequest
@@ -28,7 +29,7 @@ type Base<T> = T extends PropType ? {
 
 export type EntityListRequest = Base<ListLookupPropType> & {
     children: FieldRequest[]
-    args?: EntityListArguments
+    args?: SqlArguments
 }
 
 
@@ -38,3 +39,22 @@ export type ObjectRequest = Base<FkPropType | LookupPropType | ObjectPropType |
 
 
 export type OpaqueRequest = Base<ScalarPropType | EnumPropType | ListPropType>
+
+
+
+export type FieldsByEntity = Record<string, FieldRequest[]>
+
+
+export type AnyFields = FieldRequest[] | FieldsByEntity
+
+
+export function asEntityFields(fields: AnyFields): FieldRequest[] {
+    assert(Array.isArray(fields))
+    return fields
+}
+
+
+export function asQueryableFields(fields: AnyFields): FieldsByEntity {
+    assert(!Array.isArray(fields))
+    return fields
+}

package/src/limit.size.ts

@@ -1,11 +1,16 @@
-import {unexpectedCase} from "@subsquid/util-internal"
-import {FieldRequest} from "./ir/fields"
+import {unexpectedCase} from '@subsquid/util-internal'
+import assert from 'assert'
+import {Where} from './ir/args'
+import {RelayConnectionRequest} from './ir/connection'
+import {AnyFields, FieldRequest} from './ir/fields'
+import {Model} from './model'
+import {getEntity, getQueryableEntities} from './model.tools'
 
 
-export function getSize(fields: FieldRequest[]): number {
+export function getObjectSize(model: Model, fields: FieldRequest[]): number {
     let total = 0
     for (let req of fields) {
-        let size = getFieldSize(req)
+        let size = getFieldSize(model, req)
         if (Number.isFinite(size)) {
             total += size * req.aliases.length
         } else {
@@ -16,7 +21,7 @@ export function getSize(fields: FieldRequest[]): number {
 }
 
 
-function getFieldSize(req: FieldRequest): number {
+function getFieldSize(model: Model, req: FieldRequest): number {
     switch(req.kind) {
         case "scalar":
         case "list":
@@ -27,20 +32,124 @@ function getFieldSize(req: FieldRequest): number {
         case "fk":
         case "lookup":
         case "union":
-            return getSize(req.children) + 1
-        case "list-lookup": {
-            let limit = Math.min(req.args?.limit ?? Infinity, req.prop.cardinality ?? Infinity)
-            if (Number.isFinite(limit)) {
-                return limit * Math.max(getSize(req.children), 1)
-            } else {
-                return Infinity
+            return getObjectSize(model, req.children) + 1
+        case "list-lookup":
+            return getListSize(
+                model,
+                req.type.entity,
+                req.children,
+                Math.min(req.args?.limit ?? Infinity, req.prop.cardinality ?? Infinity),
+                req.args?.where
+            ) + 1
+        default:
+            throw unexpectedCase()
+    }
+}
+
+
+export function getListSize(
+    model: Model,
+    typeName: string,
+    fields: AnyFields,
+    limit?: number,
+    where?: Where
+): number {
+    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()
+            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)
+    }
+}
+
+
+function getWhereCardinality(where?: Where): number {
+    if (where == null) return Infinity
+    switch(where.op) {
+        case 'AND': {
+            let min = Infinity
+            for (let co of where.args) {
+                min = Math.min(min, getWhereCardinality(co))
+            }
+            return min
+        }
+        case 'OR': {
+            if (where.args.length == 0) return Infinity
+            let max = 0
+            for (let co of where.args) {
+                max = Math.max(max, getWhereCardinality(co))
+            }
+            return max
+        }
+        case 'eq':
+            if (where.field == 'id') {
+                return 1
+            } else {
+                return Infinity
+            }
+        case 'in':
+            if (where.field == 'id') {
+                return where.values.length
+            } else {
+                return Infinity
+            }
+        default:
+            return Infinity
+    }
+}
 
 
+export function getConnectionSize(model: Model, typeName: string, req: RelayConnectionRequest<AnyFields>): number {
+    let first = req.first ?? 100
+    let total = 0
+    if (req.edgeNode) {
+        total += getListSize(model, typeName, req.edgeNode, first, req.where)
+    }
+    if (req.edgeCursor) {
+        total += getCardinality(model, typeName, first, req.where)
+    }
+    if (req.pageInfo) {
+        total += 4
+    }
+    if (req.totalCount) {
+        total += 1
+    }
+    return total
+}

package/src/main.ts

@@ -1,12 +1,12 @@
-import {createLogger} from "@subsquid/logger"
-import {runProgram} from "@subsquid/util-internal"
-import {nat, Url} from "@subsquid/util-internal-commander"
-import {waitForInterruption} from "@subsquid/util-internal-http-server"
-import {Command, Option} from "commander"
-import {Pool} from "pg"
-import {Dialect} from "./dialect"
-import {serve} from "./server"
-import {loadModel} from "./tools"
+import {createLogger} from '@subsquid/logger'
+import {runProgram} from '@subsquid/util-internal'
+import {nat, Url} from '@subsquid/util-internal-commander'
+import {waitForInterruption} from '@subsquid/util-internal-http-server'
+import {Command, Option} from 'commander'
+import {Pool} from 'pg'
+import {Dialect} from './dialect'
+import {serve} from './server'
+import {loadModel} from './tools'
 
 
 const LOG = createLogger('sqd:openreader')
@@ -26,10 +26,12 @@ GraphQL server for postgres-compatible databases
     )
     program.option('-p, --port <number>', 'port to listen on', nat, 3000)
     program.option('--max-request-size <kb>', 'max request size in kilobytes', nat, 256)
+    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('--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 {
         schema: string
@@ -37,10 +39,12 @@ GraphQL server for postgres-compatible databases
         dbType: Dialect
         port: number
         maxRequestSize: number
+        maxRootFields?: number
+        maxResponseSize?: number
         sqlStatementTimeout?: number
         subscriptions?: boolean
         subscriptionPollInterval: number
-        subscriptionSqlStatementTimeout?: number
+        subscriptionMaxResponseSize?: number
     }
 
     let model = loadModel(opts.schema)
@@ -50,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,
@@ -65,9 +61,11 @@ GraphQL server for postgres-compatible databases
         port: opts.port,
         log: LOG,
         maxRequestSizeBytes: opts.maxRequestSize * 1024,
+        maxRootFields: opts.maxRootFields,
+        maxResponseNodes: opts.maxResponseSize,
         subscriptions: opts.subscriptions,
         subscriptionPollInterval: opts.subscriptionPollInterval,
-        subscriptionConnection
+        subscriptionMaxResponseNodes: opts.subscriptionMaxResponseSize
     })
 
     LOG.info(`listening on port ${server.port}`)

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,19 +17,20 @@ 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
     directive @fulltext(query: String!) on FIELD_DEFINITION
-    directive @cardinality(value: Int!) on FIELD_DEFINITION
+    directive @cardinality(value: Int!) on OBJECT | FIELD_DEFINITION
     directive @byteWeight(value: Float!) on FIELD_DEFINITION
     directive @variant on OBJECT # legacy
     directive @jsonField on OBJECT # legacy
@@ -77,17 +78,18 @@ function addEntityOrJsonObjectOrInterface(model: Model, type: GraphQLObjectType
     let properties: Record<string, Prop> = {}
     let interfaces: string[] = []
     let indexes: Index[] = type instanceof GraphQLObjectType ? checkEntityIndexes(type) : []
+    let cardinality = checkEntityCardinality(type)
     let description = type.description || undefined
 
     switch(kind) {
         case 'entity':
-            model[type.name] = {kind, properties, description, interfaces, indexes}
+            model[type.name] = {kind, properties, description, interfaces, indexes, ...cardinality}
             break
         case 'object':
             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)
@@ -172,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) {
@@ -195,7 +197,7 @@ function addEntityOrJsonObjectOrInterface(model: Model, type: GraphQLObjectType
                             properties[key] = {
                                 type: {
                                     kind: 'fk',
-                                    foreignEntity: fieldType.name
+                                    entity: fieldType.name
                                 },
                                 nullable,
                                 unique,
@@ -467,10 +469,29 @@ function checkDerivedFrom(type: GraphQLNamedType, f: GraphQLField<any, any>): {f
 }
 
 
+function checkEntityCardinality(type: GraphQLObjectType | GraphQLInterfaceType): {cardinality?: number} {
+    let directives = type.astNode?.directives?.filter(d => d.name.value == 'cardinality') || []
+    if (directives.length > 0 && !isEntityType(type)) {
+        throw new SchemaError(`@cardinality directive can be only applied to entities, but were applied to ${type.name}`)
+    }
+    if (directives.length > 1) throw new SchemaError(
+        `Multiple @cardinality directives where applied to ${type.name}`
+    )
+    if (directives.length == 0) return {}
+    let arg = assertNotNull(directives[0].arguments?.find(arg => arg.name.value == 'value'))
+    assert(arg.value.kind == 'IntValue')
+    let cardinality = parseInt(arg.value.value, 10)
+    if (cardinality < 0) throw new SchemaError(
+        `Incorrect @cardinality where applied to ${type.name}. Cardinality value must be positive.`
+    )
+    return {cardinality}
+}
+
+
 function checkCardinalityLimitDirective(type: GraphQLNamedType, f: GraphQLField<any, any>): {cardinality?: number} {
     let directives = f.astNode?.directives?.filter(d => d.name.value == 'cardinality') || []
     if (directives.length > 1) throw new SchemaError(
-        `Multiple @cardinality where applied to ${type.name}.${f.name}`
+        `Multiple @cardinality directives where applied to ${type.name}.${f.name}`
     )
     if (directives.length == 0) return {}
     let arg = assertNotNull(directives[0].arguments?.find(arg => arg.name.value == 'value'))
@@ -486,7 +507,7 @@ function checkCardinalityLimitDirective(type: GraphQLNamedType, f: GraphQLField<
 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(
-        `Multiple @byteWeight where applied to ${type.name}.${f.name}`
+        `Multiple @byteWeight directives where applied to ${type.name}.${f.name}`
     )
     if (directives.length == 0) return {}
     let arg = assertNotNull(directives[0].arguments?.find(arg => arg.name.value == 'value'))
@@ -499,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`)
 }