@subsquid/openreader 1.0.1 → 2.0.0

package/lib/util/resolve-tree.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasTreeRequest = exports.getTreeRequest = exports.getResolveTree = exports.simplifyResolveTree = void 0;
+const apollo_server_core_1 = require("apollo-server-core");
+const assert_1 = __importDefault(require("assert"));
+const graphql_parse_resolve_info_1 = require("graphql-parse-resolve-info");
+function simplifyResolveTree(schema, tree, typeName) {
+    let type = schema.getType(typeName);
+    (0, assert_1.default)(type != null);
+    return (0, graphql_parse_resolve_info_1.simplifyParsedResolveInfoFragmentWithType)(tree, type);
+}
+exports.simplifyResolveTree = simplifyResolveTree;
+function getResolveTree(info, typeName) {
+    let tree = (0, graphql_parse_resolve_info_1.parseResolveInfo)(info);
+    (0, assert_1.default)(isResolveTree(tree));
+    if (typeName) {
+        return simplifyResolveTree(info.schema, tree, typeName);
+    }
+    else {
+        return tree;
+    }
+}
+exports.getResolveTree = getResolveTree;
+function isResolveTree(resolveInfo) {
+    return resolveInfo != null && resolveInfo.fieldsByTypeName != null;
+}
+function getTreeRequest(treeFields, fieldName) {
+    let req;
+    for (let alias in treeFields) {
+        let e = treeFields[alias];
+        if (e.name != fieldName)
+            continue;
+        if (req != null)
+            throw new apollo_server_core_1.UserInputError(`multiple aliases for field '${fieldName}' are not supported`);
+        req = e;
+    }
+    return req;
+}
+exports.getTreeRequest = getTreeRequest;
+function hasTreeRequest(treeFields, fieldName) {
+    for (let alias in treeFields) {
+        let e = treeFields[alias];
+        if (e.name == fieldName)
+            return true;
+    }
+    return false;
+}
+exports.hasTreeRequest = hasTreeRequest;
+//# sourceMappingURL=resolve-tree.js.map

package/lib/util/resolve-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-tree.js","sourceRoot":"","sources":["../../src/util/resolve-tree.ts"],"names":[],"mappings":";;;;;;AAAA,2DAAiD;AACjD,oDAA2B;AAE3B,2EAKmC;AAanC,SAAgB,mBAAmB,CAAC,MAAqB,EAAE,IAAiB,EAAE,QAAgB;IAC1F,IAAI,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IACnC,IAAA,gBAAM,EAAC,IAAI,IAAI,IAAI,CAAC,CAAA;IACpB,OAAO,IAAA,sEAAyC,EAAC,IAAI,EAAE,IAAI,CAAC,CAAA;AAChE,CAAC;AAJD,kDAIC;AAKD,SAAgB,cAAc,CAAC,IAAwB,EAAE,QAAiB;IACtE,IAAI,IAAI,GAAG,IAAA,6CAAgB,EAAC,IAAI,CAAC,CAAA;IACjC,IAAA,gBAAM,EAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAA;IAC3B,IAAI,QAAQ,EAAE;QACV,OAAO,mBAAmB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAA;KAC1D;SAAM;QACH,OAAO,IAAI,CAAA;KACd;AACL,CAAC;AARD,wCAQC;AAGD,SAAS,aAAa,CAAC,WAA8D;IACjF,OAAO,WAAW,IAAI,IAAI,IAAI,WAAW,CAAC,gBAAgB,IAAI,IAAI,CAAA;AACtE,CAAC;AAGD,SAAgB,cAAc,CAAC,UAA6B,EAAE,SAAiB;IAC3E,IAAI,GAA4B,CAAA;IAChC,KAAK,IAAI,KAAK,IAAI,UAAU,EAAE;QAC1B,IAAI,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;QACzB,IAAI,CAAC,CAAC,IAAI,IAAI,SAAS;YAAE,SAAQ;QACjC,IAAI,GAAG,IAAI,IAAI;YAAE,MAAM,IAAI,mCAAc,CAAC,+BAA+B,SAAS,qBAAqB,CAAC,CAAA;QACxG,GAAG,GAAG,CAAC,CAAA;KACV;IACD,OAAO,GAAG,CAAA;AACd,CAAC;AATD,wCASC;AAGD,SAAgB,cAAc,CAAC,UAA6B,EAAE,SAAiB;IAC3E,KAAK,IAAI,KAAK,IAAI,UAAU,EAAE;QAC1B,IAAI,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;QACzB,IAAI,CAAC,CAAC,IAAI,IAAI,SAAS;YAAE,OAAO,IAAI,CAAA;KACvC;IACD,OAAO,KAAK,CAAA;AAChB,CAAC;AAND,wCAMC"}

