Merge pull request #6740 from luffy1727/adding-transaction-timeout-option

luffy1727 · web-flow · commit 0556fca07d86 · 2025-10-16T14:22:22.000+02:00
Add ability to specify transaction config in Neo4jGraphQLContext
diff --git a/.changeset/slow-plants-beam.md b/.changeset/slow-plants-beam.md
@@ -0,0 +1,24 @@
+---
+"@neo4j/graphql": minor
+---
+
+Add the ability to specify transaction configuration. e.g. timeout
+
+```js
+const transactionConfig = {
+    timeout: 60 * 1000,
+    metadata: {
+        "my-very-own-metadata": "is very good!"
+    }
+};
+
+const neoSchema = new Neo4jGraphQL({ typeDefs, driver });
+
+const server = new ApolloServer({
+    schema: await neoSchema.getSchema(),
+});
+
+await startStandaloneServer(server, {
+    context: async ({ req }) => ({ req, transaction: transactionConfig }),
+});
+```
diff --git a/packages/graphql/src/classes/Executor.ts b/packages/graphql/src/classes/Executor.ts
@@ -21,6 +21,7 @@ import Debug from "debug";
 import type { GraphQLResolveInfo } from "graphql";
 import type {
     Driver,
+    Integer,
     ManagedTransaction,
     QueryResult,
     Result,
@@ -73,6 +74,7 @@ type TransactionConfig = {
         // Possible values from https://neo4j.com/docs/operations-manual/current/monitoring/logging/#attach-metadata-tx (will only be user-transpiled for @neo4j/graphql)
         type: "system" | "user-direct" | "user-action" | "user-transpiled";
     };
+    timeout?: number | Integer | undefined;
 };
 
 export type ExecutionContext = Driver | Session | Transaction;
@@ -82,9 +84,14 @@ export type ExecutorConstructorParam = {
     cypherQueryOptions?: CypherQueryOptions;
     sessionConfig?: SessionConfig;
     cypherParams?: Record<string, unknown>;
-    transactionMetadata?: Record<string, unknown>;
+    transaction?: UserTransactionConfig;
 };
 
