@constructive-io/graphql-test 4.11.8 → 4.12.1

package/codegen-helper.d.ts

@@ -0,0 +1,34 @@
+import type { GraphQLQueryFn, GraphQLQueryFnObj } from 'graphile-test';
+import type { Table } from '@constructive-io/graphql-query';
+export interface CodegenResult {
+    /** Factory function to create an ORM client from a GraphQLAdapter */
+    createClient: (config: any) => Record<string, any>;
+    /** Inferred table metadata from introspection */
+    tables: Table[];
+    /** Raw codegen output (generated files) */
+    ormResult: {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    };
+}
+/**
+ * Run the codegen pipeline against a live graphile-test schema and load the result.
+ *
+ * Each test suite must pass a unique `name` to avoid collisions when Jest
+ * runs suites in parallel — each gets its own `__generated__/<name>` dir.
+ *
+ * Accepts either positional-style `GraphQLQueryFn` or object-style `GraphQLQueryFnObj`.
+ * The generated files are compiled to JavaScript and loaded via require().
+ *
+ * IMPORTANT: This must be called inside an active transaction (e.g. in beforeEach
+ * after db.beforeEach()), because graphile-test's query wrapper uses savepoints
+ * which require a transaction block.
+ *
+ * @param queryFn - The graphile-test query function (positional or object-style)
+ * @param name - Unique suite name for generated file isolation
+ * @param outputDir - Optional custom output directory (defaults to __generated__/<name> next to caller)
+ * @returns CodegenResult with createClient factory, tables, and raw ormResult
+ */
+export declare function runCodegenAndLoad(queryFn: GraphQLQueryFn | GraphQLQueryFnObj, name: string, outputDir?: string): Promise<CodegenResult>;

