feat(core): Add Apollo server cache configuration option

packages/core/e2e/apollo-cache.e2e-spec.ts

@@ -0,0 +1,223 @@
+import { KeyValueCache } from '@apollo/utils.keyvaluecache';
+import { mergeConfig } from '@vendure/core';
+import { createTestEnvironment } from '@vendure/testing';
+import path from 'path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import { initialData } from '../../../e2e-common/e2e-initial-data';
+import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-config';
+
+import * as Codegen from './graphql/generated-e2e-admin-types';
+import { GET_PRODUCT_LIST, GET_PRODUCT_SIMPLE } from './graphql/shared-definitions';
+
+class MockCache implements KeyValueCache<string> {
+    static getCalls: Array<{ key: string; result: string | undefined }> = [];
+    static setCalls: Array<{ key: string; value: string; options?: { ttl?: number } }> = [];
+    static deleteCalls: Array<{ key: string; result: boolean }> = [];
+
+    private store = new Map<string, string>();
+
+    static reset() {
+        this.getCalls = [];
+        this.setCalls = [];
+        this.deleteCalls = [];
+    }
+
+    get(key: string): Promise<string | undefined> {
+        // eslint-disable-next-line
+        console.log(`MockCache get: ${key}`);
+        const result = this.store.get(key);
+        MockCache.getCalls.push({ key, result });
+        return Promise.resolve(result);
+    }
+
+    set(key: string, value: string, options?: { ttl?: number }): Promise<void> {
+        // eslint-disable-next-line
+        console.log(`MockCache set: ${key}`, value);
+        this.store.set(key, value);
+        MockCache.setCalls.push({ key, value, options });
+        return Promise.resolve();
+    }
+
+    delete(key: string): Promise<boolean> {
+        const result = this.store.delete(key);
+        MockCache.deleteCalls.push({ key, result });
+        return Promise.resolve(result);
+    }
+}
+
+describe('Apollo cache configuration', () => {
+    describe('with custom cache implementation', () => {
+        const mockCache = new MockCache();
+        const { server, adminClient, shopClient } = createTestEnvironment(
+            mergeConfig(testConfig(), {
+                apiOptions: {
+                    cache: mockCache,
+                },
+            }),
+        );
+
+        beforeAll(async () => {
+            await server.init({
+                initialData,
+                productsCsvPath: path.join(__dirname, 'fixtures/e2e-products-minimal.csv'),
+                customerCount: 1,
+            });
+            await adminClient.asSuperAdmin();
+        }, TEST_SETUP_TIMEOUT_MS);
+
+        afterAll(async () => {
+            await server.destroy();
+        });
+
+        it('should configure Apollo Server with custom cache', async () => {
+            MockCache.reset();
+
+            // Make a GraphQL query that could potentially be cached
+            const result = await shopClient.query<
+                Codegen.GetProductListQuery,
+                Codegen.GetProductListQueryVariables
+            >(GET_PRODUCT_LIST, {
+                options: {
+                    filter: { id: { eq: 'T_1' } },
+                    take: 1,
+                },
+            });
+
+            expect(result.products.items.length).toBe(1);
+            expect(result.products.items[0].id).toBe('T_1');
+            expect(result.products.items[0].name).toBe('Laptop');
+        });
+
+        it('should handle cache operations without errors', async () => {
+            MockCache.reset();
+
+            // Test multiple queries to potentially trigger cache operations
+            const shopResponse = await shopClient.query<
+                Codegen.GetProductListQuery,
+                Codegen.GetProductListQueryVariables
+            >(GET_PRODUCT_LIST, {
+                options: {
+                    take: 1,
+                },
+            });
+
+            expect(shopResponse.products.items.length).toBe(1);
+
+            const adminResponse = await adminClient.query<
+                Codegen.GetProductListQuery,
+                Codegen.GetProductListQueryVariables
+            >(GET_PRODUCT_LIST, {
+                options: { take: 1 },
+            });
+
+            expect(adminResponse.products.items.length).toBe(1);
+        });
+
+        it('should work with both shop and admin APIs', async () => {
+            MockCache.reset();
+
+            const [shopResult, adminResult] = await Promise.all([
+                shopClient.query<Codegen.GetProductSimpleQuery, Codegen.GetProductSimpleQueryVariables>(
+                    GET_PRODUCT_SIMPLE,
+                    {
+                        id: 'T_1',
+                    },
+                ),
+                adminClient.query<Codegen.GetProductSimpleQuery, Codegen.GetProductSimpleQueryVariables>(
+                    GET_PRODUCT_SIMPLE,
+                    {
+                        id: 'T_1',
+                    },
+                ),
+            ]);
+
+            expect(shopResult.product).toBeDefined();
+            expect(adminResult.product).toBeDefined();
+            expect(shopResult.product?.id).toBe(adminResult.product?.id);
+        });
+    });
+
+    describe('with bounded cache', () => {
+        const { server, adminClient, shopClient } = createTestEnvironment(
+            mergeConfig(testConfig(), {
+                apiOptions: {
+                    cache: 'bounded',
+                },
+            }),
+        );
+
+        beforeAll(async () => {
+            await server.init({
+                initialData,
+                productsCsvPath: path.join(__dirname, 'fixtures/e2e-products-minimal.csv'),
+                customerCount: 1,
+            });
+            await adminClient.asSuperAdmin();
+        }, TEST_SETUP_TIMEOUT_MS);
+
+        afterAll(async () => {
+            await server.destroy();
+        });
+
+        it('should configure Apollo Server with bounded cache', async () => {
+            const result = await shopClient.query<
+                Codegen.GetProductSimpleQuery,
+                Codegen.GetProductSimpleQueryVariables
+            >(GET_PRODUCT_SIMPLE, {
+                id: 'T_1',
+            });
+
+            expect(result.product).toBeDefined();
+            expect(result.product?.id).toBe('T_1');
+        });
+
+        it('should handle concurrent requests with bounded cache', async () => {
+            const queries = Array.from({ length: 5 }, (_, i) =>
+                shopClient.query<Codegen.GetProductSimpleQuery, Codegen.GetProductSimpleQueryVariables>(
+                    GET_PRODUCT_SIMPLE,
+                    {
+                        id: `T_${i + 1}`,
+                    },
+                ),
+            );
+
+            const results = await Promise.all(queries);
+
+            results.forEach((result, index) => {
+                if (result.product) {
+                    expect(result.product.id).toBe(`T_${index + 1}`);
+                }
+            });
+        });
+    });
+
+    describe('without cache configuration', () => {
+        const { server, adminClient, shopClient } = createTestEnvironment(testConfig());
+
+        beforeAll(async () => {
+            await server.init({
+                initialData,
+                productsCsvPath: path.join(__dirname, 'fixtures/e2e-products-minimal.csv'),
+                customerCount: 1,
+            });
+            await adminClient.asSuperAdmin();
+        }, TEST_SETUP_TIMEOUT_MS);
+
+        afterAll(async () => {
+            await server.destroy();
+        });
+
+        it('should work without cache configuration', async () => {
+            const result = await shopClient.query<
+                Codegen.GetProductSimpleQuery,
+                Codegen.GetProductSimpleQueryVariables
+            >(GET_PRODUCT_SIMPLE, {
+                id: 'T_1',
+            });
+
+            expect(result.product).toBeDefined();
+            expect(result.product?.id).toBe('T_1');
+        });
+    });
+});

