@subsquid/openreader 0.3.2 → 0.3.3

package/dist/test/where.test.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const setup_1 = require("./util/setup");
+describe('AND, OR on entity filters', function () {
+    (0, setup_1.useDatabase)([
+        `create table item (id text primary key, a int, b int)`,
+        `insert into item (id, a, b) values ('1', 1, 1)`,
+        `insert into item (id, a, b) values ('2', 2, 2)`,
+        `insert into item (id, a, b) values ('3', 3, 2)`,
+        `insert into item (id, a, b) values ('4', 4, 4)`,
+        `insert into item (id, a, b) values ('5', 5, 4)`,
+        `insert into item (id, a, b) values ('6', 5, 6)`,
+    ]);
+    const client = (0, setup_1.useServer)(`
+        type Item @entity {
+            id: ID!
+            a: Int
+            b: Int
+        }
+    `);
+    it('{c, and: {c}}', function () {
+        return client.test(`
+            query {
+                items(where: {a_eq: 1, AND: {b_eq: 1}} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                { id: '1' }
+            ]
+        });
+    });
+    it('{and: {and: {c}, c}}', function () {
+        return client.test(`
+            query {
+                items(where: {AND: {b_eq: 2, AND: {a_eq: 3}}} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                { id: '3' }
+            ]
+        });
+    });
+    it('{and: [{c}, {c}]}', function () {
+        return client.test(`
+            query {
+                items(where: {AND: [{a_eq: 2}, {b_eq: 2}]} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                { id: '2' }
+            ]
+        });
+    });
+    it('{c, {or: {c}}}', function () {
+        return client.test(`
+            query {
+                items(where: {a_eq: 1, OR: {a_eq: 2}} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                { id: '1' },
+                { id: '2' }
+            ]
+        });
+    });
+    it('{or: [{c}, {c}]}', function () {
+        return client.test(`
+            query {
+                items(where: {OR: [{a_eq: 2}, {a_eq: 3}]} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                { id: '2' },
+                { id: '3' }
+            ]
+        });
+    });
+    it('{or: {or: {c}, c}}', function () {
+        return client.test(`
+            query {
+                items(where: {OR: {a_eq: 1, OR: {b_eq: 2}}} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                { id: '1' },
+                { id: '2' },
+                { id: '3' }
+            ]
+        });
+    });
+    it('{and: [{or: {c}, c}, {or: {c}, c}]}', function () {
+        return client.test(`
+            query {
+                items(where: {AND: [{OR: {a_eq: 5}, a_eq: 4}, {OR: {b_eq: 2}, b_eq: 4}]} orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                { id: '4' },
+                { id: '5' }
+            ]
+        });
+    });
+    it('{c, and: {c}, or: {c}}', function () {
+        return client.test(`
+            query {
+                items(where: { a_eq: 4, AND: {b_eq: 4}, OR: {b_eq: 6} } orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                { id: '4' },
+                { id: '6' }
+            ]
+        });
+    });
+    it('handles empty wheres', function () {
+        return client.test(`
+            query {
+                items(where: { a_eq: 4, AND: { OR: {}, AND: {} }, OR: { OR: {AND: {} } } } orderBy: id_ASC) { id }
+            }
+        `, {
+            items: [
+                { id: '4' }
+            ]
+        });
+    });
+});
+//# sourceMappingURL=where.test.js.map

