@constructive-io/graphql-server 3.1.1 → 4.0.0

package/esm/schema.js

@@ -1,21 +1,34 @@
 import { printSchema, getIntrospectionQuery, buildClientSchema } from 'graphql';
-import { getGraphileSettings } from 'graphile-settings';
+import { ConstructivePreset, makePgService } from 'graphile-settings';
+import { makeSchema } from 'graphile-build';
 import { getPgPool } from 'pg-cache';
-import { createPostGraphileSchema } from 'postgraphile';
 import * as http from 'node:http';
 import * as https from 'node:https';
-// Build GraphQL Schema SDL directly from Postgres using PostGraphile, without HTTP.
+// Build GraphQL Schema SDL directly from Postgres using PostGraphile v5, without HTTP.
 export async function buildSchemaSDL(opts) {
     const database = opts.database ?? 'constructive';
     const schemas = Array.isArray(opts.schemas) ? opts.schemas : [];
-    const settings = getGraphileSettings({
-        graphile: {
-            schema: schemas,
-            ...(opts.graphile ?? {})
-        }
-    });
-    const pgPool = getPgPool({ database });
-    const schema = await createPostGraphileSchema(pgPool, schemas, settings);
+    // Get pool config for connection string
+    const pool = getPgPool({ database });
+    const poolConfig = pool.options || {};
+    const connectionString = `postgres://${poolConfig.user || 'postgres'}:${poolConfig.password || ''}@${poolConfig.host || 'localhost'}:${poolConfig.port || 5432}/${database}`;
+    // Build v5 preset
+    const preset = {
+        extends: [
+            ConstructivePreset,
+            ...(opts.graphile?.extends ?? []),
+        ],
+        ...(opts.graphile?.disablePlugins && { disablePlugins: opts.graphile.disablePlugins }),
+        ...(opts.graphile?.plugins && { plugins: opts.graphile.plugins }),
+        ...(opts.graphile?.schema && { schema: opts.graphile.schema }),
+        pgServices: [
+            makePgService({
+                connectionString,
+                schemas,
+            }),
+        ],
+    };
+    const { schema } = await makeSchema(preset);
     return printSchema(schema);
 }
 // Fetch GraphQL Schema SDL from a running GraphQL endpoint via introspection.

package/esm/server.js

@@ -6,18 +6,46 @@ import { randomUUID } from 'crypto';
 import express from 'express';
 // @ts-ignore
 import graphqlUpload from 'graphql-upload';
-import { graphileCache } from 'graphile-cache';
-import { getPgPool, pgCache } from 'pg-cache';
+import { graphileCache, closeAllCaches } from 'graphile-cache';
+import { getPgPool } from 'pg-cache';
 import requestIp from 'request-ip';
 import { createApiMiddleware } from './middleware/api';
 import { createAuthenticateMiddleware } from './middleware/auth';
 import { cors } from './middleware/cors';
+import { errorHandler, notFoundHandler } from './middleware/error-handler';
+import { favicon } from './middleware/favicon';
 import { flush, flushService } from './middleware/flush';
 import { graphile } from './middleware/graphile';
+import { normalizeServerOptions } from './options';
 const log = new Logger('server');
 const isDev = () => getNodeEnv() === 'development';
+/**
+ * Creates and starts a GraphQL server instance
+ *
+ * Accepts ConstructiveOptions or PgpmOptions.
+ * Options are normalized using normalizeServerOptions to apply defaults.
+ *
+ * @param rawOpts - Server configuration options
+ * @returns void (server runs until shutdown)
+ *
+ * @example
+ * ```typescript
+ * // Using ConstructiveOptions (recommended)
+ * GraphQLServer({
+ *   pg: { database: 'myapp' },
+ *   server: { port: 4000 }
+ * });
+ *
+ * // Using PgpmOptions (backward compatible)
+ * GraphQLServer(pgpmOptions);
+ * ```
+ */
 export const GraphQLServer = (rawOpts = {}) => {
-    const envOptions = getEnvOptions(rawOpts);
+    // Normalize options to ConstructiveOptions with defaults applied
+    const normalizedOpts = normalizeServerOptions(rawOpts);
+    // Apply environment variable overrides via getEnvOptions
+    // Cast to PgpmOptions for backward compatibility with getEnvOptions
+    const envOptions = getEnvOptions(normalizedOpts);
     const app = new Server(envOptions);
     app.addEventListener();
     app.listen();
@@ -71,6 +99,7 @@ class Server {
             roleName: apiOpts.roleName
         });
         healthz(app);
+        app.use(favicon);
         trustProxy(app, effectiveOpts.server.trustProxy);
         // Warn if a global CORS override is set in production
         const fallbackOrigin = effectiveOpts.server?.origin?.trim();
@@ -92,6 +121,9 @@ class Server {
         app.use(authenticate);
         app.use(graphile(effectiveOpts));
         app.use(flush);
+        // Error handling - MUST be LAST
+        app.use(notFoundHandler); // Catches unmatched routes (404)
+        app.use(errorHandler); // Catches all thrown errors
         this.app = app;
     }
     listen() {
@@ -192,9 +224,13 @@ class Server {
     static async closeCaches(opts = {}) {
         const { closePools = false } = opts;
         svcCache.clear();
-        graphileCache.clear();
+        // Use closeAllCaches to properly await async disposal of PostGraphile instances
+        // before closing pg pools - this ensures all connections are released
         if (closePools) {
-            await pgCache.close();
+            await closeAllCaches();
+        }
+        else {
+            graphileCache.clear();
         }
     }
     log(text) {

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './server';
 export * from './schema';
+export * from './options';
 export { createApiMiddleware, getSubdomain, getApiConfig } from './middleware/api';
 export { createAuthenticateMiddleware } from './middleware/auth';
 export { cors } from './middleware/cors';

package/index.js

@@ -17,6 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flushService = exports.flush = exports.graphile = exports.cors = exports.createAuthenticateMiddleware = exports.getApiConfig = exports.getSubdomain = exports.createApiMiddleware = void 0;
 __exportStar(require("./server"), exports);
 __exportStar(require("./schema"), exports);
+// Export options module - types, defaults, type guards, and utility functions
+__exportStar(require("./options"), exports);
 // Export middleware for use in testing packages
 var api_1 = require("./middleware/api");
 Object.defineProperty(exports, "createApiMiddleware", { enumerable: true, get: function () { return api_1.createApiMiddleware; } });

package/middleware/api.d.ts

@@ -1,19 +1,7 @@
 import { NextFunction, Request, Response } from 'express';
-/**
- * Normalizes API records into ApiStructure
- */
-import { type ApiQueryOps } from './gql';
-import { ApiConfigResult, ApiOptions, ApiStructure } from '../types';
+import { ApiConfigResult, ApiOptions } from '../types';
 import './types';
-export { normalizeApiRecord } from './gql';
-export declare const getSubdomain: (reqDomains: string[]) => string | null;
-export declare const createApiMiddleware: (opts: ApiOptions) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
-export declare const queryServiceByApiName: ({ opts, key, queryOps, databaseId, name, }: {
-    opts: ApiOptions;
-    key: string;
-    queryOps: ApiQueryOps;
-    databaseId?: string;
-    name: string;
-}) => Promise<ApiStructure | null>;
+export declare const getSubdomain: (subdomains: string[]) => string | null;
 export declare const getSvcKey: (opts: ApiOptions, req: Request) => string;
 export declare const getApiConfig: (opts: ApiOptions, req: Request) => Promise<ApiConfigResult>;
+export declare const createApiMiddleware: (opts: ApiOptions) => (req: Request, res: Response, next: NextFunction) => Promise<void>;