@constructive-io/graphql-server 2.10.5

package/server.d.ts

@@ -0,0 +1,17 @@
+import 'dotenv/config';
+import { PgpmOptions } from '@pgpmjs/types';
+import { Pool, PoolClient } from 'pg';
+export declare const GraphQLServer: (rawOpts?: PgpmOptions) => void;
+declare class Server {
+    private app;
+    private opts;
+    constructor(opts: PgpmOptions);
+    listen(): void;
+    flush(databaseId: string): Promise<void>;
+    getPool(): Pool;
+    addEventListener(): void;
+    listenForChanges(err: Error | null, client: PoolClient, release: () => void): void;
+    log(text: string): void;
+    error(text: string, err?: unknown): void;
+}
+export { Server };

package/server.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = exports.GraphQLServer = void 0;
+require("dotenv/config");
+const graphql_env_1 = require("@constructive-io/graphql-env");
+const logger_1 = require("@pgpmjs/logger");
+const server_utils_1 = require("@pgpmjs/server-utils");
+const url_domains_1 = require("@constructive-io/url-domains");
+const express_1 = __importDefault(require("express"));
+// @ts-ignore
+const graphql_upload_1 = __importDefault(require("graphql-upload"));
+const pg_cache_1 = require("pg-cache");
+const request_ip_1 = __importDefault(require("request-ip"));
+const api_1 = require("./middleware/api");
+const auth_1 = require("./middleware/auth");
+const cors_1 = require("./middleware/cors");
+const flush_1 = require("./middleware/flush");
+const graphile_1 = require("./middleware/graphile");
+const log = new logger_1.Logger('server');
+const GraphQLServer = (rawOpts = {}) => {
+    const envOptions = (0, graphql_env_1.getEnvOptions)(rawOpts);
+    const app = new Server(envOptions);
+    app.addEventListener();
+    app.listen();
+};
+exports.GraphQLServer = GraphQLServer;
+class Server {
+    app;
+    opts;
+    constructor(opts) {
+        this.opts = (0, graphql_env_1.getEnvOptions)(opts);
+        const app = (0, express_1.default)();
+        const api = (0, api_1.createApiMiddleware)(opts);
+        const authenticate = (0, auth_1.createAuthenticateMiddleware)(opts);
+        (0, server_utils_1.healthz)(app);
+        (0, server_utils_1.trustProxy)(app, opts.server.trustProxy);
+        // Warn if a global CORS override is set in production
+        const fallbackOrigin = opts.server?.origin?.trim();
+        if (fallbackOrigin && process.env.NODE_ENV === 'production') {
+            if (fallbackOrigin === '*') {
+                log.warn('CORS wildcard ("*") is enabled in production; this effectively disables CORS and is not recommended. Prefer per-API CORS via meta schema.');
+            }
+            else {
+                log.warn(`CORS override origin set to ${fallbackOrigin} in production. Prefer per-API CORS via meta schema.`);
+            }
+        }
+        app.use((0, server_utils_1.poweredBy)('constructive'));
+        app.use((0, cors_1.cors)(fallbackOrigin));
+        app.use(graphql_upload_1.default.graphqlUploadExpress());
+        app.use((0, url_domains_1.middleware)());
+        app.use(request_ip_1.default.mw());
+        app.use(api);
+        app.use(authenticate);
+        app.use((0, graphile_1.graphile)(opts));
+        app.use(flush_1.flush);
+        this.app = app;
+    }
+    listen() {
+        const { server } = this.opts;
+        this.app.listen(server?.port, server?.host, () => log.info(`listening at http://${server?.host}:${server?.port}`));
+    }
+    async flush(databaseId) {
+        await (0, flush_1.flushService)(this.opts, databaseId);
+    }
+    getPool() {
+        return (0, pg_cache_1.getPgPool)(this.opts.pg);
+    }
+    addEventListener() {
+        const pgPool = this.getPool();
+        pgPool.connect(this.listenForChanges.bind(this));
+    }
+    listenForChanges(err, client, release) {
+        if (err) {
+            this.error('Error connecting with notify listener', err);
+            setTimeout(() => this.addEventListener(), 5000);
+            return;
+        }
+        client.on('notification', ({ channel, payload }) => {
+            if (channel === 'schema:update' && payload) {
+                log.info('schema:update', payload);
+                this.flush(payload);
+            }
+        });
+        client.query('LISTEN "schema:update"');
+        client.on('error', (e) => {
+            this.error('Error with database notify listener', e);
+            release();
+            this.addEventListener();
+        });
+        this.log('connected and listening for changes...');
+    }
+    log(text) {
+        log.info(text);
+    }
+    error(text, err) {
+        log.error(text, err);
+    }
+}
+exports.Server = Server;

package/types.d.ts

@@ -0,0 +1,85 @@
+export interface CorsModuleData {
+    urls: string[];
+}
+export interface PublicKeyChallengeData {
+    schema: string;
+    crypto_network: string;
+    sign_up_with_key: string;
+    sign_in_request_challenge: string;
+    sign_in_record_failure: string;
+    sign_in_with_challenge: string;
+}
+export interface GenericModuleData {
+    [key: string]: any;
+}
+export type ApiModule = {
+    name: 'cors';
+    data: CorsModuleData;
+} | {
+    name: 'pubkey_challenge';
+    data: PublicKeyChallengeData;
+} | {
+    name: string;
+    data?: GenericModuleData;
+};
+export interface RlsModule {
+    authenticate?: string;
+    authenticateStrict?: string;
+    privateSchema: {
+        schemaName: string;
+    };
+}
+export interface SchemaNode {
+    schemaName: string;
+}
+export interface SchemaNodes {
+    nodes: SchemaNode[];
+}
+export interface Domain {
+    subdomain?: string;
+    domain: string;
+}
+export interface DomainNodes {
+    nodes: Domain[];
+}
+export interface Site {
+    domains: DomainNodes;
+}
+export interface SiteNodes {
+    nodes: Site[];
+}
+export interface ApiModuleNodes {
+    nodes: ApiModule[];
+}
+export interface Database {
+    sites: SiteNodes;
+}
+export interface OldApiStructure {
+    dbname: string;
+    anonRole: string;
+    roleName: string;
+    schemaNames: SchemaNodes;
+    schemaNamesFromExt: SchemaNodes;
+    apiModules: ApiModuleNodes;
+    rlsModule?: RlsModule;
+    database?: Database;
+    databaseId?: string;
+    isPublic?: boolean;
+}
+export interface ServiceData {
+    api: OldApiStructure;
+}
+export interface Service {
+    data: ServiceData;
+}
+export interface ApiStructure {
+    dbname: string;
+    anonRole: string;
+    roleName: string;
+    schema: string[];
+    apiModules: ApiModule[];
+    rlsModule?: RlsModule;
+    domains?: string[];
+    databaseId?: string;
+    isPublic?: boolean;
+}

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });