@entrinsik/vite-plugin-informer 2.11.0 → 2.12.0

package/src/index.js

@@ -39,6 +39,36 @@ function buildMock(options) {
     };
 }
 
+/**
+ * The app id dev surfaces address on the server (the opt-in dev `embed()`
+ * posts to its `_embed` route). `informer-init` generates it locally into
+ * package.json `informer.id` and the first deploy creates the app under it.
+ * Absent, the surface says so at call time rather than the dev server
+ * refusing to start.
+ */
+function readAppId(projectRoot) {
+    const pkgPath = resolve(projectRoot, 'package.json');
+    let raw;
+    try {
+        raw = readFileSync(pkgPath, 'utf8');
+    } catch (err) {
+        // Unreadable is not the same as "no id set", and the two want
+        // different fixes. Saying which one it is beats telling someone to
+        // set a field in a file they are already looking at — or that the
+        // dev server never found.
+        if (err.code !== 'ENOENT') console.warn(`[informer] Could not read ${pkgPath}: ${err.message}`);
+        else console.warn(`[informer] No package.json at ${pkgPath}; dev surfaces that address the deployed app are unavailable.`);
+        return null;
+    }
+    try {
+        const pkg = JSON.parse(raw);
+        return (pkg.informer && pkg.informer.id) || null;
+    } catch (err) {
+        console.warn(`[informer] Could not parse ${pkgPath}: ${err.message}`);
+        return null;
+    }
+}
+
 /**
  * Occupied-spot check for the dev /api mount: does informer.yaml's
  * access.apis declare this method+path? Mirrors the server's matchWhitelist
@@ -103,8 +133,10 @@ async function writeAppDepTypes (projectRoot, dts) {
  * - Sets base to './' so built assets use relative paths
  *
  * @param {Object} [options]
- * @param {{ report?: object, theme?: 'light'|'dark', roles?: string[] }} [options.mock]
- *   window.__INFORMER__ mock injected in dev.
+ * @param {{ report?: object, theme?: 'light'|'dark', roles?: string[], user?: object, platform?: object }} [options.mock]
+ *   window.__INFORMER__ mock injected in dev. `platform` merges into the dev
+ *   descriptor, so `{ capabilities: { embeddings: true } }` opts one capability
+ *   in and leaves the rest. See InformerPluginOptions in index.d.ts.
  * @param {Object} [options.devBindings] - dev bindings for `target: app` and
  *   `target: pack` deps. App slots can't be defaultBound in the manifest; pack
  *   slots resolve their marketplace pin via installs dev doesn't have, so the
@@ -181,6 +213,15 @@ export default function informer(options = {}) {
             const projectRoot = process.cwd();
             const migrationsDir = resolve(projectRoot, 'migrations');
 
+            // One merged descriptor for the whole dev server. Built once
+            // rather than per consumer so "the channel hub, the handler bags
+            // and the browser all see the same mock" is structural — which is
+            // the property the embeddings opt-in depends on, since the flag
+            // the app reads and the flag that binds embed() must be the same
+            // flag. (transformIndexHtml is a separate hook and builds its own.)
+            const mock = buildMock(options);
+            const appId = readAppId(projectRoot);
+
             // One API client for the whole dev-server setup — createClient just
             // builds an auth header (no I/O), so it's hoisted out of the two
             // branches that each used to rebuild an identical one.
@@ -279,7 +320,7 @@ export default function informer(options = {}) {
             // Every page receives every frame; the subscribe loop mounted below
             // (join / joined / leave / send against channels/ files) is what
             // tells a page which channels it may dispatch.
-            const channels = createDevChannels({ appId: buildMock(options).report.id });
+            const channels = createDevChannels({ appId: mock.report.id });
             channels.emitter.on(BROADCAST_EVENT, (frame) => {
                 server.ws.send({ type: 'custom', event: DEV_CHANNEL_EVENT, data: frame });
             });
@@ -291,8 +332,10 @@ export default function informer(options = {}) {
                 devBindings: options.devBindings || {},
                 appToken,
                 channels,
-                user: buildMock(options).user,
-                roles: (options.mock && options.mock.roles) || []
+                user: mock.user,
+                roles: (options.mock && options.mock.roles) || [],
+                platform: mock.platform,
+                appId
             }));
 
             // Generate .d.ts types for bound `target: app` / `target: pack`
@@ -368,6 +411,11 @@ export default function informer(options = {}) {
             server.middlewares.use('/_uploads', createUploadsMiddleware(streamStore));
             server.middlewares.use('/_downloads', createDownloadsMiddleware(streamStore));
 
+            // The merged platform descriptor (dev defaults + mock.platform) is
+            // what the handler bags see too, not only the browser: an app that
+            // opts into `embeddings` there must find embed() bound, not throwing.
+            const platform = mock.platform;
+
             // Mount server-side route handlers if a server/ directory exists
             const serverDir = resolve(projectRoot, 'server');
 
@@ -378,7 +426,7 @@ export default function informer(options = {}) {
                     devWorkspaceId,
                     projectRoot,
                     roles: (options.mock && options.mock.roles) || [],
-                    user: buildMock(options).user,
+                    user: mock.user,
                     // Dev-only bindings for `target: app` / `target: pack`
                     // slots (app: overrides the manifest defaultBinding; pack:
                     // names the locally-installed pack app). Shape:
@@ -386,7 +434,9 @@ export default function informer(options = {}) {
                     devBindings: options.devBindings || {},
                     appToken,
                     channels,
-                    streamStore
+                    streamStore,
+                    platform,
+                    appId
                 });
                 server.middlewares.use('/api/_server', serverRoutes);
                 // Occupied-spot precedence (App API v2, matches production
@@ -418,7 +468,9 @@ export default function informer(options = {}) {
                     projectRoot,
                     devBindings: options.devBindings || {},
                     appToken,
-                    channels
+                    channels,
+                    platform,
+                    appId
                 });
                 server.middlewares.use('/api/_agent', agentDev);
             }
@@ -446,6 +498,7 @@ export default function informer(options = {}) {
     var __streams = ${streamsClientSource()};
     window.__INFORMER__.upload = __streams.upload;
     window.__INFORMER__.downloadUrl = __streams.downloadUrl;
+    window.__INFORMER__.streams = __streams.streams;
 })();
 </script>
 ${renderDevChannelScript({ hub: Boolean(serverOrigin) })}`;

package/src/server-routes.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { parse as parseUrl } from 'node:url';
 import { createDevBagBuilder, buildDevUser } from './dev-bag.js';
 import { createDevChannels } from './dev-channels.js';
+import { devPlatform } from './dev-platform.js';
 import { createStreamStore, createStreamServices, isStreamRef, serveDownload as serveDevDownload } from './dev-streams.js';
 
 const VALID_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
@@ -224,13 +225,13 @@ function isDescriptor(value) {
  *   and /_downloads middleware (createStreamStore()); a private one when omitted
  * @returns {Function} Connect middleware
  */
