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

package/dist/unpkg/prod-deprecated/document-storage.js

@@ -1 +1,339 @@
-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) {
+  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) {
+  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/prod-deprecated/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/prod-deprecated/image-worker.js

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

package/dist/unpkg/prod-deprecated/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@warp-drive-mirror/experiments",
   "description": "Experimental features for WarpDrive",
-  "version": "0.2.6-alpha.37",
+  "version": "0.2.6-alpha.40",
   "license": "MIT",
   "author": "Chris Thoburn <runspired@users.noreply.github.com>",
   "repository": {
@@ -13,62 +13,42 @@
   "bugs": "https://github.com/warp-drive-data/warp-drive/issues",
   "exports": {
     "./document-storage": {
-      "unpkg": {
-        "development": {
-          "deprecations": "./dist/unpkg/dev-deprecated/document-storage.js",
-          "default": "./dist/unpkg/dev/document-storage.js"
-        },
-        "deprecations": "./dist/unpkg/prod-deprecated/document-storage.js",
-        "default": "./dist/unpkg/prod/document-storage.js"
-      },
+      "unpkg-dev-deprecated": "./dist/unpkg/dev-deprecated/document-storage.js",
+      "unpkg-dev": "./dist/unpkg/dev/document-storage.js",
+      "unpkg-deprecated": "./dist/unpkg/prod-deprecated/document-storage.js",
+      "unpkg": "./dist/unpkg/prod/document-storage.js",
       "types": "./declarations/document-storage.d.ts",
       "default": "./dist/document-storage.js"
     },
     "./data-worker": {
-      "unpkg": {
-        "development": {
-          "deprecations": "./dist/unpkg/dev-deprecated/data-worker.js",
-          "default": "./dist/unpkg/dev/data-worker.js"
-        },
-        "deprecations": "./dist/unpkg/prod-deprecated/data-worker.js",
-        "default": "./dist/unpkg/prod/data-worker.js"
-      },
+      "unpkg-dev-deprecated": "./dist/unpkg/dev-deprecated/data-worker.js",
+      "unpkg-dev": "./dist/unpkg/dev/data-worker.js",
+      "unpkg-deprecated": "./dist/unpkg/prod-deprecated/data-worker.js",
+      "unpkg": "./dist/unpkg/prod/data-worker.js",
       "types": "./declarations/data-worker.d.ts",
       "default": "./dist/data-worker.js"
     },
     "./worker-fetch": {
-      "unpkg": {
-        "development": {
-          "deprecations": "./dist/unpkg/dev-deprecated/worker-fetch.js",
-          "default": "./dist/unpkg/dev/worker-fetch.js"
-        },
-        "deprecations": "./dist/unpkg/prod-deprecated/worker-fetch.js",
-        "default": "./dist/unpkg/prod/worker-fetch.js"
-      },
+      "unpkg-dev-deprecated": "./dist/unpkg/dev-deprecated/worker-fetch.js",
+      "unpkg-dev": "./dist/unpkg/dev/worker-fetch.js",
+      "unpkg-deprecated": "./dist/unpkg/prod-deprecated/worker-fetch.js",
+      "unpkg": "./dist/unpkg/prod/worker-fetch.js",
       "types": "./declarations/worker-fetch.d.ts",
       "default": "./dist/worker-fetch.js"
     },
     "./image-worker": {
-      "unpkg": {
-        "development": {
-          "deprecations": "./dist/unpkg/dev-deprecated/image-worker.js",
-          "default": "./dist/unpkg/dev/image-worker.js"
-        },
-        "deprecations": "./dist/unpkg/prod-deprecated/image-worker.js",
-        "default": "./dist/unpkg/prod/image-worker.js"
-      },
+      "unpkg-dev-deprecated": "./dist/unpkg/dev-deprecated/image-worker.js",
+      "unpkg-dev": "./dist/unpkg/dev/image-worker.js",
+      "unpkg-deprecated": "./dist/unpkg/prod-deprecated/image-worker.js",
+      "unpkg": "./dist/unpkg/prod/image-worker.js",
       "types": "./declarations/image-worker.d.ts",
       "default": "./dist/image-worker.js"
     },
     "./image-fetch": {
-      "unpkg": {
-        "development": {
-          "deprecations": "./dist/unpkg/dev-deprecated/image-fetch.js",
-          "default": "./dist/unpkg/dev/image-fetch.js"
-        },
-        "deprecations": "./dist/unpkg/prod-deprecated/image-fetch.js",
-        "default": "./dist/unpkg/prod/image-fetch.js"
-      },
+      "unpkg-dev-deprecated": "./dist/unpkg/dev-deprecated/image-fetch.js",
+      "unpkg-dev": "./dist/unpkg/dev/image-fetch.js",
+      "unpkg-deprecated": "./dist/unpkg/prod-deprecated/image-fetch.js",
+      "unpkg": "./dist/unpkg/prod/image-fetch.js",
       "types": "./declarations/image-fetch.d.ts",
       "default": "./dist/image-fetch.js"
     }
@@ -84,7 +64,7 @@
   ],
   "peerDependencies": {
     "@sqlite.org/sqlite-wasm": "3.46.0-build2",
-    "@warp-drive-mirror/core": "5.8.0-alpha.37"
+    "@warp-drive-mirror/core": "5.8.0-alpha.40"
   },
   "peerDependenciesMeta": {
     "@sqlite.org/sqlite-wasm": {
@@ -99,8 +79,8 @@
     "@babel/plugin-transform-typescript": "^7.28.0",
     "@babel/preset-env": "^7.28.3",
     "@babel/preset-typescript": "^7.27.1",
-    "@warp-drive/internal-config": "5.8.0-alpha.37",
-    "@warp-drive-mirror/core": "5.8.0-alpha.37",
+    "@warp-drive/internal-config": "5.8.0-alpha.40",
+    "@warp-drive-mirror/core": "5.8.0-alpha.40",
     "@sqlite.org/sqlite-wasm": "3.46.0-build2",
     "typescript": "^5.9.2",
     "vite": "^7.1.3"

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

@@ -1,7 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

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