package/dist/test/where.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"where.test.js","sourceRoot":"","sources":["../../src/test/where.test.ts"],"names":[],"mappings":";;AAAA,wCAAmD;AAEnD,QAAQ,CAAC,2BAA2B,EAAE;IAClC,IAAA,mBAAW,EAAC;QACR,uDAAuD;QACvD,gDAAgD;QAChD,gDAAgD;QAChD,gDAAgD;QAChD,gDAAgD;QAChD,gDAAgD;QAChD,gDAAgD;KACnD,CAAC,CAAA;IAEF,MAAM,MAAM,GAAG,IAAA,iBAAS,EAAC;;;;;;KAMxB,CAAC,CAAA;IAEF,EAAE,CAAC,eAAe,EAAE;QAChB,OAAO,MAAM,CAAC,IAAI,CAAC;;;;SAIlB,EAAE;YACC,KAAK,EAAE;gBACH,EAAC,EAAE,EAAE,GAAG,EAAC;aACZ;SACJ,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,sBAAsB,EAAE;QACvB,OAAO,MAAM,CAAC,IAAI,CAAC;;;;SAIlB,EAAE;YACC,KAAK,EAAE;gBACH,EAAC,EAAE,EAAE,GAAG,EAAC;aACZ;SACJ,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,mBAAmB,EAAE;QACpB,OAAO,MAAM,CAAC,IAAI,CAAC;;;;SAIlB,EAAE;YACC,KAAK,EAAE;gBACH,EAAC,EAAE,EAAE,GAAG,EAAC;aACZ;SACJ,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,gBAAgB,EAAE;QACjB,OAAO,MAAM,CAAC,IAAI,CAAC;;;;SAIlB,EAAE;YACC,KAAK,EAAE;gBACH,EAAC,EAAE,EAAE,GAAG,EAAC;gBACT,EAAC,EAAE,EAAE,GAAG,EAAC;aACZ;SACJ,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,kBAAkB,EAAE;QACnB,OAAO,MAAM,CAAC,IAAI,CAAC;;;;SAIlB,EAAE;YACC,KAAK,EAAE;gBACH,EAAC,EAAE,EAAE,GAAG,EAAC;gBACT,EAAC,EAAE,EAAE,GAAG,EAAC;aACZ;SACJ,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,oBAAoB,EAAE;QACrB,OAAO,MAAM,CAAC,IAAI,CAAC;;;;SAIlB,EAAE;YACC,KAAK,EAAE;gBACH,EAAC,EAAE,EAAE,GAAG,EAAC;gBACT,EAAC,EAAE,EAAE,GAAG,EAAC;gBACT,EAAC,EAAE,EAAE,GAAG,EAAC;aACZ;SACJ,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,qCAAqC,EAAE;QACtC,OAAO,MAAM,CAAC,IAAI,CAAC;;;;SAIlB,EAAE;YACC,KAAK,EAAE;gBACH,EAAC,EAAE,EAAE,GAAG,EAAC;gBACT,EAAC,EAAE,EAAE,GAAG,EAAC;aACZ;SACJ,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,wBAAwB,EAAE;QACzB,OAAO,MAAM,CAAC,IAAI,CAAC;;;;SAIlB,EAAE;YACC,KAAK,EAAE;gBACH,EAAC,EAAE,EAAE,GAAG,EAAC;gBACT,EAAC,EAAE,EAAE,GAAG,EAAC;aACZ;SACJ,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,sBAAsB,EAAE;QACvB,OAAO,MAAM,CAAC,IAAI,CAAC;;;;SAIlB,EAAE;YACC,KAAK,EAAE;gBACH,EAAC,EAAE,EAAE,GAAG,EAAC;aACZ;SACJ,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA"}

package/dist/tools.d.ts

@@ -1,2 +1,3 @@
 import type { Model } from "./model";
 export declare function loadModel(schemaFile: string): Model;
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,SAAS,CAAA;AAGlC,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,CAwBnD"}

package/dist/util.d.ts

@@ -5,3 +5,4 @@ export declare function toTable(entityName: string): string;
 export declare function ensureArray<T>(item: T | T[]): T[];
 export declare function unsupportedCase(value: string): Error;
 export declare function toInt(val: number | string): number;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE3D;AAGD,wBAAgB,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAErD;AAGD,wBAAgB,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAEvD;AAGD,wBAAgB,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAElD;AAGD,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAEjD;AAGD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAEpD;AAGD,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAIlD"}

package/dist/where.d.ts

