@warp-drive-mirror/experiments 0.2.6-alpha.30 → 0.2.6-alpha.34

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

@@ -0,0 +1,378 @@
+import { D as DocumentStorage } from "./index-CGCX7hY2.js";
+import { assertPrivateStore } from '@warp-drive-mirror/core/store/-private';
+import { SkipCache } from '@warp-drive-mirror/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().WarpDriveMirror.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().WarpDriveMirror.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().WarpDriveMirror.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/declarations/data-worker/cache-handler.d.ts

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

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

@@ -0,0 +1,21 @@
+import type { Context, Deferred, Future, NextFn } from "@warp-drive-mirror/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/declarations/data-worker/types.d.ts

@@ -0,0 +1,31 @@
+import type { RequestInfo, StructuredDataDocument, StructuredErrorDocument } from "@warp-drive-mirror/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/declarations/data-worker/utils.d.ts

@@ -0,0 +1,12 @@
+import type { ImmutableCreateRequestOptions, ImmutableDeleteRequestOptions, ImmutableRequestInfo, ImmutableUpdateRequestOptions, StructuredDataDocument } from "@warp-drive-mirror/core/types/request";
+import type { ApiError } from "@warp-drive-mirror/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/declarations/data-worker/worker.d.ts

@@ -0,0 +1,23 @@
+import type { Store } from "@warp-drive-mirror/core";
+import type { Future } from "@warp-drive-mirror/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/declarations/data-worker.d.ts

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

package/dist/unpkg/dev/declarations/document-storage/index.d.ts