package/{dist → lib/util}/util.d.ts

@@ -1,9 +1,8 @@
-export declare function toQueryListField(entityName: string): string;
 export declare function toColumn(gqlFieldName: string): string;
 export declare function toFkColumn(gqlFieldName: string): string;
 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;
+export declare function toSafeInteger(s: number | string): number;
 export declare function invalidFormat(type: string, value: string): Error;
+export declare function identity<T>(x: T): T;
 //# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util/util.ts"],"names":[],"mappings":"AAIA,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,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAIxD;AAGD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAEhE;AAGD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAEnC"}

package/{dist → lib/util}/util.js

@@ -3,13 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.invalidFormat = exports.toInt = exports.unsupportedCase = exports.ensureArray = exports.toTable = exports.toFkColumn = exports.toColumn = exports.toQueryListField = void 0;
+exports.identity = exports.invalidFormat = exports.toSafeInteger = exports.ensureArray = exports.toTable = exports.toFkColumn = exports.toColumn = void 0;
 const util_naming_1 = require("@subsquid/util-naming");
 const assert_1 = __importDefault(require("assert"));
-function toQueryListField(entityName) {
-    return (0, util_naming_1.toPlural)((0, util_naming_1.toCamelCase)(entityName));
-}
-exports.toQueryListField = toQueryListField;
 function toColumn(gqlFieldName) {
     return (0, util_naming_1.toSnakeCase)(gqlFieldName);
 }
@@ -26,18 +22,18 @@ function ensureArray(item) {
     return Array.isArray(item) ? item : [item];
 }
 exports.ensureArray = ensureArray;