+export type UserTransactionConfig = {
+    timeout?: number | Integer | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+
 export type Neo4jGraphQLSessionConfig = Pick<SessionConfig, "database" | "impersonatedUser" | "auth">;
 
 export class Executor {
@@ -95,20 +102,23 @@ export class Executor {
     private sessionConfig: SessionConfig | undefined;
 
     private cypherParams: Record<string, unknown>;
-    private transactionMetadata: Record<string, unknown>;
+    private transaction: UserTransactionConfig;
 
     constructor({
         executionContext,
         cypherQueryOptions,
         sessionConfig,
         cypherParams = {},
-        transactionMetadata = {},
+        transaction = {
+            timeout: undefined,
+            metadata: undefined,
+        },
     }: ExecutorConstructorParam) {
         this.executionContext = executionContext;
         this.cypherQueryOptions = cypherQueryOptions;
         this.sessionConfig = sessionConfig;
         this.cypherParams = cypherParams;
-        this.transactionMetadata = transactionMetadata;
+        this.transaction = transaction;
     }
 
     public async execute(
@@ -118,7 +128,6 @@ export class Executor {
         info?: GraphQLResolveInfo
     ): Promise<QueryResult> {
         const params = { ...parameters, ...this.cypherParams };
-
         try {
             if (isDriverLike(this.executionContext)) {
                 return await this.driverRun({
@@ -205,9 +214,10 @@ export class Executor {
         return {
             metadata: {
                 app: APP_ID,
-                ...this.transactionMetadata,
+                ...this.transaction.metadata,
                 type: "user-transpiled",
             },
+            timeout: this.transaction.timeout,
         };
     }
 
diff --git a/packages/graphql/src/schema/resolvers/composition/wrap-query-and-mutation.ts b/packages/graphql/src/schema/resolvers/composition/wrap-query-and-mutation.ts
@@ -104,7 +104,10 @@ export const wrapQueryAndMutation =
             cypherQueryOptions: context.cypherQueryOptions,
             sessionConfig: context.sessionConfig,
             cypherParams: context.cypherParams,
-            transactionMetadata: context.transactionMetadata,
+            transaction: {
+                ...context.transaction,
+                metadata: {...context.transaction?.metadata, ...context.transactionMetadata},
+            },
         });
 
         if (dbInfo) {
diff --git a/packages/graphql/src/types/neo4j-graphql-context.ts b/packages/graphql/src/types/neo4j-graphql-context.ts
@@ -17,8 +17,9 @@
  * limitations under the License.
  */
 
+import { Integer } from "neo4j-driver";
 import type { CypherQueryOptions } from ".";
-import type { ExecutionContext, Neo4jGraphQLSessionConfig } from "../classes/Executor";
+import type { ExecutionContext, Neo4jGraphQLSessionConfig, UserTransactionConfig } from "../classes/Executor";
 import type { Neo4jGraphQLContextInterface } from "./neo4j-graphql-context-interface";
 
 export interface Neo4jGraphQLContext extends Neo4jGraphQLContextInterface {
@@ -51,6 +52,15 @@ export interface Neo4jGraphQLContext extends Neo4jGraphQLContextInterface {
      * Attach metadata to the database transaction.
      * This can be used to output information to the query log not related to the query itself.
      * Will be ignored if {@link executionContext} is an instance of a transaction.
+     * 
+     * @deprecated This method will be removed in a future version. Please, use {@link transaction} instead.
+     *
+     * @see {@link #transaction}
      */
     transactionMetadata?: Record<string, unknown>;
+
+    /**
+     * User transaction object which has both the metadata object and the timeout period inside
+     */
+    transaction?: UserTransactionConfig;
 }
diff --git a/packages/graphql/src/utils/execute.test.ts b/packages/graphql/src/utils/execute.test.ts
@@ -22,6 +22,9 @@ import { trimmer } from ".";
 import { ContextBuilder } from "../../tests/utils/builders/context-builder";
 import { Executor } from "../classes/Executor";
 import execute from "./execute";
+import {
+    APP_ID,
+} from "../constants";
 
 describe("execute", () => {
     test("should execute return records.toObject", async () => {
@@ -271,4 +274,192 @@ describe("execute", () => {
             expect(executeResult.records).toEqual([{ title }]);
         });
     });
+
+    describe("should set transaction config", () => {
+        test("user described transaction config", async () => {
+            const defaultAccessMode = "READ";
+
+            const cypher = trimmer(`
+                CREATE (u:User {title: $title})
+                RETURN u { .title } as u
+            `);
+
+            const title = "some title";
+            const params = { title };
+            const records = [{ toObject: () => ({ title }) }];
+            const database = "neo4j";
+            const bookmarks = ["test"];
+            let transactionConfig: any; // transaction config that is used in the actual driver class.
+
+            // @ts-ignore
+            const driver: Driver = {
+                // @ts-ignore
+                session: (options) => {
+                    expect(options).toMatchObject({ defaultAccessMode, database, bookmarks });
+
+                    const tx = {
+                        run: (paramCypher: string, paramParams) => {
+                            expect(trimmer(paramCypher)).toBe(`CYPHER 5 ${cypher}`);
+                            expect(paramParams).toEqual(params);
+
+                            return { records, summary: { counters: { updates: () => ({ test: 1 }) } } };
+                        },
+                        commit: () => true,
+                    };
+
+                    return {
+                        beginTransaction: () => tx,
+                        readTransaction: (fn, config) => {
+                            transactionConfig = config;
+                            // @ts-ignore
+                            return fn(tx);
+                        },
+                        writeTransaction: (fn, config) => {
+                            transactionConfig = config;
+                            // @ts-ignore
+                            return fn(tx);
+                        },
+                        executeRead: (fn, config) => {
+                            transactionConfig = config;
+                            // @ts-ignore
+                            return fn(tx);
+                        },
+                        executeWrite: (fn, config) => {
+                            transactionConfig = config;
+                            // @ts-ignore
+                            return fn(tx);
+                        },
+                        close: () => true,
+                        lastBookmark: () => [],
+                        lastBookmarks: () => [],
+                    };
+                },
+                // @ts-ignore
+                _config: {},
+            };
+
+            const executeResult = await execute({
+                cypher,
+                params,
+                defaultAccessMode,
+                context: new ContextBuilder({
+                    executor: new Executor({
+                        executionContext: driver,
+                        sessionConfig: {
+                            database,
+                            bookmarks,
+                        },
+                        transaction: {
+                            timeout: 100,
+                            metadata: {
+                                app: "my-app-name",
+                                type: "system",
+                                someOtherUserDefinedField: "test",
+                            },
+                        },
+                        cypherQueryOptions: {},
+                    }),
+                }).instance(),
+            });
+
+            expect(executeResult.records).toEqual([{ title }]);
+            expect(transactionConfig).toEqual({
+                timeout: 100,
+                metadata: {
+                    app: "my-app-name",
+                    type: "user-transpiled",
+                    someOtherUserDefinedField: "test",
+                },
+            });
+        });
+
+        test("empty transaction config", async () => {
+            const defaultAccessMode = "READ";
+
+            const cypher = trimmer(`
+                CREATE (u:User {title: $title})
+                RETURN u { .title } as u
+            `);
+
+            const title = "some title";
+            const params = { title };
+            const records = [{ toObject: () => ({ title }) }];
+            const database = "neo4j";
+            const bookmarks = ["test"];
+            let transactionConfig: any; // transaction config that is used in the actual driver class.
+
+            // @ts-ignore
+            const driver: Driver = {
+                // @ts-ignore
+                session: (options) => {
+                    expect(options).toMatchObject({ defaultAccessMode, database, bookmarks });
+
+                    const tx = {
+                        run: (paramCypher: string, paramParams) => {
+                            expect(trimmer(paramCypher)).toBe(`CYPHER 5 ${cypher}`);
+                            expect(paramParams).toEqual(params);
+
+                            return { records, summary: { counters: { updates: () => ({ test: 1 }) } } };
+                        },
+                        commit: () => true,
+                    };
+
+                    return {
+                        beginTransaction: () => tx,
+                        readTransaction: (fn, config) => {
+                            transactionConfig = config;
+                            // @ts-ignore
+                            return fn(tx);
+                        },
+                        writeTransaction: (fn, config) => {
+                            transactionConfig = config;
+                            // @ts-ignore
+                            return fn(tx);
+                        },
+                        executeRead: (fn, config) => {
+                            transactionConfig = config;
+                            // @ts-ignore
+                            return fn(tx);
+                        },
+                        executeWrite: (fn, config) => {
+                            transactionConfig = config;
+                            // @ts-ignore
+                            return fn(tx);
+                        },
+                        close: () => true,
+                        lastBookmark: () => [],
+                        lastBookmarks: () => [],
+                    };
+                },
+                // @ts-ignore
+                _config: {},
+            };
+
+            const executeResult = await execute({
+                cypher,
+                params,
+                defaultAccessMode,
+                context: new ContextBuilder({
+                    executor: new Executor({
+                        executionContext: driver,
+                        sessionConfig: {
+                            database,
+                            bookmarks,
+                        },
+                        cypherQueryOptions: {},
+                    }),
+                }).instance(),
+            });
+            // console.log(executeResult)
+
+            expect(executeResult.records).toEqual([{ title }]);
+            expect(transactionConfig).toEqual({
+                timeout: undefined,
+                metadata: {
+                    app: APP_ID,
+                    type: "user-transpiled",
+                },
+            });
+        });
+    });
 });
