@constructive-io/graphql-server 5.25.1 → 5.26.0

package/esm/middleware/graphile-introspection.js

@@ -0,0 +1,65 @@
+import { resolvePreset } from 'graphile-config';
+import { makePgService } from 'graphile-settings';
+const SCOPED_INTROSPECTION_PLUGIN = 'ConstructivePgIntrospectionPlugin';
+let scopedIntrospectionPresetPromise;
+const loadScopedIntrospectionPreset = () => {
+    scopedIntrospectionPresetPromise ??=
+        import('graphile-scoped-introspection').then(({ ScopedIntrospectionPreset }) => ScopedIntrospectionPreset);
+    return scopedIntrospectionPresetPromise;
+};
+/**
+ * Resolve caller-provided Graphile configuration before deciding whether the
+ * optional scoped introspection package is needed. Graphile config applies
+ * nested `extends` entries before the containing preset, so this preserves the
+ * same precedence used by the eventual schema build.
+ */
+export const resolveCallerPreset = (graphileOptions) => {
+    const preset = graphileOptions?.preset;
+    const presets = [
+        ...(graphileOptions?.extends ?? []),
+        ...(preset ? [preset] : [])
+    ];
+    return presets.length > 0 ? resolvePreset({ extends: presets }) : undefined;
+};
+const hasLocalScopedIntrospectionPreset = (preset) => preset?.plugins.some((plugin) => plugin.name === SCOPED_INTROSPECTION_PLUGIN) ??
+    false;
+const hasUpstreamIntrospectionDisabled = (preset) => preset?.disablePlugins.includes('PgIntrospectionPlugin') ?? false;
+/**
+ * Select the stock or scoped introspection wiring once, while constructing a
+ * server-owned schema handler. The stock branch returns before the scoped
+ * package (and its upstream contract sentinel) is loaded.
+ */
+export const makeIntrospectionWiring = async (pool, schemas, graphileOptions, loadScopedPreset = loadScopedIntrospectionPreset, introspectionRole) => {
+    const pgSettingsForIntrospection = introspectionRole ? { role: introspectionRole } : undefined;
+    const pgService = makePgService({ pool, schemas, pgSettingsForIntrospection });
+    const callerPreset = resolveCallerPreset(graphileOptions);
+    const scopedConfig = callerPreset?.gather?.pgScopedIntrospection;
+    const hasScopedConfiguration = scopedConfig !== undefined;
+    // An explicitly supplied local preset already installs the replacement
+    // plugin. Keep that path synchronous and avoid importing the optional
+    // package a second time. A raw plugin entry may omit the stock plugin's
+    // disablement, so add that narrow preset to keep the replacement atomic.
+    if (hasLocalScopedIntrospectionPreset(callerPreset)) {
+        return {
+            presets: hasUpstreamIntrospectionDisabled(callerPreset)
+                ? []
+                : [{ disablePlugins: ['PgIntrospectionPlugin'] }],
+            pgService
+        };
+    }
+    if (!hasScopedConfiguration) {
+        return {
+            presets: [],
+            pgService
+        };
+    }
+    // Load the replacement whenever the map is supplied, including an empty map,
+    // entries set to false, or entries keyed by an unknown service. The
+    // replacement owns validation; leaving it out would cause Graphile's stock
+    // plugin to silently ignore the gather option in those cases.
+    const scopedPreset = await loadScopedPreset();
+    return {
+        presets: [scopedPreset],
+        pgService
+    };
+};

package/esm/middleware/graphile.js

@@ -5,7 +5,7 @@ import { getNodeEnv } from '@pgpmjs/env';
 import { Logger } from '@pgpmjs/logger';
 import { createGraphileInstance, graphileCache } from 'graphile-cache';
 import { createFunctionBindingsPlugin } from 'graphile-function-bindings';
-import { createConstructivePreset, makePgService } from 'graphile-settings';
+import { createConstructivePreset } from 'graphile-settings';
 import { getPgPool } from 'pg-cache';
 import { getPgEnvOptions } from 'pg-env';
 import { isGraphqlObservabilityEnabled } from '../diagnostics/observability';
@@ -14,6 +14,7 @@ import { respondWithGraphQLError } from '../errors/graphql-response';
 import { AuthCookiePlugin } from '../plugins/auth-cookie-plugin';
 import { createErrorEventsPlugin } from '../plugins/error-events-plugin';
 import { RequestProtectionPlugin } from '../plugins/request-protection-plugin';
