Peer answered — carry its local aggregate.
models
Source src/FleetHealth.ts:594 lines
export class class Reachableclass Reachable {
_tag: 'Reachable';
status: 'ok' | 'degraded';
services: ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>;
}
Peer answered — carry its local aggregate.
Reachable extends import SchemaSchema.const TaggedClass: {
<Self = never, Brand = {}>(
identifier?: string
): {
<
Tag extends string,
Fields extends Struct.Fields
>(
tag: Tag,
fields: Fields,
annotations?: Annotations.Declaration<
Self,
readonly [TaggedStruct<Tag, Fields>]
>
): [Self] extends [never]
? MissingSelfGeneric<"Schema.TaggedClass">
: Class<
Self,
TaggedStruct<Tag, Fields>,
Brand
>
<
Tag extends string,
S extends Struct<Struct.Fields>
>(
tag: Tag,
schema: S,
annotations?: Annotations.Declaration<
Self,
readonly [
Struct<
Simplify<
{
readonly _tag: tag<Tag>
} & S["fields"]
>
>
]
>
): [Self] extends [never]
? MissingSelfGeneric<"Schema.TaggedClass">
: Class<
Self,
Struct<
Simplify<
{
readonly _tag: tag<Tag>
} & S["fields"]
>
>,
Brand
>
}
}
Defines a schema-backed class with an automatically populated _tag field.
When to use
Use to define class instances that are validated by a schema and participate
in tagged union matching.
Details
The optional identifier parameter overrides the schema identifier;
it defaults to the tag value.
Example (Defining a tagged class)
import { Schema } from "effect"
class Circle extends Schema.TaggedClass<Circle>()("Circle", {
radius: Schema.Number
}) {}
const c = new Circle({ radius: 5 })
console.log(c._tag) // "Circle"
console.log(c.radius) // 5
TaggedClass<class Reachableclass Reachable {
_tag: 'Reachable';
status: 'ok' | 'degraded';
services: ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>;
}
Peer answered — carry its local aggregate.
Reachable>()("Reachable", {
status: Schema.Literals<
readonly ["ok", "degraded"]
>
(property) status: {
literals: L;
members: { readonly [K in keyof L]: Literal<L[K]>; };
mapMembers: (f: (members: readonly [Schema.Literal<'ok'>, Schema.Literal<'degraded'>]) => To) => Schema.Union<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
pick: (literals: L2) => Schema.Literals<L2>;
transform: (to: L2) => Schema.Union<readonly [Schema.decodeTo<Schema.Literal<L2['0']>, Schema.Literal<'ok'>, never, never>, Schema.decodeTo<Schema.Literal<L2['1']>, Schema.Literal<'degraded'>, never, never>]>;
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<'ok' | 'degraded', readonly []>) => Schema.Literals<readonly ['ok', 'degraded']>;
annotateKey: (annotations: Schema.Annotations.Key<'ok' | 'degraded'>) => Schema.Literals<readonly ['ok', 'degraded']>;
check: (checks_0: Check<'ok' | 'degraded'>, ...checks: Array<Check<'ok' | 'degraded'>>) => Schema.Literals<readonly ['ok', 'degraded']>;
rebuild: (ast: Union<Literal>) => Schema.Literals<readonly ['ok', 'degraded']>;
make: (input: 'ok' | 'degraded', options?: MakeOptions) => 'ok' | 'degraded';
makeOption: (input: 'ok' | 'degraded', options?: MakeOptions) => Option_.Option<'ok' | 'degraded'>;
makeEffect: (input: 'ok' | 'degraded', options?: MakeOptions) => Effect.Effect<'ok' | 'degraded', SchemaError, never>;
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; <…;
}
import SchemaSchema.function Literals<
L extends ReadonlyArray<SchemaAST.LiteralValue>
>(literals: L): Literals<L>
Creates a union schema from an array of literal values.
Example (Defining status codes)
import { Schema } from "effect"
const schema = Schema.Literals(["active", "inactive", "pending"])
// accepts "active", "inactive", or "pending"
Literals(["ok", "degraded"]),
services: Schema.$Array<
Schema.Struct<{
readonly key: Schema.String
readonly kind: Schema.String
readonly ready: Schema.Boolean
readonly detail: Schema.optionalKey<Schema.String>
readonly contractHash: Schema.optionalKey<Schema.String>
}>
>
(property) services: {
Type: ReadonlyArray<S["Type"]>;
Encoded: ReadonlyArray<S["Encoded"]>;
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: ReadonlyArray<S["Iso"]>;
value: S;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined; }>, readonly []>) => Schema.$Ar…;
annotateKey: (annotations: Schema.Annotations.Key<ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>>) => Schema.$Array<Schema.Struct…;
check: (checks_0: Check<ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>>, ...checks: Array<Check<ReadonlyArray<{ readonly ke…;
rebuild: (ast: Arrays) => Schema.$Array<Schema.Struct<{ readonly key: Schema.String; readonly kind: Schema.String; readonly ready: Schema.Boolean; readonly detail: Schema.optionalKey<Schema.String>; readonly contractHash: Schema.optionalKey<Schema.…;
make: (input: ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>, options?: MakeOptions) => ReadonlyArray<{ readonly key: stri…;
makeOption: (input: ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>, options?: MakeOptions) => Option_.Option<ReadonlyArray<{ rea…;
makeEffect: (input: ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>, options?: MakeOptions) => Effect.Effect<ReadonlyArray<{ read…;
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; <…;
}
import SchemaSchema.Array<Schema.Struct<{
readonly key: Schema.String;
readonly kind: Schema.String;
readonly ready: Schema.Boolean;
readonly detail: Schema.optionalKey<Schema.String>;
readonly contractHash: Schema.optionalKey<Schema.String>;
}>>(self: Schema.Struct<{
readonly key: Schema.String;
readonly kind: Schema.String;
readonly ready: Schema.Boolean;
readonly detail: Schema.optionalKey<Schema.String>;
readonly contractHash: Schema.optionalKey<Schema.String>;
}>): Schema.$Array<...>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(const serviceReadiness: Schema.Struct<{
readonly key: Schema.String
readonly kind: Schema.String
readonly ready: Schema.Boolean
readonly detail: Schema.optionalKey<Schema.String>
readonly contractHash: Schema.optionalKey<Schema.String>
}>
(alias) const serviceReadiness: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly key: Schema.String; readonly kind: Schema.String; readonly ready: Schema.Boolean; readonly detail: Schema.optionalKey<Schema.String>; readonly contractHash: Schema.optionalKey<Schema.String> }) => To, options?: { re…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined; }, readonly []>) => Schema.Struct<{ readonly …;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>) => Schema.Struct<{ readonly key: Schema.Strin…;
check: (checks_0: Check<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>, ...checks: Array<Check<{ readonly key: string; readonly kind: str…;
rebuild: (ast: Objects) => Schema.Struct<{ readonly key: Schema.String; readonly kind: Schema.String; readonly ready: Schema.Boolean; readonly detail: Schema.optionalKey<Schema.String>; readonly contractHash: Schema.optionalKey<Schema.String> }>;
make: (input: { readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }, options?: MakeOptions) => { readonly key: string; readonly kind: string; re…;
makeOption: (input: { readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }, options?: MakeOptions) => Option_.Option<{ readonly key: string; readonly k…;
makeEffect: (input: { readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly key: string; readonly ki…;
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; <…;
}
One served HyperService's readiness, as the node reports it — its wire key,
Hyperlink.kindOf
kind, optional F4
contractHash
, whether it's ready, and (when not) why. The element of
nodeStatus
's services.
serviceReadiness),
}) {}
Referenced by 1 symbols