@graphql-box/worker-client 5.4.5 → 5.4.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@graphql-box/worker-client",
   "description": "The GraphQL Box web worker client module.",
-  "version": "5.4.5",
+  "version": "5.4.7",
   "author": "Dylan Aubrey",
   "license": "MIT",
   "homepage": "https://github.com/badbatch/graphql-box",
@@ -41,18 +41,22 @@
     "iterall": "^1.3.0",
     "lodash-es": "^4.17.21",
     "uuid": "^11.0.3",
-    "@graphql-box/core": "5.4.1",
-    "@graphql-box/helpers": "5.4.1"
+    "@graphql-box/core": "5.4.2",
+    "@graphql-box/helpers": "5.4.2"
   },
   "peerDependencies": {
     "graphql": "<17",
-    "@graphql-box/client": "5.4.1"
+    "@graphql-box/cache-manager": "5.4.3",
+    "@graphql-box/client": "5.4.3",
+    "@graphql-box/request-parser": "5.4.2"
   },
   "devDependencies": {
     "cts-types": "^0.0.8",
     "del-cli": "^6.0.0",
     "graphql": "^16.9.0",
-    "@graphql-box/client": "5.4.1"
+    "@graphql-box/cache-manager": "5.4.3",
+    "@graphql-box/request-parser": "5.4.2",
+    "@graphql-box/client": "5.4.3"
   },
   "keywords": [
     "client",

package/src/main.ts

@@ -1,9 +1,12 @@
 import { type CoreWorker } from '@cachemap/core-worker';
+import { type CacheManagerDef } from '@graphql-box/cache-manager';
 import {
   type DebugManagerDef,
   type PartialRequestContext,
   type PartialRequestResult,
+  type PartialResponseData,
   REQUEST_RESOLVED,
+  type RawResponseDataWithMaybeCacheMetadata,
   type RequestContext,
   type RequestOptions,
   SUBSCRIPTION_RESOLVED,
@@ -17,6 +20,7 @@ import {
   isPlainObject,
   rehydrateCacheMetadata,
 } from '@graphql-box/helpers';
+import { type RequestParserDef } from '@graphql-box/request-parser';
 import { EventEmitter } from 'eventemitter3';
 import { OperationTypeNode } from 'graphql';
 import { isError } from 'lodash-es';
@@ -34,8 +38,26 @@ import {
 } from './types.ts';
 
 export class WorkerClient {
-  private static _getMessageContext({ hasDeferOrStream = false, requestID }: RequestContext): MessageContext {
-    return { hasDeferOrStream, requestID };
+  private static _getMessageContext({
+    hasDeferOrStream = false,
+    operation,
+    requestID,
+  }: RequestContext): MessageContext {
+    return { hasDeferOrStream, operation, requestID };
+  }
+
+  private static _resolve(
+    { cacheMetadata, ...rest }: PartialResponseData,
+    options: RequestOptions,
+    { requestID }: RequestContext,
+  ): PartialRequestResult {
+    const result: PartialRequestResult = { ...rest, requestID };
+
+    if (options.returnCacheMetadata && cacheMetadata) {
+      result._cacheMetadata = cacheMetadata;
+    }
+
+    return result;
   }
 
   private _onMessage = ({ data }: MessageEvent<MessageResponsePayload>): void => {
@@ -92,16 +114,35 @@ export class WorkerClient {
         stats: { endTime: this._debugManager.now() },
       });
 
+      if (context.operation === OperationTypeNode.QUERY && pending.requestData && pending.options && pending.context) {
+        void this._cacheManager.cacheQuery(
+          pending.requestData,
+          undefined,
+          // Need to look at what type guards can be put in place
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          response as RawResponseDataWithMaybeCacheMetadata,
+          pending.options,
+          pending.context,
+        );
+      }
+
       pending.resolve(response);
     }
   };
 
+  /**
+   * This cache instance does not actually store anything itself,
+   * it is for communicating with the worker cache that the worker
+   * client is using within the worker.
+   */
   private _cache: CoreWorker;
+  private _cacheManager: CacheManagerDef;
   private _debugManager: DebugManagerDef | null;
   private _eventEmitter: EventEmitter;
   private _experimentalDeferStreamSupport: boolean;
   private _messageQueue: MessageRequestPayload[] = [];
   private _pending: PendingTracker = new Map();
+  private _requestParser: RequestParserDef;
   private _worker: Worker | undefined;
 
   constructor(options: UserOptions) {
@@ -115,6 +156,14 @@ export class WorkerClient {
       errors.push(new ArgsError('@graphql-box/worker-client expected options.cache.'));
     }
 
+    if (!('cacheManager' in options)) {
+      errors.push(new ArgsError('@graphql-box/worker-client expected options.cacheManager.'));
+    }
+
+    if (!('requestParser' in options)) {
+      errors.push(new ArgsError('@graphql-box/worker-client expected options.requestParser.'));
+    }
+
     if (!options.lazyWorkerInit && !('worker' in options)) {
       errors.push(new ArgsError('@graphql-box/worker-client expected options.worker.'));
     }
@@ -124,9 +173,11 @@ export class WorkerClient {
     }
 
     this._cache = options.cache;
+    this._cacheManager = options.cacheManager;
     this._debugManager = options.debugManager ?? null;
     this._eventEmitter = new EventEmitter();
     this._experimentalDeferStreamSupport = options.experimentalDeferStreamSupport ?? false;
+    this._requestParser = options.requestParser;
 
     if (typeof options.worker === 'function') {
       Promise.resolve(options.worker())
@@ -148,12 +199,16 @@ export class WorkerClient {
     return this._cache;
   }
 
+  get cacheManager(): CacheManagerDef {
+    return this._cacheManager;
+  }
+
   public async mutate(request: string, options: RequestOptions = {}, context: PartialRequestContext = {}) {
     return this._request(request, options, this._getRequestContext(OperationTypeNode.MUTATION, request, context));
   }
 
   public async query(request: string, options: RequestOptions = {}, context: PartialRequestContext = {}) {
-    return this._request(request, options, this._getRequestContext(OperationTypeNode.QUERY, request, context));
+    return this._query(request, options, this._getRequestContext(OperationTypeNode.QUERY, request, context));
   }
 
   public async request(request: string, options: RequestOptions = {}, context: PartialRequestContext = {}) {
@@ -201,12 +256,59 @@ export class WorkerClient {
     };
   }
 
+  private async _query(
+    request: string,
+    options: RequestOptions,
+    context: RequestContext,
+  ): Promise<PartialRequestResult | AsyncIterableIterator<PartialRequestResult | undefined>> {
+    try {
+      const { ast, request: updateRequest } = this._requestParser.updateRequest(request, options, context);
+      const requestData = { ast, hash: hashRequest(updateRequest), request: updateRequest };
+      const checkResult = await this._cacheManager.checkQueryResponseCacheEntry(requestData.hash, options, context);
+
+      if (checkResult) {
+        return WorkerClient._resolve(checkResult, options, context);
+      }
+
+      return await new Promise((resolve: PendingResolver) => {
+        if (this._worker) {
+          this._worker.postMessage({
+            context: WorkerClient._getMessageContext(context),
+            method: REQUEST,
+            options,
+            request,
+            type: GRAPHQL_BOX,
+          });
+        } else {
+          this._messageQueue.push({
+            context: WorkerClient._getMessageContext(context),
+            method: REQUEST,
+            options,
+            request,
+            type: GRAPHQL_BOX,
+          });
+        }
+
+        this._pending.set(context.requestID, { context, options, requestData, resolve });
+      });
+    } catch (error) {
+      const confirmedError = isError(error)
+        ? error
+        : new Error('@graphql-box/worker-client request had an unexpected error.');
+
+      return { errors: [confirmedError], requestID: context.requestID };
+    }
+  }
+
   private _releaseMessageQueue(): void {
     if (!this._worker) {
       throw new Error('A worker is required for the WorkerClient to work correctly.');
     }
 
-    for (const message of this._messageQueue) {
+    const messageQueue = [...this._messageQueue];
+    this._messageQueue = [];
+
+    for (const message of messageQueue) {
       this._worker.postMessage(message);
     }
   }

package/src/types.ts

@@ -1,17 +1,26 @@
 import { type CoreWorker } from '@cachemap/core-worker';
+import { type CacheManagerDef } from '@graphql-box/cache-manager';
 import { type Client } from '@graphql-box/client';
 import {
   type DebugManagerDef,
   type PartialRawFetchData,
   type PartialRequestResult,
+  type RequestContext,
+  type RequestData,
   type RequestOptions,
 } from '@graphql-box/core';
+import { type RequestParserDef } from '@graphql-box/request-parser';
+import { type OperationTypeNode } from 'graphql';
 
 export interface UserOptions {
   /**
    * The cache.
    */
   cache: CoreWorker;
+  /**
+   * The curried function to initialize the cache manager.
+   */
+  cacheManager: CacheManagerDef;
   /**
    * The debug manager.
    */
@@ -26,6 +35,10 @@ export interface UserOptions {
    * initialise the worker after the constructor.
    */
   lazyWorkerInit?: boolean;
+  /**
+   * The curried function to initialzie the request parser.
+   */
+  requestParser: RequestParserDef;
   /**
    * The web worker instance.
    */
@@ -39,6 +52,9 @@ export type PendingResolver = (
 ) => void;
 
 export interface PendingData {
+  context?: RequestContext;
+  options?: RequestOptions;
+  requestData?: RequestData;
   resolve: PendingResolver;
 }
 
@@ -61,6 +77,7 @@ export interface MessageResponsePayload {
 
 export interface MessageContext {
   hasDeferOrStream: boolean;
+  operation: OperationTypeNode;
   requestID: string;
 }