Merge branch 'dev' into update-perf-tests

angrykoala · web-flow · commit 553d404d94e0 · 2026-01-28T09:47:12.000Z
diff --git a/.changeset/tiny-tips-cross.md b/.changeset/tiny-tips-cross.md
@@ -0,0 +1,36 @@
+---
+"@neo4j/graphql": patch
+---
+
+Allow enabling/disabling of connection query fields on type by type basis as well as for the whole schema via a new `@query` directive argument `connection`. Default value of `connection` is the same as `read`, inheriting its default value of `true` if not provided.
+
+Usage example:
+
+The following type definitions will create the GraphQL Query fields:
+
+```gql
+type Actor @query(read: false, connection: true) @node {
+    name: String
+}
+```
+
+```graphql
+type Query {
+    # only connection field
+    actorsConnection(after: String, first: Int, sort: [ActorSort!], where: ActorWhere): ActorsConnection!
+}
+```
+
+Inheriting the value of the read argument as default:
+
+```gql
+type Actor @query(read: false) @node {
+    name: String
+}
+```
+
+```graphql
+type Query {
+    # no reads
+}
+```
diff --git a/.github/workflows/reusable-codeql-analysis.yml b/.github/workflows/reusable-codeql-analysis.yml
@@ -15,9 +15,9 @@ jobs:
           node-version: lts/*
           package-manager-cache: false
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4
+        uses: github/codeql-action/init@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4
         with:
           config-file: ./.github/codeql/codeql-config.yml
           languages: javascript
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4
+        uses: github/codeql-action/analyze@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4
diff --git a/package.json b/package.json
@@ -25,8 +25,8 @@
     },
     "devDependencies": {
         "@tsconfig/node24": "24.0.4",
-        "@typescript-eslint/eslint-plugin": "8.53.0",
-        "@typescript-eslint/parser": "8.53.0",
+        "@typescript-eslint/eslint-plugin": "8.53.1",
+        "@typescript-eslint/parser": "8.53.1",
         "concurrently": "9.2.1",
         "dotenv": "17.2.3",
         "eslint": "8.57.1",
diff --git a/packages/graphql/package.json b/packages/graphql/package.json
@@ -46,7 +46,7 @@
     },
     "author": "Neo4j Inc.",
     "devDependencies": {
-        "@apollo/gateway": "2.12.2",
+        "@apollo/gateway": "2.13.0",
         "@apollo/server": "5.2.0",
         "@types/is-uuid": "1.0.2",
         "@types/jest": "30.0.0",
@@ -65,7 +65,7 @@
         "jest-extended": "7.0.0",
         "jsonwebtoken": "9.0.3",
         "jwks-rsa": "3.2.1",
-        "knip": "5.82.0",
+        "knip": "5.82.1",
         "koa": "3.1.1",
         "koa-jwt": "4.0.4",
         "koa-router": "14.0.0",
diff --git a/packages/graphql/src/graphql/directives/query.ts b/packages/graphql/src/graphql/directives/query.ts
@@ -21,15 +21,21 @@ import { DirectiveLocation, GraphQLBoolean, GraphQLDirective, GraphQLNonNull } f
 
 export const queryDirective = new GraphQLDirective({
     name: "query",
-    description: "Instructs @neo4j/graphql to exclude read or aggregate operations from the query root type.",
+    description:
+        "Instructs @neo4j/graphql to exclude read, connection, or aggregate operations from the query root type.",
     args: {
         read: {
-            description: "Disable/Enabled read operations from query root type",
+            description: "Disable/Enabled all read operations from query root type (this means connections too).",
             type: new GraphQLNonNull(GraphQLBoolean),
             defaultValue: true,
         },
+        connection: {
+            description:
+                "Disable/Enabled connection operations from query root type. Default value matches value of read argument, or true if not provided.",
+            type: GraphQLBoolean,
+        },
         aggregate: {
-            description: "Disable/Enabled aggregate operations from query root type",
+            description: "Disable/Enabled aggregate operations from the connection read operations.",
             type: new GraphQLNonNull(GraphQLBoolean),
             defaultValue: false,
         },
diff --git a/packages/graphql/src/schema-model/annotation/QueryAnnotation.ts b/packages/graphql/src/schema-model/annotation/QueryAnnotation.ts
@@ -23,9 +23,11 @@ export class QueryAnnotation implements Annotation {
     readonly name = "query";
     public readonly read: boolean;
     public readonly aggregate: boolean;
+    public readonly connection: boolean;
 
-    constructor({ read, aggregate }: { read: boolean; aggregate: boolean }) {
+    constructor({ read, aggregate, connection }: { read: boolean; aggregate: boolean; connection: boolean }) {
         this.read = read;
         this.aggregate = aggregate;
+        this.connection = connection;
     }
 }
diff --git a/packages/graphql/src/schema-model/entity/model-adapters/ConcreteEntityAdapter.ts b/packages/graphql/src/schema-model/entity/model-adapters/ConcreteEntityAdapter.ts
@@ -101,6 +101,17 @@ export class ConcreteEntityAdapter {
         return schemaModel.annotations.query === undefined || schemaModel.annotations.query.read === true;
     }
 
+    public isReadableFromConnectionRootQuery(schemaModel: Neo4jGraphQLSchemaModel): boolean {
+        if (this.annotations.query) {
+            if (this.annotations.query.connection !== undefined) {
+                return this.annotations.query.connection;
+            }
+            return this.annotations.query.read;
+        }
+
+        return schemaModel.annotations.query === undefined || schemaModel.annotations.query.connection === true;
+    }
+
     public isAggregable(schemaModel: Neo4jGraphQLSchemaModel): boolean {
         if (this.annotations.query) {
             return this.annotations.query.aggregate;
diff --git a/packages/graphql/src/schema-model/entity/model-adapters/InterfaceEntityAdapter.ts b/packages/graphql/src/schema-model/entity/model-adapters/InterfaceEntityAdapter.ts
@@ -104,6 +104,15 @@ export class InterfaceEntityAdapter {
 
         return schemaModel.annotations.query === undefined || schemaModel.annotations.query.read === true;
     }
+    public isReadableFromConnectionRootQuery(schemaModel: Neo4jGraphQLSchemaModel): boolean {
+        if (this.annotations.query) {
+            if (this.annotations.query.connection !== undefined) {
+                return this.annotations.query.connection;
+            }
+            return this.annotations.query.read;
+        }
+        return schemaModel.annotations.query === undefined || schemaModel.annotations.query.connection === true;
+    }
 
     public isAggregable(schemaModel: Neo4jGraphQLSchemaModel): boolean {
         if (this.annotations.query) {
diff --git a/packages/graphql/src/schema-model/parser/annotations-parser/query-annotation.ts b/packages/graphql/src/schema-model/parser/annotations-parser/query-annotation.ts
@@ -23,10 +23,14 @@ import { QueryAnnotation } from "../../annotation/QueryAnnotation";
 import { parseArguments } from "../parse-arguments";
 
 export function parseQueryAnnotation(directive: DirectiveNode): QueryAnnotation {
-    const { read, aggregate } = parseArguments<{ read: boolean; aggregate: boolean }>(queryDirective, directive);
+    const { read, aggregate, connection } = parseArguments<{ read: boolean; aggregate: boolean; connection: boolean }>(
+        queryDirective,
+        directive
+    );
 
     return new QueryAnnotation({
         read,
         aggregate,
+        connection,
     });
 }
diff --git a/packages/graphql/src/schema/make-augmented-schema.ts b/packages/graphql/src/schema/make-augmented-schema.ts
@@ -594,7 +594,10 @@ function generateObjectType({
 
     ensureNonEmptyInput(composer, concreteEntityAdapter.operations.updateInputTypeName);
     ensureNonEmptyInput(composer, concreteEntityAdapter.operations.createInputTypeName);
-    if (concreteEntityAdapter.isReadable(schemaModel) || concreteEntityAdapter.isAggregable(schemaModel)) {
+    if (
+        concreteEntityAdapter.isReadableFromConnectionRootQuery(schemaModel) ||
+        concreteEntityAdapter.isAggregable(schemaModel)
+    ) {
         complexityEstimatorHelper.registerField(
             "Query",
             concreteEntityAdapter.operations.rootTypeFieldNames.connection
@@ -608,6 +611,10 @@ function generateObjectType({
                 schemaModel,
             }),
         });
+        composer.Query.setFieldDirectives(
+            concreteEntityAdapter.operations.rootTypeFieldNames.connection,
+            graphqlDirectivesToCompose(propagatedDirectives)
+        );
     }
     if (concreteEntityAdapter.isReadable(schemaModel)) {
         complexityEstimatorHelper.registerField("Query", concreteEntityAdapter.operations.rootTypeFieldNames.read);
@@ -622,11 +629,6 @@ function generateObjectType({
             concreteEntityAdapter.operations.rootTypeFieldNames.read,
             graphqlDirectivesToCompose(propagatedDirectives)
         );
-
-        composer.Query.setFieldDirectives(
-            concreteEntityAdapter.operations.rootTypeFieldNames.connection,
-            graphqlDirectivesToCompose(propagatedDirectives)
-        );
     }
     if (concreteEntityAdapter.isAggregable(schemaModel)) {
         withAggregateSelectionType({
@@ -736,7 +738,10 @@ function generateInterfaceObjectType({
     const hasImplementedEntities = interfaceEntityAdapter.concreteEntities.length > 0;
     if (hasImplementedEntities) {
         const propagatedDirectives = propagatedDirectivesForNode.get(interfaceEntityAdapter.name) || [];
-        if (interfaceEntityAdapter.isReadable(schemaModel) || interfaceEntityAdapter.isAggregable(schemaModel)) {
+        if (
+            interfaceEntityAdapter.isReadableFromConnectionRootQuery(schemaModel) ||
+            interfaceEntityAdapter.isAggregable(schemaModel)
+        ) {
             composer.Query.addFields({
                 [interfaceEntityAdapter.operations.rootTypeFieldNames.connection]: rootConnectionResolver({
                     composer,
@@ -746,6 +751,15 @@ function generateInterfaceObjectType({
                     schemaModel,
                 }),
             });
+            complexityEstimatorHelper.registerField(
+                "Query",
+                interfaceEntityAdapter.operations.rootTypeFieldNames.connection
+            );
+
+            composer.Query.setFieldDirectives(
+                interfaceEntityAdapter.operations.rootTypeFieldNames.connection,
+                graphqlDirectivesToCompose(propagatedDirectives)
+            );
         }
         if (interfaceEntityAdapter.isReadable(schemaModel)) {
             complexityEstimatorHelper.registerField("Query", interfaceEntityAdapter.operations.rootTypeFieldNames.read);
@@ -761,25 +775,6 @@ function generateInterfaceObjectType({
                 interfaceEntityAdapter.operations.rootTypeFieldNames.read,
                 graphqlDirectivesToCompose(propagatedDirectives)
             );
-
-            complexityEstimatorHelper.registerField(
-                "Query",
-                interfaceEntityAdapter.operations.rootTypeFieldNames.connection
-            );
-
-            composer.Query.addFields({
-                [interfaceEntityAdapter.operations.rootTypeFieldNames.connection]: rootConnectionResolver({
-                    composer,
-                    entityAdapter: interfaceEntityAdapter,
-                    propagatedDirectives,
-                    isLimitRequired: features?.limitRequired,
-                    schemaModel,
-                }),
-            });
-            composer.Query.setFieldDirectives(
-                interfaceEntityAdapter.operations.rootTypeFieldNames.connection,
-                graphqlDirectivesToCompose(propagatedDirectives)
-            );
         }
 
         if (interfaceEntityAdapter.isAggregable(schemaModel)) {
diff --git a/packages/graphql/src/schema/resolvers/query/root-connection.ts b/packages/graphql/src/schema/resolvers/query/root-connection.ts
@@ -106,7 +106,7 @@ export function rootConnectionResolver({
         directives: graphqlDirectivesToCompose(propagatedDirectives),
     });
 
-    if (entityAdapter.isReadable(schemaModel)) {
+    if (entityAdapter.isReadableFromConnectionRootQuery(schemaModel)) {
         rootConnection.addFields({
             edges: rootEdge.NonNull.List.NonNull,
             totalCount: new GraphQLNonNull(GraphQLInt),
diff --git a/packages/graphql/tests/schema/directives/query.test.ts b/packages/graphql/tests/schema/directives/query.test.ts
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -23,9 +23,11 @@ export class QueryAnnotation implements Annotation {`
`23`	`23`	`readonly name = "query";`
`24`	`24`	`public readonly read: boolean;`
`25`	`25`	`public readonly aggregate: boolean;`
	`26`	`+ public readonly connection: boolean;`
`26`	`27`
`27`		`- constructor({ read, aggregate }: { read: boolean; aggregate: boolean }) {`
	`28`	`+ constructor({ read, aggregate, connection }: { read: boolean; aggregate: boolean; connection: boolean }) {`
`28`	`29`	`this.read = read;`
`29`	`30`	`this.aggregate = aggregate;`
	`31`	`+ this.connection = connection;`
`30`	`32`	`}`
`31`	`33`	`}`