@constructive-io/playwright-test 3.1.1 → 3.3.2

package/README.md

@@ -14,7 +14,12 @@
 
 Constructive Playwright Testing with HTTP server support for end-to-end testing.
 
-This package extends `@constructive-io/graphql-test` to provide an actual HTTP server for Playwright and other E2E testing frameworks. It creates isolated test databases and starts a GraphQL server that bypasses domain routing, making it perfect for integration testing.
+This package extends `@constructive-io/graphql-test` to provide an actual HTTP server for Playwright and other E2E testing frameworks. It creates isolated test databases and starts a GraphQL server for your suite to hit over HTTP.
+
+It can run either server, selected per-suite with `server.scopedRouting`:
+
+- `server.scopedRouting: false` (default) — the single-tenant `@constructive-io/graphql-dev-server` (pure PostGraphile). No host route resolution and no database id; the configured schemas are exposed directly. Best for UI/local suites.
+- `server.scopedRouting: true` — the production `@constructive-io/graphql-server`. Every request is resolved through the scoped-routing plane (`constructive_routing_public.resolve_route()`), so the suite must seed real routing/database records and reach the api surface via its seeded host (`Host` header).
 
 ## Installation
 
@@ -54,6 +59,43 @@ describe('E2E Tests', () => {
 });
 ```
 
+### Against the real (scoped-routing) server
+
+Set `server.scopedRouting: true` to run the production `@constructive-io/graphql-server`. Seed real routing/database records and address the api surface by its seeded host:
+
+```typescript
+import { test, expect } from '@playwright/test';
+import { getConnectionsWithServer, seed } from '@constructive-io/playwright-test';
+
+test('resolves through the scoped routing plane', async ({ request }) => {
+  const { server, teardown } = await getConnectionsWithServer(
+    {
+      schemas: ['simple-pets-public'],
+      authRole: 'anonymous',
+      server: {
+        scopedRouting: true,
+        api: {
+          scopedRoutingSchema: 'constructive_routing_public',
+          isPublic: true,
+          metaSchemas: ['constructive_routing_public', 'metaschema_public']
+        }
+      }
+    },
+    [seed.pgpm(pgpmWorkspace), seed.sqlfile([/* app schema + routing records */])]
+  );
+
+  try {
+    const res = await request.post(server.graphqlUrl, {
+      headers: { 'Content-Type': 'application/json', Host: 'app.test.constructive.io' },
+      data: { query: '{ animals { nodes { name } } }' }
+    });
+    expect(res.ok()).toBeTruthy();
+  } finally {
+    await teardown();
+  }
+});
+```
+
 ### With Playwright
 
 ```typescript
@@ -124,6 +166,8 @@ Creates database connections and starts an HTTP server for testing.
 - `input.authRole` - Default authentication role (e.g., 'anonymous', 'authenticated')
 - `input.server.port` - Port to run the server on (defaults to random available port)
 - `input.server.host` - Host to bind to (defaults to 'localhost')
+- `input.server.scopedRouting` - `false` (default) runs the dev server; `true` runs the production scoped-routing server
+- `input.server.api` - API options forwarded to the production scoped server (e.g. `metaSchemas`, `isPublic`); only used when `scopedRouting` is `true`
 - `input.graphile` - Optional Graphile configuration overrides
 - `seedAdapters` - Optional array of seed adapters for database setup
 
@@ -144,24 +188,31 @@ Same as `getConnectionsWithServer` but throws on GraphQL errors instead of retur
 
 ### createTestServer(opts, serverOpts?)
 
-Low-level function to create just the HTTP server without database setup.
+Low-level function to create just the single-tenant dev HTTP server without database setup.
+
+### createScopedTestServer(opts, serverOpts?)
+
+Low-level function to create just the production `@constructive-io/graphql-server` (scoped routing) HTTP server without database setup.
 
 ## How It Works
 
 1. Creates an isolated test database using `pgsql-test`
-2. Starts an Express server with Constructive GraphQL middleware
-3. Configures `enableScopedRouting: false` (static mode) to bypass host route resolution
-4. Exposes the specified schemas directly via the GraphQL endpoint
-5. Returns the server URL for Playwright to connect to
-6. Provides a teardown function that stops the server and cleans up the database
+2. Starts either the dev server or the production scoped-routing server (see `server.scopedRouting`)
+3. Exposes the GraphQL endpoint for your suite to hit over HTTP
+4. Returns the server URL for Playwright to connect to
+5. Provides a teardown function that stops the server and cleans up the database
 
 ## Configuration
 
