feat: wire BlueprintTypesPlugin into production schema build

Query node_type_registry at schema build time and pass entries to
BlueprintTypesPreset so @OneOf typed blueprint input types with
SuperCase node type names are generated in the live GraphQL schema.

Changes:
- Add fetchNodeTypeRegistry() utility that queries metaschema_public.node_type_registry
  (gracefully returns [] if table doesn't exist yet)
- Wire BlueprintTypesPreset into production server (graphile.ts)
- Wire BlueprintTypesPreset into build-schema (codegen path)
- Wire BlueprintTypesPreset into query executor
- Wire BlueprintTypesPreset into explorer server

Builds on PR #857 which added the plugin, codegen support, and tests.

Author: pyramation

graphile/graphile-schema/src/build-schema.ts

@@ -1,6 +1,6 @@
 import deepmerge from 'deepmerge'
 import { printSchema } from 'graphql'
-import { ConstructivePreset, makePgService } from 'graphile-settings'
+import { ConstructivePreset, makePgService, fetchNodeTypeRegistry, BlueprintTypesPreset } from 'graphile-settings'
 import { makeSchema } from 'graphile-build'
 import { buildConnectionString } from 'pg-cache'
 import { getPgEnvOptions } from 'pg-env'
@@ -25,8 +25,10 @@ export async function buildSchemaSDL(opts: BuildSchemaOptions): Promise<string>
     config.database,
   )
 
