@warp-drive-mirror/experiments 0.2.6-alpha.37 → 0.2.6-alpha.40

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

@@ -1,7 +1,7 @@
-import { D as DocumentStorage } from "./index-CGCX7hY2.js";
+import { DocumentStorage } from './document-storage.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) {
@@ -147,6 +147,7 @@ function prepareRequest(event) {
   }
   return event;
 }
+
 const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
 
 /**
@@ -217,7 +218,7 @@ const CacheHandler = {
           }
           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);
           }
@@ -235,11 +236,11 @@ function completeRequest(identifier, store, context, next) {
   if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
     return fetchContentAndHydrate(next, context, identifier);
   }
-  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected a peeked request to be present`);
     }
-  })(peeked) : {};
+  })(peeked);
   context.setResponse(peeked.response);
   if ('error' in peeked) {
     throw peeked;
@@ -361,11 +362,11 @@ function fetchContentAndHydrate(next, context, identifier) {
   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 => {
+    (test => {
       if (!test) {
         throw new Error(`Expected to receive a list of records included in the ${request.op} request`);
       }
-    })(record) : {};
+    })(record);
     if (record) {
       store.cache.willCommit(record, context);
     }
@@ -375,4 +376,5 @@ function fetchContentAndHydrate(next, context, identifier) {
   }
   return next(request).then(document => handleFetchSuccess(store, request, identifier, document), error => handleFetchError(store, request, identifier, error));
 }
-export { CacheHandler, DataWorker };
+
+export { CacheHandler, DataWorker };

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

@@ -1 +1,349 @@
-export { D as DocumentStorage } from "./index-CGCX7hY2.js";
+const WARP_DRIVE_STORAGE_FILE_NAME = 'warp-drive_document-storage';
+const WARP_DRIVE_STORAGE_VERSION = 1;
+
+/**
+ * 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.
+ */
+
+/**
+ * A CacheDocument is a reconstructed request response that rehydrates ResourceDocument
+ * with the associated resources based on their identifiers.
+ */
+
+class InternalDocumentStorage {
+  constructor(options) {
+    this.options = options;
+    this._lastModified = 0;
+    this._invalidated = true;
+    this._fileHandle = this._open(options.scope);
+    this._channel = Object.assign(new BroadcastChannel(options.scope), {
+      onmessage: this._onMessage.bind(this)
+    });
+  }
+  _onMessage(_event) {
+    this._invalidated = true;
+  }
+  async _open(scope) {
+    const directoryHandle = await navigator.storage.getDirectory();
+    const fileHandle = await directoryHandle.getFileHandle(scope, {
+      create: true
+    });
+    return fileHandle;
+  }
+  async _read() {
+    if (this._filePromise) {
+      return this._filePromise;
+    }
+    if (this._invalidated) {
+      const updateFile = async () => {
+        const fileHandle = await this._fileHandle;
+        const file = await fileHandle.getFile();
+        const lastModified = file.lastModified;
+        if (lastModified === this._lastModified && this._cache) {
+          return this._cache;
+        }
+        const contents = await file.text();
+        const cache = contents ? JSON.parse(contents) : {
+          documents: [],
+          resources: []
+        };
+        const documents = new Map(cache.documents);
+        const resources = new Map(cache.resources);
+        const cacheMap = {
+          documents,
+          resources
+        };
+        this._cache = cacheMap;
+        this._invalidated = false;
+        this._lastModified = lastModified;
+        return cacheMap;
+      };
+      this._filePromise = updateFile();
+      await this._filePromise;
+      this._filePromise = null;
+    }
+    return this._cache;
+  }
+  async _patch(documentKey, document, updatedResources) {
+    const fileHandle = await this._fileHandle;
+    // secure a lock before getting latest state
+    const writable = await fileHandle.createWritable();
+    const cache = await this._read();
+    cache.documents.set(documentKey, document);
+    updatedResources.forEach((resource, key) => {
+      cache.resources.set(key, resource);
+    });
+    const documents = [...cache.documents.entries()];
+    const resources = [...cache.resources.entries()];
+    const cacheFile = {
+      documents,
+      resources
+    };
+    await writable.write(JSON.stringify(cacheFile));
+    await writable.close();
+    this._channel.postMessage({
+      type: 'patch',
+      key: documentKey,
+      resources: [...updatedResources.keys()]
+    });
+  }
+  async getDocument(key) {
+    const cache = await this._read();
+    // clone the document to avoid leaking the internal cache
+    const document = safeDocumentHydrate(cache.documents.get(key.lid));
+    if (!document) {
+      return null;
+    }
+
+    // expand the document with the resources
+    if (document.content) {
+      if (docHasData(document.content)) {
+        let data = null;
+        if (Array.isArray(document.content.data)) {
+          data = document.content.data.map(resourceIdentifier => {
+            const resource = cache.resources.get(resourceIdentifier.lid);
+            if (!resource) {
+              throw new Error(`Resource not found for ${resourceIdentifier.lid}`);
+            }
+
+            // clone the resource to avoid leaking the internal cache
+            return structuredClone(resource);
+          });
+        } else if (document.content.data) {
+          const resource = cache.resources.get(document.content.data.lid);
+          if (!resource) {
+            throw new Error(`Resource not found for ${document.content.data.lid}`);
+          }
+
+          // clone the resource to avoid leaking the internal cache
+          data = structuredClone(resource);
+        }
+        if (document.content.included) {
+          const included = document.content.included.map(resourceIdentifier => {
+            const resource = cache.resources.get(resourceIdentifier.lid);
+            if (!resource) {
+              throw new Error(`Resource not found for ${resourceIdentifier.lid}`);
+            }
+
+            // clone the resource to avoid leaking the internal cache
+            return structuredClone(resource);
+          });
+          document.content.included = included;
+        }
+        document.content.data = data;
+      }
+    }
+    return document;
+  }
+  async putDocument(document, resourceCollector) {
+    const resources = new Map();
+    if (!document.content) {
+      throw new Error(`Document content is missing, only finalized documents can be stored`);
+    }
+    if (!document.content.lid) {
+      throw new Error(`Document content is missing a lid, only documents with a cache-key can be stored`);
+    }
+    if (docHasData(document.content)) {
+      this._getResources(document.content, resourceCollector, resources);
+    }
+    await this._patch(document.content.lid, safeDocumentSerialize(document), resources);
+  }
+  _getResources(document, resourceCollector, resources = new Map()) {
+    if (Array.isArray(document.data)) {
+      document.data.forEach(resourceIdentifier => {
+        const resource = resourceCollector(resourceIdentifier);
+        resources.set(resourceIdentifier.lid, structuredClone(resource));
+      });
+    } else if (document.data) {
+      const resource = resourceCollector(document.data);
+      resources.set(document.data.lid, structuredClone(resource));
+    }
+    if (document.included) {
+      document.included.forEach(resourceIdentifier => {
+        const resource = resourceCollector(resourceIdentifier);
+        resources.set(resourceIdentifier.lid, structuredClone(resource));
+      });
+    }
+    return resources;
+  }
+  async putResources(document, resourceCollector) {
+    const fileHandle = await this._fileHandle;
+    // secure a lock before getting latest state
+    const writable = await fileHandle.createWritable();
+    const cache = await this._read();
+    const updatedResources = this._getResources(document, resourceCollector);
+    updatedResources.forEach((resource, key) => {
+      cache.resources.set(key, resource);
+    });
+    const documents = [...cache.documents.entries()];
+    const resources = [...cache.resources.entries()];
+    const cacheFile = {
+      documents,
+      resources
+    };
+    await writable.write(JSON.stringify(cacheFile));
+    await writable.close();
+    this._channel.postMessage({
+      type: 'patch',
+      key: null,
+      resources: [...updatedResources.keys()]
+    });
+  }
+  async clear(reset) {
+    const fileHandle = await this._fileHandle;
+    const writable = await fileHandle.createWritable();
+    await writable.write('');
+    await writable.close();
+    this._invalidated = true;
+    this._lastModified = 0;
+    this._cache = null;
+    this._filePromise = null;
+    this._channel.postMessage({
+      type: 'clear'
+    });
+    if (!reset) {
+      this._channel.close();
+      this._channel = null;
+      if (!this.options.isolated) {
+        Storages.delete(this.options.scope);
+      }
+    }
+  }
+}
+function safeDocumentSerialize(document) {
+  (test => {
+    if (!test) {
+      throw new Error(`Expected to receive a document`);
+    }
+  })(document && typeof document === 'object');
+  const doc = document;
+  const newDoc = {};
+  if ('request' in doc) {
+    newDoc.request = prepareRequest(doc.request);
+  }
+  if ('response' in doc) {
+    newDoc.response = prepareResponse(doc.response);
+  }
+  if ('content' in doc) {
+    newDoc.content = structuredClone(doc.content);
+  }
+  return newDoc;
+}
+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 requestCopy;
+}
+function prepareResponse(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 safeDocumentHydrate(document) {
+  (test => {
+    if (!test) {
+      throw new Error(`Expected to receive a document`);
+    }
+  })(document && typeof document === 'object');
+  const doc = document;
+  const newDoc = {};
+  if ('request' in doc) {
+    const headers = new Headers(doc.request.headers);
+    const req = Object.assign({}, doc.request, {
+      headers
+    });
+    newDoc.request = new Request(doc.request.url ?? '', req);
+  }
+  if ('response' in doc) {
+    const headers = new Headers(doc.response.headers);
+    const resp = Object.assign({}, doc.response, {
+      headers
+    });
+    newDoc.response = new Response(null, resp);
+  }
+  if ('content' in doc) {
+    newDoc.content = structuredClone(doc.content);
+  }
+  return newDoc;
+}
+function docHasData(doc) {
+  return 'data' in doc;
+}
+const Storages = new Map();
+
+/**
+ * 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
+ */
+class DocumentStorage {
+  constructor(options = {}) {
+    options.isolated = options.isolated ?? false;
+    options.scope = options.scope ?? 'default';
+    const fileName = `${WARP_DRIVE_STORAGE_FILE_NAME}@version_${WARP_DRIVE_STORAGE_VERSION}:${options.scope}`;
+    if (!options.isolated && Storages.has(fileName)) {
+      const storage = Storages.get(fileName);
+      if (storage) {
+        this._storage = storage.deref();
+        return;
+      }
+    }
+    const storage = new InternalDocumentStorage({
+      scope: fileName,
+      isolated: options.isolated
+    });
+    this._storage = storage;
+    if (!options.isolated) {
+      Storages.set(fileName, new WeakRef(storage));
+    }
+  }
+  getDocument(key) {
+    return this._storage.getDocument(key);
+  }
+  putDocument(document, resourceCollector) {
+    return this._storage.putDocument(document, resourceCollector);
+  }
+  putResources(document, resourceCollector) {
+    return this._storage.putResources(document, resourceCollector);
+  }
+  clear(reset) {
+    return this._storage.clear(reset);
+  }
+}
+
+export { DocumentStorage };

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

@@ -1,5 +1,4 @@
 import { createDeferred } from '@warp-drive-mirror/core/request';
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
 // @ts-expect-error untyped global
 const isServerEnv = typeof FastBoot !== 'undefined';
@@ -8,12 +7,6 @@ class ImageFetch {
     this.threadId = isServerEnv ? '' : crypto.randomUUID();
     this.pending = new Map();
     this.cache = new Map();
-    const isTesting = macroCondition(getGlobalConfig().WarpDriveMirror.env.TESTING) ? true : false;
-    macroCondition(getGlobalConfig().WarpDriveMirror.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 => {
@@ -77,4 +70,5 @@ class ImageFetch {
     return deferred.promise;
   }
 }
-export { ImageFetch };
+
+export { ImageFetch };

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

@@ -95,4 +95,5 @@ class ImageWorker {
     });
   }
 }