-The server is configured with `enableScopedRouting: false`, which means:
-- No host route resolution (`resolve_route()`) is required
+By default (`scopedRouting: false`) the server runs `@constructive-io/graphql-dev-server`, which means:
+- No host route resolution (`resolve_route()`) is required and no database id is needed
 - Schemas are exposed directly based on the `schemas` parameter
 - Perfect for isolated testing without complex domain setup
 
+With `scopedRouting: true` the server runs the production `@constructive-io/graphql-server`:
+- Every request is resolved through `constructive_routing_public.resolve_route()`
+- The suite must seed real routing/database records and address the api surface by its seeded host
+
 ---
 
 ## Education and Tutorials

package/esm/get-connections.js

@@ -1,7 +1,7 @@
 import { getEnvOptions } from '@constructive-io/graphql-env';
 import { GraphQLTest } from '@constructive-io/graphql-test';
 import { getConnections as getPgConnections } from 'pgsql-test';
-import { createTestServer } from './server';
+import { createScopedTestServer, createTestServer } from './server';
 /**
  * Core unwrapping utility - throws on GraphQL errors
  */
@@ -24,18 +24,24 @@ const createConnectionsWithServerBase = async (input, seedAdapters) => {
     // Set up GraphQL test context for direct queries
     const gqlContext = GraphQLTest(input, conn);
     await gqlContext.setup();
-    // Build options for the HTTP server in static mode (scoped routing off)
+    // Build options for the HTTP server. Merge any user-provided server.api
+    // options (used by the production scoped server) with the convenience
+    // properties (schemas, authRole).
     const serverOpts = getEnvOptions({
         pg: pg.config,
         api: {
-            enableScopedRouting: false,
+            ...input.server?.api,
             exposedSchemas: input.schemas,
-            defaultDatabaseId: 'test-database',
             ...(input.authRole && { anonRole: input.authRole, roleName: input.authRole })
         }
     });
-    // Start the HTTP server
-    const server = await createTestServer(serverOpts, input.server);
+    // Start the HTTP server. Suites default to the single-tenant dev server;
+    // suites exercising the real routing plane opt into the production
+    // scoped-routing server with `server.scopedRouting: true`.
+    const scopedRouting = input.server?.scopedRouting ?? false;
+    const server = scopedRouting
+        ? await createScopedTestServer(serverOpts, input.server)
+        : await createTestServer(serverOpts, input.server);
     // Combined teardown function
     const teardown = async () => {
         await server.stop();

package/esm/index.js

@@ -1,7 +1,7 @@
 // Export our types
 export * from './types';
 // Export server utilities
-export { createTestServer, getTestPool } from './server';
+export { createScopedTestServer, createTestServer, getTestPool } from './server';
 // Export connection functions with server support
 export { getConnectionsWithServer, getConnectionsWithServerObject, getConnectionsWithServerUnwrapped } from './get-connections';
 // Re-export seed and snapshot utilities from pgsql-test

package/esm/server.js

@@ -1,64 +1,52 @@
-import { cors, createApiMiddleware, createAuthenticateMiddleware, graphile } from '@constructive-io/graphql-server';
-import express from 'express';
-import { createServer } from 'http';
+import { createDevServer } from '@constructive-io/graphql-dev-server';
+import { Server } from '@constructive-io/graphql-server';
 import { getPgPool } from 'pg-cache';
 /**
- * Find an available port starting from the given port
+ * Create a single-tenant dev test server for Playwright testing.
+ *
+ * Delegates to `@constructive-io/graphql-dev-server`, a pure-PostGraphile
+ * single-tenant server (no scoped routing, no database id) that exposes the
+ * configured schemas directly.
  */
-const findAvailablePort = async (startPort) => {
-    return new Promise((resolve, reject) => {
-        const server = createServer();
-        server.listen(startPort, () => {
-            const address = server.address();
-            const port = typeof address === 'object' && address ? address.port : startPort;
-            server.close(() => resolve(port));
-        });
-        server.on('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                resolve(findAvailablePort(startPort + 1));
-            }
-            else {
-                reject(err);
-            }
-        });
+export const createTestServer = async (opts, serverOpts = {}) => {
+    const { httpServer, url, graphqlUrl, port, host, stop } = await createDevServer(opts, {
+        host: serverOpts.host ?? 'localhost',
+        port: serverOpts.port ?? 0
     });
+    return { httpServer, url, graphqlUrl, port, host, stop };
 };
 /**
- * Create a test server for Playwright testing
+ * Create a production scoped test server for Playwright testing.
  *
- * This creates an Express server with the Constructive GraphQL middleware
- * configured with enableScopedRouting: false (static mode) to bypass routing.
+ * Uses the `Server` class from `@constructive-io/graphql-server` directly, so
+ * every request is resolved through the scoped-routing plane
+ * (`constructive_routing_public.resolve_route()`). Suites using this must seed
+ * real routing/database records so a real database id is resolved.
  */
-export const createTestServer = async (opts, serverOpts = {}) => {
+export const createScopedTestServer = async (opts, serverOpts = {}) => {
     const host = serverOpts.host ?? 'localhost';
-    const requestedPort = serverOpts.port ?? 0;
-    const port = requestedPort === 0 ? await findAvailablePort(5555) : requestedPort;
-    const app = express();
-    // Create middleware in static mode (enableScopedRouting: false) to bypass routing
-    const api = createApiMiddleware(opts);
-    const authenticate = createAuthenticateMiddleware(opts);
-    // Basic middleware setup
-    app.use(cors('*'));
-    app.use(api);
-    app.use(authenticate);
-    app.use(graphile(opts));
-    // Create HTTP server
-    const httpServer = await new Promise((resolve, reject) => {
-        const server = app.listen(port, host, () => {
-            resolve(server);
-        });
-        server.on('error', reject);
+    const port = serverOpts.port ?? 0;
+    const serverConfig = {
+        ...opts,
+        server: {
+            ...opts.server,
+            host,
+            port
+        }
+    };
+    const server = new Server(serverConfig);
+    const httpServer = server.listen();
+    await new Promise((resolve) => {
+        if (httpServer.listening) {
+            resolve();
+        }
+        else {
+            httpServer.once('listening', () => resolve());
+        }
     });
     const actualPort = httpServer.address().port;
     const stop = async () => {
-        return new Promise((resolve, reject) => {
-            httpServer.close((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-        });
+        await server.close({ closeCaches: true });
     };
     return {
         httpServer,

package/get-connections.js

@@ -27,18 +27,24 @@ const createConnectionsWithServerBase = async (input, seedAdapters) => {
     // Set up GraphQL test context for direct queries
     const gqlContext = (0, graphql_test_1.GraphQLTest)(input, conn);
     await gqlContext.setup();
-    // Build options for the HTTP server in static mode (scoped routing off)
+    // Build options for the HTTP server. Merge any user-provided server.api
+    // options (used by the production scoped server) with the convenience
+    // properties (schemas, authRole).
     const serverOpts = (0, graphql_env_1.getEnvOptions)({
         pg: pg.config,
         api: {
-            enableScopedRouting: false,
+            ...input.server?.api,
             exposedSchemas: input.schemas,
-            defaultDatabaseId: 'test-database',
             ...(input.authRole && { anonRole: input.authRole, roleName: input.authRole })
         }
     });
-    // Start the HTTP server
-    const server = await (0, server_1.createTestServer)(serverOpts, input.server);
+    // Start the HTTP server. Suites default to the single-tenant dev server;
+    // suites exercising the real routing plane opt into the production
+    // scoped-routing server with `server.scopedRouting: true`.
+    const scopedRouting = input.server?.scopedRouting ?? false;
+    const server = scopedRouting
+        ? await (0, server_1.createScopedTestServer)(serverOpts, input.server)
+        : await (0, server_1.createTestServer)(serverOpts, input.server);
     // Combined teardown function
     const teardown = async () => {
         await server.stop();

package/index.d.ts

@@ -1,5 +1,5 @@
 export { type GraphQLQueryOptions, type GraphQLTestContext, type GetConnectionsInput, type GraphQLResponse, type GraphQLQueryFn, type GraphQLQueryFnObj, type GraphQLQueryUnwrappedFn, type GraphQLQueryUnwrappedFnObj, } from '@constructive-io/graphql-test';
 export * from './types';
-export { createTestServer, getTestPool } from './server';
+export { createScopedTestServer, createTestServer, getTestPool } from './server';
 export { getConnectionsWithServer, getConnectionsWithServerObject, getConnectionsWithServerUnwrapped } from './get-connections';
 export { seed, snapshot } from 'pgsql-test';

package/index.js

@@ -14,11 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.snapshot = exports.seed = exports.getConnectionsWithServerUnwrapped = exports.getConnectionsWithServerObject = exports.getConnectionsWithServer = exports.getTestPool = exports.createTestServer = void 0;
+exports.snapshot = exports.seed = exports.getConnectionsWithServerUnwrapped = exports.getConnectionsWithServerObject = exports.getConnectionsWithServer = exports.getTestPool = exports.createTestServer = exports.createScopedTestServer = void 0;
 // Export our types
 __exportStar(require("./types"), exports);
 // Export server utilities
 var server_1 = require("./server");
+Object.defineProperty(exports, "createScopedTestServer", { enumerable: true, get: function () { return server_1.createScopedTestServer; } });
 Object.defineProperty(exports, "createTestServer", { enumerable: true, get: function () { return server_1.createTestServer; } });
 Object.defineProperty(exports, "getTestPool", { enumerable: true, get: function () { return server_1.getTestPool; } });
 // Export connection functions with server support

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/playwright-test",
-  "version": "3.1.1",
+  "version": "3.3.2",
   "author": "Constructive <developers@constructive.io>",
   "description": "Constructive Playwright Testing with HTTP server support",
   "main": "index.js",
@@ -35,16 +35,17 @@
     "makage": "^0.3.0"
   },
   "dependencies": {
-    "@constructive-io/graphql-env": "^3.17.1",
-    "@constructive-io/graphql-server": "^5.1.1",
-    "@constructive-io/graphql-test": "^5.0.6",
-    "@constructive-io/graphql-types": "^3.16.1",
-    "@pgpmjs/types": "^2.36.0",
+    "@constructive-io/graphql-dev-server": "^3.3.2",
+    "@constructive-io/graphql-env": "^3.19.2",
+    "@constructive-io/graphql-server": "^5.3.2",
+    "@constructive-io/graphql-test": "^5.1.2",
+    "@constructive-io/graphql-types": "^3.18.2",
+    "@pgpmjs/types": "^2.37.2",
     "express": "^5.2.1",
-    "graphile-test": "^5.0.6",
+    "graphile-test": "^5.1.2",
     "pg": "^8.21.0",
-    "pg-cache": "^3.15.3",
-    "pgsql-test": "^5.0.5"
+    "pg-cache": "^3.16.2",
+    "pgsql-test": "^5.1.2"
   },
   "keywords": [
     "testing",
@@ -55,5 +56,5 @@
     "e2e",
     "integration"
   ],
-  "gitHead": "ebba3f838664032e6f6adf6c9c6d2b6cdddd994a"
+  "gitHead": "08741ce3a6897192c2dbc7d1da48b9f456ffb59f"
 }

package/server.d.ts

@@ -2,12 +2,22 @@ import type { ConstructiveOptions } from '@constructive-io/graphql-types';
 import { Pool } from 'pg';
 import type { PlaywrightServerOptions, ServerInfo } from './types';
 /**
- * Create a test server for Playwright testing
+ * Create a single-tenant dev test server for Playwright testing.
  *
- * This creates an Express server with the Constructive GraphQL middleware
- * configured with enableScopedRouting: false (static mode) to bypass routing.
+ * Delegates to `@constructive-io/graphql-dev-server`, a pure-PostGraphile
+ * single-tenant server (no scoped routing, no database id) that exposes the
+ * configured schemas directly.
  */
 export declare const createTestServer: (opts: ConstructiveOptions, serverOpts?: PlaywrightServerOptions) => Promise<ServerInfo>;
+/**
+ * Create a production scoped test server for Playwright testing.
+ *
+ * Uses the `Server` class from `@constructive-io/graphql-server` directly, so
+ * every request is resolved through the scoped-routing plane
+ * (`constructive_routing_public.resolve_route()`). Suites using this must seed
+ * real routing/database records so a real database id is resolved.
+ */
+export declare const createScopedTestServer: (opts: ConstructiveOptions, serverOpts?: PlaywrightServerOptions) => Promise<ServerInfo>;
 /**
  * Get the PostgreSQL pool for the test server
  */

package/server.js

@@ -1,70 +1,56 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTestPool = exports.createTestServer = void 0;
+exports.getTestPool = exports.createScopedTestServer = exports.createTestServer = void 0;
+const graphql_dev_server_1 = require("@constructive-io/graphql-dev-server");
 const graphql_server_1 = require("@constructive-io/graphql-server");
-const express_1 = __importDefault(require("express"));
-const http_1 = require("http");
 const pg_cache_1 = require("pg-cache");
 /**
- * Find an available port starting from the given port
+ * Create a single-tenant dev test server for Playwright testing.
+ *
+ * Delegates to `@constructive-io/graphql-dev-server`, a pure-PostGraphile
+ * single-tenant server (no scoped routing, no database id) that exposes the
+ * configured schemas directly.
  */
-const findAvailablePort = async (startPort) => {
-    return new Promise((resolve, reject) => {
-        const server = (0, http_1.createServer)();
-        server.listen(startPort, () => {
-            const address = server.address();
-            const port = typeof address === 'object' && address ? address.port : startPort;
-            server.close(() => resolve(port));
-        });
-        server.on('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                resolve(findAvailablePort(startPort + 1));
-            }
-            else {
-                reject(err);
-            }
-        });
+const createTestServer = async (opts, serverOpts = {}) => {
+    const { httpServer, url, graphqlUrl, port, host, stop } = await (0, graphql_dev_server_1.createDevServer)(opts, {
+        host: serverOpts.host ?? 'localhost',
+        port: serverOpts.port ?? 0
     });
+    return { httpServer, url, graphqlUrl, port, host, stop };
 };
+exports.createTestServer = createTestServer;
 /**
- * Create a test server for Playwright testing
+ * Create a production scoped test server for Playwright testing.
  *
- * This creates an Express server with the Constructive GraphQL middleware
- * configured with enableScopedRouting: false (static mode) to bypass routing.
+ * Uses the `Server` class from `@constructive-io/graphql-server` directly, so
+ * every request is resolved through the scoped-routing plane
+ * (`constructive_routing_public.resolve_route()`). Suites using this must seed
+ * real routing/database records so a real database id is resolved.
  */
-const createTestServer = async (opts, serverOpts = {}) => {
+const createScopedTestServer = async (opts, serverOpts = {}) => {
     const host = serverOpts.host ?? 'localhost';
-    const requestedPort = serverOpts.port ?? 0;
-    const port = requestedPort === 0 ? await findAvailablePort(5555) : requestedPort;
-    const app = (0, express_1.default)();
-    // Create middleware in static mode (enableScopedRouting: false) to bypass routing
-    const api = (0, graphql_server_1.createApiMiddleware)(opts);
-    const authenticate = (0, graphql_server_1.createAuthenticateMiddleware)(opts);
-    // Basic middleware setup
-    app.use((0, graphql_server_1.cors)('*'));
-    app.use(api);
-    app.use(authenticate);
-    app.use((0, graphql_server_1.graphile)(opts));
-    // Create HTTP server
-    const httpServer = await new Promise((resolve, reject) => {
-        const server = app.listen(port, host, () => {
-            resolve(server);
-        });
-        server.on('error', reject);
+    const port = serverOpts.port ?? 0;
+    const serverConfig = {
+        ...opts,
+        server: {
+            ...opts.server,
+            host,
+            port
+        }
+    };
+    const server = new graphql_server_1.Server(serverConfig);
+    const httpServer = server.listen();
+    await new Promise((resolve) => {
+        if (httpServer.listening) {
+            resolve();
+        }
+        else {
+            httpServer.once('listening', () => resolve());
+        }
     });
     const actualPort = httpServer.address().port;
     const stop = async () => {
-        return new Promise((resolve, reject) => {
-            httpServer.close((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-        });
+        await server.close({ closeCaches: true });
     };
     return {
         httpServer,
@@ -75,7 +61,7 @@ const createTestServer = async (opts, serverOpts = {}) => {
         stop
     };
 };
-exports.createTestServer = createTestServer;
+exports.createScopedTestServer = createScopedTestServer;
 /**
  * Get the PostgreSQL pool for the test server
  */

package/types.d.ts

@@ -1,5 +1,6 @@
 import type { Server } from 'http';
 import type { PgTestClient } from 'pgsql-test/test-client';
+import type { ApiOptions } from '@constructive-io/graphql-types';
 import type { GetConnectionsInput, GraphQLQueryFn, GraphQLQueryFnObj } from '@constructive-io/graphql-test';
 /**
  * Options for creating a Playwright test server
@@ -9,6 +10,21 @@ export interface PlaywrightServerOptions {
     port?: number;
     /** Host to bind the server to (defaults to localhost) */
     host?: string;
+    /**
+     * Which server to run this suite against:
+     * - `false` (default): the single-tenant `@constructive-io/graphql-dev-server`
+     *   (pure PostGraphile, no routing, no database id) exposing the configured
+     *   schemas directly. Best for UI/local suites that don't need routing.
+     * - `true`: the production `@constructive-io/graphql-server`, which resolves
+     *   every request through the scoped-routing plane. Suites must seed real
+     *   routing/database records so `resolve_route()` returns a real database id.
+     */
+    scopedRouting?: boolean;
+    /**
+     * API configuration forwarded to the production scoped server (e.g.
+     * `metaSchemas`, `isPublic`). Only used when `scopedRouting` is `true`.
+     */
+    api?: Partial<ApiOptions>;
 }
 /**
  * Input options for getConnectionsWithServer