graphile-query 0.1.4 → 2.1.5

package/LICENSE

@@ -1,6 +1,8 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Hyperweb <developers@hyperweb.io>
+Copyright (c) 2020-present, Interweb, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,51 +1,177 @@
 # graphile-query
 
-```sh
+<p align="center" width="100%">
+  <img height="250" src="https://raw.githubusercontent.com/launchql/launchql/refs/heads/main/assets/outline-logo.svg" />
+</p>
+
+<p align="center" width="100%">
+  <a href="https://github.com/launchql/launchql/actions/workflows/run-tests.yaml">
+    <img height="20" src="https://github.com/launchql/launchql/actions/workflows/run-tests.yaml/badge.svg" />
+  </a>
+   <a href="https://github.com/launchql/launchql/blob/main/LICENSE"><img height="20" src="https://img.shields.io/badge/license-MIT-blue.svg"/></a>
+   <a href="https://www.npmjs.com/package/graphile-query"><img height="20" src="https://img.shields.io/github/package-json/v/launchql/launchql?filename=packages%2Fgraphile-query%2Fpackage.json"/></a>
+</p>
+
+## GraphileQuery: Simple GraphQL Execution with PostGraphile Context
+
+This module provides utilities to execute GraphQL queries against a PostGraphile-generated schema using PostgreSQL connection pooling and contextual role-based settings.
+
+It includes two main classes:
+
+* `GraphileQuery`: A flexible query runner that supports `pgSettings`, role-based access control, and custom request context.
+* `GraphileQuerySimple`: A minimal wrapper for GraphQL execution without advanced role or settings logic.
+
+## Features
+
+* Built-in support for PostGraphile context and role-based `pgSettings`
+* Works with pre-built PostGraphile schemas
+* Supports raw string queries or parsed `DocumentNode`s
+* Integrates with PostgreSQL via `pg.Pool`
+
+## Installation
+
+```bash
 npm install graphile-query
 ```
 
-## usage
+## Usage
 
-Use as a particular role, skipping any auth logic
+Use as a particular role, skipping any auth logic:
 
-```js
+```ts
 const results = await client.query({
-    role: 'postgres',
-    query,
-    variables
+  role: 'postgres',
+  query,
+  variables
 });
 ```
 
-Or pass a request object to be evaluated based on logic
+Or pass a request object to be evaluated based on logic:
 
-```js
+```ts
 const results = await client.query({
-    req: { something: { special: 'e90829ef-1da4-448d-3e44-b3d275702b86' } },
-    query: MyGraphQLQuery,
-    variables
+  req: { something: { special: 'e90829ef-1da4-448d-3e44-b3d275702b86' } },
+  query: MyGraphQLQuery,
+  variables
 });
 ```
 
-## initialization
 
-```js
-import { GraphileQuery, getSchema } from 'graphile-query';
+### 1. Create a GraphQL Schema
 
-// get the pg pool
-const pool = getRootPgPool();
+```ts
+import { Pool } from 'pg';
+import { getSchema } from 'graphile-query';
 
-// get Graphile Settings
-const settings = getGraphileSettings({
-    schema: [SCHEMA_NAME],
-    pgSettings (req) {
-        // custom logic for requests
-        return { role: 'public' };
-    }
+const pool = new Pool();
+const schema = await getSchema(pool, {
+  schema: ['app_public'],
+  pgSettings: req => ({ 'myapp.user_id': req.user?.id }),
 });
+```
+
+### 2. Execute Queries with `GraphileQuery`
 
-// get schema
-const schema = await getSchema(pool, settings);
+```ts
+import { GraphileQuery } from 'graphile-query';
 
-// initialize client
 const client = new GraphileQuery({ schema, pool, settings });
+
+const result = await client.query({
+  query: `
+    query GetUsers {
+      allUsers {
+        nodes {
+          id
+          username
+        }
+      }
+    }
+  `,
+  role: 'authenticated', // optional
+  req: { user: { id: 123 } }, // optional
+});
 ```