-function unsupportedCase(value) {
-    return new Error(`Unsupported case: ${value}`);
-}
-exports.unsupportedCase = unsupportedCase;
-function toInt(val) {
-    let i = parseInt(val);
-    (0, assert_1.default)(!isNaN(i) && isFinite(i));
+function toSafeInteger(s) {
+    let i = parseInt(s, 10);
+    (0, assert_1.default)(Number.isSafeInteger(i));
     return i;
 }
-exports.toInt = toInt;
+exports.toSafeInteger = toSafeInteger;
 function invalidFormat(type, value) {
     return new TypeError(`Not a ${type}: ${value}`);
 }
 exports.invalidFormat = invalidFormat;
+function identity(x) {
+    return x;
+}
+exports.identity = identity;
 //# sourceMappingURL=util.js.map

package/lib/util/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util/util.ts"],"names":[],"mappings":";;;;;;AAAA,uDAAiD;AACjD,oDAA2B;AAG3B,SAAgB,QAAQ,CAAC,YAAoB;IACzC,OAAO,IAAA,yBAAW,EAAC,YAAY,CAAC,CAAA;AACpC,CAAC;AAFD,4BAEC;AAGD,SAAgB,UAAU,CAAC,YAAoB;IAC3C,OAAO,IAAA,yBAAW,EAAC,YAAY,CAAC,GAAG,KAAK,CAAA;AAC5C,CAAC;AAFD,gCAEC;AAGD,SAAgB,OAAO,CAAC,UAAkB;IACtC,OAAO,IAAA,yBAAW,EAAC,UAAU,CAAC,CAAA;AAClC,CAAC;AAFD,0BAEC;AAGD,SAAgB,WAAW,CAAI,IAAa;IACxC,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;AAC9C,CAAC;AAFD,kCAEC;AAGD,SAAgB,aAAa,CAAC,CAAkB;IAC5C,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAW,EAAE,EAAE,CAAC,CAAA;IACjC,IAAA,gBAAM,EAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;IAC/B,OAAO,CAAC,CAAA;AACZ,CAAC;AAJD,sCAIC;AAGD,SAAgB,aAAa,CAAC,IAAY,EAAE,KAAa;IACrD,OAAO,IAAI,SAAS,CAAC,SAAS,IAAI,KAAK,KAAK,EAAE,CAAC,CAAA;AACnD,CAAC;AAFD,sCAEC;AAGD,SAAgB,QAAQ,CAAI,CAAI;IAC5B,OAAO,CAAC,CAAA;AACZ,CAAC;AAFD,4BAEC"}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@subsquid/openreader",
-  "version": "1.0.1",
-  "description": "GraphQL server for squid framework",
+  "version": "2.0.0",
+  "description": "GraphQL server for postgres-compatible databases",
   "keywords": [
     "graphql",
-    "opencrud"
+    "opencrud",
+    "postgres"
   ],
   "license": "GPL-3.0-or-later",
   "repository": "git@github.com:subsquid/squid.git",
@@ -16,29 +17,36 @@
   },
   "files": [
     "bin",
-    "dist",
+    "lib",
     "src"
   ],
   "dependencies": {
     "@graphql-tools/merge": "^8",
-    "@graphql-tools/utils": "^8",
     "@subsquid/graphiql-console": "^0.2.0",
+    "@subsquid/logger": "^0.1.0",
     "@subsquid/util-internal": "^0.0.1",
-    "@subsquid/util-internal-code-printer": "^0.0.1",
-    "@subsquid/util-naming": "^0.0.1",
+    "@subsquid/util-internal-commander": "^0.0.0",
     "@subsquid/util-internal-hex": "^0.0.1",
+    "@subsquid/util-internal-http-server": "^0.1.0",
+    "@subsquid/util-naming": "^0.0.1",
     "apollo-server-core": "^3.9.0",
     "apollo-server-express": "^3.9.0",
+    "commander": "^9.3.0",
+    "deep-equal": "^2.0.5",
     "express": "^4.18.1",
     "graphql": "^15.8.0",
     "graphql-parse-resolve-info": "^4.12.3",
-    "pg": "^8.7.3"
+    "graphql-ws": "^5.9.1",
+    "pg": "^8.7.3",
+    "ws": "^8.8.1"
   },
   "devDependencies": {
+    "@types/deep-equal": "^1.0.1",
     "@types/express": "^4.17.13",
     "@types/mocha": "^9.1.1",
     "@types/node": "^16.11.41",
-    "@types/pg": "8.6.5",
+    "@types/pg": "^8.6.5",
+    "@types/ws": "^8.5.3",
     "dotenv": "^10.0.0",
     "expect": "^27.5.1",
     "gql-test-client": "^0.0.0",

package/src/context.ts

@@ -0,0 +1,14 @@
+import {Dialect} from "./dialect"
+import {Query} from "./sql/query"
+
+
+export interface Context {
+    openreader: OpenreaderContext
+}
+
+
+export interface OpenreaderContext {
+    dialect: Dialect
+    executeQuery<T>(query: Query<T>): Promise<T>
+    subscription<T>(query: Query<T>): AsyncIterable<T>
+}

package/src/db.ts

@@ -1,83 +1,72 @@
-import type {ClientBase, Pool, PoolClient, PoolConfig} from "pg"
+import type {ClientBase, Pool} from "pg"
+import {OpenreaderContext} from "./context"
+import {Dialect} from "./dialect"
+import {Query} from "./sql/query"
+import {Subscription} from "./subscription"
+import {withErrorContext} from "./util/error-handling"
+import {LazyTransaction} from "./util/lazy-transaction"
 
 
 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)
+    query(sql: string, parameters?: any[]): Promise<any[][]> {
+        return this.client.query({text: sql, rowMode: 'array'}, parameters)
+            .then(result => result.rows)
+            .catch(withErrorContext({sql, parameters}))
     }
 }
 
 