@@ -0,0 +1,90 @@
+import type { PersistedResourceKey } from "@warp-drive-mirror/core/types/identifier";
+import type { StructuredDocument } from "@warp-drive-mirror/core/types/request";
+import type { ResourceDataDocument, ResourceDocument } from "@warp-drive-mirror/core/types/spec/document";
+import type { ExistingResourceObject } from "@warp-drive-mirror/core/types/spec/json-api-raw";
+export declare const WARP_DRIVE_STORAGE_FILE_NAME = "warp-drive_document-storage";
+export declare const WARP_DRIVE_STORAGE_VERSION = 1;
+export type DocumentStorageOptions = {
+	/**
+	* The scope of the storage. This is used to enable multiple distinct
+	* storage areas within the same origin.
+	*
+	* One use case for this is to have a separate storage area for each
+	* user credential. So for instance, in applications that allow a single
+	* user to have multiple accounts, each account can have its own storage!
+	*/
+	scope: string;
+	/**
+	* When set to true, if other instances of the storage are created with
+	* the same scope, they will not share the same in-memory cache and BroadcastChannel.
+	*
+	* This is mostly useful for testing purposes to replicate the behavior of
+	* multiple tabs or workers.
+	*/
+	isolated: boolean;
+};
+/**
+* DocumentStorage is specifically designed around WarpDrive Cache and Request concepts.
+*
+* CacheFileDocument is a StructuredDocument (request response) whose `content` is
+* the ResourceDocument returned by inserting the request into a Store's Cache.
+*/
+type CacheFileDocument = StructuredDocument<ResourceDocument>;
+/**
+* A CacheDocument is a reconstructed request response that rehydrates ResourceDocument
+* with the associated resources based on their identifiers.
+*/
+type CacheDocument = StructuredDocument<ResourceDocument<ExistingResourceObject>>;
+type DocumentIdentifier = {
+	lid: string;
+};
+type MemCache = {
+	documents: Map<string, CacheFileDocument>;
+	resources: Map<string, ExistingResourceObject>;
+};
+declare class InternalDocumentStorage {
+	readonly options: DocumentStorageOptions;
+	_fileHandle: Promise<FileSystemFileHandle>;
+	_channel: BroadcastChannel;
+	_invalidated: boolean;
+	_lastModified: number;
+	_cache: MemCache | null;
+	_filePromise: Promise<MemCache> | null;
+	constructor(options: DocumentStorageOptions);
+	_onMessage(_event: MessageEvent): void;
+	_open(scope: string): Promise<FileSystemFileHandle>;
+	_read(): Promise<MemCache>;
+	_patch(documentKey: string, document: CacheFileDocument, updatedResources: Map<string, ExistingResourceObject>): Promise<void>;
+	getDocument(key: DocumentIdentifier): Promise<CacheDocument | null>;
+	putDocument(document: CacheFileDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+	_getResources(document: ResourceDataDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject, resources?: Map<string, ExistingResourceObject>): Map<string, ExistingResourceObject>;
+	putResources(document: ResourceDataDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+	clear(reset?: boolean): Promise<void>;
+}
+/**
+* DocumentStorage is a wrapper around the StorageManager API that provides
+* a simple interface for reading and updating documents and requests.
+*
+* Some goals for this experiment:
+*
+* - optimize for storing requests/documents
+* - optimize for storing resources
+* - optimize for looking up resources associated to a document
+* - optimize for notifying cross-tab when data is updated
+*
+* optional features:
+*
+* - support for offline mode
+* - ?? support for relationship based cache traversal
+* - a way to index records by type + another field (e.g updatedAt/createAt/name)
+*   such that simple queries can be done without having to scan all records
+*/
+export declare class DocumentStorage {
+	readonly _storage: InternalDocumentStorage;
+	constructor(options?: Partial<DocumentStorageOptions>);
+	getDocument(key: DocumentIdentifier): Promise<CacheDocument | null>;
+	putDocument(document: CacheFileDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+	putResources(document: ResourceDataDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+	clear(reset?: boolean): Promise<void>;
+}
+export {};

package/dist/unpkg/dev/declarations/document-storage.d.ts

@@ -0,0 +1 @@
+export { DocumentStorage } from "./document-storage/index.js";

package/dist/unpkg/dev/declarations/image-fetch.d.ts

@@ -0,0 +1 @@
+export { ImageFetch } from "./image-worker/fetch.js";

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

@@ -0,0 +1,18 @@
+import type { Deferred } from "@warp-drive-mirror/core/request";
+import type { RequestEventData } from "./types.js";
+export interface FastBoot {
+	require(moduleName: string): unknown;
+	isFastBoot: boolean;
+	request: Request;
+}
+export declare class ImageFetch {
+	worker: Worker | SharedWorker;
+	threadId: string;
+	pending: Map<string, Deferred<string>>;
+	channel: MessageChannel;
+	cache: Map<string, string>;
+	constructor(worker: Worker | SharedWorker | null);
+	cleanupRequest(url: string): Deferred<string> | undefined;
+	_send(event: RequestEventData): void;
+	load(url: string): Promise<string>;
+}

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

@@ -0,0 +1,21 @@
+export type SuccessResponseEventData = {
+	type: "success-response";
+	thread: string;
+	url: string;
+};
+export type ErrorResponseEventData = {
+	type: "error-response";
+	thread: string;
+	url: string;
+};
+export type RequestEventData = {
+	type: "load";
+	thread: string;
+	url: string;
+};
+export type ThreadInitEventData = {
+	type: "connect";
+	thread: string;
+};
+export type MainThreadEvent = MessageEvent<SuccessResponseEventData | ErrorResponseEventData>;
+export type WorkerThreadEvent = MessageEvent<RequestEventData> | MessageEvent<ThreadInitEventData>;

package/dist/unpkg/dev/declarations/image-worker/worker.d.ts

@@ -0,0 +1,14 @@
+export declare class ImageWorker {
+	private threads;
+	private pendingImages;
+	private options;
+	private isSharedWorker;
+	private cache;
+	constructor(options?: {
+		persisted: boolean;
+	});
+	private fetch;
+	private initialize;
+	private setupThread;
+	private request;
+}

package/dist/unpkg/dev/declarations/image-worker.d.ts

@@ -0,0 +1 @@
+export { ImageWorker } from "./image-worker/worker.js";

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

@@ -0,0 +1 @@
+export { WorkerFetch } from "./data-worker/fetch.js";

package/dist/unpkg/dev/document-storage.js

@@ -0,0 +1 @@
+export { D as DocumentStorage } from "./index-CGCX7hY2.js";