+
+### 3. Use `GraphileQuerySimple` for Lightweight Execution
+
+```ts
+import { GraphileQuerySimple } from 'graphile-query';
+
+const client = new GraphileQuerySimple({ schema, pool });
+
+const result = await client.query(`
+  query {
+    currentUser {
+      id
+      email
+    }
+  }
+`);
+```
+
+## API
+
+### `getSchema(pool, settings)`
+
+* Builds a PostGraphile schema using the given database pool and settings.
+
+### `GraphileQuery`
+
+* `constructor({ schema, pool, settings })`
+* `query({ query, variables?, role?, req? })`
+
+Supports full context, roles, and settings for advanced scenarios.
+
+### `GraphileQuerySimple`
+
+* `constructor({ schema, pool })`
+* `query(query, variables?)`
+
+Lightweight version with no role or settings support.
+
+## Related LaunchQL Tooling
+
+### 🧪 Testing
+
+* [launchql/pgsql-test](https://github.com/launchql/launchql/tree/main/packages/pgsql-test): **📊 Isolated testing environments** with per-test transaction rollbacks—ideal for integration tests, complex migrations, and RLS simulation.
+* [launchql/graphile-test](https://github.com/launchql/launchql/tree/main/packages/graphile-test): **🔐 Authentication mocking** for Graphile-focused test helpers and emulating row-level security contexts.
+* [launchql/pg-query-context](https://github.com/launchql/launchql/tree/main/packages/pg-query-context): **🔒 Session context injection** to add session-local context (e.g., `SET LOCAL`) into queries—ideal for setting `role`, `jwt.claims`, and other session settings.
+
+### 🧠 Parsing & AST
+
+* [launchql/pgsql-parser](https://github.com/launchql/pgsql-parser): **🔄 SQL conversion engine** that interprets and converts PostgreSQL syntax.
+* [launchql/libpg-query-node](https://github.com/launchql/libpg-query-node): **🌉 Node.js bindings** for `libpg_query`, converting SQL into parse trees.
+* [launchql/pg-proto-parser](https://github.com/launchql/pg-proto-parser): **📦 Protobuf parser** for parsing PostgreSQL Protocol Buffers definitions to generate TypeScript interfaces, utility functions, and JSON mappings for enums.
+* [@pgsql/enums](https://github.com/launchql/pgsql-parser/tree/main/packages/enums): **🏷️ TypeScript enums** for PostgreSQL AST for safe and ergonomic parsing logic.
+* [@pgsql/types](https://github.com/launchql/pgsql-parser/tree/main/packages/types): **📝 Type definitions** for PostgreSQL AST nodes in TypeScript.
+* [@pgsql/utils](https://github.com/launchql/pgsql-parser/tree/main/packages/utils): **🛠️ AST utilities** for constructing and transforming PostgreSQL syntax trees.
+* [launchql/pg-ast](https://github.com/launchql/launchql/tree/main/packages/pg-ast): **🔍 Low-level AST tools** and transformations for Postgres query structures.
+
+### 🚀 API & Dev Tools
+
+* [launchql/server](https://github.com/launchql/launchql/tree/main/packages/server): **⚡ Express-based API server** powered by PostGraphile to expose a secure, scalable GraphQL API over your Postgres database.
+* [launchql/explorer](https://github.com/launchql/launchql/tree/main/packages/explorer): **🔎 Visual API explorer** with GraphiQL for browsing across all databases and schemas—useful for debugging, documentation, and API prototyping.
+
+### 🔁 Streaming & Uploads
+
+* [launchql/s3-streamer](https://github.com/launchql/launchql/tree/main/packages/s3-streamer): **📤 Direct S3 streaming** for large files with support for metadata injection and content validation.
+* [launchql/etag-hash](https://github.com/launchql/launchql/tree/main/packages/etag-hash): **🏷️ S3-compatible ETags** created by streaming and hashing file uploads in chunks.
+* [launchql/etag-stream](https://github.com/launchql/launchql/tree/main/packages/etag-stream): **🔄 ETag computation** via Node stream transformer during upload or transfer.
+* [launchql/uuid-hash](https://github.com/launchql/launchql/tree/main/packages/uuid-hash): **🆔 Deterministic UUIDs** generated from hashed content, great for deduplication and asset referencing.
+* [launchql/uuid-stream](https://github.com/launchql/launchql/tree/main/packages/uuid-stream): **🌊 Streaming UUID generation** based on piped file content—ideal for upload pipelines.
+* [launchql/upload-names](https://github.com/launchql/launchql/tree/main/packages/upload-names): **📂 Collision-resistant filenames** utility for structured and unique file names for uploads.
+
+### 🧰 CLI & Codegen
+
+* [@launchql/cli](https://github.com/launchql/launchql/tree/main/packages/cli): **🖥️ Command-line toolkit** for managing LaunchQL projects—supports database scaffolding, migrations, seeding, code generation, and automation.
+* [launchql/launchql-gen](https://github.com/launchql/launchql/tree/main/packages/launchql-gen): **✨ Auto-generated GraphQL** mutations and queries dynamically built from introspected schema data.
+* [@launchql/query-builder](https://github.com/launchql/launchql/tree/main/packages/query-builder): **🏗️ SQL constructor** providing a robust TypeScript-based query builder for dynamic generation of `SELECT`, `INSERT`, `UPDATE`, `DELETE`, and stored procedure calls—supports advanced SQL features like `JOIN`, `GROUP BY`, and schema-qualified queries.
+* [@launchql/query](https://github.com/launchql/launchql/tree/main/packages/query): **🧩 Fluent GraphQL builder** for PostGraphile schemas. ⚡ Schema-aware via introspection, 🧩 composable and ergonomic for building deeply nested queries.
+
+## Disclaimer
+
+AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED "AS IS", AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.
+
+No developer or entity involved in creating this software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the code, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.
+

package/esm/index.js

@@ -0,0 +1,64 @@
+import { withPostGraphileContext, createPostGraphileSchema } from 'postgraphile';
+import { graphql } from 'graphql';
+import { print } from 'graphql/language/printer';
+export const getSchema = async (pool, settings) => await createPostGraphileSchema(pool, settings.schema, settings);
+export class GraphileQuery {
+    pool;
+    schema;
+    settings;
+    constructor({ schema, pool, settings }) {
+        if (!schema)
+            throw new Error('requires a schema');
+        if (!pool)
+            throw new Error('requires a pool');
+        if (!settings)
+            throw new Error('requires graphile settings');
+        this.pool = pool;
+        this.schema = schema;
+        this.settings = settings;
+    }
+    async query({ req = {}, query, variables, role }) {
+        const queryString = typeof query === 'string' ? query : print(query);
+        const { pgSettings: pgSettingsGenerator } = this.settings;
+        const pgSettings = role != null
+            ? { role }
+            : typeof pgSettingsGenerator === 'function'
+                ? await pgSettingsGenerator(req)
+                : pgSettingsGenerator;
+        return await withPostGraphileContext({
+            ...this.settings,
+            pgPool: this.pool,
+            pgSettings
+        }, async (context) => {
+            return await graphql({
+                schema: this.schema,
+                source: queryString,
+                contextValue: context,
+                variableValues: variables
+            });
+        });
+    }
+}
+export class GraphileQuerySimple {
+    pool;
+    schema;
+    constructor({ schema, pool }) {
+        if (!schema)
+            throw new Error('requires a schema');
+        if (!pool)
+            throw new Error('requires a pool');
+        this.pool = pool;
+        this.schema = schema;
+    }
+    async query(query, variables) {
+        const queryString = typeof query === 'string' ? query : print(query);
+        return await withPostGraphileContext({ pgPool: this.pool }, async (context) => {
+            return await graphql({
+                schema: this.schema,
+                source: queryString,
+                contextValue: context,
+                variableValues: variables
+            });
+        });
+    }
+}

package/index.d.ts

@@ -0,0 +1,36 @@
+import { PostGraphileOptions } from 'postgraphile';
+import { GraphQLSchema, ExecutionResult } from 'graphql';
+import { Pool } from 'pg';
+interface GraphileSettings extends PostGraphileOptions {
+    schema: string | string[];
+}
+export declare const getSchema: (pool: Pool, settings: GraphileSettings) => Promise<GraphQLSchema>;
+interface GraphileQueryParams {
+    schema: GraphQLSchema;
+    pool: Pool;
+    settings: GraphileSettings;
+}
+interface QueryOptions {
+    req?: any;
+    query: string;
+    variables?: Record<string, any>;
+    role?: string;
+}
+export declare class GraphileQuery {
+    private pool;
+    private schema;
+    private settings;
+    constructor({ schema, pool, settings }: GraphileQueryParams);
+    query({ req, query, variables, role }: QueryOptions): Promise<ExecutionResult>;
+}
+interface GraphileQuerySimpleParams {
+    schema: GraphQLSchema;
+    pool: Pool;
+}
+export declare class GraphileQuerySimple {
+    private pool;
+    private schema;
+    constructor({ schema, pool }: GraphileQuerySimpleParams);
+    query(query: string, variables?: Record<string, any>): Promise<ExecutionResult>;
+}
+export {};

package/index.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphileQuerySimple = exports.GraphileQuery = exports.getSchema = void 0;
+const postgraphile_1 = require("postgraphile");
+const graphql_1 = require("graphql");
+const printer_1 = require("graphql/language/printer");
+const getSchema = async (pool, settings) => await (0, postgraphile_1.createPostGraphileSchema)(pool, settings.schema, settings);
+exports.getSchema = getSchema;
+class GraphileQuery {
+    pool;
+    schema;
+    settings;
+    constructor({ schema, pool, settings }) {
+        if (!schema)
+            throw new Error('requires a schema');
+        if (!pool)
+            throw new Error('requires a pool');
+        if (!settings)
+            throw new Error('requires graphile settings');
+        this.pool = pool;
+        this.schema = schema;
+        this.settings = settings;
+    }
+    async query({ req = {}, query, variables, role }) {
+        const queryString = typeof query === 'string' ? query : (0, printer_1.print)(query);
+        const { pgSettings: pgSettingsGenerator } = this.settings;
+        const pgSettings = role != null
+            ? { role }
+            : typeof pgSettingsGenerator === 'function'
+                ? await pgSettingsGenerator(req)
+                : pgSettingsGenerator;
+        return await (0, postgraphile_1.withPostGraphileContext)({
+            ...this.settings,
+            pgPool: this.pool,
+            pgSettings
+        }, async (context) => {
+            return await (0, graphql_1.graphql)({
+                schema: this.schema,
+                source: queryString,
+                contextValue: context,
+                variableValues: variables
+            });
+        });
+    }
+}
+exports.GraphileQuery = GraphileQuery;
+class GraphileQuerySimple {
+    pool;
+    schema;
+    constructor({ schema, pool }) {
+        if (!schema)
+            throw new Error('requires a schema');
+        if (!pool)
+            throw new Error('requires a pool');
+        this.pool = pool;
+        this.schema = schema;
+    }
+    async query(query, variables) {
+        const queryString = typeof query === 'string' ? query : (0, printer_1.print)(query);
+        return await (0, postgraphile_1.withPostGraphileContext)({ pgPool: this.pool }, async (context) => {
+            return await (0, graphql_1.graphql)({
+                schema: this.schema,
+                source: queryString,
+                contextValue: context,
+                variableValues: variables
+            });
+        });
+    }
+}
+exports.GraphileQuerySimple = GraphileQuerySimple;

package/package.json

@@ -1,70 +1,38 @@
 {
   "name": "graphile-query",
-  "version": "0.1.4",
-  "description": "query graphile schemas",
+  "version": "2.1.5",
   "author": "Dan Lynch <pyramation@gmail.com>",
-  "homepage": "https://github.com/pyramation/graphile-query#readme",
-  "license": "SEE LICENSE IN LICENSE",
-  "main": "main/index.js",
-  "module": "module/index.js",
-  "directories": {
-    "lib": "src",
-    "test": "__tests__"
-  },
-  "files": [
-    "main",
-    "module"
-  ],
-  "scripts": {
-    "build:main": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start",
-    "build:module": "cross-env MODULE=true babel src --out-dir module --delete-dir-on-start",
-    "build": "npm run build:module && npm run build:main",
-    "prepublish": "npm run build",
-    "dev": "cross-env NODE_ENV=development babel-node src/index",
-    "watch": "cross-env NODE_ENV=development babel-watch src/index",
-    "lint": "eslint src --fix",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
-  },
+  "description": "graphile query",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/launchql/launchql",
+  "license": "MIT",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "directory": "dist"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/pyramation/graphile-query"
+    "url": "https://github.com/launchql/launchql"
   },
-  "keywords": [],
   "bugs": {
-    "url": "https://github.com/pyramation/graphile-query/issues"
+    "url": "https://github.com/launchql/launchql/issues"
   },
-  "devDependencies": {
-    "@babel/cli": "7.11.6",
-    "@babel/core": "7.11.6",
-    "@babel/node": "^7.10.5",
-    "@babel/plugin-proposal-class-properties": "7.10.4",
-    "@babel/plugin-proposal-export-default-from": "7.10.4",
-    "@babel/plugin-proposal-object-rest-spread": "7.11.0",
-    "@babel/plugin-transform-runtime": "7.11.5",
-    "@babel/preset-env": "7.11.5",
-    "babel-core": "7.0.0-bridge.0",
-    "babel-eslint": "10.1.0",
-    "babel-jest": "25.1.0",
-    "babel-watch": "^7.0.0",
-    "cross-env": "^7.0.2",
-    "eslint": "6.8.0",
-    "eslint-config-prettier": "^6.10.0",
-    "eslint-plugin-prettier": "^3.1.2",
-    "jest": "^24.5.0",
-    "jest-in-case": "^1.0.2",
-    "prettier": "^2.1.2",
-    "regenerator-runtime": "^0.13.7"
-  },
-  "peerDependencies": {
-    "postgraphile": "4.x"
+  "scripts": {
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist/**",
+    "prepare": "npm run build",
+    "build": "npm run clean; tsc; tsc -p tsconfig.esm.json; npm run copy",
+    "build:dev": "npm run clean; tsc --declarationMap; tsc -p tsconfig.esm.json; npm run copy",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@babel/runtime": "^7.11.2",
-    "graphql": "^14.0.2"
-  }
-}
+    "graphql": "15.5.2",
+    "pg": "^8.16.0",
+    "postgraphile": "^4.14.1"
+  },
+  "gitHead": "8a638ef47a175c964a63431017d83587e62efbb8"
+}

package/main/index.js

@@ -1,245 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.GraphileQuerySimple = exports.GraphileQuery = exports.getSchema = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _postgraphile = require("postgraphile");
-
-var _graphql = require("graphql");
-
-var _printer = require("graphql/language/printer");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-var getSchema = /*#__PURE__*/function () {
-  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(pool, settings) {
-    return _regenerator["default"].wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return (0, _postgraphile.createPostGraphileSchema)(pool, settings.schema, settings);
-
-          case 2:
-            return _context.abrupt("return", _context.sent);
-
-          case 3:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-
-  return function getSchema(_x, _x2) {
-    return _ref.apply(this, arguments);
-  };
-}();
-
-exports.getSchema = getSchema;
-
-var GraphileQuery = /*#__PURE__*/function () {
-  function GraphileQuery(_ref2) {
-    var schema = _ref2.schema,
-        pool = _ref2.pool,
-        settings = _ref2.settings;
-    (0, _classCallCheck2["default"])(this, GraphileQuery);
-    if (!schema) throw new Error('requires a schema');
-    if (!pool) throw new Error('requires a pool');
-    if (!settings) throw new Error('requires graphile settings');
-    this.pool = pool;
-    this.schema = schema;
-    this.settings = settings;
-  } // role is optional! it overrides anything from req passed in.
-
-
-  (0, _createClass2["default"])(GraphileQuery, [{
-    key: "query",
-    value: function () {
-      var _query2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(_ref3) {
-        var _this = this;
-
-        var _ref3$req, req, _query, variables, role, queryString, pgSettingsGenerator, pgSettings;
-
-        return _regenerator["default"].wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                _ref3$req = _ref3.req, req = _ref3$req === void 0 ? {} : _ref3$req, _query = _ref3.query, variables = _ref3.variables, role = _ref3.role;
-                queryString = typeof _query === 'string' ? _query : (0, _printer.print)(_query);
-                pgSettingsGenerator = this.settings.pgSettings;
-
-                if (!role) {
-                  _context3.next = 7;
-                  break;
-                }
-
-                _context3.t0 = {
-                  role: role
-                };
-                _context3.next = 15;
-                break;
-
-              case 7:
-                if (!(typeof pgSettingsGenerator === 'function')) {
-                  _context3.next = 13;
-                  break;
-                }
-
-                _context3.next = 10;
-                return pgSettingsGenerator(req);
-
-              case 10:
-                _context3.t1 = _context3.sent;
-                _context3.next = 14;
-                break;
-
-              case 13:
-                _context3.t1 = pgSettingsGenerator;
-
-              case 14:
-                _context3.t0 = _context3.t1;
-
-              case 15:
-                pgSettings = _context3.t0;
-                _context3.next = 18;
-                return (0, _postgraphile.withPostGraphileContext)(_objectSpread(_objectSpread({}, this.settings), {}, {
-                  pgPool: this.pool,
-                  pgSettings: pgSettings
-                }), /*#__PURE__*/function () {
-                  var _ref4 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(context) {
-                    return _regenerator["default"].wrap(function _callee2$(_context2) {
-                      while (1) {
-                        switch (_context2.prev = _context2.next) {
-                          case 0:
-                            _context2.next = 2;
-                            return (0, _graphql.graphql)(_this.schema, queryString, null, _objectSpread({}, context), variables);
-
-                          case 2:
-                            return _context2.abrupt("return", _context2.sent);
-
-                          case 3:
-                          case "end":
-                            return _context2.stop();
-                        }
-                      }
-                    }, _callee2);
-                  }));
-
-                  return function (_x4) {
-                    return _ref4.apply(this, arguments);
-                  };
-                }());
-
-              case 18:
-                return _context3.abrupt("return", _context3.sent);
-
-              case 19:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee3, this);
-      }));
-
-      function query(_x3) {
-        return _query2.apply(this, arguments);
-      }
-
-      return query;
-    }()
-  }]);
-  return GraphileQuery;
-}();
-
-exports.GraphileQuery = GraphileQuery;
-
-var GraphileQuerySimple = /*#__PURE__*/function () {
-  function GraphileQuerySimple(_ref5) {
-    var schema = _ref5.schema,
-        pool = _ref5.pool;
-    (0, _classCallCheck2["default"])(this, GraphileQuerySimple);
-    if (!schema) throw new Error('requires a schema');
-    if (!pool) throw new Error('requires a pool');
-    this.pool = pool;
-    this.schema = schema;
-  }
-
-  (0, _createClass2["default"])(GraphileQuerySimple, [{
-    key: "query",
-    value: function () {
-      var _query4 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(_query3, variables) {
-        var _this2 = this;
-
-        var queryString;
-        return _regenerator["default"].wrap(function _callee5$(_context5) {
-          while (1) {
-            switch (_context5.prev = _context5.next) {
-              case 0:
-                queryString = typeof _query3 === 'string' ? _query3 : (0, _printer.print)(_query3);
-                _context5.next = 3;
-                return (0, _postgraphile.withPostGraphileContext)({
-                  pgPool: this.pool
-                }, /*#__PURE__*/function () {
-                  var _ref6 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(context) {
-                    return _regenerator["default"].wrap(function _callee4$(_context4) {
-                      while (1) {
-                        switch (_context4.prev = _context4.next) {
-                          case 0:
-                            _context4.next = 2;
-                            return (0, _graphql.graphql)(_this2.schema, queryString, null, _objectSpread({}, context), variables);
-
-                          case 2:
-                            return _context4.abrupt("return", _context4.sent);
-
-                          case 3:
-                          case "end":
-                            return _context4.stop();
-                        }
-                      }
-                    }, _callee4);
-                  }));
-
-                  return function (_x7) {
-                    return _ref6.apply(this, arguments);
-                  };
-                }());
-
-              case 3:
-                return _context5.abrupt("return", _context5.sent);
-
-              case 4:
-              case "end":
-                return _context5.stop();
-            }
-          }
-        }, _callee5, this);
-      }));
-
-      function query(_x5, _x6) {
-        return _query4.apply(this, arguments);
-      }
-
-      return query;
-    }()
-  }]);
-  return GraphileQuerySimple;
-}();
-
-exports.GraphileQuerySimple = GraphileQuerySimple;

package/module/index.js

@@ -1,68 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-import { withPostGraphileContext, createPostGraphileSchema } from 'postgraphile';
-import { graphql } from 'graphql';
-import { print } from 'graphql/language/printer';
-export const getSchema = async (pool, settings) => await createPostGraphileSchema(pool, settings.schema, settings);
-export class GraphileQuery {
-  constructor({
-    schema,
-    pool,
-    settings
-  }) {
-    if (!schema) throw new Error('requires a schema');
-    if (!pool) throw new Error('requires a pool');
-    if (!settings) throw new Error('requires graphile settings');
-    this.pool = pool;
-    this.schema = schema;
-    this.settings = settings;
-  } // role is optional! it overrides anything from req passed in.
-
-
-  async query({
-    req = {},
-    query,
-    variables,
-    role
-  }) {
-    const queryString = typeof query === 'string' ? query : print(query);
-    const {
-      pgSettings: pgSettingsGenerator
-    } = this.settings;
-    const pgSettings = role ? {
-      role
-    } : typeof pgSettingsGenerator === 'function' ? await pgSettingsGenerator(req) : pgSettingsGenerator;
-    return await withPostGraphileContext(_objectSpread(_objectSpread({}, this.settings), {}, {
-      pgPool: this.pool,
-      pgSettings
-    }), async context => {
-      return await graphql(this.schema, queryString, null, _objectSpread({}, context), variables);
-    });
-  }
-
-}
-export class GraphileQuerySimple {
-  constructor({
-    schema,
-    pool
-  }) {
-    if (!schema) throw new Error('requires a schema');
-    if (!pool) throw new Error('requires a pool');
-    this.pool = pool;
-    this.schema = schema;
-  }
-
-  async query(query, variables) {
-    const queryString = typeof query === 'string' ? query : print(query);
-    return await withPostGraphileContext({
-      pgPool: this.pool
-    }, async context => {
-      return await graphql(this.schema, queryString, null, _objectSpread({}, context), variables);
-    });
-  }
-
-}