@entrinsik/vite-plugin-informer 2.11.0 → 2.13.0

package/src/streams-client.js

@@ -1,6 +1,8 @@
 /**
  * Dev copy of the injected app streams client (I5-12979):
- * `__INFORMER__.upload(file, opts)` and `__INFORMER__.downloadUrl(id, filename)`.
+ * `__INFORMER__.upload(file, opts)`, `__INFORMER__.downloadUrl(id, filename)` and
+ * `__INFORMER__.streams` (I5-13030: status / list / discard, plus upload()'s onEvent
+ * and task.created).
  *
  * VERBATIM copy of modules/app/routes/lib/html-utils.js#generateStreamsHelper
  * in its origin-mode form (base "", plain window.fetch / XHR transport — the
@@ -11,7 +13,7 @@
  * that test says exactly what to paste here. The dev page must upload the way
  * a deployed one does.
  *
- * @returns {string} JavaScript expression evaluating to { upload, downloadUrl }
+ * @returns {string} JavaScript expression evaluating to { upload, downloadUrl, streams }
  */
 export function streamsClientSource() {
     return `(function (base, transport) {
@@ -80,6 +82,24 @@ export function streamsClientSource() {
             return [opts.filename || file.name || '', file.size, file.lastModified || 0].join(':');
         }
 
+        // The transfer's event stream for the page (I5-13030): what the helper
+        // already knows at each step, handed out rather than inferred from a
+        // percentage. A listener's own throw must not fail the transfer it is
+        // watching, so it is rethrown on a fresh tick — still reaching
+        // window.onerror and the console, but not the chunk promise chain.
+        function notify (opts, event) {
+            if (typeof opts.onEvent !== 'function') return;
+            try {
+                opts.onEvent(event);
+            } catch (err) {
+                // Say so where it happened: the deferred rethrow below reaches
+                // window.onerror and nothing else, by which point the event it
+                // came from is long gone.
+                try { console.error('[informer] upload onEvent listener threw for ' + event.type + '; the transfer continues', err); } catch (e) {}
+                setTimeout(function () { throw err; }, 0);
+            }
+        }
+
         function upload (file, opts) {
             opts = opts || {};
             if (!file || typeof file.slice !== 'function' || typeof file.size !== 'number') {
@@ -97,6 +117,20 @@ export function streamsClientSource() {
             var task = { id: opts.resume || null, abort: function () { controller.abort(); } };
             var loaded = {};
 
+            // Settles with the upload's geometry the moment the store has reserved
+            // it — before a chunk moves — or with the create-time refusal (a 413
+            // over the cap, a resume that does not match). Nobody has to await
+            // it: a create failure still surfaces on the task itself.
+            var settleCreated;
+            var createdSettled = false;
+            task.created = new Promise(function (resolve, reject) {
+                // failed is its own argument rather than inferred from err:
+                // code that throws a falsy value would otherwise settle this
+                // as a resolve(undefined) — a failure read as success.
+                settleCreated = function (failed, err, value) { createdSettled = true; if (failed) reject(err); else resolve(value); };
+            });
+            task.created.catch(function () {});
+
             function progress () {
                 if (typeof opts.onProgress !== 'function') return;
                 var sum = 0;
@@ -105,16 +139,24 @@ export function streamsClientSource() {
             }
             function abortError () { var err = new Error('Upload aborted'); err.code = 'aborted'; return err; }
 
+            // 'attempt' is 1-based in events: the first try is attempt 1, and a
+            // 'retry' names the attempt that just failed.
             function sendChunk (meta, n, attempt) {
                 if (signal.aborted) return Promise.reject(abortError());
                 var start = (n - 1) * meta.chunkSize;
                 var blob = file.slice(start, Math.min(file.size, start + meta.chunkSize));
+                notify(opts, { type: 'chunk', n: n, state: 'sent', attempt: attempt + 1 });
                 return putChunk(base + '/_uploads/' + meta.id + '/' + n, blob, signal, function (sent) { loaded[n] = sent; progress(); })
-                    .then(function () { loaded[n] = blob.size; progress(); })
+                    .then(function () {
+                        loaded[n] = blob.size;
+                        progress();
+                        notify(opts, { type: 'chunk', n: n, state: 'landed', attempt: attempt + 1 });
+                    })
                     .catch(function (err) {
                         if (err.code === 'aborted' || signal.aborted) throw err;
                         if (err.status === 404) { var gone = new Error('Upload expired before it completed'); gone.code = 'upload_expired'; gone.status = 404; throw gone; }
                         if (!retryable(err.status) || attempt >= retries) throw err;
+                        notify(opts, { type: 'chunk', n: n, state: 'retry', attempt: attempt + 1, status: err.status });
                         return delay(backoff(attempt)).then(function () { return sendChunk(meta, n, attempt + 1); });
                     });
             }
@@ -131,6 +173,24 @@ export function streamsClientSource() {
                 return Promise.all(workers);
             }
 
+            // Seal. A 412 means the store is missing chunks a PUT reported as
+            // landed (a proxy that answered before the bytes were durable, an
+            // expiry racing the last write): send exactly those once more and
+            // seal again. The server names at most 50 (app-streams.js
+            // completeUpload), so a gap wider than that cannot be closed this
+            // way — a second 412 is a failure the caller resumes from.
+            function seal (meta, resent) {
+                return json('POST', base + '/_uploads/' + meta.id + '/_complete').catch(function (err) {
+                    var missing = err.status === 412 && err.data && err.data.missing;
+                    if (resent || !missing || !missing.length) throw err;
+                    for (var i = 0; i < missing.length; i++) notify(opts, { type: 'chunk', n: missing[i], state: 'resend' });
+                    return sendAll(meta, missing).then(function () {
+                        if (signal.aborted) throw abortError();
+                        return seal(meta, true);
+                    });
+                });
+            }
+
             var plan = signal.aborted ? Promise.reject(abortError()) : opts.resume
                 ? json('GET', base + '/_uploads/' + encodeURIComponent(opts.resume)).then(function (meta) {
                     // Size alone is not identity: two same-length files would be
@@ -159,26 +219,45 @@ export function streamsClientSource() {
             var promise = plan
                 .then(function (p) {
                     task.id = p.meta.id;
+                    var created = {
+                        id: p.meta.id,
+                        size: p.meta.size,
+                        chunks: p.meta.chunks,
+                        chunkSize: p.meta.chunkSize,
+                        resumed: !!opts.resume,
+                        // Chunks a resumed upload already holds; empty for a new one.
+                        received: opts.resume ? (p.meta.received || []) : []
+                    };
+                    settleCreated(false, null, created);
+                    notify(opts, { type: 'created', id: created.id, size: created.size, chunks: created.chunks, chunkSize: created.chunkSize, resumed: created.resumed, received: created.received });
                     progress();
                     return sendAll(p.meta, p.chunks).then(function () {
                         if (signal.aborted) throw abortError();
-                        return json('POST', base + '/_uploads/' + p.meta.id + '/_complete');
+                        return seal(p.meta, false);
                     });
                 })
-                .then(function (handle) { progress(); return handle; })
+                .then(function (handle) {
+                    progress();
+                    notify(opts, { type: 'sealed', handle: handle });
+                    return handle;
+                })
                 .catch(function (err) {
                     var aborted = err.code === 'aborted' || signal.aborted;
                     // Promise.all rejects on the first failure but leaves the other
                     // workers retrying with backoff; stop them before returning.
                     controller.abort();
+                    if (!createdSettled) settleCreated(true, err);
                     if (task.id) {
                         // Discard only on an explicit abort — the caller is done
                         // with it. Any other failure keeps the staged chunks so
                         // upload({ resume: err.uploadId }) can finish the job; the
-                        // TTL reclaims them if it never does.
+                        // TTL reclaims them if it never does. An expired upload is
+                        // the exception: the server already reclaimed it, so
+                        // offering a resume would send the page into a 404 loop.
                         if (aborted) transport.fetch(base + '/_uploads/' + task.id, { method: 'DELETE', credentials: 'same-origin' }).catch(function () {});
-                        else err.uploadId = task.id;
+                        else if (err.code !== 'upload_expired') err.uploadId = task.id;
                     }
+                    notify(opts, { type: 'failed', error: err, aborted: aborted, resumable: !!err.uploadId });
                     throw err;
                 });
 
@@ -192,7 +271,41 @@ export function streamsClientSource() {
             return base + '/_downloads/' + encodeURIComponent(id) + (filename ? '/' + encodeURIComponent(filename) : '');
         }
 
-        return { upload: upload, downloadUrl: downloadUrl };
+        // What the store holds for this user in this app (I5-13030). The helper
+        // owns the base URL, so these are the sanctioned way to ask — a page
+        // must not derive the prefix from downloadUrl() and hand-build the calls.
+        var streams = {
+            // Resume state for an upload there is no task for: which chunks
+            // landed, which are missing, whether it is sealed.
+            status: function (id) {
+                return json('GET', base + '/_uploads/' + encodeURIComponent(id));
+            },
+            // Every upload and download this user has staged for the app,
+            // oldest first. What a truthful "n of maxStreamsPerUser" reads.
+            list: function () {
+                return Promise.all([json('GET', base + '/_uploads'), json('GET', base + '/_downloads')])
+                    .then(function (r) {
+                        // A truthy non-array (an auth-bounce page body) would
+                        // otherwise pass through as an empty-looking listing.
+                        if (!Array.isArray(r[0]) || !Array.isArray(r[1])) {
+                            throw new Error('streams.list(): the staging routes did not answer with listings');
+                        }
+                        return { uploads: r[0], downloads: r[1] };
+                    });
+            },
+            // Free a staged stream now rather than at expiry. Takes a handle or
+            // a bare id; a handle already carries its kind, so only a bare id
+            // needs the second argument (which still defaults to 'upload').
+            discard: function (idOrHandle, type) {
+                var handle = idOrHandle && typeof idOrHandle === 'object' ? idOrHandle : null;
+                var id = handle ? handle.id : idOrHandle;
+                var kind = type || (handle && handle.__appStream) || 'upload';
+                var prefix = kind === 'download' ? '/_downloads/' : '/_uploads/';
+                return json('DELETE', base + prefix + encodeURIComponent(id)).then(function () { return true; });
+            }
+        };
+
+        return { upload: upload, downloadUrl: downloadUrl, streams: streams };
     })("", {
             fetch: function (url, opts) { return window.fetch(url, opts); },
             open: function (xhr, method, url) { xhr.open(method, url); }