<Self>(tag: FleetHealthTag<Self>): Layer.Layer<
PeersId<Self> | SelfNodeId<Self>
>Discharge the mesh with no peers — this node's readiness alone.
layers & serving
Source src/FleetHealth.ts:2257 lines
export const const alone: <Self>(
tag: FleetHealthTag<Self>
) => Layer.Layer<PeersId<Self> | SelfNodeId<Self>>
Discharge the mesh with no peers — this node's readiness alone.
alone = <function (type parameter) Self in <Self>(tag: FleetHealthTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self>(
tag: FleetHealthTag<Self>(parameter) tag: {
key: Identifier;
Service: {
local: Effect.Effect<LocalHealth, never, never>;
byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>;
status: Effect.Effect<'ok' | 'degraded' | 'partial', never, never>;
};
description: string | undefined;
of: (this: void, self: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', n…;
context: (self: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', never, never>…;
use: (f: (service: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', never,…;
useSync: (f: (service: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', never,…;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
type FleetHealthTag<Self> = Hyperlink.HyperlinkTag<Self, {
local: Hyperlink.Method<undefined, typeof LocalHealth, Schema.Never, false, Hyperlink.MethodAnnotations & {
description: string;
}, Hyperlink.Derive>;
byNode: Hyperlink.Marked<Hyperlink.Method<undefined, Schema.$Record<Schema.String, Schema.Union<readonly [typeof Reachable, typeof Unreachable]>>, Schema.Never, false, Hyperlink.MethodAnnotations & {
description: string;
}, Hyperlink.Derive>, {
readonly fleet: true;
}>;
status: Hyperlink.Marked<...>;
}, {
...;
}>
A FleetHealth instance tag.
FleetHealthTag<function (type parameter) Self in <Self>(tag: FleetHealthTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self>,
): import LayerLayer.interface Layer<in ROut, out E = never, out RIn = never>A Layer describes how to build one or more services for dependency injection.
When to use
Use to model construction of application services for dependency injection,
especially when services have dependencies, can fail during construction, or
need scoped setup and release.
Details
A Layer<ROut, E, RIn> represents ROut as the services this layer
provides, E as the possible errors during layer construction, and RIn as
the services this layer requires as dependencies.
Layer<interface PeersId<Self>Phantom brand for the per-HyperService
peers
capability, so distinct HyperServices' peer sets
don't collide in one context.
PeersId<function (type parameter) Self in <Self>(tag: FleetHealthTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self> | interface SelfNodeId<Self>Phantom brand for the per-HyperService
selfNode
capability (which node this instance runs as),
so distinct HyperServices' self-node identities don't collide in one context.
SelfNodeId<function (type parameter) Self in <Self>(tag: FleetHealthTag<Self>): Layer.Layer<PeersId<Self> | SelfNodeId<Self>>Self>> =>
import LayerLayer.const merge: {
<RIn, E, ROut>(that: Layer<ROut, E, RIn>): <
RIn2,
E2,
ROut2
>(
self: Layer<ROut2, E2, RIn2>
) => Layer<ROut | ROut2, E | E2, RIn | RIn2>
<Layers extends [Any, ...Array<Any>]>(
that: Layers
): <A, E, R>(
self: Layer<A, E, R>
) => Layer<
A | Success<Layers[number]>,
E | Error<Layers[number]>,
Services<Layers[number]> | R
>
<RIn2, E2, ROut2, RIn, E, ROut>(
self: Layer<ROut2, E2, RIn2>,
that: Layer<ROut, E, RIn>
): Layer<ROut | ROut2, E | E2, RIn | RIn2>
<A, E, R, Layers extends [Any, ...Array<Any>]>(
self: Layer<A, E, R>,
that: Layers
): Layer<
A | Success<Layers[number]>,
E | Error<Layers[number]>,
Services<Layers[number]> | R
>
}
Merges this layer with another layer concurrently, producing a new layer with
combined input, error, and output types.
When to use
Use to combine an existing Layer with another Layer or an array of
layers while preserving pipeline style.
Details
This is a binary version of mergeAll that merges exactly two layers or one
layer with an array of layers. The layers are built concurrently and their
outputs are combined.
Example (Merging two layers)
import { Context, Effect, Layer } from "effect"
class Database extends Context.Service<Database, {
readonly query: (sql: string) => Effect.Effect<string>
}>()("Database") {}
class Logger extends Context.Service<Logger, {
readonly log: (msg: string) => Effect.Effect<void>
}>()("Logger") {}
const dbLayer = Layer.succeed(Database, {
query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
})
const loggerLayer = Layer.succeed(Logger, {
log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
})
const mergedLayer = Layer.merge(dbLayer, loggerLayer)
merge(
import HyperlinkHyperlink.const peersFrom: <Self, S extends Spec>(
tag: HyperlinkTag<Self, S>,
peers: Record<string, PeerServiceOf<S>>
) => Layer.Layer<PeersId<Self>>
Provide the
peers
capability from an explicit client map — for a holder that already
holds the per-node clients (a dashboard's per-node bundles), or for a test.
peersLayer
is
the auto-connecting form (from the tag's distributed set + urls); this one takes the clients as-is.
peersFrom(tag: FleetHealthTag<Self>(parameter) tag: {
key: Identifier;
Service: {
local: Effect.Effect<LocalHealth, never, never>;
byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>;
status: Effect.Effect<'ok' | 'degraded' | 'partial', never, never>;
};
description: string | undefined;
of: (this: void, self: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', n…;
context: (self: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', never, never>…;
use: (f: (service: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', never,…;
useSync: (f: (service: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', never,…;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
import HyperlinkHyperlink.const selfNodeLayer: <
Self,
S extends Spec
>(
tag: HyperlinkTag<Self, S>,
self: AnyNode
) => Layer.Layer<SelfNodeId<Self>>
Provide the
selfNode
capability on this node — the node key this instance runs as. Bundled
into
peersLayer
(so a mesh resource gets it for free); use this standalone when a HyperService
keys per node but doesn't gather peers, or alongside
peersFrom
in a test. No transport, no
failure path — just the identity.
selfNodeLayer(tag: FleetHealthTag<Self>(parameter) tag: {
key: Identifier;
Service: {
local: Effect.Effect<LocalHealth, never, never>;
byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>;
status: Effect.Effect<'ok' | 'degraded' | 'partial', never, never>;
};
description: string | undefined;
of: (this: void, self: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', n…;
context: (self: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', never, never>…;
use: (f: (service: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', never,…;
useSync: (f: (service: { readonly local: Effect.Effect<LocalHealth, never, never>; readonly byNode: Effect.Effect<{ readonly [x: string]: Reachable | Unreachable }, never, never>; readonly status: Effect.Effect<'ok' | 'degraded' | 'partial', never,…;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
class FleetHealthAloneNodeclass FleetHealthAloneNode {
key: Identifier;
Service: {
protocol: Context.Service.Shape<typeof RpcClient.Protocol>;
ping: Effect.Effect<number, NodeUnreachable>;
status: { readonly get: Effect.Effect<NodeStatusSnapshot, NodeUnreachable>; readonly changes: Stream.Stream<NodeStatusSnapshot, NodeUnreachable> };
logs: { readonly stream: Stream.Stream<LogEntry, NodeUnreachable>; readonly query: (options: { readonly limit: number }) => Effect.Effect<ReadonlyArray<LogEntry>, NodeUnreachable> };
};
of: (this: void, self: NodeProtocol) => NodeProtocol;
context: (self: NodeProtocol) => Context<FleetHealthAloneNode>;
use: (f: (service: NodeProtocol) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, FleetHealthAloneNode | R>;
useSync: (f: (service: NodeProtocol) => A) => Effect.Effect<A, never, FleetHealthAloneNode>;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
url: undefined;
path: undefined;
kind: undefined;
logs: unknown;
onConflict: OnConflict;
}
Identity node for a non-meshed FleetHealth instance.
FleetHealthAloneNode),
);