@eltjs/elt 0.3.3 → 0.3.4

package/README.md

@@ -810,6 +810,7 @@ try {
 ```
 
 - `PipelineError` is an `AggregateError`. `errors` holds each failure. `results` holds the committed `count` and `deleted` of each copy beside its `failures`, in the order of the connections, then of the copies. Each failure has its `partition`, `error` and [`failureType`](#failure-types).
+- The `message` of `PipelineError`, and the error that `passError` gives the sync history, names each distinct failure message once, with each copy and partition that failed with it. Thus a store that refuses five streams gives its remedy once: `The following copies did not load completely: calls, contacts: Turn on … Full Disk Access.; notes: The store is corrupt.`
 - A failure after rows committed, such as a checkpoint that the store could not save or a cleanup error after the publication, shows in the same way, with the committed counts. It does not mean a rollback.
 - A count of zero also covers an empty input that committed.
 - A `PipelineError` holds only failures that the sync history recorded. A pass that could not run, such as a pass whose sync history the pipeline could not write, is recorded nowhere. Thus `run()` rejects with that error itself, after each other pass ends.

package/dist/core/copy.d.ts

@@ -14,7 +14,7 @@ export type CopyOutcome<Target extends DestinationTarget> = CopyResult<Target> &
     readonly failures: readonly LoadFailure[];
     readonly cancelled: boolean;
 };
-export declare function describeFailures<Target extends DestinationTarget>({ copy, failures, }: CopyOutcome<Target>): string;
+export declare function describeFailures<Target extends DestinationTarget>(outcomes: readonly CopyOutcome<Target>[]): string;
 export declare class Copy<Target extends DestinationTarget> {
     readonly configuration: CopyConfiguration;
     readonly to: Target;

package/dist/core/copy.js

@@ -2,10 +2,18 @@ import { errorMessage } from '../state/sync-history.js';
 import { CopyConfiguration } from './copy-configuration.js';
 import { FileTransfer } from './file-transfer.js';
 import { Target as DestinationTarget } from './target.js';
-export function describeFailures({ copy, failures, }) {
-    return failures
-        .map(({ partition, error }) => `${copy.id ?? copy.from.name}${partition === null ? '' : ` ${JSON.stringify(partition)}`}: ${errorMessage(error)}`)
-        .join('; ');
+// What did not load, naming each distinct failure message once with every
+// copy and partition it failed, in order of first appearance, as a log
+// aggregator folds repeated lines: a store that refuses five streams gives
+// its remedy once.
+export function describeFailures(outcomes) {
+    const failed = new Map();
+    for (const { copy, failures } of outcomes)
+        for (const { partition, error } of failures)
+            failed
+                .getOrInsertComputed(errorMessage(error), () => [])
+                .push(`${copy.id ?? copy.from.name}${partition === null ? '' : ` ${JSON.stringify(partition)}`}`);
+    return `The following copies did not load completely: ${Array.from(failed, ([message, copies]) => `${copies.join(', ')}: ${message}`).join('; ')}`;
 }
 // One configured transfer from a source stream to a destination declaration.
 export class Copy {

package/dist/core/pipeline.js

@@ -33,9 +33,8 @@ export class PipelineError extends AggregateError {
     name = 'PipelineError';
     results;
     constructor(results) {
-        const incomplete = results.filter(({ failures }) => failures.length > 0);
-        const errors = incomplete.flatMap(({ failures }) => failures.map(({ error }) => error));
-        super(errors, `The following copies did not load completely: ${incomplete.map(describeFailures).join('; ')}`, { cause: errors[0] });
+        const errors = results.flatMap(({ failures }) => failures.map(({ error }) => error));
+        super(errors, describeFailures(results), { cause: errors[0] });
         this.results = Object.freeze([...results]);
     }
 }

package/dist/state/sync-history.js

@@ -73,8 +73,7 @@ export function passFailureType(outcomes) {
 }
 // What did not load in a pass, or null when every copy loaded completely.
 export function passError(outcomes) {
-    const incomplete = outcomes.filter(({ failures }) => failures.length > 0);
-    if (incomplete.length === 0)
-        return null;
-    return `The following copies did not load completely: ${incomplete.map(describeFailures).join('; ')}`;
+    return outcomes.some(({ failures }) => failures.length > 0)
+        ? describeFailures(outcomes)
+        : null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eltjs/elt",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "A pipeline that copies the data of apps and services into stores that SQL can read: sources, streams, checkpoints, watches and derived datasets.",
   "license": "Apache-2.0",
   "repository": {