-export { ImageWorker };
+
+export { ImageWorker };

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

@@ -1,5 +1,4 @@
 import { createDeferred } from '@warp-drive-mirror/core/request';
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
 // @ts-expect-error untyped global
 const isServerEnv = typeof FastBoot !== 'undefined';
@@ -26,12 +25,6 @@ class WorkerFetch {
   constructor(worker) {
     this.threadId = isServerEnv ? '' : crypto.randomUUID();
     this.pending = new Map();
-    const isTesting = macroCondition(getGlobalConfig().WarpDriveMirror.env.TESTING) ? true : false;
-    macroCondition(getGlobalConfig().WarpDriveMirror.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 => {
@@ -161,4 +154,5 @@ function prepareRequest(request) {
     request: requestCopy
   };
 }
-export { WorkerFetch };
+
+export { WorkerFetch };

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

@@ -1,7 +1,7 @@
-import { D as DocumentStorage } from "./index-CGCX7hY2.js";
+import { DocumentStorage } from './document-storage.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) {
@@ -147,6 +147,7 @@ function prepareRequest(event) {
   }
   return event;
 }
+
 const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
 
 /**
@@ -217,7 +218,7 @@ const CacheHandler = {
           }
           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);
           }
@@ -235,11 +236,11 @@ function completeRequest(identifier, store, context, next) {
   if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
     return fetchContentAndHydrate(next, context, identifier);
   }
-  macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected a peeked request to be present`);
     }
-  })(peeked) : {};
+  })(peeked);
   context.setResponse(peeked.response);
   if ('error' in peeked) {
     throw peeked;
@@ -361,11 +362,11 @@ function fetchContentAndHydrate(next, context, identifier) {
   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 => {
+    (test => {
       if (!test) {
         throw new Error(`Expected to receive a list of records included in the ${request.op} request`);
       }
-    })(record) : {};
+    })(record);
     if (record) {
       store.cache.willCommit(record, context);
     }
@@ -375,4 +376,5 @@ function fetchContentAndHydrate(next, context, identifier) {
   }
   return next(request).then(document => handleFetchSuccess(store, request, identifier, document), error => handleFetchError(store, request, identifier, error));
 }
-export { CacheHandler, DataWorker };
+
+export { CacheHandler, DataWorker };