@larc-iu/plaid-client 0.2.0-alpha.20 → 0.2.0-alpha.22

package/src/serviceSchema.js

@@ -16,7 +16,7 @@
  *
  *   {
  *     schemaVersion: 1,
- *     tasks: ["tokenize"],              // controlled vocab; REPLACES tok:/asr: id prefixes
+ *     tasks: ["tokenize"],              // controlled vocab (TASKS)
  *     summary: "## markdown …",         // rich human description
  *     parameters: [                     // ordered; rendered into a form
  *       { key, label, type, description?, default?, required?,
@@ -63,8 +63,8 @@ export const TASKS = Object.freeze({
    *
    * Apart from `analyze` on purpose. A task is the CONTRACT a spot offers a
    * service against, and these two share almost none of it: an analyze
-   * request names the three token layers plus the language, metalanguage and
-   * orthography, and writes morphemes and glosses. Both claimed `analyze` for
+   * request names the three token layers plus the language and metalanguage,
+   * and writes morphemes and glosses. Both claimed `analyze` for
    * a while, so every app offering an analyze spot offered the other app's
    * services, which could not answer the request they would have been given.
    */
@@ -93,32 +93,14 @@ export const TASKS = Object.freeze({
 });
 
 /**
- * Legacy id-prefix → task map, for services that have not yet migrated to a
- * declared `tasks` array. Drop once all services advertise `tasks`.
- */
-const LEGACY_TASK_PREFIXES = Object.freeze({
-  [TASKS.TOKENIZE]: "tok:",
-  [TASKS.TRANSCRIBE]: "asr:",
-});
-
-/**
- * Does `service` serve `task`? Prefers the declared `extras.tasks` array; falls
- * back to the legacy id-prefix convention for un-migrated services.
+ * Does `service` serve `task`, as its declared `extras.tasks` says?
  * @param {{serviceId?: string, extras?: {tasks?: string[]}}} service
  * @param {string} task one of TASKS
  * @returns {boolean}
  */
 export function servesTask(service, task) {
   const declared = service?.extras?.tasks;
-  if (Array.isArray(declared) && declared.length) {
-    return declared.includes(task);
-  }
-  const prefix = LEGACY_TASK_PREFIXES[task];
-  return (
-    !!prefix &&
-    typeof service?.serviceId === "string" &&
-    service.serviceId.startsWith(prefix)
-  );
+  return Array.isArray(declared) && declared.includes(task);
 }
 
 /**

package/src/services.js

@@ -434,14 +434,18 @@ export function serve(client, projectId, serviceInfo, onServiceRequest, extras =
  * you already made rejoins it instead of starting another.
  *
  * Errors that leave the request alive carry `pending: true`: a timeout, a
- * stop, a dropped connection. An error without it is the end of the request.
+ * stop, a dropped connection, a proxy's 502 or 504. An error without it is
+ * the end of the request. With `opts.requestId`, a request whose answer went
+ * missing (a dropped connection, a 502 or 504) is rejoined by that id a few
+ * times before the error is given.
  *
  * @param {Object} client - PlaidClient instance
  * @param {string} projectId - Project UUID
  * @param {string} serviceId - Service ID to request
  * @param {any} data - Request payload
  * @param {number} [timeout=10000] - How long the service may say NOTHING, in ms.
- *   Every event it sends starts the clock again, so this does not cap a long run
+ *   Every event it sends starts the clock again, so this does not cap a long run.
+ *   0, a negative number or null: no limit (wait until `signal` stops it)
  * @param {function} [onProgress] - Called with each progress payload {percent, message}
  * @param {AbortSignal} [signal] - Abort to stop waiting; rejects with an AbortError
  * @param {Object} [opts]
@@ -485,14 +489,21 @@ export function requestService(client, projectId, serviceId, data, timeout = 100
   if (opts.requestId) query.set('request-id', opts.requestId);
   if (opts.projectIds?.length) query.set('project-ids', opts.projectIds.join(','));
   const qs = String(query) ? `?${query}` : '';
-  return streamServiceRequest(
+  const submit = () => streamServiceRequest(
     client,
     {
       url: `${client.baseUrl}/api/v1/projects/${projectId}/services/${encodeURIComponent(serviceId)}/requests${qs}`,
       method: 'POST',
       body: JSON.stringify(payload === undefined ? null : transformRequest(payload)),
+      // `notLive` (with `serviceId`) lets an app say it in the service's own
+      // name rather than its id.
       onStatus: (response) =>
-        response.status === 503 ? new Error(`No live service '${serviceId}' on this project`) : null,
+        response.status === 503
+          ? Object.assign(new Error(`No live service '${serviceId}' on this project`), {
+              notLive: true,
+              serviceId,
+            })
+          : null,
       what: 'Service request',
     },
     timeout,
@@ -500,6 +511,14 @@ export function requestService(client, projectId, serviceId, data, timeout = 100
     signal,
     opts.onAccepted,
   );
+  // A request whose id is known is rejoined when its answer goes missing, so
+  // a run the service took and finished is not reported failed.
+  if (!opts.requestId) return submit();
+  return rejoinLost(
+    submit,
+    () => attachServiceRequest(client, projectId, opts.requestId, timeout, onProgress, signal),
+    signal,
+  );
 }
 
 /**
@@ -515,6 +534,7 @@ export function requestService(client, projectId, serviceId, data, timeout = 100
  * @param {string} projectId - Project UUID
  * @param {string} requestId - The request id (from `onAccepted` or your own)
  * @param {number} [timeout=10000] - How long the service may say NOTHING, in ms
+ *   (0, a negative number or null: no limit)
  * @param {function} [onProgress] - Called with each progress payload {percent, message}
  * @param {AbortSignal} [signal] - Abort to stop waiting; rejects with an AbortError
  * @returns {Promise<any>} The service's result
@@ -612,6 +632,62 @@ export function cancelServiceRequest(client, projectId, requestId) {
  */
 const stillRunning = (err) => Object.assign(err, { pending: true });
 
+/**
+ * A still-running error whose cause is that the ANSWER went missing: the
+ * request could not be sent or read to its end, or a proxy answered for the
+ * server (502, 504). Not a timeout or a stop, which are the caller's own
+ * choice to stop waiting. A submit whose answer was lost rejoins its request
+ * (`rejoinLost`).
+ */
+const lostAnswer = (err) => Object.assign(stillRunning(err), { lostAnswer: true });
+
+/** How long to wait before each attempt to rejoin a request whose answer was lost. */
+const REJOIN_DELAYS_MS = [1000, 3000, 9000];
+
+const delay = (ms, signal) =>
+  new Promise((resolve) => {
+    if (signal?.aborted) return resolve();
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true },
+    );
+  });
+
+/**
+ * `submit()` again, by attaching to the request `requestId` names, while its
+ * answer is the one that went missing. The request was taken, or never
+ * reached the server: attaching follows a taken one to its end, and a 404
+ * says the server never had it, so the first error stands. Each attempt
+ * whose answer goes missing too waits a little longer before the next.
+ */
+async function rejoinLost(submit, attach, signal) {
+  let first;
+  try {
+    return await submit();
+  } catch (err) {
+    if (!err?.lostAnswer) throw err;
+    first = err;
+  }
+  let last = first;
+  for (const ms of REJOIN_DELAYS_MS) {
+    await delay(ms, signal);
+    if (signal?.aborted) throw last;
+    try {
+      return await attach();
+    } catch (err) {
+      if (err?.status === 404) throw first;
+      if (!err?.lostAnswer) throw err;
+      last = err;
+    }
+  }
+  throw last;
+}
+
 /**
  * Open a request stream (submit or attach) and read it to its terminal
  * event: `accepted` names the request, `progress` events go to `onProgress`,
@@ -635,9 +711,11 @@ function streamServiceRequest(client, { url, method, body, onStatus, what }, tim
     // deadline on the whole run it killed working transcriptions at the
     // five-minute default and left their writes to land on a document the page
     // had already handed back to the user as editable.
+    // 0, a negative number or null is no limit, as for every other timeout.
     let timer;
     const waitAgain = () => {
       clearTimeout(timer);
+      if (!(timeout > 0)) return;
       timer = setTimeout(
         () =>
           finish(reject, stillRunning(new Error(`${what} timed out after ${timeout}ms of silence`))),
@@ -679,7 +757,7 @@ function streamServiceRequest(client, { url, method, body, onStatus, what }, tim
       } catch (error) {
         // The POST may or may not have reached the server. Treat it as alive:
         // rejoining a request that was never made simply 404s.
-        if (error.name !== 'AbortError') finish(reject, stillRunning(new Error(`${what} could not be sent: ${error.message}`)));
+        if (error.name !== 'AbortError') finish(reject, lostAnswer(new Error(`${what} could not be sent: ${error.message}`)));
         return;
       }
 
@@ -691,7 +769,9 @@ function streamServiceRequest(client, { url, method, body, onStatus, what }, tim
       if (!response.ok) {
         const err = new Error(`${what} failed: HTTP ${response.status} ${response.statusText}`);
         err.status = response.status;
-        finish(reject, err);
+        // A proxy's 502 or 504 is no answer from the server: the request may
+        // have been taken, and the service may be running it.
+        finish(reject, response.status === 502 || response.status === 504 ? lostAnswer(err) : err);
         return;
       }
 
@@ -733,9 +813,9 @@ function streamServiceRequest(client, { url, method, body, onStatus, what }, tim
             }
           }
         }
-        finish(reject, stillRunning(new Error('Service closed the connection without a result')));
+        finish(reject, lostAnswer(new Error('Service closed the connection without a result')));
       } catch (error) {
-        if (error.name !== 'AbortError') finish(reject, stillRunning(new Error(`${what} stream error: ${error.message}`)));
+        if (error.name !== 'AbortError') finish(reject, lostAnswer(new Error(`${what} stream error: ${error.message}`)));
       }
     })();
   });

package/src/textEdits.js

@@ -20,6 +20,22 @@
 
 const codePoints = (s) => [...s];
 
+// The last body split into code points, kept: an edit log composes the same
+// long body once for each of its kept states, and splitting it each time made
+// a save on a long text block the page (H31-TEXT-1). Frozen, as every caller
+// shares it.
+let lastBody = null;
+let lastPoints = Object.freeze([]);
+
+/** The code points of `body`, as a frozen array shared with other callers. */
+export function bodyCodePoints(body) {
+  if (body !== lastBody) {
+    lastPoints = Object.freeze(codePoints(body));
+    lastBody = body;
+  }
+  return lastPoints;
+}
+
 function opName(op) {
   return JSON.stringify(op);
 }
@@ -98,7 +114,7 @@ function cutAt(segs, at) {
  * malformed or out-of-bounds op.
  */
 export function composeTextEdits(body, ops) {
-  const old = codePoints(body);
+  const old = bodyCodePoints(body);
   let segs = old.length ? [{ old: true, start: 0, end: old.length }] : [];
   let len = old.length;
   for (const op of ops) {
@@ -128,7 +144,7 @@ export function composeTextEdits(body, ops) {
       close(seg.start);
       kept = seg.end;
     } else {
-      typed.push(...seg.chars);
+      for (const c of seg.chars) typed.push(c);
     }
   }
   close(old.length);