@warp-drive/experiments 0.2.6-alpha.3 → 0.2.6-alpha.32

package/dist/unpkg/dev/worker-fetch.js

@@ -0,0 +1,164 @@
+import { createDeferred } from '@warp-drive/core/request';
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+
+// @ts-expect-error untyped global
+const isServerEnv = typeof FastBoot !== 'undefined';
+function isAggregateError(error) {
+  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
+}
+function stitchTrace(stack, origin) {
+  if (origin.startsWith('Error\n')) {
+    return origin.slice(6) + '\n' + stack;
+  }
+  return origin + '\n' + stack;
+}
+function cloneError(error, stack) {
+  const isAggregate = isAggregateError(error);
+  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
+  cloned.stack = stitchTrace(error.stack || '', stack);
+  cloned.error = error.error;
+
+  // copy over enumerable properties
+  Object.assign(cloned, error);
+  return cloned;
+}
+class WorkerFetch {
+  constructor(worker) {
+    this.threadId = isServerEnv ? '' : crypto.randomUUID();
+    this.pending = new Map();
+    const isTesting = macroCondition(getGlobalConfig().WarpDrive.env.TESTING) ? true : false;
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a SharedWorker instance`);
+      }
+    })(isTesting || isServerEnv || worker instanceof SharedWorker) : {};
+    this.worker = worker;
+    if (!isServerEnv) {
+      const fn = event => {
+        const {
+          type,
+          id,
+          data
+        } = event.data;
+        const info = this.cleanupRequest(id);
+
+        // typically this means the request was aborted
+        if (!info) {
+          return;
+        }
+        if (type === 'success-response') {
+          const {
+            deferred
+          } = info;
+          const {
+            response,
+            content
+          } = data;
+          if (response) {
+            response.headers = new Headers(response.headers);
+            info.context.setResponse(new Response(null, response));
+          }
+          deferred.resolve(content);
+          return;
+        }
+        if (type === 'error-response') {
+          const {
+            deferred,
+            stack
+          } = info;
+          deferred.reject(cloneError(data, stack));
+          return;
+        }
+      };
+      if (worker instanceof SharedWorker) {
+        worker.port.postMessage({
+          type: 'connect',
+          thread: this.threadId
+        });
+        worker.port.onmessage = fn;
+      } else if (worker) {
+        this.channel = new MessageChannel();
+        worker.postMessage({
+          type: 'connect',
+          thread: this.threadId
+        }, [this.channel.port2]);
+        this.channel.port1.onmessage = fn;
+      }
+    }
+  }
+  cleanupRequest(id) {
+    const info = this.pending.get(id);
+    this.pending.delete(id);
+    if (info?.signal) {
+      info.signal.removeEventListener('abort', info.abortFn);
+    }
+    return info;
+  }
+  send(event) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    this.worker instanceof SharedWorker ? this.worker.port.postMessage(event) : this.channel.port1.postMessage(event);
+  }
+  request(context, next) {
+    if (isServerEnv) {
+      return next(context.request);
+    }
+    const deferred = createDeferred();
+    const {
+      signal,
+      request
+    } = prepareRequest(context.request);
+    const abortFn = signal ? () => {
+      deferred.reject(enhanceReason(signal.reason));
+      this.send({
+        type: 'abort',
+        thread: this.threadId,
+        id: context.id,
+        data: signal.reason
+      });
+      this.cleanupRequest(context.id);
+    } : () => {
+      return;
+    };
+    signal?.addEventListener('abort', abortFn);
+    try {
+      throw new Error();
+    } catch (e) {
+      this.pending.set(context.id, {
+        context,
+        deferred,
+        signal,
+        abortFn,
+        stack: e.stack
+      });
+    }
+    this.send({
+      type: 'request',
+      thread: this.threadId,
+      id: context.id,
+      data: request
+    });
+    return deferred.promise;
+  }
+}
+function enhanceReason(reason) {
+  return new DOMException(reason || 'The user aborted a request.', 'AbortError');
+}
+function prepareRequest(request) {
+  const {
+    signal,
+    headers
+  } = request;
+  const requestCopy = Object.assign({}, request);
+  delete requestCopy.store;
+  if (signal instanceof AbortSignal) {
+    delete requestCopy.signal;
+  }
+  if (headers instanceof Headers) {
+    requestCopy.headers = Array.from(headers);
+  }
+  return {
+    signal: signal || null,
+    request: requestCopy
+  };
+}
+export { WorkerFetch };

package/dist/unpkg/dev-deprecated/data-worker.js

@@ -0,0 +1,378 @@
+import { D as DocumentStorage } from "./index-CGCX7hY2.js";
+import { assertPrivateStore } from '@warp-drive/core/store/-private';
+import { SkipCache } from '@warp-drive/core/types/request';
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+const WorkerScope = globalThis.SharedWorkerGlobalScope;
+class DataWorker {
+  constructor(UserStore, options) {
+    // disable if running on main thread
+    if (typeof window !== 'undefined') {
+      return;
+    }
+    this.store = new UserStore();
+    this.threads = new Map();
+    this.pending = new Map();
+    this.options = Object.assign({
+      persisted: false,
+      scope: ''
+    }, options);
+    this.isSharedWorker = WorkerScope && globalThis instanceof WorkerScope;
+    this.initialize();
+  }
+  initialize() {
+    // enable the CacheHandler to access the worker
+    this.store._worker = this;
+    if (this.options.persisted) {
+      // will be accessed by the worker's CacheHandler off of store
+      this.storage = new DocumentStorage({
+        scope: this.options.scope
+      });
+    }
+    if (this.isSharedWorker) {
+      globalThis.onconnect = e => {
+        const port = e.ports[0];
+        port.onmessage = event => {
+          const {
+            type
+          } = event.data;
+          switch (type) {
+            case 'connect':
+              this.setupThread(event.data.thread, port);
+              break;
+          }
+        };
+        port.start();
+      };
+    } else {
+      globalThis.onmessage = event => {
+        const {
+          type
+        } = event.data;
+        switch (type) {
+          case 'connect':
+            this.setupThread(event.data.thread, event.ports[0]);
+            break;
+        }
+      };
+    }
+  }
+  setupThread(thread, port) {
+    this.threads.set(thread, port);
+    this.pending.set(thread, new Map());
+    port.onmessage = event => {
+      if (event.type === 'close') {
+        this.threads.delete(thread);
+        return;
+      }
+      const {
+        type
+      } = event.data;
+      switch (type) {
+        case 'abort':
+          this.abortRequest(event.data);
+          break;
+        case 'request':
+          void this.request(prepareRequest(event.data));
+          break;
+      }
+    };
+  }
+  abortRequest(event) {
+    const {
+      thread,
+      id
+    } = event;
+    const future = this.pending.get(thread).get(id);
+    if (future) {
+      future.abort();
+      this.pending.get(thread).delete(id);
+    }
+  }
+  async request(event) {
+    const {
+      thread,
+      id,
+      data
+    } = event;
+    try {
+      const future = this.store.request(data);
+      this.pending.get(thread).set(id, future);
+      const result = await future;
+      this.threads.get(thread)?.postMessage({
+        type: 'success-response',
+        id,
+        thread,
+        data: prepareResponse(result)
+      });
+    } catch (error) {
+      if (isAbortError(error)) return;
+      this.threads.get(thread)?.postMessage({
+        type: 'error-response',
+        id,
+        thread,
+        data: error
+      });
+    } finally {
+      this.pending.get(thread).delete(id);
+    }
+  }
+}
+function softCloneResponse(response) {
+  if (!response) return null;
+  const clone = {};
+  if (response.headers) {
+    clone.headers = Array.from(response.headers);
+  }
+  clone.ok = response.ok;
+  clone.redirected = response.redirected;
+  clone.status = response.status;
+  clone.statusText = response.statusText;
+  clone.type = response.type;
+  clone.url = response.url;
+  return clone;
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === 'AbortError';
+}
+function prepareResponse(result) {
+  const newResponse = {
+    response: softCloneResponse(result.response),
+    content: result.content
+  };
+  return newResponse;
+}
+function prepareRequest(event) {
+  if (event.data.headers) {
+    event.data.headers = new Headers(event.data.headers);
+  }
+  return event;
+}
+const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
+
+/**
+ * In a Worker, any time we are asked to make a request, data needs to be returned.
+ * background requests are ergo no different than foreground requests.
+ * @internal
+ */
+function calcShouldFetch(store, request, hasCachedValue, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || cacheOptions?.backgroundReload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) || store.lifetimes.isSoftExpired(identifier, store) : false);
+}
+function isMutation(request) {
+  return Boolean(request.op && MUTATION_OPS.has(request.op));
+}
+function isCacheAffecting(document) {
+  if (!isMutation(document.request)) {
+    return true;
+  }
+  // a mutation combined with a 204 has no cache impact when no known records were involved
+  // a createRecord with a 201 with an empty response and no known records should similarly
+  // have no cache impact
+
+  if (document.request.op === 'createRecord' && document.response?.status === 201) {
+    return document.content ? Object.keys(document.content).length > 0 : false;
+  }
+  return document.response?.status !== 204;
+}
+function isAggregateError(error) {
+  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
+}
+// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
+function cloneError(error) {
+  const isAggregate = isAggregateError(error);
+  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
+  cloned.stack = error.stack;
+  cloned.error = error.error;
+
+  // copy over enumerable properties
+  Object.assign(cloned, error);
+  return cloned;
+}
+
+/**
+ * A simplified CacheHandler that hydrates ResourceDataDocuments from the cache
+ * with their referenced resources.
+ *
+ */
+const CacheHandler = {
+  request(context, next) {
+    // if we have no cache or no cache-key skip cache handling
+    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
+      return next(context.request);
+    }
+    const {
+      store
+    } = context.request;
+    const identifier = store.cacheKeyManager.getOrCreateDocumentIdentifier(context.request);
+    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
+    if (identifier && !peeked) {
+      // if we are using persisted cache, we should attempt to populate the in-memory cache now
+      const worker = store._worker;
+      if (worker?.storage) {
+        return worker.storage.getDocument(identifier).then(document => {
+          if (document) {
+            store.cache.put(document);
+          }
+          return completeRequest(identifier, store, context, next);
+        }).catch(e => {
+          if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+            // eslint-disable-next-line no-console
+            console.log('Unable to retrieve document from persisted storage', e);
+          }
+          return completeRequest(identifier, store, context, next);
+        });
+      }
+    }
+    return completeRequest(identifier, store, context, next);
+  }
+};
+function completeRequest(identifier, store, context, next) {
+  const peeked = identifier ? store.cache.peekRequest(identifier) : null;
+  // In a Worker, any time we are asked to make a request, data needs to be returned.
+  // background requests are ergo no different than foreground requests.
+  if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
+    return fetchContentAndHydrate(next, context, identifier);
+  }
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a peeked request to be present`);
+    }
+  })(peeked) : {};
+  context.setResponse(peeked.response);
+  if ('error' in peeked) {
+    throw peeked;
+  }
+  return maybeUpdateObjects(store, peeked.content);
+}
+function maybeUpdateObjects(store, document) {
+  if (!document) {
+    return document;
+  }
+  if (Array.isArray(document.data)) {
+    const data = document.data.map(identifier => {
+      return store.cache.peek(identifier);
+    });
+    return Object.assign({}, document, {
+      data
+    });
+  } else {
+    // @ts-expect-error FIXME investigate why document.data won't accept the signature
+    const data = document.data ? store.cache.peek(document.data) : null;
+    return Object.assign({}, document, {
+      data
+    });
+  }
+}
+function maybeUpdatePersistedCache(store, document, resourceDocument) {
+  const worker = store._worker;
+  if (!worker?.storage) {
+    return;
+  }
+  if (!document && resourceDocument) {
+    // we have resources to update but not a full request to cache
+    void worker.storage.putResources(resourceDocument, resourceIdentifier => {
+      return store.cache.peek(resourceIdentifier);
+    });
+  } else if (document) {
+    void worker.storage.putDocument(document, resourceIdentifier => {
+      return store.cache.peek(resourceIdentifier);
+    });
+  }
+}
+function updateCacheForSuccess(store, request, document) {
+  let response = null;
+  if (isMutation(request)) {
+    const record = request.data?.record || request.records?.[0];
+    if (record) {
+      // @ts-expect-error while this is valid, we should update the CacheHandler for transactional saves
+      response = store.cache.didCommit(record, document);
+
+      // a mutation combined with a 204 has no cache impact when no known records were involved
+      // a createRecord with a 201 with an empty response and no known records should similarly
+      // have no cache impact
+    } else if (isCacheAffecting(document)) {
+      response = store.cache.put(document);
+      maybeUpdatePersistedCache(store, null, response);
+    }
+  } else {
+    response = store.cache.put(document);
+    if (response.lid) {
+      const identifier = store.cacheKeyManager.getOrCreateDocumentIdentifier(request);
+      const full = store.cache.peekRequest(identifier);
+      maybeUpdatePersistedCache(store, full);
+    }
+  }
+  return maybeUpdateObjects(store, response);
+}
+function handleFetchSuccess(store, request, identifier, document) {
+  let response;
+  assertPrivateStore(store);
+  store._join(() => {
+    response = updateCacheForSuccess(store, request, document);
+  });
+  if (store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(request, document.response, identifier, store);
+  }
+  return response;
+}
+function updateCacheForError(store, request, error) {
+  if (isMutation(request)) {
+    // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
+    // currently we let the response remain undefiend.
+    const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
+    const record = request.data?.record || request.records?.[0];
+    store.cache.commitWasRejected(record, errors);
+  } else {
+    const identifier = store.cacheKeyManager.getOrCreateDocumentIdentifier(request);
+    if (identifier) {
+      maybeUpdatePersistedCache(store, error);
+    }
+    return store.cache.put(error);
+  }
+}
+function handleFetchError(store, request, identifier, error) {
+  if (request.signal?.aborted) {
+    throw error;
+  }
+  assertPrivateStore(store);
+  let response;
+  store._join(() => {
+    response = updateCacheForError(store, request, error);
+  });
+  if (identifier && store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(request, error.response, identifier, store);
+  }
+  if (isMutation(request)) {
+    throw error;
+  }
+  const newError = cloneError(error);
+  newError.content = response;
+  throw newError;
+}
+function fetchContentAndHydrate(next, context, identifier) {
+  const {
+    request
+  } = context;
+  const {
+    store
+  } = context.request;
+  if (isMutation(request)) {
+    // TODO should we handle multiple records in request.records by iteratively calling willCommit for each
+    const record = request.data?.record || request.records?.[0];
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected to receive a list of records included in the ${request.op} request`);
+      }
+    })(record) : {};
+    if (record) {
+      store.cache.willCommit(record, context);
+    }
+  }
+  if (store.lifetimes?.willRequest) {
+    store.lifetimes.willRequest(request, identifier, store);
+  }
+  return next(request).then(document => handleFetchSuccess(store, request, identifier, document), error => handleFetchError(store, request, identifier, error));
+}
+export { CacheHandler, DataWorker };

package/dist/unpkg/dev-deprecated/declarations/data-worker/cache-handler.d.ts

@@ -0,0 +1,7 @@
+import type { CacheHandler as CacheHandlerType } from "@warp-drive/core/request";
+/**
+* A simplified CacheHandler that hydrates ResourceDataDocuments from the cache
+* with their referenced resources.
+*
+*/
+export declare const CacheHandler: CacheHandlerType;

package/dist/unpkg/dev-deprecated/declarations/data-worker/fetch.d.ts

@@ -0,0 +1,21 @@
+import type { Context, Deferred, Future, NextFn } from "@warp-drive/core/request";
+import type { AbortEventData, RequestEventData } from "./types.js";
+interface PendingItem {
+	context: Context;
+	signal: AbortSignal | null;
+	abortFn: () => void;
+	deferred: Deferred<unknown>;
+	stack: string;
+}
+export declare class WorkerFetch {
+	worker: Worker | SharedWorker;
+	threadId: string;
+	pending: Map<number, PendingItem>;
+	channel: MessageChannel;
+	constructor(worker: Worker | SharedWorker | null);
+	cleanupRequest(id: number): PendingItem | undefined;
+	send(event: RequestEventData | AbortEventData): void;
+	request<T>(context: Context, next: NextFn<T>): Promise<T> | Future<T>;
+}
+export declare function enhanceReason(reason?: string): DOMException;
+export {};

package/dist/unpkg/dev-deprecated/declarations/data-worker/types.d.ts

@@ -0,0 +1,31 @@
+import type { RequestInfo, StructuredDataDocument, StructuredErrorDocument } from "@warp-drive/core/types/request";
+export type SuccessResponseEventData<T> = {
+	type: "success-response";
+	thread: string;
+	id: number;
+	data: StructuredDataDocument<T>;
+};
+export type ErrorResponseEventData<T> = {
+	type: "error-response";
+	thread: string;
+	id: number;
+	data: StructuredErrorDocument<T>;
+};
+export type RequestEventData = {
+	type: "request";
+	thread: string;
+	id: number;
+	data: RequestInfo;
+};
+export type AbortEventData = {
+	type: "abort";
+	thread: string;
+	id: number;
+	data: string;
+};
+export type ThreadInitEventData = {
+	type: "connect";
+	thread: string;
+};
+export type MainThreadEvent<T> = MessageEvent<SuccessResponseEventData<T> | ErrorResponseEventData<T>>;
+export type WorkerThreadEvent = MessageEvent<RequestEventData> | MessageEvent<ThreadInitEventData> | MessageEvent<AbortEventData>;

package/dist/unpkg/dev-deprecated/declarations/data-worker/utils.d.ts

@@ -0,0 +1,12 @@
+import type { ImmutableCreateRequestOptions, ImmutableDeleteRequestOptions, ImmutableRequestInfo, ImmutableUpdateRequestOptions, StructuredDataDocument } from "@warp-drive/core/types/request";
+import type { ApiError } from "@warp-drive/core/types/spec/error";
+export declare const MUTATION_OPS: Set<string>;
+export declare function isMutation(request: Partial<ImmutableRequestInfo>): request is ImmutableUpdateRequestOptions | ImmutableCreateRequestOptions | ImmutableDeleteRequestOptions;
+export declare function isCacheAffecting<T>(document: StructuredDataDocument<T>): boolean;
+type RobustError = Error & {
+	error: string | object;
+	errors?: ApiError[];
+	content?: unknown;
+};
+export declare function cloneError(error: RobustError): RobustError;
+export {};

package/dist/unpkg/dev-deprecated/declarations/data-worker/worker.d.ts

@@ -0,0 +1,23 @@
+import type { Store } from "@warp-drive/core";
+import type { Future } from "@warp-drive/core/request";
+import { DocumentStorage } from "../document-storage.js";
+import type { AbortEventData, RequestEventData } from "./types.js";
+export declare class DataWorker {
+	store: Store;
+	threads: Map<string, MessagePort>;
+	pending: Map<string, Map<number, Future<unknown>>>;
+	isSharedWorker: boolean;
+	options: {
+		persisted: boolean;
+		scope?: string;
+	};
+	storage: DocumentStorage;
+	constructor(UserStore: typeof Store, options?: {
+		persisted: boolean;
+		scope?: string;
+	});
+	initialize(): void;
+	setupThread(thread: string, port: MessagePort): void;
+	abortRequest(event: AbortEventData): void;
+	request(event: RequestEventData): Promise<void>;
+}

package/dist/unpkg/dev-deprecated/declarations/data-worker.d.ts

@@ -0,0 +1,2 @@
+export { DataWorker } from "./data-worker/worker.js";
+export { CacheHandler } from "./data-worker/cache-handler.js";