@@ -6,3 +6,4 @@ export declare function parseWhereField(field: string): {
 };
 export declare function hasConditions(where?: any): where is any;
 export declare function whereOpToSqlOperator(op: WhereOp): string;
+//# sourceMappingURL=where.d.ts.map

package/dist/where.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"where.d.ts","sourceRoot":"","sources":["../src/where.ts"],"names":[],"mappings":"AACA,oBAAY,OAAO,GACf,GAAG,GAAG,cAAc;AACpB,IAAI,GAAG,QAAQ,GACf,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,KAAK,GACL,IAAI,GAAG,QAAQ,GACf,UAAU,GAAG,cAAc,GAC3B,YAAY,GAAG,gBAAgB,GAC/B,UAAU,GAAG,cAAc,GAC3B,aAAa,GACb,aAAa,GACb,cAAc,GACd,MAAM,GACN,OAAO,GACP,MAAM,CAAA;AAmCV,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG;IAAC,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAQ3E;AAGD,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,GAAG,GAAG,KAAK,IAAI,GAAG,CAsBvD;AAGD,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,CAqBxD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@subsquid/openreader",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "GraphQL server for squid framework",
   "keywords": [
     "graphql",
@@ -15,14 +15,15 @@
     "openreader": "./bin/main.js"
   },
   "files": [
+    "bin",
     "dist",
-    "!dist/test"
+    "src"
   ],
   "dependencies": {
     "@graphql-tools/merge": "^8",
     "@graphql-tools/utils": "^8",
     "@subsquid/graphiql-console": "^0.2.0",
-    "@subsquid/util": "^0.0.2",
+    "@subsquid/util": "^0.0.3",
     "apollo-server-core": "^3.5.0",
     "apollo-server-express": "^3.5.0",
     "express": "^4.17.2",

package/src/db.ts

@@ -0,0 +1,83 @@
+import type {ClientBase, Pool, PoolClient, PoolConfig} from "pg"
+
+
+export interface Database {
+    query(sql: string, parameters?: any[]): Promise<any[][]>
+    escapeIdentifier(name: string): string
+}
+
+
+/**
+ * This is an interface OpenReader uses to interact with underling database.
+ */
+export interface Transaction {
+    get(): Promise<Database>
+}
+
+
+export class PgDatabase implements Database {
+    constructor(private client: ClientBase) {}
+
+    query(sql: string, parameters?: any[]): Promise<any[]> {
+        return this.client.query({text: sql, rowMode: 'array'}, parameters).then(result => result.rows)
+    }
+
+    escapeIdentifier(name: string): string {
+        return this.client.escapeIdentifier(name)
+    }
+}
+
+
+export class PoolTransaction implements Transaction {
+    private tx: Promise<{client: PoolClient, db: Database}> | undefined
+    private closed = false
+
+    constructor(private pool: Pool) {}
+
+    async get(): Promise<Database> {
+        if (this.closed) {
+            throw new Error('Too late to request transaction')
+        }
+        this.tx = this.tx || this.startTransaction()
+        let {db} = await this.tx
+        return db
+    }
+
+    private async startTransaction(): Promise<{client: PoolClient, db: Database}> {
+        let client = await this.pool.connect()
+        try {
+            await client.query('START TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY')
+            return {
+                client,
+                db: new PgDatabase(client)
+            }
+        } catch(e: any) {
+            client.release()
+            throw e
+        }
+    }
+
+    close(): Promise<void> {
+        this.closed = true
+        return this.tx?.then(async ({client}) => {
+            try {
+                await client.query('COMMIT')
+            } catch(e: any) {
+                // ignore
+            } finally {
+                client.release()
+            }
+        }) || Promise.resolve()
+    }
+}
+
+
+export function createPoolConfig(): PoolConfig {
+    return {
+        host: process.env.DB_HOST || 'localhost',
+        port: process.env.DB_PORT ? parseInt(process.env.DB_PORT) : 5432,
+        database: process.env.DB_NAME || 'postgres',
+        user: process.env.DB_USER || 'postgres',
+        password: process.env.DB_PASS || 'postgres'
+    }
+}

package/src/gql/opencrud.ts

@@ -0,0 +1,328 @@
+import {Output, toCamelCase, toPlural} from "@subsquid/util"
+import assert from "assert"
+import {DocumentNode, parse, print} from "graphql"
+import {Entity, Enum, FTS_Query, Interface, JsonObject, Model, Prop, Union} from "../model"
+import {getOrderByMapping} from "../orderBy"
+import {scalars_list} from "../scalars"
+import {toQueryListField} from "../util"
+
+
+export function generateOpenCrudQueries(model: Model): string {
+    let out = new Output()
+
+    generatePageInfoType()
+
+    for (let name in model) {
+        let item = model[name]
+        switch(item.kind) {
+            case 'entity':
+                generateOrderByInput(name)
+                generateWhereUniqueInput(name)
+                generateWhereInput(name, item)
+                generateObjectType(name, item)
+                generateEntityConnection(name)
+                break
+            case 'object':
+                if (hasFilters(item)) {
+                    generateWhereInput(name, item)
+                }
+                generateObjectType(name, item)
+                break
+            case 'interface':
+                generateObjectType(name, item)
+                break
+            case 'union':
+                generateUnionWhereInput(name, item)
+                generateUnionType(name, item)
+                break
+            case 'enum':
+                generateEnumType(name, item)
+                break
+            case 'fts':
+                generateFtsTypes(name, item)
+                break
+        }
+    }
+
+    out.block('type Query', () => {
+        for (let name in model) {
+            let item = model[name]
+            if (item.kind == 'entity') {
+                out.line(`${toCamelCase(name)}ById(id: ID!): ${name}`)
+                out.line(`${toCamelCase(name)}ByUniqueInput(where: ${name}WhereUniqueInput!): ${name} @deprecated(reason: "Use \`${toCamelCase(name)}ById\`")`)
+                out.line(`${toQueryListField(name)}${manyArguments(name)}: [${name}!]!`)
+                out.line(`${toQueryListField(name)}Connection${connectionArguments(name)}: ${toPlural(name)}Connection!`)
+            }
+            if (item.kind == 'fts') {
+                generateFtsQuery(name, item)
+            }
+        }
+    })
+
+    function generateObjectType(name: string, object: Entity | JsonObject | Interface): void {
+        let head: string
+        if (object.kind == 'interface') {
+            head = `interface ${name}`
+        } else {
+            head = `type ${name}`
+            if (object.interfaces?.length) {
+                head += ` implements ${object.interfaces.join(' & ')}`
+            }
+        }
+        generateDescription(object.description)
+        out.block(head, () => {
+            for (let key in object.properties) {
+                let prop = object.properties[key]
+                let gqlType = renderPropType(prop)
+                generateDescription(prop.description)
+                if (prop.type.kind == 'list-lookup') {
+                    out.line(`${key}${manyArguments(prop.type.entity)}: ${gqlType}`)
+                } else {
+                    out.line(`${key}: ${gqlType}`)
+                }
+            }
+        })
+        out.line()
+    }
+
+    function renderPropType(prop: Prop): string {
+        switch(prop.type.kind) {
+            case "list":
+                return `[${renderPropType(prop.type.item)}]${prop.nullable ? '' : '!'}`
+            case 'fk':
+                return `${prop.type.foreignEntity}${prop.nullable ? '' : '!'}`
+            case 'lookup':
+                return prop.type.entity
+            case 'list-lookup':
+                return `[${prop.type.entity}!]!`
+            default:
+                return prop.type.name + (prop.nullable ? '' : '!')
+        }
+    }
+
+    function manyArguments(entityName: string): string {
+        return `(where: ${entityName}WhereInput orderBy: [${entityName}OrderByInput] offset: Int limit: Int)`
+    }
+
+    function connectionArguments(entityName: string): string {
+        return `(orderBy: [${entityName}OrderByInput!]! after: String first: Int where: ${entityName}WhereInput)`
+    }
+
+    function generateOrderByInput(entityName: string): void {
+        out.block(`enum ${entityName}OrderByInput`, () => {
+            let mapping = getOrderByMapping(model, entityName)
+            for (let key of mapping.keys()) {
+                out.line(key)
+            }
+        })
+        out.line()
+    }
+
+    function generateWhereUniqueInput(entityName: string): void {
+        out.block(`input ${entityName}WhereUniqueInput`, () => {
+            out.line('id: ID!')
+        })
+    }
+
+    function generateWhereInput(name: string, object: Entity | JsonObject): void {
+        out.block(`input ${name}WhereInput`, () => {
+            generatePropsFilters(object.properties)
+            if (object.kind == 'entity') {
+                out.line(`AND: [${name}WhereInput!]`)
+                out.line(`OR: [${name}WhereInput!]`)
+            }
+        })
+        out.line()
+    }
+
+    function generatePropsFilters(props: Record<string, Prop>): void {
+        for (let key in props) {
+            let prop = props[key]
+            switch(prop.type.kind) {
+                case 'scalar':
+                case 'enum':
+                    generateScalarFilters(key, prop.type.name)
+                    break
+                case 'list':
+                    if (prop.type.item.type.kind == 'scalar' || prop.type.item.type.kind == 'enum') {
+                        let item = prop.type.item.type.name
+                        out.line(`${key}_containsAll: [${item}!]`)
+                        out.line(`${key}_containsAny: [${item}!]`)
+                        out.line(`${key}_containsNone: [${item}!]`)
+                    }
+                    break
+                case 'object':
+                    if (hasFilters(getObject(prop.type.name))) {
+                        out.line(`${key}: ${prop.type.name}WhereInput`)
+                    }
+                    break
+                case 'union':
+                    out.line(`${key}: ${prop.type.name}WhereInput`)
+                    break
+                case 'fk':
+                    out.line(`${key}: ${prop.type.foreignEntity}WhereInput`)
+                    break
+                case 'lookup':
+                    out.line(`${key}: ${prop.type.entity}WhereInput`)
+                    break
+                case 'list-lookup':
+                    out.line(`${key}_every: ${prop.type.entity}WhereInput`)
+                    out.line(`${key}_some: ${prop.type.entity}WhereInput`)
+                    out.line(`${key}_none: ${prop.type.entity}WhereInput`)
+                    break
+            }
+        }
+    }
+
+    function hasFilters(obj: JsonObject): boolean {
+        for (let key in obj.properties) {
+            let propType = obj.properties[key].type
+            switch(propType.kind) {
+                case 'scalar':
+                case 'enum':
+                case 'union':
+                    return true
+                case 'object':
+                    if (hasFilters(getObject(propType.name))) {
+                        return true
+                    }
+            }
+        }
+        return false
+    }
+
+    function getObject(name: string): JsonObject {
+        let obj = model[name]
+        assert(obj.kind == 'object')
+        return obj
+    }
+
+    function generateUnionWhereInput(name: string, union: Union): void {
+        out.block(`input ${name}WhereInput`, () => {
+            // TODO: unify and use enum
+            out.line('isTypeOf_eq: String')
+            out.line('isTypeOf_not_eq: String')
+            out.line('isTypeOf_in: [String!]')
+            out.line('isTypeOf_not_in: [String!]')
+
+            let props: Record<string, Prop> = {}
+            union.variants.forEach(variant => {
+                let obj = getObject(variant)
+                Object.assign(props, obj.properties)
+            })
+
+            generatePropsFilters(props)
+        })
+    }
+
+    function generateScalarFilters(fieldName: string, graphqlType: string): void {
+        out.line(`${fieldName}_eq: ${graphqlType}`)
+        out.line(`${fieldName}_not_eq: ${graphqlType}`)
+
+        switch(graphqlType) {
+            case 'ID':
+            case 'String':
+            case 'Int':
+            case 'Float':
+            case 'DateTime':
+            case 'BigInt':
+                out.line(`${fieldName}_gt: ${graphqlType}`)
+                out.line(`${fieldName}_gte: ${graphqlType}`)
+                out.line(`${fieldName}_lt: ${graphqlType}`)
+                out.line(`${fieldName}_lte: ${graphqlType}`)
+                out.line(`${fieldName}_in: [${graphqlType}!]`)
+                out.line(`${fieldName}_not_in: [${graphqlType}!]`)
+                break
+        }
+
+        if (graphqlType == 'String' || graphqlType == 'ID') {
+            out.line(`${fieldName}_contains: ${graphqlType}`)
+            out.line(`${fieldName}_not_contains: ${graphqlType}`)
+            out.line(`${fieldName}_startsWith: ${graphqlType}`)
+            out.line(`${fieldName}_not_startsWith: ${graphqlType}`)
+            out.line(`${fieldName}_endsWith: ${graphqlType}`)
+            out.line(`${fieldName}_not_endsWith: ${graphqlType}`)
+        }
+
+        if (model[graphqlType]?.kind == 'enum') {
+            out.line(`${fieldName}_in: [${graphqlType}!]`)
+            out.line(`${fieldName}_not_in: [${graphqlType}!]`)
+        }
+    }
+
+    function generateUnionType(name: string, union: Union) {
+        generateDescription(union.description)
+        out.line(`union ${name} = ${union.variants.join(' | ')}`)
+        out.line()
+    }
+
+    function generateEnumType(name: string, e: Enum): void {
+        generateDescription(e.description)
+        out.block(`enum ${name}`, () => {
+            for (let key in e.values) {
+                out.line(key)
+            }
+        })
+    }
+
+    function generatePageInfoType(): void {
+        out.block(`type PageInfo`, () => {
+            out.line('hasNextPage: Boolean!')
+            out.line('hasPreviousPage: Boolean!')
+            out.line('startCursor: String!')
+            out.line('endCursor: String!')
+        })
+        out.line()
+    }
+
+    function generateEntityConnection(name: string): void {
+        out.block(`type ${name}Edge`, () => {
+            out.line(`node: ${name}!`)
+            out.line(`cursor: String!`)
+        })
+        out.line()
+        out.block(`type ${toPlural(name)}Connection`, () => {
+            out.line(`edges: [${name}Edge!]!`)
+            out.line(`pageInfo: PageInfo!`)
+            out.line(`totalCount: Int!`)
+        })
+        out.line()
+    }
+
+    function generateFtsTypes(name: string, query: FTS_Query): void {
+        let itemType = name + '_Item'
+        out.line(`union ${itemType} = ${query.sources.map(s => s.entity).join(' | ')}`)
+        out.line()
+        out.block(`type ${name}_Output`, () => {
+            out.line(`item: ${itemType}!`)
+            out.line(`rank: Float!`)
+            out.line(`highlight: String!`)
+        })
+        out.line()
+    }
+
+    function generateFtsQuery(name: string, query: FTS_Query): void {
+        let where = query.sources.map(src => {
+            return `where${src.entity}: ${src.entity}WhereInput`
+        })
+        out.line(`${name}(text: String! ${where.join(' ')} limit: Int offset: Int): [${name}_Output!]!`)
+    }
+
+    function generateDescription(description?: string): void {
+        if (description) {
+            out.line(print({
+                kind: 'StringValue',
+                value: description
+            }))
+        }
+    }
+
+    return out.toString()
+}
+
+
+export function buildServerSchema(model: Model): DocumentNode {
+    let scalars = scalars_list.map(name => 'scalar ' + name).join('\n')
+    let queries = generateOpenCrudQueries(model)
+    return parse(scalars  + '\n\n' + queries)
+}