@sasjs/cli 6.29.0 → 6.30.1

package/build/commands/build/internal/mockSite/assets/boot.js

@@ -12,6 +12,12 @@
  * same tags, the same order, and the same globals, just later than the parser
  * would have run them.
  *
+ * Two of those start before the worker is ready, because neither needs it: the
+ * drive restore is the page's own read of IndexedDB and is handed over as soon
+ * as there is a worker, and the app's bundle is hinted by the page (a preload
+ * link the builder writes). Both then overlap the install instead of following
+ * it.
+ *
  * The tag list arrives in the `data-scripts` attribute as JSON, written by
  * buildMockSite. `defer` and `async` are not replayed: execution is sequenced
  * on purpose here, because the host has to be ready before the first request
@@ -81,10 +87,26 @@
     })
   }
 
+  /*
+   * The drive restore is the page's own work: persist.js reads the stored drive
+   * and hands it to the worker as soon as there is one, so it neither needs nor
+   * waits for the registration below. Started here, its download and its
+   * IndexedDB read overlap the worker's install, which is the slowest part of a
+   * first visit - sequenced after it, they are two more round trips on top.
+   */
+  var persist = new Promise(function (resolve) {
+    load('host/persist.js', resolve)
+  })
+
   function start() {
-    load('host/persist.js', function () {
+    persist.then(function () {
       Promise.resolve(window.__sasjsMockReady).then(function (boot) {
         if (boot && boot.error) console.error('[mock] boot: ' + boot.error)
+        // the drive was restored from less than the whole capture: the page still runs,
+        // but every file it did not already hold will read as missing, and nothing else
+        // says so
+        if (boot && boot.driveError)
+          console.error('[mock] drive: ' + boot.driveError)
         load('host/intercept.js', function () {
           replayAll(specs, function () {})
         })

package/build/commands/build/internal/mockSite/assets/persist.js

@@ -18,6 +18,13 @@
    */
   const IDENTITY = 'identity'
   const IDENTITY_KEY = 'current'
+  /**
+   * The drive paths the visitor deleted, kept beside the identity rather than in
+   * the files store because a deleted file has no row to keep it in. A sharded
+   * site's index lists every file the build ships, so this list is what stops a
+   * deletion from being undone by the next page load.
+   */
+  const DELETED_KEY = 'deleted'
 
   const openDb = () =>
     new Promise((resolve, reject) => {
@@ -81,24 +88,70 @@
       }
     })
 
+  /** The drive paths this visitor deleted, `[]` when the store is new or unreadable. */
+  const readDeleted = async () => {
+    try {
+      const db = await openDb()
+      return await new Promise((resolve) => {
+        const req = db
+          .transaction(IDENTITY, 'readonly')
+          .objectStore(IDENTITY)
+          .get(DELETED_KEY)
+        req.onsuccess = () =>
+          resolve(Array.isArray(req.result) ? req.result : [])
+        req.onerror = () => resolve([])
+      })
+    } catch (e) {
+      return []
+    }
+  }
+
+  // no tombstones is no row: an empty list left behind would read as a stored
+  // drive that had something in it
+  const writeDeleted = (paths) =>
+    paths.length
+      ? withStore(
+          'readwrite',
+          (store) => store.put(paths, DELETED_KEY),
+          IDENTITY
+        )
+      : withStore('readwrite', (store) => store.delete(DELETED_KEY), IDENTITY)
+
   const writeFiles = async (files) => {
     const entries = Object.entries(files || {})
     if (!entries.length) return { written: 0, deleted: 0 }
     let deleted = 0
+    const removed = []
+    const written = []
     await withStore('readwrite', (store) => {
       for (const [path, contents] of entries) {
         if (contents === null || contents === undefined) {
           store.delete(path)
+          removed.push(path)
           deleted++
         } else {
           store.put(contents, path)
+          written.push(path)
         }
       }
     })
+    // the worker forgets deletions when it is terminated, so they are recorded
+    // here: a path written again is not deleted any more, and a path deleted
+    // again stays recorded
+    if (removed.length || written.length) {
+      const known = (await readDeleted()).filter(
+        (path) => !written.includes(path)
+      )
+      for (const path of removed) if (!known.includes(path)) known.push(path)
+      await writeDeleted(known)
+    }
     return { written: entries.length - deleted, deleted }
   }
 
-  const clearAll = () => withStore('readwrite', (store) => store.clear())
+  const clearAll = async () => {
+    await withStore('readwrite', (store) => store.clear())
+    await withStore('readwrite', (store) => store.delete(DELETED_KEY), IDENTITY)
+  }
 
   /**
    * The stored identity, `null` when there is none. A row whose shape is not the
@@ -334,6 +387,12 @@
         { type: 'sasjs-snapshot' },
         'sasjs-snapshot'
       )
+      // the worker answers `sasjs-snapshot` with whatever is in memory plus an
+      // `error` when it could not read the drive whole. Downloading that would
+      // hand the next build a capture with every app bundle missing and no sign
+      // of it, which is the failure "whole means whole" exists to prevent.
+      if (snapshot && snapshot.error)
+        throw new Error('The drive could not be read whole: ' + snapshot.error)
       const files = (snapshot && snapshot.files) || {}
       // the format stamp the runtime checks on load: a snapshot that outlived a
       // marker-format change is refused by name, instead of decoding as text
@@ -369,15 +428,23 @@
    * row holds the accounts the visitor created as well as the fixture, so a
    * host-side failure (a drive that could not be read) leaves it alone.
    */
-  const boot = async (files, stored) => {
-    const loading = Object.keys(files).length > 0
+  const boot = async (files, stored, deleted) => {
+    // a drive of nothing but deletions is still a drive the visitor had: seeding
+    // over it would bring back every file they removed
+    const loading =
+      Object.keys(files).length > 0 || (deleted && deleted.length > 0)
     const type = loading ? 'sasjs-load' : 'sasjs-seed'
     const ack = loading ? 'sasjs-load-ack' : 'sasjs-seed-ack'
 
+    // only when there are some: an empty list is the common case, and the worker
+    // reads an absent one as "nothing was deleted"
+    const deletions = loading && deleted.length ? deleted : undefined
+
     const answer = await askWorker(
       {
         type,
         files,
+        deleted: deletions,
         identity: stored ? stored.fixture : undefined,
         subject: stored ? stored.subject : undefined
       },
@@ -391,7 +458,7 @@
       } catch (e) {
         console.error('[sasjs-mock] could not clear the stored identity: ' + e)
       }
-      return await askWorker({ type, files }, ack)
+      return await askWorker({ type, files, deleted: deletions }, ack)
     }
 
     return answer
@@ -442,7 +509,11 @@
       stored = null
     }
 
-    window.__sasjsMockBoot = await boot(files, stored)
+    // the deletions go with the drive: a sharded site's index lists every file
+    // the build ships, so the paths this visitor removed have to be named or the
+    // page would restore them
+    const deleted = await readDeleted()
+    window.__sasjsMockBoot = await boot(files, stored, deleted)
     if (window.__sasjsMockBoot && !window.__sasjsMockBoot.error)
       keepBuildStamp(stamp)
     return window.__sasjsMockBoot