Middleware Usage

Declaring Side-effect Handlers

Sonnets immediately execute the provided root Stanza in a forking manner. Stanzas must be declared as part of Sonnet instantiation.

import { Effect } from "effect"
import { Sonnet } from "redux-sonnet"

declare const initialize: Effect.Effect<void>
declare const watchThingOne: Effect.Effect<void>
declare const watchThingTwo: Effect.Effect<void>

/**
 * Run `initialize` first, and then run `watchThingOne` and `watchThingTwo`
 * concurrently.
 */
const rootStanza = initialize.pipe(
  Effect.andThen(() =>
    Effect.all([
      watchThingOne,
      watchThingTwo
    ], {
      discard: true,
      concurrency: "unbounded"
    })
  )
)

const sonnet = Sonnet.make(
  rootStanza,
  Sonnet.defaultLayer
)

Deciding Data Structures

Sonnets accept a Layer which describes the data structures used to communicate between side-effect declarations (Stanzas) and the Redux dispatcher.

Data structures are modeled as such:

• Actions — A Queue which has configurable capacity and bounding behaviors.
• Reducer State — A SynchronizedRef which has current value exposed as well as a Stream of its changes over time.
• Dispatch Actions — An unbounded Queue. ^{* this needs consideration}

Default

const sonnet = Sonnet.make(
  Effect.void,
  Sonnet.defaultLayer
const defaultLayer: Layer<Sonnet.SonnetService, never, never>
@since ― 0.0.0
)

Configurable

const sonnet = Sonnet.make(
  Effect.void,
  Sonnet.layer({
    replay: 8,
Sonnet<LA, LE>.Options.replay?: number | undefined
Number of actions to replay to late subscribers.
@default ― 0
    backing: {
Sonnet<LA, LE>.Options.backing?: {
    strategy: "unbounded";
} | {
    strategy: "bounded";
    capacity: number;
} | {
    strategy: "dropping";
    capacity: number;
} | {
    strategy: "sliding";
    capacity: number;
} | undefined
Configuration for queue-backed action stream.
      strategy: "bounded",
      capacity: 8
    }
  })
)

Advanced

Any Effect service which satisfies Sonnet.Service may be constructed manually.

See Sonnet.Service for reference.

Adding to Redux

With @reduxjs/toolkit

const sonnet = Sonnet.make(
  Effect.void,
  Sonnet.defaultLayer
)

const store = configureStore({
const store: EnhancedStore<void, UnknownAction, Tuple<[StoreEnhancer<{
    dispatch: {};
}>, StoreEnhancer]>>
  reducer: () => {},
  middleware: () => new Tuple(sonnet)
})

With redux

const sonnet = Sonnet.make(
  Effect.void,
  Sonnet.defaultLayer
)

const store = applyMiddleware(sonnet)(createStore)(() => {})
const store: Store<void, Action<string>, {}> & Store<unknown, Action<string>, unknown> & {
    dispatch: unknown;
}

Provisioning Resources

Side-effect handlers, or Stanzas, are resourceful, meaning they can request fulfillment of some set of services.

Layers

The second argument to Sonnet.make() is a Layer comprising the resources available to running side-effect handlers. See the below example for usage guidance. Note that SonnetService must be provisioned for all Sonnet instantiations.

Re-using a ManagedRuntime

If the integrating application already makes use of a ManagedRuntime, a MemoMap may be provided at Sonnet instantiation to facilitate layer memoization.

import { Context, Effect, Layer, ManagedRuntime } from "effect"
import { Sonnet } from "redux-sonnet"

class MyService extends Context.Tag("MyService")<
  MyService,
  { readonly _: Effect.Effect<unknown> }
>() {}

const layer = Layer.succeed(
  MyService,
  { _: Effect.succeed(void 0) }
)

const existingRuntime = ManagedRuntime.make(layer)
const existingRuntime: ManagedRuntime.ManagedRuntime<MyService, never>

const sonnet = Sonnet.make(
const sonnet: Sonnet.Sonnet<MyService, never>
  Effect.void,
  Layer.mergeAll(
    layer,
    Sonnet.defaultLayer
  ),
  existingRuntime.memoMap
ManagedRuntime<MyService, never>.memoMap: Layer.MemoMap
)

Cleanup

TODO: Unit test and document runtime disposal.