package/codegen-helper.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCodegenAndLoad = runCodegenAndLoad;
+/**
+ * Codegen Helper for Integration Tests
+ *
+ * Runs the full codegen pipeline against a live graphile-test schema:
+ *   1. Executes standard GraphQL introspection
+ *   2. Infers Table[] via inferTablesFromIntrospection()
+ *   3. Generates ORM files via generateOrm()
+ *   4. Compiles TypeScript to JavaScript
+ *   5. Loads the compiled createClient factory
+ *
+ * This allows tests with dynamically-provisioned tables (e.g. app_files,
+ * data_room_files) to get fully typed ORM models at test time, rather
+ * than relying on the pre-built SDK (which only knows about static tables).
+ *
+ * Usage:
+ *   import { runCodegenAndLoad, GraphQLTestAdapter } from '@constructive-io/graphql-test';
+ *
+ *   // In beforeEach (must be inside an active transaction for graphile-test):
+ *   const codegen = await runCodegenAndLoad(query, 'my-suite');
+ *   const adapter = new GraphQLTestAdapter(query);
+ *   const orm = codegen.createClient({ adapter });
+ *   const rows = await orm.myTable.findMany({ select: { id: true } }).execute();
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+const graphql_query_1 = require("@constructive-io/graphql-query");
+const orm_1 = require("@constructive-io/graphql-codegen/core/codegen/orm");
+/**
+ * Run the codegen pipeline against a live graphile-test schema and load the result.
+ *
+ * Each test suite must pass a unique `name` to avoid collisions when Jest
+ * runs suites in parallel — each gets its own `__generated__/<name>` dir.
+ *
+ * Accepts either positional-style `GraphQLQueryFn` or object-style `GraphQLQueryFnObj`.
+ * The generated files are compiled to JavaScript and loaded via require().
+ *
+ * IMPORTANT: This must be called inside an active transaction (e.g. in beforeEach
+ * after db.beforeEach()), because graphile-test's query wrapper uses savepoints
+ * which require a transaction block.
+ *
+ * @param queryFn - The graphile-test query function (positional or object-style)
+ * @param name - Unique suite name for generated file isolation
+ * @param outputDir - Optional custom output directory (defaults to __generated__/<name> next to caller)
+ * @returns CodegenResult with createClient factory, tables, and raw ormResult
+ */
+async function runCodegenAndLoad(queryFn, name, outputDir) {
+    const GENERATED_DIR = outputDir ?? path_1.default.join(process.cwd(), '__generated__', name);
+    // 1. Run introspection against live schema
+    //    Support both positional (query, variables) and object-style ({ query }) signatures
+    const introspectionResult = await runIntrospection(queryFn);
+    if (introspectionResult.errors?.length) {
+        throw new Error(`Introspection failed: ${introspectionResult.errors.map((e) => e.message).join('; ')}`);
+    }
+    const introspection = introspectionResult.data;
+    // 2. Infer tables from introspection (core of the codegen pipeline)
+    const tables = (0, graphql_query_1.inferTablesFromIntrospection)(introspection);
+    // 3. Get type registry for input type generation
+    const { typeRegistry } = (0, graphql_query_1.transformSchemaToOperations)(introspection);
+    // 4. Generate ORM files
+    const ormResult = (0, orm_1.generateOrm)({
+        tables,
+        customOperations: { queries: [], mutations: [], typeRegistry },
+        config: {
+            codegen: { comments: true, condition: true },
+        },
+    });
+    // 5. Write generated files to disk
+    ensureCleanDir(GENERATED_DIR);
+    for (const file of ormResult.files) {
+        const filePath = path_1.default.join(GENERATED_DIR, file.path);
+        fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+        fs_1.default.writeFileSync(filePath, file.content);
+    }
+    // 6. Compile TypeScript to JavaScript, then remove .ts sources so
+    //    Jest's TypeScript transformer doesn't try to type-check them.
+    compileGeneratedFiles(GENERATED_DIR);
+    // 7. Load the compiled createClient
+    const indexPath = path_1.default.join(GENERATED_DIR, 'index.js');
+    clearRequireCache(GENERATED_DIR);
+    const orm = require(indexPath);
+    return {
+        createClient: orm.createClient,
+        tables,
+        ormResult,
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Run introspection, handling both positional and object-style query functions.
+ *
+ * GraphQLQueryFn (positional): (query, variables?, commit?, reqOptions?) => Promise
+ * GraphQLQueryFnObj (object):  ({ query, variables, ... }) => Promise
+ *
+ * We call positional-style since graphile-test's underlying implementation
+ * accepts both — the positional wrapper in @constructive-io/graphql-test
+ * normalizes to the object form internally.
+ */
+async function runIntrospection(queryFn) {
+    // Detect signature: object-style functions typically have arity 1
+    // while positional have arity >= 1 (query, variables, commit, reqOptions)
+    // However, the most reliable way is to check if the first arg would be
+    // a string (positional) or object (object-style).
+    // Since we can't know at compile time, we support both at runtime.
+    const isObjectStyle = queryFn.length <= 1;
+    let result;
+    if (isObjectStyle) {
+        result = await queryFn({
+            query: graphql_query_1.SCHEMA_INTROSPECTION_QUERY,
+        });
+    }
+    else {
+        result = await queryFn(graphql_query_1.SCHEMA_INTROSPECTION_QUERY);
+    }
+    return result;
+}
+function ensureCleanDir(dir) {
+    if (fs_1.default.existsSync(dir)) {
+        fs_1.default.rmSync(dir, { recursive: true, force: true });
+    }
+    fs_1.default.mkdirSync(dir, { recursive: true });
+}
+function compileGeneratedFiles(dir) {
+    const tsFiles = collectTsFiles(dir);
+    for (const filePath of tsFiles) {
+        const source = fs_1.default.readFileSync(filePath, 'utf-8');
+        const result = typescript_1.default.transpileModule(source, {
+            compilerOptions: {
+                module: typescript_1.default.ModuleKind.CommonJS,
+                target: typescript_1.default.ScriptTarget.ES2020,
+                esModuleInterop: true,
+                strict: false,
+                declaration: false,
+                skipLibCheck: true,
+            },
+            fileName: filePath,
+        });
+        const jsPath = filePath.replace(/\.ts$/, '.js');
+        fs_1.default.writeFileSync(jsPath, result.outputText);
+        // Remove .ts source so Jest's transformer doesn't type-check it
+        fs_1.default.unlinkSync(filePath);
+    }
+}
+function collectTsFiles(dir) {
+    const files = [];
+    for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectTsFiles(fullPath));
+        }
+        else if (entry.name.endsWith('.ts')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function clearRequireCache(dir) {
+    for (const key of Object.keys(require.cache)) {
+        if (key.startsWith(dir)) {
+            delete require.cache[key];
+        }
+    }
+}

package/esm/codegen-helper.js

@@ -0,0 +1,165 @@
+/**
+ * Codegen Helper for Integration Tests
+ *
+ * Runs the full codegen pipeline against a live graphile-test schema:
+ *   1. Executes standard GraphQL introspection
+ *   2. Infers Table[] via inferTablesFromIntrospection()
+ *   3. Generates ORM files via generateOrm()
+ *   4. Compiles TypeScript to JavaScript
+ *   5. Loads the compiled createClient factory
+ *
+ * This allows tests with dynamically-provisioned tables (e.g. app_files,
+ * data_room_files) to get fully typed ORM models at test time, rather
+ * than relying on the pre-built SDK (which only knows about static tables).
+ *
+ * Usage:
+ *   import { runCodegenAndLoad, GraphQLTestAdapter } from '@constructive-io/graphql-test';
+ *
+ *   // In beforeEach (must be inside an active transaction for graphile-test):
+ *   const codegen = await runCodegenAndLoad(query, 'my-suite');
+ *   const adapter = new GraphQLTestAdapter(query);
+ *   const orm = codegen.createClient({ adapter });
+ *   const rows = await orm.myTable.findMany({ select: { id: true } }).execute();
+ */
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+import { SCHEMA_INTROSPECTION_QUERY, inferTablesFromIntrospection, transformSchemaToOperations, } from '@constructive-io/graphql-query';
+import { generateOrm } from '@constructive-io/graphql-codegen/core/codegen/orm';
+/**
+ * Run the codegen pipeline against a live graphile-test schema and load the result.
+ *
+ * Each test suite must pass a unique `name` to avoid collisions when Jest
+ * runs suites in parallel — each gets its own `__generated__/<name>` dir.
+ *
+ * Accepts either positional-style `GraphQLQueryFn` or object-style `GraphQLQueryFnObj`.
+ * The generated files are compiled to JavaScript and loaded via require().
+ *
+ * IMPORTANT: This must be called inside an active transaction (e.g. in beforeEach
+ * after db.beforeEach()), because graphile-test's query wrapper uses savepoints
+ * which require a transaction block.
+ *
+ * @param queryFn - The graphile-test query function (positional or object-style)
+ * @param name - Unique suite name for generated file isolation
+ * @param outputDir - Optional custom output directory (defaults to __generated__/<name> next to caller)
+ * @returns CodegenResult with createClient factory, tables, and raw ormResult
+ */
+export async function runCodegenAndLoad(queryFn, name, outputDir) {
+    const GENERATED_DIR = outputDir ?? path.join(process.cwd(), '__generated__', name);
+    // 1. Run introspection against live schema
+    //    Support both positional (query, variables) and object-style ({ query }) signatures
+    const introspectionResult = await runIntrospection(queryFn);
+    if (introspectionResult.errors?.length) {
+        throw new Error(`Introspection failed: ${introspectionResult.errors.map((e) => e.message).join('; ')}`);
+    }
+    const introspection = introspectionResult.data;
+    // 2. Infer tables from introspection (core of the codegen pipeline)
+    const tables = inferTablesFromIntrospection(introspection);
+    // 3. Get type registry for input type generation
+    const { typeRegistry } = transformSchemaToOperations(introspection);
+    // 4. Generate ORM files
+    const ormResult = generateOrm({
+        tables,
+        customOperations: { queries: [], mutations: [], typeRegistry },
+        config: {
+            codegen: { comments: true, condition: true },
+        },
+    });
+    // 5. Write generated files to disk
+    ensureCleanDir(GENERATED_DIR);
+    for (const file of ormResult.files) {
+        const filePath = path.join(GENERATED_DIR, file.path);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, file.content);
+    }
+    // 6. Compile TypeScript to JavaScript, then remove .ts sources so
+    //    Jest's TypeScript transformer doesn't try to type-check them.
+    compileGeneratedFiles(GENERATED_DIR);
+    // 7. Load the compiled createClient
+    const indexPath = path.join(GENERATED_DIR, 'index.js');
+    clearRequireCache(GENERATED_DIR);
+    const orm = require(indexPath);
+    return {
+        createClient: orm.createClient,
+        tables,
+        ormResult,
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Run introspection, handling both positional and object-style query functions.
+ *
+ * GraphQLQueryFn (positional): (query, variables?, commit?, reqOptions?) => Promise
+ * GraphQLQueryFnObj (object):  ({ query, variables, ... }) => Promise
+ *
+ * We call positional-style since graphile-test's underlying implementation
+ * accepts both — the positional wrapper in @constructive-io/graphql-test
+ * normalizes to the object form internally.
+ */
+async function runIntrospection(queryFn) {
+    // Detect signature: object-style functions typically have arity 1
+    // while positional have arity >= 1 (query, variables, commit, reqOptions)
+    // However, the most reliable way is to check if the first arg would be
+    // a string (positional) or object (object-style).
+    // Since we can't know at compile time, we support both at runtime.
+    const isObjectStyle = queryFn.length <= 1;
+    let result;
+    if (isObjectStyle) {
+        result = await queryFn({
+            query: SCHEMA_INTROSPECTION_QUERY,
+        });
+    }
+    else {
+        result = await queryFn(SCHEMA_INTROSPECTION_QUERY);
+    }
+    return result;
+}
+function ensureCleanDir(dir) {
+    if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(dir, { recursive: true });
+}
+function compileGeneratedFiles(dir) {
+    const tsFiles = collectTsFiles(dir);
+    for (const filePath of tsFiles) {
+        const source = fs.readFileSync(filePath, 'utf-8');
+        const result = ts.transpileModule(source, {
+            compilerOptions: {
+                module: ts.ModuleKind.CommonJS,
+                target: ts.ScriptTarget.ES2020,
+                esModuleInterop: true,
+                strict: false,
+                declaration: false,
+                skipLibCheck: true,
+            },
+            fileName: filePath,
+        });
+        const jsPath = filePath.replace(/\.ts$/, '.js');
+        fs.writeFileSync(jsPath, result.outputText);
+        // Remove .ts source so Jest's transformer doesn't type-check it
+        fs.unlinkSync(filePath);
+    }
+}
+function collectTsFiles(dir) {
+    const files = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectTsFiles(fullPath));
+        }
+        else if (entry.name.endsWith('.ts')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function clearRequireCache(dir) {
+    for (const key of Object.keys(require.cache)) {
+        if (key.startsWith(dir)) {
+            delete require.cache[key];
+        }
+    }
+}

package/esm/index.js

@@ -2,5 +2,10 @@
 export { GraphQLTest } from './graphile-test';
 export * from './get-connections';
 export { seed, snapshot } from 'pgsql-test';
+// Re-export low-level DB connection utilities for advanced two-phase patterns
+// (e.g. provision first, then build GraphQL schema over dynamic tables).
+export { getConnections as getDbConnections } from 'pgsql-test';
 // Export GraphQL test adapter for SDK integration
 export { GraphQLTestAdapter } from './adapter';
+// Export codegen-at-test-time helper for dynamic table ORM generation
+export { runCodegenAndLoad } from './codegen-helper';

package/index.d.ts

@@ -2,4 +2,9 @@ export { type GraphQLQueryOptions, type GraphQLTestContext, type GetConnectionsI
 export { GraphQLTest } from './graphile-test';
 export * from './get-connections';
 export { seed, snapshot } from 'pgsql-test';
+export { getConnections as getDbConnections } from 'pgsql-test';
+export type { GetConnectionResult, GetConnectionOpts } from 'pgsql-test';
+export type { PgTestClient } from 'pgsql-test/test-client';
 export { GraphQLTestAdapter } from './adapter';
+export { runCodegenAndLoad } from './codegen-helper';
+export type { CodegenResult } from './codegen-helper';

package/index.js

@@ -14,7 +14,7 @@ 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.GraphQLTestAdapter = exports.snapshot = exports.seed = exports.GraphQLTest = void 0;
+exports.runCodegenAndLoad = exports.GraphQLTestAdapter = exports.getDbConnections = exports.snapshot = exports.seed = exports.GraphQLTest = void 0;
 // Override with our custom implementations that use graphile-settings
 var graphile_test_1 = require("./graphile-test");
 Object.defineProperty(exports, "GraphQLTest", { enumerable: true, get: function () { return graphile_test_1.GraphQLTest; } });
@@ -22,6 +22,13 @@ __exportStar(require("./get-connections"), exports);
 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; } });
+// Re-export low-level DB connection utilities for advanced two-phase patterns
+// (e.g. provision first, then build GraphQL schema over dynamic tables).
+var pgsql_test_2 = require("pgsql-test");
+Object.defineProperty(exports, "getDbConnections", { enumerable: true, get: function () { return pgsql_test_2.getConnections; } });
 // Export GraphQL test adapter for SDK integration
 var adapter_1 = require("./adapter");
 Object.defineProperty(exports, "GraphQLTestAdapter", { enumerable: true, get: function () { return adapter_1.GraphQLTestAdapter; } });
+// Export codegen-at-test-time helper for dynamic table ORM generation
+var codegen_helper_1 = require("./codegen-helper");
+Object.defineProperty(exports, "runCodegenAndLoad", { enumerable: true, get: function () { return codegen_helper_1.runCodegenAndLoad; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-test",
-  "version": "4.11.8",
+  "version": "4.12.1",
   "author": "Constructive <developers@constructive.io>",
   "description": "Constructive GraphQL Testing with all plugins loaded",
   "main": "index.js",
@@ -34,20 +34,23 @@
     "makage": "^0.3.0"
   },
   "dependencies": {
+    "@constructive-io/graphql-codegen": "^4.31.1",
     "@constructive-io/graphql-env": "^3.6.1",
+    "@constructive-io/graphql-query": "^3.15.1",
     "@constructive-io/graphql-types": "^3.5.1",
     "@pgpmjs/types": "^2.22.0",
     "grafast": "1.0.0",
     "graphile-build": "5.0.0",
     "graphile-build-pg": "5.0.0",
     "graphile-config": "1.0.0",
-    "graphile-settings": "^4.21.8",
-    "graphile-test": "^4.9.3",
+    "graphile-settings": "^4.22.1",
+    "graphile-test": "^4.9.4",
     "graphql": "16.13.0",
     "mock-req": "^0.2.0",
     "pg": "^8.20.0",
-    "pgsql-test": "^4.9.3",
-    "postgraphile": "5.0.0"
+    "pgsql-test": "^4.9.4",
+    "postgraphile": "5.0.0",
+    "typescript": "^5.0.0"
   },
   "keywords": [
     "testing",
@@ -56,5 +59,5 @@
     "constructive",
     "test"
   ],
-  "gitHead": "a6424a875afd997535ca6b1636542a5158991003"
+  "gitHead": "90b15540015a927e45846923843fc1af36f5bed7"
 }