-export class PoolTransaction implements Transaction {
-    private tx: Promise<{client: PoolClient, db: Database}> | undefined
-    private closed = false
+export class PoolOpenreaderContext implements OpenreaderContext {
+    private tx: LazyTransaction<Database>
+    private subscriptionPool: Pool
 
-    constructor(private pool: Pool) {}
+    constructor(
+        public readonly dialect: Dialect,
+        pool: Pool,
+        subscriptionPool?: Pool,
+        private subscriptionPollInterval: number = 1000
+    ) {
+        this.tx = new LazyTransaction(cb => transact(pool, cb))
+        this.subscriptionPool = subscriptionPool || 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
+    close(): Promise<void> {
+        return this.tx.close()
     }
 
-    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
-        }
+    async executeQuery<T>(query: Query<T>): Promise<T> {
+        let db = await this.tx.get()
+        let result = await db.query(query.sql, query.params)
+        return query.map(result)
     }
 
-    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()
+    subscription<T>(query: Query<T>): AsyncIterable<T> {
+        return new Subscription(this.subscriptionPollInterval, () => transact(this.subscriptionPool, async db => {
+            let result = await db.query(query.sql, query.params)
+            return query.map(result)
+        }))
     }
 }
 
 
-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'
+async function transact<T>(pool: Pool, cb: (db: Database) => Promise<T>): Promise<T> {
+    let client = await pool.connect()
+    try {
+        await client.query('START TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY')
+        try {
+            let db = new PgDatabase(client)
+            return await cb(db)
+        } finally {
+            await client.query('COMMIT').catch(() => {})
+        }
+    } finally {
+        client.release()
     }
 }

package/src/ir/args.ts

@@ -0,0 +1,85 @@
+export interface EntityListArguments {
+    offset?: number
+    limit?: number
+    orderBy?: OrderBy
+    where?: Where
+}
+
+
+export type Where = AndCondition | OrCondition | InCondition | SetCondition | RefCondition | BinaryCondition | UnaryCondition
+
+
+export interface AndCondition {
+    op: 'AND'
+    args: Where[]
+}
+
+
+export interface OrCondition {
+    op: 'OR'
+    args: Where[]
+}
+
+
+export interface SetCondition {
+    op: 'some' | 'every' | 'none'
+    field: string
+    where?: Where
+}
+
+
+export interface RefCondition {
+    op: 'REF'
+    field: string
+    where: Where
+}
+
+
+export interface InCondition {
+    op: 'in' | 'not_in'
+    field: string
+    values: unknown[]
+}
+
+
+export interface BinaryCondition {
+    op: BinaryOp
+    field: string
+    value: unknown
+}
+
+
+export interface UnaryCondition {
+    op: UnaryOp
+    field: string
+    yes: boolean
+}
+
+
+export type BinaryOp =
+    'eq' |
+    'not_eq' |
+    'gt' |
+    'gte' |
+    'lt' |
+    'lte' |
+    'contains' | 'not_contains' |
+    'containsInsensitive' | 'not_containsInsensitive' |
+    'startsWith' | 'not_startsWith' |
+    'endsWith' | 'not_endsWith' |
+    'containsAll' |
+    'containsAny' |
+    'containsNone' |
+    'jsonContains' |
+    'jsonHasKey'
+
+
+export type UnaryOp = 'isNull'
+
+
+export interface OrderBy {
+    [field: string]: SortOrder | OrderBy
+}
+
+
+export type SortOrder = "ASC" | "DESC"

package/src/ir/connection.ts

@@ -0,0 +1,48 @@
+import {OrderBy, Where} from "./args"
+import {FieldRequest} from "./fields"
+
+
+export interface RelayConnectionRequest {
+    orderBy: OrderBy
+    where?: Where
+    first?: number
+    after?: string
+    edgeNode?: FieldRequest[]
+    edgeCursor?: boolean
+    pageInfo?: boolean
+    totalCount?: boolean
+}
+
+
+export interface RelayConnectionResponse {
+    edges?: RelayConnectionEdge[]
+    pageInfo?: Partial<RelayConnectionPageInfo>
+    totalCount?: number
+}
+
+
+export interface RelayConnectionEdge {
+    node?: unknown
+    cursor?: string
+}
+
+
+export interface RelayConnectionPageInfo {
+    hasNextPage: boolean
+    hasPreviousPage: boolean
+    startCursor: string
+    endCursor: string
+}
+
+
+export function decodeRelayConnectionCursor(cursor: string): number | undefined {
+    if (!/^\d+$/.test(cursor)) return undefined
+    let val = parseInt(cursor, 10)
+    if (Number.isSafeInteger(val) && val > 0) return val
+    return undefined
+}
+
+
+export function encodeRelayConnectionCursor(val: number): string {
+    return '' + val
+}

package/src/ir/fields.ts

@@ -0,0 +1,40 @@
+import {
+    EnumPropType,
+    FkPropType,
+    ListLookupPropType,
+    ListPropType,
+    LookupPropType,
+    ObjectPropType, Prop,
+    PropType,
+    ScalarPropType,
+    UnionPropType
+} from "../model"
+import {EntityListArguments} from "./args"
+
+
+export type FieldRequest = EntityListRequest | ObjectRequest | OpaqueRequest
+
+
+type Base<T> = T extends PropType ? {
+    field: string
+    kind: T['kind']
+    type: T
+    prop: Prop
+    aliases: string[]
+    ifType?: string
+    index: number
+} : never
+
+
+export type EntityListRequest = Base<ListLookupPropType> & {
+    children: FieldRequest[]
+    args?: EntityListArguments
+}
+
+
+export type ObjectRequest = Base<FkPropType | LookupPropType | ObjectPropType | UnionPropType> & {
+    children: FieldRequest[]
+}
+
+
+export type OpaqueRequest = Base<ScalarPropType | EnumPropType | ListPropType>

package/src/limit.size.ts

@@ -0,0 +1,46 @@
+import {unexpectedCase} from "@subsquid/util-internal"
+import {FieldRequest} from "./ir/fields"
+
+
+export function getSize(fields: FieldRequest[]): number {
+    let total = 0
+    for (let req of fields) {
+        let size = getFieldSize(req)
+        if (Number.isFinite(size)) {
+            total += size * req.aliases.length
+        } else {
+            return Infinity
+        }
+    }
+    return total
+}
+
+
+function getFieldSize(req: FieldRequest): number {
+    switch(req.kind) {
+        case "scalar":
+        case "list":
+            return req.prop.byteWeight || 1
+        case "enum":
+            return 1
+        case "object":
+        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
+            }
+        }
+        default:
+            throw unexpectedCase()
+    }
+}
+
+
+
+

