@constructive-io/graphql-explorer 3.1.1 → 4.0.0

package/esm/server.js

@@ -2,49 +2,47 @@ import { getEnvOptions } from '@constructive-io/graphql-env';
 import { cors, healthz, poweredBy } from '@pgpmjs/server-utils';
 import { middleware as parseDomains } from '@constructive-io/url-domains';
 import express from 'express';
-import { graphileCache } from 'graphile-cache';
-import graphqlUpload from 'graphql-upload';
-// Scalar
-import { getPgPool } from 'pg-cache';
+import { createGraphileInstance, graphileCache } from 'graphile-cache';
+import { makePgService } from 'graphile-settings';
+import { buildConnectionString, getPgPool } from 'pg-cache';
 import { getPgEnvOptions } from 'pg-env';
-import { postgraphile } from 'postgraphile';
 import { printDatabases, printSchemas } from './render';
-import { getGraphileSettings } from './settings';
+import { getGraphilePreset } from './settings';
 export const GraphQLExplorer = (rawOpts = {}) => {
     const opts = getEnvOptions(rawOpts);
     const { pg, server } = opts;
-    const getGraphileInstanceObj = (dbname, schemaname) => {
+    const getGraphileInstanceObj = async (dbname, schemaname) => {
         const key = `${dbname}.${schemaname}`;
-        if (graphileCache.has(key)) {
-            return graphileCache.get(key);
+        const cached = graphileCache.get(key);
+        if (cached) {
+            return cached;
         }
-        const settings = {
-            ...getGraphileSettings({
-                ...opts,
-                graphile: { schema: schemaname },
-            }),
-            graphqlRoute: '/graphql',
-            graphiqlRoute: '/graphiql',
-        };
-        const pgPool = getPgPool(getPgEnvOptions({
-            ...opts.pg,
+        const pgConfig = getPgEnvOptions({
+            ...pg,
             database: dbname,
-        }));
-        const handler = postgraphile(pgPool, schemaname, settings);
-        const obj = {
-            pgPool,
-            pgPoolKey: dbname,
-            handler,
+        });
+        const connectionString = buildConnectionString(pgConfig.user, pgConfig.password, pgConfig.host, pgConfig.port, pgConfig.database);
+        const basePreset = getGraphilePreset(opts);
+        const preset = {
+            ...basePreset,
+            pgServices: [
+                makePgService({ connectionString, schemas: [schemaname] }),
+            ],
+            grafserv: {
+                graphqlPath: '/graphql',
+                graphiqlPath: '/graphiql',
+                graphiql: true,
+            },
         };
-        graphileCache.set(key, obj);
-        return obj;
+        const instance = await createGraphileInstance({ preset, cacheKey: key });
+        graphileCache.set(key, instance);
+        return instance;
     };
     const app = express();
     healthz(app);
     cors(app, server.origin);
     app.use(parseDomains());
     app.use(poweredBy('constructive'));
-    app.use(graphqlUpload.graphqlUploadExpress());
     app.use(async (req, res, next) => {
         if (req.urlDomains?.subdomains.length === 1) {
             const [dbName] = req.urlDomains.subdomains;
@@ -105,8 +103,8 @@ export const GraphQLExplorer = (rawOpts = {}) => {
         if (req.urlDomains?.subdomains.length === 2) {
             const [schemaName, dbName] = req.urlDomains.subdomains;
             try {
-                const { handler } = getGraphileInstanceObj(dbName, schemaName);
-                handler(req, res, next);
+                const instance = await getGraphileInstanceObj(dbName, schemaName);
+                instance.handler(req, res, next);
                 return;
             }
             catch (e) {

package/esm/settings.js

@@ -1,10 +1,18 @@
 import { getEnvOptions } from '@constructive-io/graphql-env';
-import { getGraphileSettings as getSettings } from 'graphile-settings';
-export const getGraphileSettings = (rawOpts) => {
+import { ConstructivePreset } from 'graphile-settings';
+/**
+ * Get a GraphileConfig.Preset for the explorer with grafast context configured.
+ *
+ * This returns a v5 preset that can be extended with pgServices.
+ */
+export const getGraphilePreset = (rawOpts) => {
     const opts = getEnvOptions(rawOpts);
-    const baseOptions = getSettings(opts);
-    baseOptions.pgSettings = async function pgSettings(_req) {
-        return { role: opts.pg?.user ?? 'postgres' };
+    return {
+        extends: [ConstructivePreset],
+        grafast: {
+            context: () => ({
+                pgSettings: { role: opts.pg?.user ?? 'postgres' },
+            }),
+        },
     };
-    return baseOptions;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-explorer",
-  "version": "3.1.1",
+  "version": "4.0.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Constructive GraphQL Explorer",
   "main": "index.js",
@@ -34,27 +34,23 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@constructive-io/graphql-env": "^2.10.0",
-    "@constructive-io/graphql-types": "^2.15.0",
-    "@constructive-io/s3-streamer": "^2.11.0",
-    "@constructive-io/upload-names": "^2.5.0",
+    "@constructive-io/graphql-env": "^3.0.0",
+    "@constructive-io/graphql-types": "^3.0.0",
     "@constructive-io/url-domains": "^2.5.0",
     "@pgpmjs/server-utils": "^3.1.0",
-    "@pgpmjs/types": "^2.16.0",
     "express": "^5.2.1",
-    "graphile-build": "^4.14.1",
-    "graphile-cache": "^2.1.0",
-    "graphile-settings": "^3.1.1",
-    "graphql": "15.10.1",
-    "graphql-upload": "^13.0.0",
-    "pg-cache": "^2.1.0",
+    "grafserv": "^1.0.0-rc.4",
+    "graphile-cache": "^3.0.0",
+    "graphile-config": "1.0.0-rc.3",
+    "graphile-settings": "^4.0.0",
+    "graphql": "^16.9.0",
+    "pg-cache": "^3.0.0",
     "pg-env": "^1.4.0",
-    "postgraphile": "^4.14.1"
+    "postgraphile": "^5.0.0-rc.4"
   },
   "devDependencies": {
     "@types/express": "^5.0.6",
-    "@types/graphql-upload": "^8.0.12",
-    "makage": "^0.1.12",
+    "makage": "^0.1.10",
     "nodemon": "^3.1.10",
     "ts-node": "^10.9.2"
   },
@@ -65,5 +61,5 @@
     "constructive",
     "interface"
   ],
-  "gitHead": "49049ad3ddd762d35625f657cb42fa0862b829a0"
+  "gitHead": "b2daeefe49cdefb3d01ea63cf778fb9b847ab5fe"
 }

package/server.d.ts

@@ -1,3 +1,3 @@
-import { PgpmOptions } from '@pgpmjs/types';
+import type { ConstructiveOptions } from '@constructive-io/graphql-types';
 import { Express } from 'express';
-export declare const GraphQLExplorer: (rawOpts?: PgpmOptions) => Express;
+export declare const GraphQLExplorer: (rawOpts?: ConstructiveOptions) => Express;

package/server.js

@@ -9,48 +9,46 @@ const server_utils_1 = require("@pgpmjs/server-utils");
 const url_domains_1 = require("@constructive-io/url-domains");
 const express_1 = __importDefault(require("express"));
 const graphile_cache_1 = require("graphile-cache");
-const graphql_upload_1 = __importDefault(require("graphql-upload"));
-// Scalar
+const graphile_settings_1 = require("graphile-settings");
 const pg_cache_1 = require("pg-cache");
 const pg_env_1 = require("pg-env");
-const postgraphile_1 = require("postgraphile");
 const render_1 = require("./render");
 const settings_1 = require("./settings");
 const GraphQLExplorer = (rawOpts = {}) => {
     const opts = (0, graphql_env_1.getEnvOptions)(rawOpts);
     const { pg, server } = opts;
-    const getGraphileInstanceObj = (dbname, schemaname) => {
+    const getGraphileInstanceObj = async (dbname, schemaname) => {
         const key = `${dbname}.${schemaname}`;
-        if (graphile_cache_1.graphileCache.has(key)) {
-            return graphile_cache_1.graphileCache.get(key);
+        const cached = graphile_cache_1.graphileCache.get(key);
+        if (cached) {
+            return cached;
         }
-        const settings = {
-            ...(0, settings_1.getGraphileSettings)({
-                ...opts,
-                graphile: { schema: schemaname },
-            }),
-            graphqlRoute: '/graphql',
-            graphiqlRoute: '/graphiql',
-        };
-        const pgPool = (0, pg_cache_1.getPgPool)((0, pg_env_1.getPgEnvOptions)({
-            ...opts.pg,
+        const pgConfig = (0, pg_env_1.getPgEnvOptions)({
+            ...pg,
             database: dbname,
-        }));
-        const handler = (0, postgraphile_1.postgraphile)(pgPool, schemaname, settings);
-        const obj = {
-            pgPool,
-            pgPoolKey: dbname,
-            handler,
+        });
+        const connectionString = (0, pg_cache_1.buildConnectionString)(pgConfig.user, pgConfig.password, pgConfig.host, pgConfig.port, pgConfig.database);
+        const basePreset = (0, settings_1.getGraphilePreset)(opts);
+        const preset = {
+            ...basePreset,
+            pgServices: [
+                (0, graphile_settings_1.makePgService)({ connectionString, schemas: [schemaname] }),
+            ],
+            grafserv: {
+                graphqlPath: '/graphql',
+                graphiqlPath: '/graphiql',
+                graphiql: true,
+            },
         };
-        graphile_cache_1.graphileCache.set(key, obj);
-        return obj;
+        const instance = await (0, graphile_cache_1.createGraphileInstance)({ preset, cacheKey: key });
+        graphile_cache_1.graphileCache.set(key, instance);
+        return instance;
     };
     const app = (0, express_1.default)();
     (0, server_utils_1.healthz)(app);
     (0, server_utils_1.cors)(app, server.origin);
     app.use((0, url_domains_1.middleware)());
     app.use((0, server_utils_1.poweredBy)('constructive'));
-    app.use(graphql_upload_1.default.graphqlUploadExpress());
     app.use(async (req, res, next) => {
         if (req.urlDomains?.subdomains.length === 1) {
             const [dbName] = req.urlDomains.subdomains;
@@ -111,8 +109,8 @@ const GraphQLExplorer = (rawOpts = {}) => {
         if (req.urlDomains?.subdomains.length === 2) {
             const [schemaName, dbName] = req.urlDomains.subdomains;
             try {
-                const { handler } = getGraphileInstanceObj(dbName, schemaName);
-                handler(req, res, next);
+                const instance = await getGraphileInstanceObj(dbName, schemaName);
+                instance.handler(req, res, next);
                 return;
             }
             catch (e) {

package/settings.d.ts

@@ -1,3 +1,8 @@
 import { ConstructiveOptions } from '@constructive-io/graphql-types';
-import { PostGraphileOptions } from 'postgraphile';
-export declare const getGraphileSettings: (rawOpts: ConstructiveOptions) => PostGraphileOptions;
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * Get a GraphileConfig.Preset for the explorer with grafast context configured.
+ *
+ * This returns a v5 preset that can be extended with pgServices.
+ */
+export declare const getGraphilePreset: (rawOpts: ConstructiveOptions) => GraphileConfig.Preset;

package/settings.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGraphileSettings = void 0;
+exports.getGraphilePreset = void 0;
 const graphql_env_1 = require("@constructive-io/graphql-env");
 const graphile_settings_1 = require("graphile-settings");
-const getGraphileSettings = (rawOpts) => {
+/**
+ * Get a GraphileConfig.Preset for the explorer with grafast context configured.
+ *
+ * This returns a v5 preset that can be extended with pgServices.
+ */
+const getGraphilePreset = (rawOpts) => {
     const opts = (0, graphql_env_1.getEnvOptions)(rawOpts);
-    const baseOptions = (0, graphile_settings_1.getGraphileSettings)(opts);
-    baseOptions.pgSettings = async function pgSettings(_req) {
-        return { role: opts.pg?.user ?? 'postgres' };
+    return {
+        extends: [graphile_settings_1.ConstructivePreset],
+        grafast: {
+            context: () => ({
+                pgSettings: { role: opts.pg?.user ?? 'postgres' },
+            }),
+        },
     };
-    return baseOptions;
 };
-exports.getGraphileSettings = getGraphileSettings;
+exports.getGraphilePreset = getGraphilePreset;

package/esm/resolvers/uploads.js

@@ -1,54 +0,0 @@
-import Streamer from '@constructive-io/s3-streamer';
-import uploadNames from '@constructive-io/upload-names';
-export class UploadHandler {
-    options;
-    streamer;
-    constructor(options) {
-        this.options = options;
-        this.streamer = new Streamer({
-            defaultBucket: options.bucketName,
-            awsRegion: options.awsRegion,
-            awsSecretKey: options.awsSecretKey,
-            awsAccessKey: options.awsAccessKey,
-            minioEndpoint: options.minioEndpoint,
-            provider: options.provider
-        });
-    }
-    async handleUpload(upload, _args, _context, info) {
-        const { uploadPlugin: { tags, type } } = info;
-        const readStream = upload.createReadStream();
-        const { filename, mimetype } = upload;
-        const rand = Math.random().toString(36).substring(2, 7) +
-            Math.random().toString(36).substring(2, 7);
-        const key = rand + '-' + uploadNames(filename);
-        const result = await this.streamer.upload({
-            readStream,
-            filename,
-            key,
-            bucket: this.options.bucketName
-        });
-        const url = result.upload.Location;
-        const { contentType, magic: { charset } } = result;
-        const typ = type || tags.type;
-        const mim = tags.mime
-            ? tags.mime.trim().split(',').map((a) => a.trim())
-            : typ === 'image'
-                ? ['image/jpg', 'image/jpeg', 'image/png', 'image/svg+xml']
-                : [];
-        if (mim.length && !mim.includes(contentType)) {
-            throw new Error(`UPLOAD_MIMETYPE ${mim.join(',')}`);
-        }
-        switch (typ) {
-            case 'image':
-            case 'upload':
-                return {
-                    filename,
-                    mime: contentType,
-                    url
-                };
-            case 'attachment':
-            default:
-                return url;
-        }
-    }
-}

package/resolvers/uploads.d.ts

@@ -1,31 +0,0 @@
-import type { GraphQLResolveInfo } from 'graphql';
-import type { BucketProvider } from '@pgpmjs/types';
-interface UploaderOptions {
-    bucketName: string;
-    awsRegion: string;
-    awsSecretKey: string;
-    awsAccessKey: string;
-    minioEndpoint?: string;
-    provider?: BucketProvider;
-}
-interface Upload {
-    createReadStream: () => NodeJS.ReadableStream;
-    filename: string;
-    mimetype: string;
-    encoding: string;
-}
-interface UploadPluginInfo {
-    tags: {
-        [key: string]: any;
-    };
-    type: string;
-}
-export declare class UploadHandler {
-    private options;
-    private streamer;
-    constructor(options: UploaderOptions);
-    handleUpload(upload: Upload, _args: any, _context: any, info: GraphQLResolveInfo & {
-        uploadPlugin: UploadPluginInfo;
-    }): Promise<any>;
-}
-export {};

package/resolvers/uploads.js

@@ -1,61 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UploadHandler = void 0;
-const s3_streamer_1 = __importDefault(require("@constructive-io/s3-streamer"));
-const upload_names_1 = __importDefault(require("@constructive-io/upload-names"));
-class UploadHandler {
-    options;
-    streamer;
-    constructor(options) {
-        this.options = options;
-        this.streamer = new s3_streamer_1.default({
-            defaultBucket: options.bucketName,
-            awsRegion: options.awsRegion,
-            awsSecretKey: options.awsSecretKey,
-            awsAccessKey: options.awsAccessKey,
-            minioEndpoint: options.minioEndpoint,
-            provider: options.provider
-        });
-    }
-    async handleUpload(upload, _args, _context, info) {
-        const { uploadPlugin: { tags, type } } = info;
-        const readStream = upload.createReadStream();
-        const { filename, mimetype } = upload;
-        const rand = Math.random().toString(36).substring(2, 7) +
-            Math.random().toString(36).substring(2, 7);
-        const key = rand + '-' + (0, upload_names_1.default)(filename);
-        const result = await this.streamer.upload({
-            readStream,
-            filename,
-            key,
-            bucket: this.options.bucketName
-        });
-        const url = result.upload.Location;
-        const { contentType, magic: { charset } } = result;
-        const typ = type || tags.type;
-        const mim = tags.mime
-            ? tags.mime.trim().split(',').map((a) => a.trim())
-            : typ === 'image'
-                ? ['image/jpg', 'image/jpeg', 'image/png', 'image/svg+xml']
-                : [];
-        if (mim.length && !mim.includes(contentType)) {
-            throw new Error(`UPLOAD_MIMETYPE ${mim.join(',')}`);
-        }
-        switch (typ) {
-            case 'image':
-            case 'upload':
-                return {
-                    filename,
-                    mime: contentType,
-                    url
-                };
-            case 'attachment':
-            default:
-                return url;
-        }
-    }
-}
-exports.UploadHandler = UploadHandler;