@constructive-io/playwright-test 0.2.0

package/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Constructive <developers@constructive.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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,209 @@
+# @constructive-io/playwright-test
+
+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.
+
+## Installation
+
+```bash
+npm install @constructive-io/playwright-test
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { getConnectionsWithServer, seed } from '@constructive-io/playwright-test';
+
+describe('E2E Tests', () => {
+  let teardown: () => Promise<void>;
+  let serverUrl: string;
+
+  beforeAll(async () => {
+    const connections = await getConnectionsWithServer({
+      schemas: ['public', 'app_public'],
+      authRole: 'anonymous'
+    }, [seed.pgpm({ extensions: ['my-extension'] })]);
+
+    teardown = connections.teardown;
+    serverUrl = connections.server.graphqlUrl;
+  });
+
+  afterAll(async () => {
+    await teardown();
+  });
+
+  it('should work with Playwright', async () => {
+    // Use serverUrl in your Playwright tests
+    // e.g., await page.goto(serverUrl);
+  });
+});
+```
+
+### With Playwright
+
+```typescript
+import { test, expect } from '@playwright/test';
+import { getConnectionsWithServer } from '@constructive-io/playwright-test';
+
+let connections: Awaited<ReturnType<typeof getConnectionsWithServer>>;
+
+test.beforeAll(async () => {
+  connections = await getConnectionsWithServer({
+    schemas: ['services_public', 'app_public'],
+    authRole: 'anonymous',
+    server: {
+      port: 5555,
+      host: 'localhost'
+    }
+  });
+});
+
+test.afterAll(async () => {
+  await connections.teardown();
+});
+
+test('GraphQL API is accessible', async ({ page }) => {
+  const response = await page.request.post(connections.server.graphqlUrl, {
+    data: {
+      query: '{ __typename }'
+    }
+  });
+  expect(response.ok()).toBeTruthy();
+});
+```
+
+### Direct Query Access
+
+You can also execute GraphQL queries directly without going through HTTP:
+
+```typescript
+const { query, server, teardown } = await getConnectionsWithServer({
+  schemas: ['public'],
+  authRole: 'anonymous'
+});
+
+// Direct query (bypasses HTTP)
+const result = await query(`
+  query {
+    allUsers {
+      nodes {
+        id
+        name
+      }
+    }
+  }
+`);
+
+// HTTP endpoint for Playwright
+console.log(server.graphqlUrl); // http://localhost:5555/graphql
+```
+
+## API
+
+### getConnectionsWithServer(input, seedAdapters?)
+
+Creates database connections and starts an HTTP server for testing.
+
+**Parameters:**
+- `input.schemas` - Array of PostgreSQL schemas to expose
+- `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.graphile` - Optional Graphile configuration overrides
+- `seedAdapters` - Optional array of seed adapters for database setup
+
+**Returns:**
+- `pg` - PostgreSQL client for direct database access
+- `db` - Database client for test operations
+- `server` - Server info including `url`, `graphqlUrl`, `port`, `host`, and `stop()`
+- `query` - GraphQL query function (positional API)
+- `teardown` - Cleanup function to stop server and drop test database
+
+### getConnectionsWithServerObject(input, seedAdapters?)
+
+Same as `getConnectionsWithServer` but uses object-based query API.
+
+### getConnectionsWithServerUnwrapped(input, seedAdapters?)
+
+Same as `getConnectionsWithServer` but throws on GraphQL errors instead of returning them.
+
+### createTestServer(opts, serverOpts?)
+
+Low-level function to create just the 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 `enableServicesApi: false` to bypass domain/subdomain routing
+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
+
+## Configuration
+
+The server is configured with `enableServicesApi: false`, which means:
+- No domain/subdomain routing is required
+- Schemas are exposed directly based on the `schemas` parameter
+- Perfect for isolated testing without complex domain setup
+
+---
+
+## Education and Tutorials
+
+ 1. 🚀 [Quickstart: Getting Up and Running](https://constructive.io/learn/quickstart)
+Get started with modular databases in minutes. Install prerequisites and deploy your first module.
+
+ 2. 📦 [Modular PostgreSQL Development with Database Packages](https://constructive.io/learn/modular-postgres)
+Learn to organize PostgreSQL projects with pgpm workspaces and reusable database modules.
+
+ 3. ✏️ [Authoring Database Changes](https://constructive.io/learn/authoring-database-changes)
+Master the workflow for adding, organizing, and managing database changes with pgpm.
+
+ 4. 🧪 [End-to-End PostgreSQL Testing with TypeScript](https://constructive.io/learn/e2e-postgres-testing)
+Master end-to-end PostgreSQL testing with ephemeral databases, RLS testing, and CI/CD automation.
+
+ 5. ⚡ [Supabase Testing](https://constructive.io/learn/supabase)
+Use TypeScript-first tools to test Supabase projects with realistic RLS, policies, and auth contexts.
+
+ 6. 💧 [Drizzle ORM Testing](https://constructive.io/learn/drizzle-testing)
+Run full-stack tests with Drizzle ORM, including database setup, teardown, and RLS enforcement.
+
+ 7. 🔧 [Troubleshooting](https://constructive.io/learn/troubleshooting)
+Common issues and solutions for pgpm, PostgreSQL, and testing.
+
+## Related Constructive Tooling
+
+### 📦 Package Management
+
+* [pgpm](https://github.com/constructive-io/constructive/tree/main/pgpm/pgpm): **🖥️ PostgreSQL Package Manager** for modular Postgres development. Works with database workspaces, scaffolding, migrations, seeding, and installing database packages.
+
+### 🧪 Testing
+
+* [pgsql-test](https://github.com/constructive-io/constructive/tree/main/postgres/pgsql-test): **📊 Isolated testing environments** with per-test transaction rollbacks—ideal for integration tests, complex migrations, and RLS simulation.
+* [pgsql-seed](https://github.com/constructive-io/constructive/tree/main/postgres/pgsql-seed): **🌱 PostgreSQL seeding utilities** for CSV, JSON, SQL data loading, and pgpm deployment.
+* [supabase-test](https://github.com/constructive-io/constructive/tree/main/postgres/supabase-test): **🧪 Supabase-native test harness** preconfigured for the local Supabase stack—per-test rollbacks, JWT/role context helpers, and CI/GitHub Actions ready.
+* [graphile-test](https://github.com/constructive-io/constructive/tree/main/graphile/graphile-test): **🔐 Authentication mocking** for Graphile-focused test helpers and emulating row-level security contexts.
+* [pg-query-context](https://github.com/constructive-io/constructive/tree/main/postgres/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
+
+* [pgsql-parser](https://www.npmjs.com/package/pgsql-parser): **🔄 SQL conversion engine** that interprets and converts PostgreSQL syntax.
+* [libpg-query-node](https://www.npmjs.com/package/libpg-query): **🌉 Node.js bindings** for `libpg_query`, converting SQL into parse trees.
+* [pg-proto-parser](https://www.npmjs.com/package/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://www.npmjs.com/package/@pgsql/enums): **🏷️ TypeScript enums** for PostgreSQL AST for safe and ergonomic parsing logic.
+* [@pgsql/types](https://www.npmjs.com/package/@pgsql/types): **📝 Type definitions** for PostgreSQL AST nodes in TypeScript.
+* [@pgsql/utils](https://www.npmjs.com/package/@pgsql/utils): **🛠️ AST utilities** for constructing and transforming PostgreSQL syntax trees.
+
+## Credits
+
+**🛠 Built by the [Constructive](https://constructive.io) team — creators of modular Postgres tooling for secure, composable backends. If you like our work, contribute on [GitHub](https://github.com/constructive-io).**
+
+## 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/get-connections.js

@@ -0,0 +1,122 @@
+import { getConnections as getPgConnections } from 'pgsql-test';
+import { getEnvOptions } from '@constructive-io/graphql-env';
+import { GraphQLTest } from '@constructive-io/graphql-test';
+import { createTestServer } from './server';
+/**
+ * Core unwrapping utility - throws on GraphQL errors
+ */
+const unwrap = (res) => {
+    if (res.errors?.length) {
+        throw new Error(JSON.stringify(res.errors, null, 2));
+    }
+    if (!res.data) {
+        throw new Error('No data returned from GraphQL query');
+    }
+    return res.data;
+};
+/**
+ * Base connection setup with HTTP server - shared across all variants
+ */
+const createConnectionsWithServerBase = async (input, seedAdapters) => {
+    // Get database connections using pgsql-test
+    const conn = await getPgConnections(input, seedAdapters);
+    const { pg, db, teardown: dbTeardown } = conn;
+    // Set up GraphQL test context for direct queries
+    const gqlContext = GraphQLTest(input, conn);
+    await gqlContext.setup();
+    // Build options for the HTTP server with enableServicesApi: false
+    const serverOpts = getEnvOptions({
+        pg: pg.config,
+        api: {
+            enableServicesApi: false,
+            exposedSchemas: input.schemas,
+            defaultDatabaseId: 'test-database',
+            ...(input.authRole && { anonRole: input.authRole, roleName: input.authRole })
+        },
+        graphile: input.graphile
+    });
+    // Start the HTTP server
+    const server = await createTestServer(serverOpts, input.server);
+    // Combined teardown function
+    const teardown = async () => {
+        await server.stop();
+        await gqlContext.teardown();
+        await dbTeardown();
+    };
+    // Query functions
+    const baseQuery = (opts) => gqlContext.query(opts);
+    const baseQueryPositional = (query, variables, commit, reqOptions) => gqlContext.query({ query, variables, commit, reqOptions });
+    return {
+        pg,
+        db,
+        server,
+        teardown,
+        baseQuery,
+        baseQueryPositional
+    };
+};
+/**
+ * Creates connections with an HTTP server for Playwright testing (positional API)
+ *
+ * This is the main entry point for Playwright tests. It:
+ * 1. Creates an isolated test database
+ * 2. Starts an HTTP server with the GraphQL API
+ * 3. Returns the server URL for Playwright to connect to
+ * 4. Provides a teardown function to clean up everything
+ *
+ * @example
+ * ```typescript
+ * const { server, teardown } = await getConnectionsWithServer({
+ *   schemas: ['public', 'app_public'],
+ *   authRole: 'anonymous'
+ * });
+ *
+ * // Use server.graphqlUrl in Playwright tests
+ * await page.goto(server.url);
+ *
+ * // Clean up after tests
+ * await teardown();
+ * ```
+ */
+export const getConnectionsWithServer = async (input, seedAdapters) => {
+    const { pg, db, server, teardown, baseQueryPositional } = await createConnectionsWithServerBase(input, seedAdapters);
+    return {
+        pg,
+        db,
+        server,
+        teardown,
+        query: baseQueryPositional
+    };
+};
+/**
+ * Creates connections with an HTTP server for Playwright testing (object API)
+ *
+ * Same as getConnectionsWithServer but uses object-based query API.
+ */
+export const getConnectionsWithServerObject = async (input, seedAdapters) => {
+    const { pg, db, server, teardown, baseQuery } = await createConnectionsWithServerBase(input, seedAdapters);
+    return {
+        pg,
+        db,
+        server,
+        teardown,
+        query: baseQuery
+    };
+};
+/**
+ * Creates connections with an HTTP server and unwrapped query responses
+ *
+ * Same as getConnectionsWithServer but throws on GraphQL errors instead of
+ * returning them in the response.
+ */
+export const getConnectionsWithServerUnwrapped = async (input, seedAdapters) => {
+    const { pg, db, server, teardown, baseQueryPositional } = await createConnectionsWithServerBase(input, seedAdapters);
+    const query = async (query, variables, commit, reqOptions) => unwrap(await baseQueryPositional(query, variables, commit, reqOptions));
+    return {
+        pg,
+        db,
+        server,
+        teardown,
+        query
+    };
+};

package/esm/index.js

@@ -0,0 +1,8 @@
+// Export our types
+export * from './types';
+// Export server utilities
+export { 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
+export { seed, snapshot } from 'pgsql-test';

package/esm/server.js

@@ -0,0 +1,77 @@
+import { createApiMiddleware, createAuthenticateMiddleware, cors, graphile } from '@constructive-io/graphql-server';
+import express from 'express';
+import { createServer } from 'http';
+import { getPgPool } from 'pg-cache';
+/**
+ * Find an available port starting from the given port
+ */
+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);
+            }
+        });
+    });
+};
+/**
+ * Create a test server for Playwright testing
+ *
+ * This creates an Express server with the Constructive GraphQL middleware
+ * configured with enableServicesApi: false to bypass domain routing.
+ */
+export const createTestServer = 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 with enableServicesApi: false to bypass domain 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 actualPort = httpServer.address().port;
+    const stop = async () => {
+        return new Promise((resolve, reject) => {
+            httpServer.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    };
+    return {
+        httpServer,
+        url: `http://${host}:${actualPort}`,
+        graphqlUrl: `http://${host}:${actualPort}/graphql`,
+        port: actualPort,
+        host,
+        stop
+    };
+};
+/**
+ * Get the PostgreSQL pool for the test server
+ */
+export const getTestPool = (opts) => {
+    return getPgPool(opts.pg);
+};

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/get-connections.d.ts

@@ -0,0 +1,42 @@
+import type { GetConnectionOpts } from 'pgsql-test';
+import type { SeedAdapter } from 'pgsql-test/seed/types';
+import type { GetConnectionsWithServerInput, GetConnectionsWithServerResult, GetConnectionsWithServerObjectResult } from './types';
+/**
+ * Creates connections with an HTTP server for Playwright testing (positional API)
+ *
+ * This is the main entry point for Playwright tests. It:
+ * 1. Creates an isolated test database
+ * 2. Starts an HTTP server with the GraphQL API
+ * 3. Returns the server URL for Playwright to connect to
+ * 4. Provides a teardown function to clean up everything
+ *
+ * @example
+ * ```typescript
+ * const { server, teardown } = await getConnectionsWithServer({
+ *   schemas: ['public', 'app_public'],
+ *   authRole: 'anonymous'
+ * });
+ *
+ * // Use server.graphqlUrl in Playwright tests
+ * await page.goto(server.url);
+ *
+ * // Clean up after tests
+ * await teardown();
+ * ```
+ */
+export declare const getConnectionsWithServer: (input: GetConnectionsWithServerInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<GetConnectionsWithServerResult>;
+/**
+ * Creates connections with an HTTP server for Playwright testing (object API)
+ *
+ * Same as getConnectionsWithServer but uses object-based query API.
+ */
+export declare const getConnectionsWithServerObject: (input: GetConnectionsWithServerInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<GetConnectionsWithServerObjectResult>;
+/**
+ * Creates connections with an HTTP server and unwrapped query responses
+ *
+ * Same as getConnectionsWithServer but throws on GraphQL errors instead of
+ * returning them in the response.
+ */
+export declare const getConnectionsWithServerUnwrapped: (input: GetConnectionsWithServerInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<Omit<GetConnectionsWithServerResult, "query"> & {
+    query: (query: any, variables?: any, commit?: boolean, reqOptions?: any) => Promise<any>;
+}>;

package/get-connections.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnectionsWithServerUnwrapped = exports.getConnectionsWithServerObject = exports.getConnectionsWithServer = void 0;
+const pgsql_test_1 = require("pgsql-test");
+const graphql_env_1 = require("@constructive-io/graphql-env");
+const graphql_test_1 = require("@constructive-io/graphql-test");
+const server_1 = require("./server");
+/**
+ * Core unwrapping utility - throws on GraphQL errors
+ */
+const unwrap = (res) => {
+    if (res.errors?.length) {
+        throw new Error(JSON.stringify(res.errors, null, 2));
+    }
+    if (!res.data) {
+        throw new Error('No data returned from GraphQL query');
+    }
+    return res.data;
+};
+/**
+ * Base connection setup with HTTP server - shared across all variants
+ */
+const createConnectionsWithServerBase = async (input, seedAdapters) => {
+    // Get database connections using pgsql-test
+    const conn = await (0, pgsql_test_1.getConnections)(input, seedAdapters);
+    const { pg, db, teardown: dbTeardown } = conn;
+    // 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 with enableServicesApi: false
+    const serverOpts = (0, graphql_env_1.getEnvOptions)({
+        pg: pg.config,
+        api: {
+            enableServicesApi: false,
+            exposedSchemas: input.schemas,
+            defaultDatabaseId: 'test-database',
+            ...(input.authRole && { anonRole: input.authRole, roleName: input.authRole })
+        },
+        graphile: input.graphile
+    });
+    // Start the HTTP server
+    const server = await (0, server_1.createTestServer)(serverOpts, input.server);
+    // Combined teardown function
+    const teardown = async () => {
+        await server.stop();
+        await gqlContext.teardown();
+        await dbTeardown();
+    };
+    // Query functions
+    const baseQuery = (opts) => gqlContext.query(opts);
+    const baseQueryPositional = (query, variables, commit, reqOptions) => gqlContext.query({ query, variables, commit, reqOptions });
+    return {
+        pg,
+        db,
+        server,
+        teardown,
+        baseQuery,
+        baseQueryPositional
+    };
+};
+/**
+ * Creates connections with an HTTP server for Playwright testing (positional API)
+ *
+ * This is the main entry point for Playwright tests. It:
+ * 1. Creates an isolated test database
+ * 2. Starts an HTTP server with the GraphQL API
+ * 3. Returns the server URL for Playwright to connect to
+ * 4. Provides a teardown function to clean up everything
+ *
+ * @example
+ * ```typescript
+ * const { server, teardown } = await getConnectionsWithServer({
+ *   schemas: ['public', 'app_public'],
+ *   authRole: 'anonymous'
+ * });
+ *
+ * // Use server.graphqlUrl in Playwright tests
+ * await page.goto(server.url);
+ *
+ * // Clean up after tests
+ * await teardown();
+ * ```
+ */
+const getConnectionsWithServer = async (input, seedAdapters) => {
+    const { pg, db, server, teardown, baseQueryPositional } = await createConnectionsWithServerBase(input, seedAdapters);
+    return {
+        pg,
+        db,
+        server,
+        teardown,
+        query: baseQueryPositional
+    };
+};
+exports.getConnectionsWithServer = getConnectionsWithServer;
+/**
+ * Creates connections with an HTTP server for Playwright testing (object API)
+ *
+ * Same as getConnectionsWithServer but uses object-based query API.
+ */
+const getConnectionsWithServerObject = async (input, seedAdapters) => {
+    const { pg, db, server, teardown, baseQuery } = await createConnectionsWithServerBase(input, seedAdapters);
+    return {
+        pg,
+        db,
+        server,
+        teardown,
+        query: baseQuery
+    };
+};
+exports.getConnectionsWithServerObject = getConnectionsWithServerObject;
+/**
+ * Creates connections with an HTTP server and unwrapped query responses
+ *
+ * Same as getConnectionsWithServer but throws on GraphQL errors instead of
+ * returning them in the response.
+ */
+const getConnectionsWithServerUnwrapped = async (input, seedAdapters) => {
+    const { pg, db, server, teardown, baseQueryPositional } = await createConnectionsWithServerBase(input, seedAdapters);
+    const query = async (query, variables, commit, reqOptions) => unwrap(await baseQueryPositional(query, variables, commit, reqOptions));
+    return {
+        pg,
+        db,
+        server,
+        teardown,
+        query
+    };
+};
+exports.getConnectionsWithServerUnwrapped = getConnectionsWithServerUnwrapped;

package/index.d.ts

@@ -0,0 +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 { getConnectionsWithServer, getConnectionsWithServerObject, getConnectionsWithServerUnwrapped } from './get-connections';
+export { seed, snapshot } from 'pgsql-test';

package/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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;
+// Export our types
+__exportStar(require("./types"), exports);
+// Export server utilities
+var server_1 = require("./server");
+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
+var get_connections_1 = require("./get-connections");
+Object.defineProperty(exports, "getConnectionsWithServer", { enumerable: true, get: function () { return get_connections_1.getConnectionsWithServer; } });
+Object.defineProperty(exports, "getConnectionsWithServerObject", { enumerable: true, get: function () { return get_connections_1.getConnectionsWithServerObject; } });
+Object.defineProperty(exports, "getConnectionsWithServerUnwrapped", { enumerable: true, get: function () { return get_connections_1.getConnectionsWithServerUnwrapped; } });
+// Re-export seed and snapshot utilities from pgsql-test
+var pgsql_test_1 = require("pgsql-test");
+Object.defineProperty(exports, "seed", { enumerable: true, get: function () { return pgsql_test_1.seed; } });
+Object.defineProperty(exports, "snapshot", { enumerable: true, get: function () { return pgsql_test_1.snapshot; } });

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@constructive-io/playwright-test",
+  "version": "0.2.0",
+  "author": "Constructive <developers@constructive.io>",
+  "description": "Constructive Playwright Testing with HTTP server support",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "playwright test",
+    "test:watch": "jest --watch"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.57.0",
+    "@types/express": "^5.0.6",
+    "@types/pg": "^8.16.0",
+    "makage": "^0.1.10"
+  },
+  "dependencies": {
+    "@constructive-io/graphql-env": "^2.8.19",
+    "@constructive-io/graphql-server": "^2.16.0",
+    "@constructive-io/graphql-test": "^2.13.15",
+    "@constructive-io/graphql-types": "^2.12.13",
+    "@pgpmjs/types": "^2.14.1",
+    "express": "^5.2.1",
+    "graphile-test": "^2.13.14",
+    "pg": "^8.16.3",
+    "pg-cache": "^1.6.15",
+    "pgsql-test": "^2.24.13"
+  },
+  "keywords": [
+    "testing",
+    "playwright",
+    "graphql",
+    "graphile",
+    "constructive",
+    "e2e",
+    "integration"
+  ],
+  "gitHead": "049ab1b8c49c5711ede9a47c8e8dbb7bbbdf5a1f"
+}

package/server.d.ts

@@ -0,0 +1,14 @@
+import { PgpmOptions } from '@pgpmjs/types';
+import { Pool } from 'pg';
+import type { ServerInfo, PlaywrightServerOptions } from './types';
+/**
+ * Create a test server for Playwright testing
+ *
+ * This creates an Express server with the Constructive GraphQL middleware
+ * configured with enableServicesApi: false to bypass domain routing.
+ */
+export declare const createTestServer: (opts: PgpmOptions, serverOpts?: PlaywrightServerOptions) => Promise<ServerInfo>;
+/**
+ * Get the PostgreSQL pool for the test server
+ */
+export declare const getTestPool: (opts: PgpmOptions) => Pool;

package/server.js

@@ -0,0 +1,85 @@
+"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;
+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
+ */
+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);
+            }
+        });
+    });
+};
+/**
+ * Create a test server for Playwright testing
+ *
+ * This creates an Express server with the Constructive GraphQL middleware
+ * configured with enableServicesApi: false to bypass domain routing.
+ */
+const createTestServer = 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 with enableServicesApi: false to bypass domain 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 actualPort = httpServer.address().port;
+    const stop = async () => {
+        return new Promise((resolve, reject) => {
+            httpServer.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    };
+    return {
+        httpServer,
+        url: `http://${host}:${actualPort}`,
+        graphqlUrl: `http://${host}:${actualPort}/graphql`,
+        port: actualPort,
+        host,
+        stop
+    };
+};
+exports.createTestServer = createTestServer;
+/**
+ * Get the PostgreSQL pool for the test server
+ */
+const getTestPool = (opts) => {
+    return (0, pg_cache_1.getPgPool)(opts.pg);
+};
+exports.getTestPool = getTestPool;

package/types.d.ts

@@ -0,0 +1,66 @@
+import type { Server } from 'http';
+import type { PgTestClient } from 'pgsql-test/test-client';
+import type { GetConnectionsInput, GraphQLQueryFn, GraphQLQueryFnObj } from '@constructive-io/graphql-test';
+/**
+ * Options for creating a Playwright test server
+ */
+export interface PlaywrightServerOptions {
+    /** Port to run the server on (defaults to random available port) */
+    port?: number;
+    /** Host to bind the server to (defaults to localhost) */
+    host?: string;
+}
+/**
+ * Input options for getConnectionsWithServer
+ */
+export interface GetConnectionsWithServerInput extends GetConnectionsInput {
+    /** Server configuration options */
+    server?: PlaywrightServerOptions;
+}
+/**
+ * Server information returned by getConnectionsWithServer
+ */
+export interface ServerInfo {
+    /** The HTTP server instance */
+    httpServer: Server;
+    /** The base URL of the server (e.g., http://localhost:5555) */
+    url: string;
+    /** The GraphQL endpoint URL (e.g., http://localhost:5555/graphql) */
+    graphqlUrl: string;
+    /** The port the server is running on */
+    port: number;
+    /** The host the server is bound to */
+    host: string;
+    /** Stop the server */
+    stop: () => Promise<void>;
+}
+/**
+ * Result from getConnectionsWithServer
+ */
+export interface GetConnectionsWithServerResult {
+    /** PostgreSQL client for direct database access */
+    pg: PgTestClient;
+    /** Database client for test operations */
+    db: PgTestClient;
+    /** Server information including URL and stop function */
+    server: ServerInfo;
+    /** GraphQL query function (positional API) */
+    query: GraphQLQueryFn;
+    /** Teardown function to clean up database and server */
+    teardown: () => Promise<void>;
+}
+/**
+ * Result from getConnectionsWithServerObject (object-based query API)
+ */
+export interface GetConnectionsWithServerObjectResult {
+    /** PostgreSQL client for direct database access */
+    pg: PgTestClient;
+    /** Database client for test operations */
+    db: PgTestClient;
+    /** Server information including URL and stop function */
+    server: ServerInfo;
+    /** GraphQL query function (object API) */
+    query: GraphQLQueryFnObj;
+    /** Teardown function to clean up database and server */
+    teardown: () => Promise<void>;
+}

package/types.js

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