@@ -487,6 +487,12 @@ const makeTurnHarness = (
487487 readonly runs ?: ReadonlyArray < OrchestrationV2Run > ;
488488 /** How many times the event stream fails before it starts to deliver events. */
489489 readonly streamFailures ?: number ;
490+ /** Makes the stream a live tail: events from before it was opened are not delivered. */
491+ readonly liveTail ?: boolean ;
492+ /** Runs when the projection's runs are read, so an event can land mid catch-up. */
493+ readonly duringRunsRead ?: (
494+ events : Queue . Queue < OrchestrationV2DomainEvent > ,
495+ ) => Effect . Effect < void > ;
490496 } = { } ,
491497) =>
492498 Effect . gen ( function * ( ) {
@@ -503,22 +509,27 @@ const makeTurnHarness = (
503509 Effect . andThen ( options . duringDispatch ?.( events , input . messageId ) ?? Effect . void ) ,
504510 Effect . as ( undefined as never ) ,
505511 ) ,
506- getThreadRecords : ( _threadId , _fields , filter ) =>
507- Effect . succeed ( {
508- messages : ( filter ?. messageIds ?? [ ] ) . map ( ( id ) => ( {
509- id,
510- runId : options . messageRunId ?? null ,
511- } ) ) ,
512- runs : ( options . runs ?? [ ] ) . filter (
513- ( run ) => filter ?. runIds === undefined || filter . runIds . includes ( run . id ) ,
514- ) ,
515- } as never ) ,
512+ getThreadRecords : ( _threadId , fields : ReadonlyArray < string > , filter ) =>
513+ Effect . gen ( function * ( ) {
514+ if ( fields . includes ( "runs" ) ) yield * options . duringRunsRead ?.( events ) ?? Effect . void ;
515+ return {
516+ messages : ( filter ?. messageIds ?? [ ] ) . map ( ( id ) => ( {
517+ id,
518+ runId : options . messageRunId ?? null ,
519+ } ) ) ,
520+ runs : ( options . runs ?? [ ] ) . filter (
521+ ( run ) => filter ?. runIds === undefined || filter . runIds . includes ( run . id ) ,
522+ ) ,
523+ } as never ;
524+ } ) ,
516525 streamDomainEvents : Stream . unwrap (
517526 Ref . getAndUpdate ( subscriptions , ( n ) => n + 1 ) . pipe (
518- Effect . map ( ( attempt ) =>
527+ Effect . flatMap ( ( attempt ) =>
519528 attempt < ( options . streamFailures ?? 0 )
520- ? Stream . fail ( new Error ( "event stream dropped" ) as never )
521- : Stream . fromQueue ( events ) ,
529+ ? Effect . succeed ( Stream . fail ( new Error ( "event stream dropped" ) as never ) )
530+ : ( options . liveTail ? Queue . clear ( events ) : Effect . void ) . pipe (
531+ Effect . as ( Stream . fromQueue ( events ) ) ,
532+ ) ,
522533 ) ,
523534 ) ,
524535 ) ,
@@ -754,17 +765,74 @@ it.effect("a dropped event stream is resumed, and runs that ended meanwhile are
754765 } ) . pipe ( Effect . provide ( SqlitePersistence . layerMemory ) ) ,
755766) ;
756767
757- it . effect ( "runs are released as failed once the event stream cannot be resumed" , ( ) =>
768+ it . effect ( "the event stream keeps being resumed after many failures " , ( ) =>
758769 Effect . gen ( function * ( ) {
759- const harness = yield * makeTurnHarness ( { streamFailures : 1_000 } ) ;
770+ const runId = RunId . make ( "run:late" ) ;
771+ const harness = yield * makeTurnHarness ( {
772+ streamFailures : 8 ,
773+ messageRunId : runId ,
774+ runs : [ runOf ( runId , MessageId . make ( "unused" ) , "failed" ) ] ,
775+ } ) ;
760776 yield * Effect . gen ( function * ( ) {
761777 const service = yield * ScheduledTaskService . ScheduledTaskService ;
762778 const { task } = yield * upsertBoundTask ( service ) ;
763779 yield * service . runNow ( { id : task . id } ) ;
780+ yield * Queue . take ( harness . dispatched ) ;
764781 yield * TestClock . adjust ( "10 minutes" ) ;
765782 yield * untilStatus ( service , task . id , "failed" ) ;
783+ assert . equal ( yield * Ref . get ( harness . subscriptions ) , 9 ) ;
784+ } ) . pipe ( Effect . provide ( harness . layer ) ) ;
785+ } ) . pipe ( Effect . provide ( SqlitePersistence . layerMemory ) ) ,
786+ ) ;
787+
788+ it . effect ( "an event landing while the resumed listener catches up is not missed" , ( ) =>
789+ Effect . gen ( function * ( ) {
790+ const runId = RunId . make ( "run:handoff" ) ;
791+ const harness = yield * makeTurnHarness ( {
792+ streamFailures : 1 ,
793+ liveTail : true ,
794+ messageRunId : runId ,
795+ // The projection read is stale: the run ends right after it.
796+ runs : [ runOf ( runId , MessageId . make ( "unused" ) , "running" ) ] ,
797+ duringRunsRead : ( events ) =>
798+ Queue . offer ( events , runEvent ( runOf ( runId , MessageId . make ( "unused" ) , "completed" ) ) ) . pipe (
799+ Effect . asVoid ,
800+ ) ,
801+ } ) ;
802+ yield * Effect . gen ( function * ( ) {
803+ const service = yield * ScheduledTaskService . ScheduledTaskService ;
804+ const { task } = yield * upsertBoundTask ( service ) ;
805+ yield * service . runNow ( { id : task . id } ) ;
806+ yield * Queue . take ( harness . dispatched ) ;
807+ yield * TestClock . adjust ( "30 seconds" ) ;
808+ yield * untilStatus ( service , task . id , "succeeded" ) ;
809+ } ) . pipe ( Effect . provide ( harness . layer ) ) ;
810+ } ) . pipe ( Effect . provide ( SqlitePersistence . layerMemory ) ) ,
811+ ) ;
812+
813+ it . effect ( "a cancelled run is still recorded when its first save fails" , ( ) =>
814+ Effect . gen ( function * ( ) {
815+ const harness = yield * makeTurnHarness ( ) ;
816+ yield * Effect . gen ( function * ( ) {
817+ const service = yield * ScheduledTaskService . ScheduledTaskService ;
818+ const sql = yield * SqlClient . SqlClient ;
819+ const { task } = yield * upsertBoundTask ( service ) ;
820+ yield * service . runNow ( { id : task . id } ) ;
821+ const messageId = yield * Queue . take ( harness . dispatched ) ;
822+ // Fails the first write only; the retry must still record the cancel.
823+ yield * sql `CREATE TABLE fail_once (id INTEGER)` ;
824+ yield * sql `INSERT INTO fail_once VALUES (1)` ;
825+ yield * sql `CREATE TRIGGER fail_first_outcome BEFORE UPDATE ON scheduled_tasks
826+ WHEN OLD.last_run_status = 'running' AND NEW.last_run_status = 'failed'
827+ AND EXISTS (SELECT 1 FROM fail_once)
828+ BEGIN DELETE FROM fail_once; SELECT RAISE(FAIL, 'outcome unavailable'); END` ;
829+ yield * Queue . offerAll ( harness . events , [
830+ runEvent ( runOf ( "run:cancelled" , messageId , "queued" ) ) ,
831+ runEvent ( runOf ( "run:cancelled" , messageId , "cancelled" ) ) ,
832+ ] ) ;
833+ yield * untilStatus ( service , task . id , "failed" ) ;
766834 const [ settled ] = ( yield * service . list ( ) ) . tasks ;
767- assert . equal ( settled ?. lastRunError , "Run outcomes could no longer be followed ." ) ;
835+ assert . equal ( settled ?. lastRunError , "The run was cancelled ." ) ;
768836 } ) . pipe ( Effect . provide ( harness . layer ) ) ;
769837 } ) . pipe ( Effect . provide ( SqlitePersistence . layerMemory ) ) ,
770838) ;
0 commit comments