@o1-labs/mina-archive-node-graphql 0.0.6 → 2.0.0

package/src/resolvers-types.ts

@@ -44,7 +44,7 @@ export type Scalars = {
 export type ActionData = {
   __typename?: 'ActionData';
   accountUpdateId: Scalars['String']['output'];
-  data: Array<Maybe<Scalars['String']['output']>>;
+  data: Array<Scalars['String']['output']>;
   transactionInfo?: Maybe<TransactionInfo>;
 };
 
@@ -70,7 +70,7 @@ export type ActionFilterOptionsInput = {
 
 export type ActionOutput = {
   __typename?: 'ActionOutput';
-  actionData?: Maybe<Array<Maybe<ActionData>>>;
+  actionData?: Maybe<Array<ActionData>>;
   actionState: ActionStates;
   blockInfo?: Maybe<BlockInfo>;
   transactionInfo?: Maybe<TransactionInfo>;
@@ -142,7 +142,7 @@ export type BlockTransactions = {
 export type EventData = {
   __typename?: 'EventData';
   accountUpdateId: Scalars['String']['output'];
-  data: Array<Maybe<Scalars['String']['output']>>;
+  data: Array<Scalars['String']['output']>;
   transactionInfo?: Maybe<TransactionInfo>;
 };
 
@@ -165,7 +165,7 @@ export type EventFilterOptionsInput = {
 export type EventOutput = {
   __typename?: 'EventOutput';
   blockInfo?: Maybe<BlockInfo>;
-  eventData?: Maybe<Array<Maybe<EventData>>>;
+  eventData?: Maybe<Array<EventData>>;
 };
 
 export type FeeTransfer = {
@@ -190,10 +190,24 @@ export type NetworkStateOutput = {
 
 export type Query = {
   __typename?: 'Query';
-  actions: Array<Maybe<ActionOutput>>;
-  blocks: Array<Maybe<Block>>;
-  events: Array<Maybe<EventOutput>>;
+  actions: Array<ActionOutput>;
+  blocks: Array<Block>;
+  events: Array<EventOutput>;
   networkState: NetworkStateOutput;
+  /**
+   * The `MAJOR.MINOR` version of this schema.
+   *
+   * Clients compare it with the schema version they were built against: an equal
+   * major means the contract they code against still holds, and a higher minor
+   * means this server has additive changes they may not know about yet.
+   *
+   * Always available, even when `ENABLED_QUERIES` restricts which data queries
+   * this server exposes — a compatibility check that can itself be switched off
+   * is of no use to a client.
+   */
+  schemaVersion: Scalars['String']['output'];
+  verificationKeyUpdates: Array<VerificationKeyUpdate>;
+  zkappCommands: Array<ZkappCommandOutput>;
 };
 
 export type QueryActionsArgs = {
@@ -210,6 +224,14 @@ export type QueryEventsArgs = {
   input: EventFilterOptionsInput;
 };
 
+export type QueryVerificationKeyUpdatesArgs = {
+  input: VerificationKeyUpdateFilterInput;
+};
+
+export type QueryZkappCommandsArgs = {
+  input: ZkappCommandFilterOptionsInput;
+};
+
 export type TransactionInfo = {
   __typename?: 'TransactionInfo';
   authorizationKind: Scalars['String']['output'];
@@ -217,7 +239,7 @@ export type TransactionInfo = {
   memo: Scalars['String']['output'];
   sequenceNumber: Scalars['Int']['output'];
   status: Scalars['String']['output'];
-  zkappAccountUpdateIds: Array<Maybe<Scalars['Int']['output']>>;
+  zkappAccountUpdateIds: Array<Scalars['Int']['output']>;
 };
 
 export type UserCommand = {
@@ -234,6 +256,29 @@ export type UserCommand = {
   to: Scalars['String']['output'];
 };
 
+export type VerificationKeyUpdate = {
+  __typename?: 'VerificationKeyUpdate';
+  accountUpdateId: Scalars['String']['output'];
+  address: Scalars['String']['output'];
+  blockInfo: BlockInfo;
+  tokenId: Scalars['String']['output'];
+  transactionInfo: TransactionInfo;
+  verificationKeyHash: Scalars['String']['output'];
+};
+
+/**
+ * Find applied account updates that set a specific verification key.
+ *
+ * The block range is required and limited by the server's configured maximum.
+ * `from` is inclusive and `to` is exclusive.
+ */
+export type VerificationKeyUpdateFilterInput = {
+  from: Scalars['Int']['input'];
+  status?: InputMaybe<BlockStatusFilter>;
+  to: Scalars['Int']['input'];
+  verificationKeyHash: Scalars['String']['input'];
+};
+
 export type ZkAppCommand = {
   __typename?: 'ZkAppCommand';
   failureReason?: Maybe<Scalars['String']['output']>;
@@ -244,6 +289,80 @@ export type ZkAppCommand = {
   status: Scalars['String']['output'];
 };
 
+export type ZkappAccountPrecondition = {
+  __typename?: 'ZkappAccountPrecondition';
+  actionState?: Maybe<ZkappFieldArray>;
+  isNew?: Maybe<Scalars['Boolean']['output']>;
+  provedState?: Maybe<Scalars['Boolean']['output']>;
+  state?: Maybe<ZkappFieldArray>;
+};
+
+export type ZkappAccountUpdateOutput = {
+  __typename?: 'ZkappAccountUpdateOutput';
+  accountPrecondition?: Maybe<ZkappAccountPrecondition>;
+  actions: Array<ZkappFieldArray>;
+  appState?: Maybe<ZkappFieldArray>;
+  authorizationKind: Scalars['String']['output'];
+  balanceChange: Scalars['String']['output'];
+  callDepth: Scalars['Int']['output'];
+  events: Array<ZkappFieldArray>;
+  id: Scalars['String']['output'];
+  incrementNonce: Scalars['Boolean']['output'];
+  networkPrecondition?: Maybe<ZkappNetworkPrecondition>;
+  publicKey: Scalars['String']['output'];
+  tokenId: Scalars['String']['output'];
+};
+
+/**
+ * Filter successful zkApp commands by block range.
+ *
+ * Both `from` and `to` are required. The range is bounded by `ZKAPP_COMMAND_RANGE_SIZE`, and the server may reject dense ranges that expand to too many account updates.
+ */
+export type ZkappCommandFilterOptionsInput = {
+  /** Optional account update public key filter. */
+  accountPublicKey?: InputMaybe<Scalars['String']['input']>;
+  blockStatus?: InputMaybe<BlockStatusFilter>;
+  /** Mina block height to filter zkApp commands from, inclusive */
+  from: Scalars['Int']['input'];
+  /** Mina block height to filter zkApp commands to, exclusive */
+  to: Scalars['Int']['input'];
+  /** Optional account update token id filter. */
+  tokenId?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type ZkappCommandOutput = {
+  __typename?: 'ZkappCommandOutput';
+  accountUpdates: Array<ZkappAccountUpdateOutput>;
+  blockInfo: BlockInfo;
+  fee: Scalars['String']['output'];
+  feePayer: Scalars['String']['output'];
+  hash: Scalars['String']['output'];
+  memo: Scalars['String']['output'];
+  sequenceNumber: Scalars['Int']['output'];
+};
+
+/**
+ * Raw field array from the archive database.
+ *
+ * An empty `fields` array means the archive row exists but contains no field values.
+ * Nullable entries mean the corresponding nullable archive state slot has no field value.
+ */
+export type ZkappFieldArray = {
+  __typename?: 'ZkappFieldArray';
+  fields: Array<Maybe<Scalars['String']['output']>>;
+};
+
+export type ZkappGlobalSlotBounds = {
+  __typename?: 'ZkappGlobalSlotBounds';
+  lowerBound?: Maybe<Scalars['Int']['output']>;
+  upperBound?: Maybe<Scalars['Int']['output']>;
+};
+
+export type ZkappNetworkPrecondition = {
+  __typename?: 'ZkappNetworkPrecondition';
+  globalSlotSinceGenesis?: Maybe<ZkappGlobalSlotBounds>;
+};
+
 export type ResolverTypeWrapper<T> = Promise<T> | T;
 
 export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
@@ -386,7 +505,16 @@ export type ResolversTypes = {
   String: ResolverTypeWrapper<Scalars['String']['output']>;
   TransactionInfo: ResolverTypeWrapper<TransactionInfo>;
   UserCommand: ResolverTypeWrapper<UserCommand>;
+  VerificationKeyUpdate: ResolverTypeWrapper<VerificationKeyUpdate>;
+  VerificationKeyUpdateFilterInput: VerificationKeyUpdateFilterInput;
   ZkAppCommand: ResolverTypeWrapper<ZkAppCommand>;
+  ZkappAccountPrecondition: ResolverTypeWrapper<ZkappAccountPrecondition>;
+  ZkappAccountUpdateOutput: ResolverTypeWrapper<ZkappAccountUpdateOutput>;
+  ZkappCommandFilterOptionsInput: ZkappCommandFilterOptionsInput;
+  ZkappCommandOutput: ResolverTypeWrapper<ZkappCommandOutput>;
+  ZkappFieldArray: ResolverTypeWrapper<ZkappFieldArray>;
+  ZkappGlobalSlotBounds: ResolverTypeWrapper<ZkappGlobalSlotBounds>;
+  ZkappNetworkPrecondition: ResolverTypeWrapper<ZkappNetworkPrecondition>;
 };
 
 /** Mapping between all available schema types and the resolvers parents */
@@ -412,7 +540,16 @@ export type ResolversParentTypes = {
   String: Scalars['String']['output'];
   TransactionInfo: TransactionInfo;
   UserCommand: UserCommand;
+  VerificationKeyUpdate: VerificationKeyUpdate;
+  VerificationKeyUpdateFilterInput: VerificationKeyUpdateFilterInput;
   ZkAppCommand: ZkAppCommand;
+  ZkappAccountPrecondition: ZkappAccountPrecondition;
+  ZkappAccountUpdateOutput: ZkappAccountUpdateOutput;
+  ZkappCommandFilterOptionsInput: ZkappCommandFilterOptionsInput;
+  ZkappCommandOutput: ZkappCommandOutput;
+  ZkappFieldArray: ZkappFieldArray;
+  ZkappGlobalSlotBounds: ZkappGlobalSlotBounds;
+  ZkappNetworkPrecondition: ZkappNetworkPrecondition;
 };
 
 export type ActionDataResolvers<
@@ -421,11 +558,7 @@ export type ActionDataResolvers<
     ResolversParentTypes['ActionData'] = ResolversParentTypes['ActionData'],
 > = {
   accountUpdateId?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-  data?: Resolver<
-    Array<Maybe<ResolversTypes['String']>>,
-    ParentType,
-    ContextType
-  >;
+  data?: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
   transactionInfo?: Resolver<
     Maybe<ResolversTypes['TransactionInfo']>,
     ParentType,
@@ -439,7 +572,7 @@ export type ActionOutputResolvers<
     ResolversParentTypes['ActionOutput'] = ResolversParentTypes['ActionOutput'],
 > = {
   actionData?: Resolver<
-    Maybe<Array<Maybe<ResolversTypes['ActionData']>>>,
+    Maybe<Array<ResolversTypes['ActionData']>>,
     ParentType,
     ContextType
   >;
@@ -576,11 +709,7 @@ export type EventDataResolvers<
     ResolversParentTypes['EventData'] = ResolversParentTypes['EventData'],
 > = {
   accountUpdateId?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-  data?: Resolver<
-    Array<Maybe<ResolversTypes['String']>>,
-    ParentType,
-    ContextType
-  >;
+  data?: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
   transactionInfo?: Resolver<
     Maybe<ResolversTypes['TransactionInfo']>,
     ParentType,
@@ -599,7 +728,7 @@ export type EventOutputResolvers<
     ContextType
   >;
   eventData?: Resolver<
-    Maybe<Array<Maybe<ResolversTypes['EventData']>>>,
+    Maybe<Array<ResolversTypes['EventData']>>,
     ParentType,
     ContextType
   >;
@@ -650,19 +779,19 @@ export type QueryResolvers<
     ResolversParentTypes['Query'] = ResolversParentTypes['Query'],
 > = {
   actions?: Resolver<
-    Array<Maybe<ResolversTypes['ActionOutput']>>,
+    Array<ResolversTypes['ActionOutput']>,
     ParentType,
     ContextType,
     RequireFields<QueryActionsArgs, 'input'>
   >;
   blocks?: Resolver<
-    Array<Maybe<ResolversTypes['Block']>>,
+    Array<ResolversTypes['Block']>,
     ParentType,
     ContextType,
     Partial<QueryBlocksArgs>
   >;
   events?: Resolver<
-    Array<Maybe<ResolversTypes['EventOutput']>>,
+    Array<ResolversTypes['EventOutput']>,
     ParentType,
     ContextType,
     RequireFields<QueryEventsArgs, 'input'>
@@ -672,6 +801,19 @@ export type QueryResolvers<
     ParentType,
     ContextType
   >;
+  schemaVersion?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  verificationKeyUpdates?: Resolver<
+    Array<ResolversTypes['VerificationKeyUpdate']>,
+    ParentType,
+    ContextType,
+    RequireFields<QueryVerificationKeyUpdatesArgs, 'input'>
+  >;
+  zkappCommands?: Resolver<
+    Array<ResolversTypes['ZkappCommandOutput']>,
+    ParentType,
+    ContextType,
+    RequireFields<QueryZkappCommandsArgs, 'input'>
+  >;
 };
 
 export type TransactionInfoResolvers<
@@ -689,7 +831,7 @@ export type TransactionInfoResolvers<
   sequenceNumber?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
   status?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   zkappAccountUpdateIds?: Resolver<
-    Array<Maybe<ResolversTypes['Int']>>,
+    Array<ResolversTypes['Int']>,
     ParentType,
     ContextType
   >;
@@ -716,6 +858,27 @@ export type UserCommandResolvers<
   to?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
 };
 
+export type VerificationKeyUpdateResolvers<
+  ContextType = GraphQLContext,
+  ParentType extends
+    ResolversParentTypes['VerificationKeyUpdate'] = ResolversParentTypes['VerificationKeyUpdate'],
+> = {
+  accountUpdateId?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  address?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  blockInfo?: Resolver<ResolversTypes['BlockInfo'], ParentType, ContextType>;
+  tokenId?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  transactionInfo?: Resolver<
+    ResolversTypes['TransactionInfo'],
+    ParentType,
+    ContextType
+  >;
+  verificationKeyHash?: Resolver<
+    ResolversTypes['String'],
+    ParentType,
+    ContextType
+  >;
+};
+
 export type ZkAppCommandResolvers<
   ContextType = GraphQLContext,
   ParentType extends
@@ -733,6 +896,123 @@ export type ZkAppCommandResolvers<
   status?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
 };
 
+export type ZkappAccountPreconditionResolvers<
+  ContextType = GraphQLContext,
+  ParentType extends
+    ResolversParentTypes['ZkappAccountPrecondition'] = ResolversParentTypes['ZkappAccountPrecondition'],
+> = {
+  actionState?: Resolver<
+    Maybe<ResolversTypes['ZkappFieldArray']>,
+    ParentType,
+    ContextType
+  >;
+  isNew?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+  provedState?: Resolver<
+    Maybe<ResolversTypes['Boolean']>,
+    ParentType,
+    ContextType
+  >;
+  state?: Resolver<
+    Maybe<ResolversTypes['ZkappFieldArray']>,
+    ParentType,
+    ContextType
+  >;
+};
+
+export type ZkappAccountUpdateOutputResolvers<
+  ContextType = GraphQLContext,
+  ParentType extends
+    ResolversParentTypes['ZkappAccountUpdateOutput'] = ResolversParentTypes['ZkappAccountUpdateOutput'],
+> = {
+  accountPrecondition?: Resolver<
+    Maybe<ResolversTypes['ZkappAccountPrecondition']>,
+    ParentType,
+    ContextType
+  >;
+  actions?: Resolver<
+    Array<ResolversTypes['ZkappFieldArray']>,
+    ParentType,
+    ContextType
+  >;
+  appState?: Resolver<
+    Maybe<ResolversTypes['ZkappFieldArray']>,
+    ParentType,
+    ContextType
+  >;
+  authorizationKind?: Resolver<
+    ResolversTypes['String'],
+    ParentType,
+    ContextType
+  >;
+  balanceChange?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  callDepth?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+  events?: Resolver<
+    Array<ResolversTypes['ZkappFieldArray']>,
+    ParentType,
+    ContextType
+  >;
+  id?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  incrementNonce?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+  networkPrecondition?: Resolver<
+    Maybe<ResolversTypes['ZkappNetworkPrecondition']>,
+    ParentType,
+    ContextType
+  >;
+  publicKey?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  tokenId?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+};
+
+export type ZkappCommandOutputResolvers<
+  ContextType = GraphQLContext,
+  ParentType extends
+    ResolversParentTypes['ZkappCommandOutput'] = ResolversParentTypes['ZkappCommandOutput'],
+> = {
+  accountUpdates?: Resolver<
+    Array<ResolversTypes['ZkappAccountUpdateOutput']>,
+    ParentType,
+    ContextType
+  >;
+  blockInfo?: Resolver<ResolversTypes['BlockInfo'], ParentType, ContextType>;
+  fee?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  feePayer?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  hash?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  memo?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  sequenceNumber?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+};
+
+export type ZkappFieldArrayResolvers<
+  ContextType = GraphQLContext,
+  ParentType extends
+    ResolversParentTypes['ZkappFieldArray'] = ResolversParentTypes['ZkappFieldArray'],
+> = {
+  fields?: Resolver<
+    Array<Maybe<ResolversTypes['String']>>,
+    ParentType,
+    ContextType
+  >;
+};
+
+export type ZkappGlobalSlotBoundsResolvers<
+  ContextType = GraphQLContext,
+  ParentType extends
+    ResolversParentTypes['ZkappGlobalSlotBounds'] = ResolversParentTypes['ZkappGlobalSlotBounds'],
+> = {
+  lowerBound?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+  upperBound?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+};
+
+export type ZkappNetworkPreconditionResolvers<
+  ContextType = GraphQLContext,
+  ParentType extends
+    ResolversParentTypes['ZkappNetworkPrecondition'] = ResolversParentTypes['ZkappNetworkPrecondition'],
+> = {
+  globalSlotSinceGenesis?: Resolver<
+    Maybe<ResolversTypes['ZkappGlobalSlotBounds']>,
+    ParentType,
+    ContextType
+  >;
+};
+
 export type Resolvers<ContextType = GraphQLContext> = {
   ActionData?: ActionDataResolvers<ContextType>;
   ActionOutput?: ActionOutputResolvers<ContextType>;
@@ -750,5 +1030,12 @@ export type Resolvers<ContextType = GraphQLContext> = {
   Query?: QueryResolvers<ContextType>;
   TransactionInfo?: TransactionInfoResolvers<ContextType>;
   UserCommand?: UserCommandResolvers<ContextType>;
+  VerificationKeyUpdate?: VerificationKeyUpdateResolvers<ContextType>;
   ZkAppCommand?: ZkAppCommandResolvers<ContextType>;
+  ZkappAccountPrecondition?: ZkappAccountPreconditionResolvers<ContextType>;
+  ZkappAccountUpdateOutput?: ZkappAccountUpdateOutputResolvers<ContextType>;
+  ZkappCommandOutput?: ZkappCommandOutputResolvers<ContextType>;
+  ZkappFieldArray?: ZkappFieldArrayResolvers<ContextType>;
+  ZkappGlobalSlotBounds?: ZkappGlobalSlotBoundsResolvers<ContextType>;
+  ZkappNetworkPrecondition?: ZkappNetworkPreconditionResolvers<ContextType>;
 };

package/src/resolvers.ts

@@ -8,13 +8,26 @@ import {
   TracingState,
   setSpanNameFromGraphQLContext,
 } from './tracing/tracer.js';
+import { parseBoolean } from './config.js';
+import { SCHEMA_VERSION } from './schema-version.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const schemaPath = path.resolve(__dirname, '../../schema.graphql');
+// Dedicated switch, not ENABLE_BLOCK_TRANSACTION_DETAILS. This query walks a
+// block range and expands account updates, so it is much heavier than block
+// transaction detail; an operator must be able to take one without the other.
+// Default off.
+//
+// parseBoolean, not `=== 'true'`: ad-hoc truthiness is the bug #74 fixed, where
+// the string "false" read as true.
+const ENABLE_ZKAPP_COMMANDS_QUERY = parseBoolean(
+  process.env.ENABLE_ZKAPP_COMMANDS_QUERY
+);
 
 const fullResolvers: Resolvers = {
   Query: {
+    schemaVersion: () => SCHEMA_VERSION,
     events: async (_, { input }, context) => {
       const graphQLSpan = setSpanNameFromGraphQLContext(
         context,
@@ -33,6 +46,24 @@ const fullResolvers: Resolvers = {
         tracingState: new TracingState(graphQLSpan),
       });
     },
+    verificationKeyUpdates: async (_, { input }, context) => {
+      const graphQLSpan = setSpanNameFromGraphQLContext(
+        context,
+        'verificationKeyUpdates.graphql'
+      );
+      return context.db_client.getVerificationKeyUpdates(input, {
+        tracingState: new TracingState(graphQLSpan),
+      });
+    },
+    zkappCommands: async (_, { input }, context) => {
+      const graphQLSpan = setSpanNameFromGraphQLContext(
+        context,
+        'zkappCommands.graphql'
+      );
+      return context.db_client.getZkappCommands(input, {
+        tracingState: new TracingState(graphQLSpan),
+      });
+    },
     networkState: async (_, __, context) => {
       const graphQLSpan = setSpanNameFromGraphQLContext(
         context,
@@ -54,49 +85,54 @@ const fullResolvers: Resolvers = {
   },
 };
 
-let resolvers: Resolvers = fullResolvers;
-let typeDefs: string | undefined = undefined;
+let enabledQueries = Object.keys(fullResolvers.Query || {});
+
+// schemaVersion is a compatibility handshake, not a data query, so it survives
+// ENABLED_QUERIES. A client that cannot ask which schema it is talking to has
+// to guess, which is the situation the field exists to end.
+const ALWAYS_ENABLED = ['schemaVersion'];
 
-// If the ENABLED_QUERIES environment variable is set, filter the schema and resolvers.
 if (process.env.ENABLED_QUERIES !== undefined) {
-  const enabledQueries = process.env.ENABLED_QUERIES.split(',').map((q) =>
-    q.trim()
+  enabledQueries = [
+    ...ALWAYS_ENABLED,
+    ...process.env.ENABLED_QUERIES.split(',').map((q) => q.trim()),
+  ];
+}
+
+if (!ENABLE_ZKAPP_COMMANDS_QUERY) {
+  enabledQueries = enabledQueries.filter(
+    (queryName) => queryName !== 'zkappCommands'
   );
+}
 
-  // If the list is not empty, filter the resolvers.
-  if (enabledQueries.length > 0) {
-    resolvers = {
-      Query: Object.fromEntries(
-        Object.entries(fullResolvers.Query || {}).filter(([queryName]) =>
-          enabledQueries.includes(queryName)
-        )
-      ),
-    };
+const resolvers: Resolvers = {
+  Query: Object.fromEntries(
+    Object.entries(fullResolvers.Query || {}).filter(([queryName]) =>
+      enabledQueries.includes(queryName)
+    )
+  ),
+};
 
-    // Filter the schema AST.
-    const typeDefsString = fs.readFileSync(schemaPath, 'utf-8');
-    const typeDefsAst = parse(typeDefsString);
-    const modifiedAst = visit(typeDefsAst, {
-      ObjectTypeDefinition(node) {
-        if (node.name.value === 'Query') {
-          return {
-            ...node,
-            fields: node.fields?.filter((field) =>
-              enabledQueries.includes(field.name.value)
-            ),
-          };
-        }
-        return node;
-      },
-    });
-    typeDefs = print(modifiedAst);
-  }
-}
+const typeDefsString = fs.readFileSync(schemaPath, 'utf-8');
+const typeDefsAst = parse(typeDefsString);
+const modifiedAst = visit(typeDefsAst, {
+  ObjectTypeDefinition(node) {
+    if (node.name.value === 'Query') {
+      return {
+        ...node,
+        fields: node.fields?.filter((field) =>
+          enabledQueries.includes(field.name.value)
+        ),
+      };
+    }
+    return node;
+  },
+});
 
 // Create the executable schema.
 const schema = makeExecutableSchema({
   resolvers: [resolvers],
-  typeDefs: typeDefs || fs.readFileSync(schemaPath, 'utf-8'),
+  typeDefs: print(modifiedAst),
 });
 
 export { resolvers, schema };

package/src/schema-version.ts

@@ -0,0 +1,24 @@
+/**
+ * The version of the GraphQL schema this server serves, as `MAJOR.MINOR`.
+ *
+ * This is **not** the package version. The package version describes this
+ * server's own surface — its flags, its defaults, its behaviour. This constant
+ * describes only the contract a client codes against: the types, fields and
+ * arguments in `schema.graphql`.
+ *
+ * The client SDKs pin the schema version they were written against
+ * (`SCHEMA_VERSION` in the JS and Rust SDKs, `SchemaVersion` in the Go one) and
+ * compare it with what this server reports through the `schemaVersion` query.
+ * Before that query existed, the pin was an assertion no client could check.
+ *
+ * When to change it:
+ *
+ * - **MINOR** for an additive change: a new query, a new optional argument, a
+ *   new field on an output type. A client written against an older minor of the
+ *   same major keeps working.
+ * - **MAJOR** for a change that can break a client: a removed or renamed field,
+ *   a narrowed type, an argument that becomes required, or a field that becomes
+ *   nullable when clients were entitled to assume it was not. Also when the
+ *   package or the SDKs take a major: they all share one (docs/versioning.md).
+ */
+export const SCHEMA_VERSION = '2.0';