@winkjs/composer 0.6.0 → 0.8.0

package/src/flow/run.js

@@ -272,6 +272,21 @@ export const runFlow = async function ( flowName, specsOrSpecsByCase, importSet,
         }
     }; // runDrainStage()
 
+    // A sink stage returns `Promise.allSettled` results. The wiring
+    // logs each adapter whose drain rejected and lets its siblings
+    // finish, so one failing sink never strands another's data. The
+    // loss must still reach this handle's caller. A rejected drain is
+    // how the shutdown manager knows to exit 1 (ADR-018 §7). So once
+    // every adapter in the stage has drained, the stage throws the
+    // first rejected reason, code and dropped count intact.
+    const throwFirstRejection = function ( results ) {
+        for ( let i = 0; i < results.length; i += 1 ) {
+            if ( results[ i ].status === 'rejected' ) {
+                throw results[ i ].reason;
+            }
+        }
+    }; // throwFirstRejection()
+
     const drainAll = async function () {
         const stageErrors = [];
         try {
@@ -281,9 +296,9 @@ export const runFlow = async function ( flowName, specsOrSpecsByCase, importSet,
                     () => stopSource( { timeout: STAGE_TIMEOUT_MS } ) );
             }
             await runDrainStage( 'emitter', stageErrors,
-                () => emitters.shutdown( { timeout: STAGE_TIMEOUT_MS } ) );
+                async () => throwFirstRejection( await emitters.shutdown( { timeout: STAGE_TIMEOUT_MS } ) ) );
             await runDrainStage( 'storage', stageErrors,
-                () => storages.shutdown( { timeout: STAGE_TIMEOUT_MS } ) );
+                async () => throwFirstRejection( await storages.shutdown( { timeout: STAGE_TIMEOUT_MS } ) ) );
         } finally {
             // Whatever the path here — clean drain or a stage that threw —
             // the source has stopped producing, so unblock any
@@ -311,8 +326,15 @@ export const runFlow = async function ( flowName, specsOrSpecsByCase, importSet,
     // the process as unhandled. The classified log keeps the loss
     // loud without the crash, and a caller that later awaits
     // `handle.shutdown()` still receives the memoized rejection.
+    //
+    // The exit code carries the loss too. This drain has no awaiting
+    // caller, and the flow left the shutdown manager's list when the
+    // drain began, so no other path can set it. A batch script that
+    // replays a file and loses rows at the end must exit 1, the same
+    // as the signal path does (ADR-018 §7).
     const observedShutdown = function () {
         shutdown().catch( function ( err ) {
+            process.exitCode = 1;
             logger.error(
                 `winkComposer/flow '${flowName}': shutdown failed ` +
                 `[${( err && err.code ) || 'UNKNOWN'}]: ${( err && err.message ) || String( err )}`