+  const nodeTypes = await fetchNodeTypeRegistry(connectionString);
+
   const basePreset: GraphileConfig.Preset = {
-    extends: [ConstructivePreset],
+    extends: [ConstructivePreset, BlueprintTypesPreset(nodeTypes)],
     pgServices: [
       makePgService({
         connectionString,

graphile/graphile-settings/src/plugins/blueprint-types/fetch-registry.ts

@@ -0,0 +1,69 @@
+/**
+ * Fetch Node Type Registry
+ *
+ * Queries the node_type_registry table from the database at schema build time.
+ * Used to populate the BlueprintTypesPlugin with real node type entries
+ * so that @oneOf types reflect the actual registered node types.
+ *
+ * The query uses the metaschema_public schema and selects all columns
+ * needed by the plugin: name, slug, category, display_name, description,
+ * parameter_schema, and tags.
+ */
+
+import { Pool } from 'pg';
+import type { NodeTypeRegistryEntry } from './plugin';
+
+/**
+ * Fetch all node_type_registry entries from the database.
+ *
+ * Connects using the provided connection string, queries
+ * metaschema_public.node_type_registry, and returns the rows
+ * as NodeTypeRegistryEntry[].
+ *
+ * If the table doesn't exist or the query fails (e.g., the database
+ * hasn't been migrated yet), returns an empty array and logs a warning.
+ *
+ * @param connectionString - PostgreSQL connection string
+ * @returns Array of node type registry entries
+ */
+export async function fetchNodeTypeRegistry(
+  connectionString: string,
+): Promise<NodeTypeRegistryEntry[]> {
+  const pool = new Pool({ connectionString, max: 1 });
+
+  try {
+    const result = await pool.query<NodeTypeRegistryEntry>(`
+      SELECT
+        name,
+        slug,
+        category,
+        COALESCE(display_name, name) as display_name,
+        COALESCE(description, '') as description,
+        COALESCE(parameter_schema, '{}'::jsonb) as parameter_schema,
+        COALESCE(tags, '{}') as tags
+      FROM metaschema_public.node_type_registry
+      ORDER BY category, name
+    `);
+
+    return result.rows;
+  } catch (error: unknown) {
+    // If the table doesn't exist yet (not migrated), return empty gracefully
+    const pgError = error as { code?: string; message?: string };
+    if (pgError.code === '42P01') {
+      // 42P01 = undefined_table
+      // This is expected when the database hasn't been migrated with the metaschema package
+      return [];
+    }
+
+    // For other errors, log a warning and return empty
+    // This ensures the schema build doesn't fail just because
+    // node_type_registry isn't accessible
+    console.warn(
+      '[BlueprintTypesPlugin] Failed to fetch node_type_registry:',
+      pgError.message ?? String(error),
+    );
+    return [];
+  } finally {
+    await pool.end();
+  }
+}

graphile/graphile-settings/src/plugins/blueprint-types/index.ts

@@ -9,3 +9,4 @@ export {
   BlueprintTypesPreset,
 } from './plugin';
 export type { NodeTypeRegistryEntry } from './plugin';
+export { fetchNodeTypeRegistry } from './fetch-registry';

graphile/graphile-settings/src/plugins/index.ts

@@ -115,5 +115,6 @@ export type {
 export {
   createBlueprintTypesPlugin,
   BlueprintTypesPreset,
+  fetchNodeTypeRegistry,
 } from './blueprint-types';
 export type { NodeTypeRegistryEntry } from './blueprint-types';

graphql/explorer/src/server.ts

@@ -4,7 +4,7 @@ import { cors, healthz, poweredBy } from '@pgpmjs/server-utils';
 import { middleware as parseDomains } from '@constructive-io/url-domains';
 import express, { Express, NextFunction, Request, Response } from 'express';
 import { createGraphileInstance, graphileCache, GraphileCacheEntry } from 'graphile-cache';
-import { makePgService } from 'graphile-settings';
+import { makePgService, fetchNodeTypeRegistry, BlueprintTypesPreset } from 'graphile-settings';
 import type { GraphileConfig } from 'graphile-config';
 import { buildConnectionString, getPgPool } from 'pg-cache';
 import { getPgEnvOptions } from 'pg-env';
@@ -40,9 +40,12 @@ export const GraphQLExplorer = (rawOpts: ConstructiveOptions = {}): Express => {
       pgConfig.database
     );
 
+    const nodeTypes = await fetchNodeTypeRegistry(connectionString);
+
     const basePreset = getGraphilePreset(opts);
     const preset: GraphileConfig.Preset = {
       ...basePreset,
+      extends: [...(basePreset.extends ?? []), BlueprintTypesPreset(nodeTypes)],
       pgServices: [
         makePgService({ connectionString, schemas: [schemaname] }),
       ],

graphql/query/src/executor.ts

@@ -7,7 +7,7 @@
 
 import { execute } from 'grafast';
 import { postgraphile, type PostGraphileInstance } from 'postgraphile';
-import { ConstructivePreset, makePgService } from 'graphile-settings';
+import { ConstructivePreset, makePgService, fetchNodeTypeRegistry, BlueprintTypesPreset } from 'graphile-settings';
 import { withPgClientFromPgService } from 'graphile-build-pg';
 import type {
   DocumentNode,
@@ -111,11 +111,14 @@ export class QueryExecutor {
       schemas: this.options.schemas,
     });
 
+    // Fetch node type registry for blueprint @oneOf types
+    const nodeTypes = await fetchNodeTypeRegistry(this.options.connectionString);
+
     // Note: Using 'as unknown as' to bypass strict type checking
     // because GraphileConfig.Preset doesn't include pgServices in its type definition
     // but postgraphile() accepts it at runtime
     const preset = {
-      extends: [ConstructivePreset],
+      extends: [ConstructivePreset, BlueprintTypesPreset(nodeTypes)],
       pgServices: [pgService],
       grafast: {
         context: () => ({

graphql/server/src/middleware/graphile.ts

@@ -6,7 +6,7 @@ import type { NextFunction, Request, RequestHandler, Response } from 'express';
 import type { GraphQLError, GraphQLFormattedError } from 'grafast/graphql';
 import { createGraphileInstance, type GraphileCacheEntry, graphileCache } from 'graphile-cache';
 import type { GraphileConfig } from 'graphile-config';
-import { ConstructivePreset, makePgService } from 'graphile-settings';
+import { ConstructivePreset, makePgService, fetchNodeTypeRegistry, BlueprintTypesPreset } from 'graphile-settings';
 import { buildConnectionString } from 'pg-cache';
 import { getPgEnvOptions } from 'pg-env';
 import './types'; // for Request type
@@ -124,15 +124,21 @@ const log = new Logger('graphile');
 const reqLabel = (req: Request): string => (req.requestId ? `[${req.requestId}]` : '[req]');
 
 /**
- * Build a PostGraphile v5 preset for a tenant
+ * Build a PostGraphile v5 preset for a tenant.
+ *
+ * Queries node_type_registry at build time to generate @oneOf typed
+ * blueprint input types with SuperCase node type names as discriminant keys.
  */
-const buildPreset = (
+const buildPreset = async (
   connectionString: string,
   schemas: string[],
   anonRole: string,
   roleName: string,
-): GraphileConfig.Preset => ({
-  extends: [ConstructivePreset],
+): Promise<GraphileConfig.Preset> => {
+  const nodeTypes = await fetchNodeTypeRegistry(connectionString);
+
+  return {
+  extends: [ConstructivePreset, BlueprintTypesPreset(nodeTypes)],
   pgServices: [
     makePgService({
       connectionString,
@@ -187,7 +193,8 @@ const buildPreset = (
       };
     },
   },
-});
+};
+};
 
 export const graphile = (opts: ConstructiveOptions): RequestHandler => {
   const observabilityEnabled = isGraphqlObservabilityEnabled(opts.server?.host);
@@ -270,7 +277,7 @@ export const graphile = (opts: ConstructiveOptions): RequestHandler => {
       );
 
       // Create promise and store in in-flight map BEFORE try block
-      const preset = buildPreset(connectionString, schema || [], anonRole, roleName);
+      const preset = await buildPreset(connectionString, schema || [], anonRole, roleName);
       const creationPromise = observeGraphileBuild(
         {
           cacheKey: key,