package/src/main.ts

@@ -1,51 +1,76 @@
+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 {createPoolConfig} from "./db"
+import {Dialect} from "./dialect"
 import {serve} from "./server"
 import {loadModel} from "./tools"
 
 
-module.exports = function main() {
-    let args = process.argv.slice(2)
+const LOG = createLogger('sqd:openreader')
 
-    if (args.indexOf('--help') >= 0) {
-        help()
-        process.exit(1)
-    }
 
-    if (args.length != 1) {
-        help()
-        process.exit(1)
-    }
+runProgram(async () => {
+    let program = new Command()
 
-    let model = loadModel(args[0])
-    let db = new Pool(createPoolConfig())
-    let port = process.env.GRAPHQL_SERVER_PORT || 3000
-
-    serve({model, db, port}).then(
-        () => {
-            console.log('OpenReader is listening on port ' + port)
-        },
-        err => {
-            console.error(err)
-            process.exit(1)
-        }
+    program.description(`
+GraphQL server for postgres-compatible databases
+    `.trim())
+
+    program.requiredOption('-s, --schema <file>', 'a path to a file or folder with database description')
+    program.requiredOption('-d, --db-url <url>', 'database connection string', Url(['postgres:']))
+    program.addOption(
+        new Option('-t, --db-type <type>', 'database type').choices(['postgres', 'cockroach']).default('postgres')
     )
-}
+    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('--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)
 
+    let opts = program.parse().opts() as {
+        schema: string
+        dbUrl: string
+        dbType: Dialect
+        port: number
+        maxRequestSize: number
+        sqlStatementTimeout?: number
+        subscriptions?: boolean
+        subscriptionPollInterval: number
+        subscriptionSqlStatementTimeout?: number
+    }
 
-function help() {
-    console.error(`
-Usage:  openreader SCHEMA
+    let model = loadModel(opts.schema)
+
+    let connection = new Pool({
+        connectionString: opts.dbUrl,
+        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
+        })
+    }
 
-OpenCRUD GraphQL server.
+    let server = await serve({
+        model,
+        dialect: opts.dbType,
+        connection,
+        port: opts.port,
+        log: LOG,
+        maxRequestSizeBytes: opts.maxRequestSize * 1024,
+        subscriptions: opts.subscriptions,
+        subscriptionPollInterval: opts.subscriptionPollInterval,
+        subscriptionConnection
+    })
 
-Can be configured using the following environment variables:
+    LOG.info(`listening on port ${server.port}`)
 
-    DB_NAME
-    DB_USER
-    DB_PASS
-    DB_HOST
-    DB_PORT
-    GRAPHQL_SERVER_PORT
-`)
-}
+    return waitForInterruption(server)
+}, err => LOG.fatal(err))