@warp-drive/experiments 0.2.7-alpha.9 → 0.2.7-beta.1

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

@@ -1,380 +1,273 @@
-import { DocumentStorage } from './document-storage.js';
-import { assertPrivateStore } from '@warp-drive/core/store/-private';
-import { SkipCache } from '@warp-drive/core/types/request';
+import { t as DocumentStorage } from "./document-storage-DkiEg9rY.js";
+import { assertPrivateStore } from "@warp-drive/core/store/-private";
+import { SkipCache } from "@warp-drive/core/types/request";
 
+//#region src/data-worker/worker.ts
 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);
-    }
-  }
-}
+var DataWorker = class {
+	constructor(UserStore, options) {
+		if (typeof window !== "undefined") return;
+		this.store = new UserStore();
+		this.threads = /* @__PURE__ */ new Map();
+		this.pending = /* @__PURE__ */ new Map();
+		this.options = Object.assign({
+			persisted: false,
+			scope: ""
+		}, options);
+		this.isSharedWorker = WorkerScope && globalThis instanceof WorkerScope;
+		this.initialize();
+	}
+	initialize() {
+		this.store._worker = this;
+		if (this.options.persisted) 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);
+				}
+			};
+			port.start();
+		};
+		else globalThis.onmessage = (event) => {
+			const { type } = event.data;
+			switch (type) {
+				case "connect": this.setupThread(event.data.thread, event.ports[0]);
+			}
+		};
+	}
+	setupThread(thread, port) {
+		this.threads.set(thread, port);
+		this.pending.set(thread, /* @__PURE__ */ 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": this.request(prepareRequest(event.data));
+			}
+		};
+	}
+	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;
+	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';
+	return error instanceof Error && error.name === "AbortError";
 }
 function prepareResponse(result) {
-  const newResponse = {
-    response: softCloneResponse(result.response),
-    content: result.content
-  };
-  return newResponse;
+	return {
+		response: softCloneResponse(result.response),
+		content: result.content
+	};
 }
 function prepareRequest(event) {
-  if (event.data.headers) {
-    event.data.headers = new Headers(event.data.headers);
-  }
-  return event;
+	if (event.data.headers) event.data.headers = new Headers(event.data.headers);
+	return event;
 }
 
-const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
-
+//#endregion
+//#region src/data-worker/utils.ts
+const MUTATION_OPS = /* @__PURE__ */ 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
- */
+* 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);
+	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));
+	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;
+	if (!isMutation(document.request)) return true;
+	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);
+	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;
+	const cloned = isAggregateError(error) ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
+	cloned.stack = error.stack;
+	cloned.error = error.error;
+	Object.assign(cloned, error);
+	return cloned;
 }
 
+//#endregion
+//#region src/data-worker/cache-handler.ts
 /**
- * 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 => {
-          {
-            // 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);
-  }
-};
+* A simplified CacheHandler that hydrates ResourceDataDocuments from the cache
+* with their referenced resources.
+*
+*/
+const CacheHandler = { request(context, next) {
+	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) {
+		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) => {
+			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);
-  }
-  (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);
+	const peeked = identifier ? store.cache.peekRequest(identifier) : null;
+	if (calcShouldFetch(store, context.request, !!peeked, identifier)) return fetchContentAndHydrate(next, context, identifier);
+	((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
-    });
-  }
+	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 {
+		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);
-    });
-  }
+	const worker = store._worker;
+	if (!worker?.storage) return;
+	if (!document && resourceDocument) worker.storage.putResources(resourceDocument, (resourceIdentifier) => {
+		return store.cache.peek(resourceIdentifier);
+	});
+	else if (document) 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);
+	let response = null;
+	if (isMutation(request)) {
+		const record = request.data?.record || request.records?.[0];
+		if (record) response = store.cache.didCommit(record, document);
+		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);
+			maybeUpdatePersistedCache(store, store.cache.peekRequest(identifier));
+		}
+	}
+	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;
+	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);
-  }
+	if (isMutation(request)) {
+		const errors = error && error.content && typeof error.content === "object" && "errors" in error.content && Array.isArray(error.content.errors) ? error.content.errors : void 0;
+		const record = request.data?.record || request.records?.[0];
+		store.cache.commitWasRejected(record, errors);
+	} else {
+		if (store.cacheKeyManager.getOrCreateDocumentIdentifier(request)) 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;
+	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];
-    (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));
+	const { request } = context;
+	const { store } = context.request;
+	if (isMutation(request)) {
+		const record = request.data?.record || request.records?.[0];
+		((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));
 }
 
+//#endregion
 export { CacheHandler, DataWorker };
+//# sourceMappingURL=data-worker.js.map