-export function createMiddleware(viteServer, { serverOrigin, authHeader, devWorkspaceId, projectRoot, roles, user, devBindings, appToken, channels = createDevChannels(), streamStore }) {
+export function createMiddleware(viteServer, { serverOrigin, authHeader, devWorkspaceId, projectRoot, roles, user, devBindings, appToken, channels = createDevChannels(), streamStore, platform = devPlatform(), appId = null }) {
     // `@user/${request.user.username}` on the server names the channel the
     // page subscribes to.
     const devUser = buildDevUser(user);
     const serverDir = join(projectRoot, 'server');
     const streams = streamStore || createStreamStore();
-    const bagBuilder = createDevBagBuilder({ serverOrigin, authHeader, devWorkspaceId, projectRoot, devBindings, appToken, channels, logPrefix: '[app]' });
+    const bagBuilder = createDevBagBuilder({ serverOrigin, authHeader, devWorkspaceId, projectRoot, devBindings, appToken, channels, logPrefix: '[app]', platform, appId });
     const { query } = bagBuilder;
 
     return async function serverRoutesMiddleware(req, res, next) {
@@ -333,7 +334,7 @@ export function createMiddleware(viteServer, { serverOrigin, authHeader, devWork
                 res.end(JSON.stringify(earlyBody));
             }
 
-            const { bag } = await bagBuilder.build();
+            const { bag } = await bagBuilder.build({ forwarding: streamServices.forwarding });
 
             // Call handler — bag mirrors the prod sandbox (see app-sandbox.js).
             const result = await handler({ ...bag, request, query: streamQuery, respond, uploads: streamServices.uploads, downloads: streamServices.downloads });

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); }