packages/core/src/api/config/configure-graphql-module.ts

@@ -85,6 +85,7 @@ async function createGraphQLOptions(
         new AssetInterceptorPlugin(configService),
         ...configService.apiOptions.apolloServerPlugins,
     ];
+
     // We only need to add the IdCodecPlugin if the user has configured
     // a non-default EntityIdStrategy. This is a performance optimization
     // that prevents unnecessary traversal of each response when no
@@ -113,6 +114,7 @@ async function createGraphQLOptions(
         context: (req: any) => req,
         // This is handled by the Express cors plugin
         cors: false,
+        cache: configService.apiOptions.cache,
         plugins: apolloServerPlugins,
         validationRules: options.validationRules,
         introspection: configService.apiOptions.introspection ?? true,

packages/core/src/config/default-config.ts

@@ -91,6 +91,7 @@ export const defaultConfig: RuntimeVendureConfig = {
         middleware: [],
         introspection: true,
         apolloServerPlugins: [],
+        cache: 'bounded',
     },
     entityIdStrategy: new AutoIncrementIdStrategy(),
     authOptions: {

packages/core/src/config/vendure-config.ts

@@ -1,4 +1,5 @@
 import { ApolloServerPlugin } from '@apollo/server';
+import type { KeyValueCache } from '@apollo/utils.keyvaluecache';
 import { RenderPageOptions } from '@apollographql/graphql-playground-html';
 import { DynamicModule, Type } from '@nestjs/common';
 import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
@@ -209,6 +210,17 @@ export interface ApiOptions {
      * @default []
      */
     apolloServerPlugins?: ApolloServerPlugin[];
+    /**
+     * @description
+     * Pass a [custom Apollo cache](https://www.apollographql.com/docs/apollo-server/performance/caching) to the underlying Apollo Server.
+     * Note: this option only supplies the cache instance. To enable GraphQL response caching you must also add
+     * the `responseCachePlugin` (or another plugin that uses `server.cache`) to `apolloServerPlugins`, and set
+     * appropriate cache hints on fields. This option is unrelated to Vendure's {@link SystemOptions}.`cacheStrategy`.
+     *
+     * @default 'bounded'
+     * @since 3.5.0
+     */
+    cache?: KeyValueCache<string> | 'bounded';
     /**
      * @description
      * Controls whether introspection of the GraphQL APIs is enabled. For production, it is recommended to disable