+import { makeIntrospectionWiring } from './graphile-introspection';
 import { maskError } from './mask-error';
 import { observeGraphileBuild } from './observability/graphile-build-stats';
 const isDev = () => getNodeEnv() === 'development';
@@ -56,10 +57,19 @@ const reqLabel = (req) => (req.requestId ? `[${req.requestId}]` : '[req]');
  * plugin preset.  Without settings the default preset is used
  * (everything on except aggregates).
  */
-const buildPreset = (pool, schemas, anonRole, roleName, introspectionRole, databaseSettings, apiId, compute) => {
+const buildPreset = async (pool, schemas, anonRole, roleName, introspectionRole, graphileOptions, databaseSettings, apiId, compute) => {
+    const introspection = await makeIntrospectionWiring(pool, schemas, graphileOptions, undefined, introspectionRole);
+    const configuredPreset = graphileOptions?.preset ?? {};
     return {
-        extends: [createConstructivePreset(databaseSettings)],
+        ...configuredPreset,
+        extends: [
+            createConstructivePreset(databaseSettings),
+            ...(graphileOptions?.extends ?? []),
+            ...(configuredPreset.extends ?? []),
+            ...introspection.presets
+        ],
         plugins: [
+            ...(configuredPreset.plugins ?? []),
             AuthCookiePlugin,
             RequestProtectionPlugin,
             createErrorEventsPlugin(pool),
@@ -83,20 +93,7 @@ const buildPreset = (pool, schemas, anonRole, roleName, introspectionRole, datab
                 ]
                 : [])
         ],
-        pgServices: [
-            makePgService({
-                pool,
-                schemas,
-                // Introspection runs outside any request, so it has no served role to
-                // inherit: unset, it reads the catalog as whatever role the pool
-                // connected as (a superuser in most deployments) and the schema
-                // advertises that role's reach. Naming the role keeps schema shape
-                // tied to a bounded role's grants.
-                ...(introspectionRole && {
-                    pgSettingsForIntrospection: { role: introspectionRole }
-                })
-            })
-        ],
+        pgServices: [introspection.pgService],
         grafserv: {
             graphqlPath: '/graphql',
             graphiqlPath: '/graphiql',
@@ -304,18 +301,21 @@ export const graphile = (opts) => {
             // Route through pg-cache so the pool is tracked and can be cleaned up
             // properly, preventing leaked connections during database teardown.
             const pool = getPgPool(pgConfig);
-            // Create promise and store in in-flight map BEFORE try block
-            const compute = api.apiId ? await req.constructive?.useModule('compute') : undefined;
-            const preset = buildPreset(pool, schema || [], anonRole, roleName, opts.api?.introspectionRole, api.databaseSettings, api.apiId, compute);
-            const creationPromise = observeGraphileBuild({
-                cacheKey: key,
-                serviceKey: key,
-                databaseId: api.databaseId ?? null
-            }, () => createGraphileInstance({
-                preset,
-                cacheKey: key,
-                enableRealtime: api.databaseSettings?.enableRealtime
-            }), { enabled: observabilityEnabled });
+            // Register the creation promise before any asynchronous preset work so
+            // concurrent requests coalesce while optional plugin modules load.
+            const creationPromise = (async () => {
+                const compute = api.apiId ? await req.constructive?.useModule('compute') : undefined;
+                const preset = await buildPreset(pool, schema || [], anonRole, roleName, opts.api?.introspectionRole, opts.graphile, api.databaseSettings, api.apiId, compute);
+                return observeGraphileBuild({
+                    cacheKey: key,
+                    serviceKey: key,
+                    databaseId: api.databaseId ?? null
+                }, () => createGraphileInstance({
+                    preset,
+                    cacheKey: key,
+                    enableRealtime: api.databaseSettings?.enableRealtime
+                }), { enabled: observabilityEnabled });
+            })();
             creating.set(key, creationPromise);
             try {
                 const instance = await creationPromise;

package/esm/protection/document-gate.js

@@ -17,12 +17,15 @@
  * have to be followed (a document can hide its depth entirely inside
  * fragments) and the visitor does not follow them.
  *
- * Schema introspection (`__schema` / `__type`) is governed only by
- * `enableIntrospection`. Its selections are not walked: the introspection types
- * carry no connections, so there is nothing to cost, and the standard
- * introspection document nests a fixed `ofType` chain deeper than a sensible
- * tenant depth budget, so charging depth would make the budget decide whether
- * clients can introspect at all — a decision the dedicated switch already owns.
+ * Schema introspection (`__schema` / `__type`) is switched by
+ * `enableIntrospection` and bounded by its own fixed depth ceiling rather than
+ * the tenant's `maxQueryDepth`. The standard introspection document nests a
+ * fixed `ofType` chain deeper than a sensible tenant depth budget, so charging
+ * it against that budget would let the budget decide whether clients can
+ * introspect at all. It still needs a bound of its own, though: the
+ * introspection schema is recursive (`__Type.fields → __Field.type → __Type`),
+ * so an unbounded walk would let a client nest it arbitrarily. Introspection
+ * types carry no connections, so cost is naturally zero.
  */
 import { errors } from '@constructive-io/errors';
 import { ASSUMED_PAGE_SIZE } from '@constructive-io/express-context';
@@ -43,6 +46,14 @@ const reject = (error) => {
         statusCode: error.http
     });
 };
+/**
+ * Depth allowed inside a `__schema` / `__type` subtree, counted from the
+ * introspection field itself. graphql-js's `getIntrospectionQuery` with every
+ * option enabled reaches 13 (`types → fields → args → type → ofType×9`), so
+ * this leaves headroom for tooling without permitting the recursive
+ * `fields { type { fields { type … } } }` shape to run away.
+ */
+export const INTROSPECTION_MAX_DEPTH = 16;
 /** Arguments a connection field uses to size its page. */
 const PAGE_SIZE_ARGS = ['first', 'last'];
 /** A connection is any object type that carries Relay's `pageInfo`. */
@@ -78,20 +89,28 @@ const requestedPageSize = (args, variableValues) => {
  *   the walk only stops charging cost rather than raising its own error)
  * @param depth - nesting level of these selections
  * @param multiplier - rows the enclosing connections can return
+ * @param bound - which depth limit applies to these selections
  */
-function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier) {
-    if (depth > walk.maxDepth)
-        walk.maxDepth = depth;
-    if (depth > walk.protection.maxQueryDepth) {
-        reject(errors.QUERY_TOO_DEEP({ depth, limit: walk.protection.maxQueryDepth }));
+function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier, bound) {
+    if (bound.kind === 'query') {
+        if (depth > walk.maxDepth)
+            walk.maxDepth = depth;
+        if (depth > walk.protection.maxQueryDepth) {
+            reject(errors.QUERY_TOO_DEEP({ depth, limit: walk.protection.maxQueryDepth }));
+        }
+    }
+    else if (depth - bound.base > INTROSPECTION_MAX_DEPTH) {
+        reject(errors.QUERY_TOO_DEEP({ depth: depth - bound.base, limit: INTROSPECTION_MAX_DEPTH }));
     }
     for (const selection of selectionSet.selections) {
         if (selection.kind === Kind.FIELD) {
+            let childBound = bound;
             if (selection.name.value === '__schema' || selection.name.value === '__type') {
                 if (!walk.protection.enableIntrospection) {
                     reject(errors.INTROSPECTION_DISABLED());
                 }
-                continue;
+                if (bound.kind === 'query')
+                    childBound = { kind: 'introspection', base: depth };
             }
             const field = parentType && isObjectType(parentType)
                 ? parentType.getFields()[selection.name.value]
@@ -118,7 +137,7 @@ function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier) {
                 }
             }
             if (selection.selectionSet) {
-                walkSelectionSet(walk, selection.selectionSet, fieldType, depth + 1, childMultiplier);
+                walkSelectionSet(walk, selection.selectionSet, fieldType, depth + 1, childMultiplier, childBound);
             }
             continue;
         }
@@ -127,7 +146,7 @@ function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier) {
                 ? typeFromAST(walk.schema, selection.typeCondition)
                 : parentType;
             // An inline fragment is not a level of nesting of its own.
-            walkSelectionSet(walk, selection.selectionSet, onType ?? null, depth, multiplier);
+            walkSelectionSet(walk, selection.selectionSet, onType ?? null, depth, multiplier, bound);
             continue;
         }
         if (selection.kind === Kind.FRAGMENT_SPREAD) {
@@ -143,7 +162,7 @@ function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier) {
             const onType = typeFromAST(walk.schema, fragment.typeCondition);
             walk.activeFragments.add(name);
             try {
-                walkSelectionSet(walk, fragment.selectionSet, onType ?? null, depth, multiplier);
+                walkSelectionSet(walk, fragment.selectionSet, onType ?? null, depth, multiplier, bound);
             }
             finally {
                 walk.activeFragments.delete(name);
@@ -185,6 +204,6 @@ export function enforceDocumentProtection(schema, document, variableValues, prot
         maxDepth: 0,
         cost: 0
     };
-    walkSelectionSet(walk, operation.selectionSet, rootType ?? null, 1, 1);
+    walkSelectionSet(walk, operation.selectionSet, rootType ?? null, 1, 1, { kind: 'query' });
     return { depth: walk.maxDepth, cost: walk.cost };
 }

package/middleware/graphile-introspection.d.ts

@@ -0,0 +1,23 @@
+import type { GraphileOptions } from '@constructive-io/graphql-types';
+import { type GraphileConfig } from 'graphile-config';
+import type { Pool } from 'pg';
+export interface IntrospectionWiring {
+    presets: GraphileConfig.Preset[];
+    pgService: GraphileConfig.PgServiceConfiguration;
+}
+export type ScopedIntrospectionPresetLoader = () => Promise<GraphileConfig.Preset>;
+type ResolvedCallerPreset = GraphileConfig.ResolvedPreset | undefined;
+/**
+ * Resolve caller-provided Graphile configuration before deciding whether the
+ * optional scoped introspection package is needed. Graphile config applies
+ * nested `extends` entries before the containing preset, so this preserves the
+ * same precedence used by the eventual schema build.
+ */
+export declare const resolveCallerPreset: (graphileOptions: GraphileOptions | undefined) => ResolvedCallerPreset;
+/**
+ * Select the stock or scoped introspection wiring once, while constructing a
+ * server-owned schema handler. The stock branch returns before the scoped
+ * package (and its upstream contract sentinel) is loaded.
+ */
+export declare const makeIntrospectionWiring: (pool: Pool, schemas: string[], graphileOptions: GraphileOptions | undefined, loadScopedPreset?: ScopedIntrospectionPresetLoader, introspectionRole?: string) => Promise<IntrospectionWiring>;
+export {};

package/middleware/graphile-introspection.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIntrospectionWiring = exports.resolveCallerPreset = void 0;
+const graphile_config_1 = require("graphile-config");
+const graphile_settings_1 = require("graphile-settings");
+const SCOPED_INTROSPECTION_PLUGIN = 'ConstructivePgIntrospectionPlugin';
+let scopedIntrospectionPresetPromise;
+const loadScopedIntrospectionPreset = () => {
+    scopedIntrospectionPresetPromise ??=
+        import('graphile-scoped-introspection').then(({ ScopedIntrospectionPreset }) => ScopedIntrospectionPreset);
+    return scopedIntrospectionPresetPromise;
+};
+/**
+ * Resolve caller-provided Graphile configuration before deciding whether the
+ * optional scoped introspection package is needed. Graphile config applies
+ * nested `extends` entries before the containing preset, so this preserves the
+ * same precedence used by the eventual schema build.
+ */
+const resolveCallerPreset = (graphileOptions) => {
+    const preset = graphileOptions?.preset;
+    const presets = [
+        ...(graphileOptions?.extends ?? []),
+        ...(preset ? [preset] : [])
+    ];
+    return presets.length > 0 ? (0, graphile_config_1.resolvePreset)({ extends: presets }) : undefined;
+};
+exports.resolveCallerPreset = resolveCallerPreset;
+const hasLocalScopedIntrospectionPreset = (preset) => preset?.plugins.some((plugin) => plugin.name === SCOPED_INTROSPECTION_PLUGIN) ??
+    false;
+const hasUpstreamIntrospectionDisabled = (preset) => preset?.disablePlugins.includes('PgIntrospectionPlugin') ?? false;
+/**
+ * Select the stock or scoped introspection wiring once, while constructing a
+ * server-owned schema handler. The stock branch returns before the scoped
+ * package (and its upstream contract sentinel) is loaded.
+ */
+const makeIntrospectionWiring = async (pool, schemas, graphileOptions, loadScopedPreset = loadScopedIntrospectionPreset, introspectionRole) => {
+    const pgSettingsForIntrospection = introspectionRole ? { role: introspectionRole } : undefined;
+    const pgService = (0, graphile_settings_1.makePgService)({ pool, schemas, pgSettingsForIntrospection });
+    const callerPreset = (0, exports.resolveCallerPreset)(graphileOptions);
+    const scopedConfig = callerPreset?.gather?.pgScopedIntrospection;
+    const hasScopedConfiguration = scopedConfig !== undefined;
+    // An explicitly supplied local preset already installs the replacement
+    // plugin. Keep that path synchronous and avoid importing the optional
+    // package a second time. A raw plugin entry may omit the stock plugin's
+    // disablement, so add that narrow preset to keep the replacement atomic.
+    if (hasLocalScopedIntrospectionPreset(callerPreset)) {
+        return {
+            presets: hasUpstreamIntrospectionDisabled(callerPreset)
+                ? []
+                : [{ disablePlugins: ['PgIntrospectionPlugin'] }],
+            pgService
+        };
+    }
+    if (!hasScopedConfiguration) {
+        return {
+            presets: [],
+            pgService
+        };
+    }
+    // Load the replacement whenever the map is supplied, including an empty map,
+    // entries set to false, or entries keyed by an unknown service. The
+    // replacement owns validation; leaving it out would cause Graphile's stock
+    // plugin to silently ignore the gather option in those cases.
+    const scopedPreset = await loadScopedPreset();
+    return {
+        presets: [scopedPreset],
+        pgService
+    };
+};
+exports.makeIntrospectionWiring = makeIntrospectionWiring;

package/middleware/graphile.js

@@ -20,6 +20,7 @@ const graphql_response_1 = require("../errors/graphql-response");
 const auth_cookie_plugin_1 = require("../plugins/auth-cookie-plugin");
 const error_events_plugin_1 = require("../plugins/error-events-plugin");
 const request_protection_plugin_1 = require("../plugins/request-protection-plugin");
+const graphile_introspection_1 = require("./graphile-introspection");
 const mask_error_1 = require("./mask-error");
 const graphile_build_stats_1 = require("./observability/graphile-build-stats");
 const isDev = () => (0, env_1.getNodeEnv)() === 'development';
@@ -62,10 +63,19 @@ const reqLabel = (req) => (req.requestId ? `[${req.requestId}]` : '[req]');
  * plugin preset.  Without settings the default preset is used
  * (everything on except aggregates).
  */
-const buildPreset = (pool, schemas, anonRole, roleName, introspectionRole, databaseSettings, apiId, compute) => {
+const buildPreset = async (pool, schemas, anonRole, roleName, introspectionRole, graphileOptions, databaseSettings, apiId, compute) => {
+    const introspection = await (0, graphile_introspection_1.makeIntrospectionWiring)(pool, schemas, graphileOptions, undefined, introspectionRole);
+    const configuredPreset = graphileOptions?.preset ?? {};
     return {
-        extends: [(0, graphile_settings_1.createConstructivePreset)(databaseSettings)],
+        ...configuredPreset,
+        extends: [
+            (0, graphile_settings_1.createConstructivePreset)(databaseSettings),
+            ...(graphileOptions?.extends ?? []),
+            ...(configuredPreset.extends ?? []),
+            ...introspection.presets
+        ],
         plugins: [
+            ...(configuredPreset.plugins ?? []),
             auth_cookie_plugin_1.AuthCookiePlugin,
             request_protection_plugin_1.RequestProtectionPlugin,
             (0, error_events_plugin_1.createErrorEventsPlugin)(pool),
@@ -89,20 +99,7 @@ const buildPreset = (pool, schemas, anonRole, roleName, introspectionRole, datab
                 ]
                 : [])
         ],
-        pgServices: [
-            (0, graphile_settings_1.makePgService)({
-                pool,
-                schemas,
-                // Introspection runs outside any request, so it has no served role to
-                // inherit: unset, it reads the catalog as whatever role the pool
-                // connected as (a superuser in most deployments) and the schema
-                // advertises that role's reach. Naming the role keeps schema shape
-                // tied to a bounded role's grants.
-                ...(introspectionRole && {
-                    pgSettingsForIntrospection: { role: introspectionRole }
-                })
-            })
-        ],
+        pgServices: [introspection.pgService],
         grafserv: {
             graphqlPath: '/graphql',
             graphiqlPath: '/graphiql',
@@ -310,18 +307,21 @@ const graphile = (opts) => {
             // Route through pg-cache so the pool is tracked and can be cleaned up
             // properly, preventing leaked connections during database teardown.
             const pool = (0, pg_cache_1.getPgPool)(pgConfig);
-            // Create promise and store in in-flight map BEFORE try block
-            const compute = api.apiId ? await req.constructive?.useModule('compute') : undefined;
-            const preset = buildPreset(pool, schema || [], anonRole, roleName, opts.api?.introspectionRole, api.databaseSettings, api.apiId, compute);
-            const creationPromise = (0, graphile_build_stats_1.observeGraphileBuild)({
-                cacheKey: key,
-                serviceKey: key,
-                databaseId: api.databaseId ?? null
-            }, () => (0, graphile_cache_1.createGraphileInstance)({
-                preset,
-                cacheKey: key,
-                enableRealtime: api.databaseSettings?.enableRealtime
-            }), { enabled: observabilityEnabled });
+            // Register the creation promise before any asynchronous preset work so
+            // concurrent requests coalesce while optional plugin modules load.
+            const creationPromise = (async () => {
+                const compute = api.apiId ? await req.constructive?.useModule('compute') : undefined;
+                const preset = await buildPreset(pool, schema || [], anonRole, roleName, opts.api?.introspectionRole, opts.graphile, api.databaseSettings, api.apiId, compute);
+                return (0, graphile_build_stats_1.observeGraphileBuild)({
+                    cacheKey: key,
+                    serviceKey: key,
+                    databaseId: api.databaseId ?? null
+                }, () => (0, graphile_cache_1.createGraphileInstance)({
+                    preset,
+                    cacheKey: key,
+                    enableRealtime: api.databaseSettings?.enableRealtime
+                }), { enabled: observabilityEnabled });
+            })();
             creating.set(key, creationPromise);
             try {
                 const instance = await creationPromise;

package/middleware/types.d.ts

@@ -1,17 +1,5 @@
-import type { RequestProtection } from '@constructive-io/express-context';
-import type { ApiStructure } from '../types';
-export type ConstructiveAPIToken = {
-    id?: string;
-    user_id?: string;
-    principal_id?: string;
-    session_id?: string;
-    access_level?: string;
-    kind?: string;
-    root_session_id?: string;
-    parent_session_id?: string;
-    intent?: string;
-    [key: string]: unknown;
-};
+import type { ApiStructure, ConstructiveAPIToken, RequestProtection } from '@constructive-io/express-context';
+export type { ConstructiveAPIToken } from '@constructive-io/express-context';
 declare global {
     namespace Express {
         interface Request {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-server",
-  "version": "5.25.1",
+  "version": "5.26.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Constructive GraphQL Server",
   "main": "index.js",
@@ -43,19 +43,19 @@
   "dependencies": {
     "@agentic-kit/ollama": "2.14.0",
     "@constructive-io/csrf": "^0.29.1",
-    "@constructive-io/errors": "^0.14.0",
-    "@constructive-io/express-context": "^0.31.0",
-    "@constructive-io/graphql-env": "^3.32.1",
-    "@constructive-io/graphql-types": "^3.31.1",
+    "@constructive-io/errors": "^0.17.0",
+    "@constructive-io/express-context": "^0.32.0",
+    "@constructive-io/graphql-env": "^3.33.0",
+    "@constructive-io/graphql-types": "^3.32.0",
     "@constructive-io/llm-env": "^0.14.1",
-    "@constructive-io/query-builder": "^3.13.6",
-    "@constructive-io/s3-utils": "^2.33.0",
+    "@constructive-io/query-builder": "^3.14.0",
+    "@constructive-io/s3-utils": "^2.33.1",
     "@constructive-io/url-domains": "^2.30.1",
     "@graphile-contrib/pg-many-to-many": "2.0.0-rc.2",
-    "@pgpmjs/env": "^2.43.5",
+    "@pgpmjs/env": "^2.44.0",
     "@pgpmjs/logger": "^2.25.1",
-    "@pgpmjs/server-utils": "^3.27.5",
-    "@pgpmjs/types": "^2.53.3",
+    "@pgpmjs/server-utils": "^3.28.0",
+    "@pgpmjs/types": "^2.54.0",
     "cors": "^2.8.6",
     "deepmerge": "^4.3.1",
     "express": "^5.2.1",
@@ -64,16 +64,17 @@
     "grafserv": "1.0.1",
     "graphile-build": "5.1.1",
     "graphile-build-pg": "5.1.3",
-    "graphile-cache": "^4.12.5",
+    "graphile-cache": "^4.13.0",
     "graphile-config": "1.1.0",
-    "graphile-function-bindings": "^1.14.6",
-    "graphile-settings": "^6.21.8",
+    "graphile-function-bindings": "^1.15.0",
+    "graphile-scoped-introspection": "^0.2.0",
+    "graphile-settings": "^6.22.0",
     "graphile-utils": "5.0.3",
     "graphql": "16.13.0",
     "graphql-upload": "^13.0.0",
     "lru-cache": "^11.2.7",
     "pg": "^8.21.0",
-    "pg-cache": "^3.27.5",
+    "pg-cache": "^3.28.0",
     "pg-env": "^1.31.1",
     "pg-query-context": "^2.30.1",
     "pg-sql2": "5.0.1",
@@ -90,11 +91,11 @@
     "@types/request-ip": "^0.0.41",
     "@types/supertest": "^7.2.1",
     "cookie-parser": "^1.4.7",
-    "graphile-test": "5.14.6",
+    "graphile-test": "5.15.0",
     "makage": "^0.8.0",
     "nodemon": "^3.1.14",
     "supertest": "^7.2.2",
     "ts-node": "^10.9.2"
   },
-  "gitHead": "164f6e481961196e681eb3dee9e5f9ebcb8fb834"
+  "gitHead": "399437801c27b070312125f3f0ee821ce16e183e"
 }

package/protection/document-gate.d.ts

@@ -17,15 +17,26 @@
  * have to be followed (a document can hide its depth entirely inside
  * fragments) and the visitor does not follow them.
  *
- * Schema introspection (`__schema` / `__type`) is governed only by
- * `enableIntrospection`. Its selections are not walked: the introspection types
- * carry no connections, so there is nothing to cost, and the standard
- * introspection document nests a fixed `ofType` chain deeper than a sensible
- * tenant depth budget, so charging depth would make the budget decide whether
- * clients can introspect at all — a decision the dedicated switch already owns.
+ * Schema introspection (`__schema` / `__type`) is switched by
+ * `enableIntrospection` and bounded by its own fixed depth ceiling rather than
+ * the tenant's `maxQueryDepth`. The standard introspection document nests a
+ * fixed `ofType` chain deeper than a sensible tenant depth budget, so charging
+ * it against that budget would let the budget decide whether clients can
+ * introspect at all. It still needs a bound of its own, though: the
+ * introspection schema is recursive (`__Type.fields → __Field.type → __Type`),
+ * so an unbounded walk would let a client nest it arbitrarily. Introspection
+ * types carry no connections, so cost is naturally zero.
  */
 import { type RequestProtection } from '@constructive-io/express-context';
 import type { DocumentNode, GraphQLSchema } from 'graphql';
+/**
+ * Depth allowed inside a `__schema` / `__type` subtree, counted from the
+ * introspection field itself. graphql-js's `getIntrospectionQuery` with every
+ * option enabled reaches 13 (`types → fields → args → type → ofType×9`), so
+ * this leaves headroom for tooling without permitting the recursive
+ * `fields { type { fields { type … } } }` shape to run away.
+ */
+export declare const INTROSPECTION_MAX_DEPTH = 16;
 export interface DocumentAnalysis {
     /** Deepest field nesting in the operation. */
     depth: number;

package/protection/document-gate.js

@@ -18,14 +18,18 @@
  * have to be followed (a document can hide its depth entirely inside
  * fragments) and the visitor does not follow them.
  *
- * Schema introspection (`__schema` / `__type`) is governed only by
- * `enableIntrospection`. Its selections are not walked: the introspection types
- * carry no connections, so there is nothing to cost, and the standard
- * introspection document nests a fixed `ofType` chain deeper than a sensible
- * tenant depth budget, so charging depth would make the budget decide whether
- * clients can introspect at all — a decision the dedicated switch already owns.
+ * Schema introspection (`__schema` / `__type`) is switched by
+ * `enableIntrospection` and bounded by its own fixed depth ceiling rather than
+ * the tenant's `maxQueryDepth`. The standard introspection document nests a
+ * fixed `ofType` chain deeper than a sensible tenant depth budget, so charging
+ * it against that budget would let the budget decide whether clients can
+ * introspect at all. It still needs a bound of its own, though: the
+ * introspection schema is recursive (`__Type.fields → __Field.type → __Type`),
+ * so an unbounded walk would let a client nest it arbitrarily. Introspection
+ * types carry no connections, so cost is naturally zero.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTROSPECTION_MAX_DEPTH = void 0;
 exports.enforceDocumentProtection = enforceDocumentProtection;
 const errors_1 = require("@constructive-io/errors");
 const express_context_1 = require("@constructive-io/express-context");
@@ -46,6 +50,14 @@ const reject = (error) => {
         statusCode: error.http
     });
 };
+/**
+ * Depth allowed inside a `__schema` / `__type` subtree, counted from the
+ * introspection field itself. graphql-js's `getIntrospectionQuery` with every
+ * option enabled reaches 13 (`types → fields → args → type → ofType×9`), so
+ * this leaves headroom for tooling without permitting the recursive
+ * `fields { type { fields { type … } } }` shape to run away.
+ */
+exports.INTROSPECTION_MAX_DEPTH = 16;
 /** Arguments a connection field uses to size its page. */
 const PAGE_SIZE_ARGS = ['first', 'last'];
 /** A connection is any object type that carries Relay's `pageInfo`. */
@@ -81,20 +93,28 @@ const requestedPageSize = (args, variableValues) => {
  *   the walk only stops charging cost rather than raising its own error)
  * @param depth - nesting level of these selections
  * @param multiplier - rows the enclosing connections can return
+ * @param bound - which depth limit applies to these selections
  */
-function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier) {
-    if (depth > walk.maxDepth)
-        walk.maxDepth = depth;
-    if (depth > walk.protection.maxQueryDepth) {
-        reject(errors_1.errors.QUERY_TOO_DEEP({ depth, limit: walk.protection.maxQueryDepth }));
+function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier, bound) {
+    if (bound.kind === 'query') {
+        if (depth > walk.maxDepth)
+            walk.maxDepth = depth;
+        if (depth > walk.protection.maxQueryDepth) {
+            reject(errors_1.errors.QUERY_TOO_DEEP({ depth, limit: walk.protection.maxQueryDepth }));
+        }
+    }
+    else if (depth - bound.base > exports.INTROSPECTION_MAX_DEPTH) {
+        reject(errors_1.errors.QUERY_TOO_DEEP({ depth: depth - bound.base, limit: exports.INTROSPECTION_MAX_DEPTH }));
     }
     for (const selection of selectionSet.selections) {
         if (selection.kind === graphql_1.Kind.FIELD) {
+            let childBound = bound;
             if (selection.name.value === '__schema' || selection.name.value === '__type') {
                 if (!walk.protection.enableIntrospection) {
                     reject(errors_1.errors.INTROSPECTION_DISABLED());
                 }
-                continue;
+                if (bound.kind === 'query')
+                    childBound = { kind: 'introspection', base: depth };
             }
             const field = parentType && (0, graphql_1.isObjectType)(parentType)
                 ? parentType.getFields()[selection.name.value]
@@ -121,7 +141,7 @@ function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier) {
                 }
             }
             if (selection.selectionSet) {
-                walkSelectionSet(walk, selection.selectionSet, fieldType, depth + 1, childMultiplier);
+                walkSelectionSet(walk, selection.selectionSet, fieldType, depth + 1, childMultiplier, childBound);
             }
             continue;
         }
@@ -130,7 +150,7 @@ function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier) {
                 ? (0, graphql_1.typeFromAST)(walk.schema, selection.typeCondition)
                 : parentType;
             // An inline fragment is not a level of nesting of its own.
-            walkSelectionSet(walk, selection.selectionSet, onType ?? null, depth, multiplier);
+            walkSelectionSet(walk, selection.selectionSet, onType ?? null, depth, multiplier, bound);
             continue;
         }
         if (selection.kind === graphql_1.Kind.FRAGMENT_SPREAD) {
@@ -146,7 +166,7 @@ function walkSelectionSet(walk, selectionSet, parentType, depth, multiplier) {
             const onType = (0, graphql_1.typeFromAST)(walk.schema, fragment.typeCondition);
             walk.activeFragments.add(name);
             try {
-                walkSelectionSet(walk, fragment.selectionSet, onType ?? null, depth, multiplier);
+                walkSelectionSet(walk, fragment.selectionSet, onType ?? null, depth, multiplier, bound);
             }
             finally {
                 walk.activeFragments.delete(name);
@@ -188,6 +208,6 @@ function enforceDocumentProtection(schema, document, variableValues, protection,
         maxDepth: 0,
         cost: 0
     };
-    walkSelectionSet(walk, operation.selectionSet, rootType ?? null, 1, 1);
+    walkSelectionSet(walk, operation.selectionSet, rootType ?? null, 1, 1, { kind: 'query' });
     return { depth: walk.maxDepth, cost: walk.cost };
 }