This node's readiness aggregate — same element shape as serviceReadiness.
modelsserviceReadiness
Source src/FleetHealth.ts:484 lines
export class class LocalHealthclass LocalHealth {
status: 'ok' | 'degraded';
services: ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>;
}
This node's readiness aggregate — same element shape as
serviceReadiness
.
LocalHealth extends import SchemaSchema.const Class: {
<Self = never, Brand = {}>(
identifier: string
): {
<Fields extends Struct.Fields>(
fields: Fields,
annotations?: Annotations.Declaration<
Self,
readonly [Struct<Fields>]
>
): [Self] extends [never]
? MissingSelfGeneric<"Schema.Class">
: Class<Self, Struct<Fields>, Brand>
<S extends Struct<Struct.Fields>>(
schema: S,
annotations?: Annotations.Declaration<
Self,
readonly [S]
>
): [Self] extends [never]
? MissingSelfGeneric<"Schema.Class">
: Class<Self, S, Brand>
}
}
Creates a schema-backed class whose constructor validates input against a
Struct
schema. Construction throws a
SchemaError
on invalid
input.
When to use
Use when you need a schema-backed data class with validated construction,
schema-derived decoding/encoding, and class-style methods or inheritance.
Details
Pass the desired class type as the first type parameter. The second optional
type parameter can be used to add nominal brands.
Gotchas
Passing disableChecks in the options skips constructor validation.
Example (Defining a basic class)
import { Schema } from "effect"
class Person extends Schema.Class<Person>("Person")({
name: Schema.String,
age: Schema.Number
}) {}
const alice = new Person({ name: "Alice", age: 30 })
console.log(alice.name) // "Alice"
console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
Example (Extending a class)
import { Schema } from "effect"
class Animal extends Schema.Class<Animal>("Animal")({
name: Schema.String
}) {}
class Dog extends Animal.extend<Dog>("Dog")({
breed: Schema.String
}) {}
const dog = new Dog({ name: "Rex", breed: "Labrador" })
console.log(dog.name) // "Rex"
console.log(dog.breed) // "Labrador"
Class<class LocalHealthclass LocalHealth {
status: 'ok' | 'degraded';
services: ReadonlyArray<{ readonly key: string; readonly kind: string; readonly ready: boolean; readonly detail?: string | undefined; readonly contractHash?: string | undefined }>;
}
This node's readiness aggregate — same element shape as
serviceReadiness
.
LocalHealth>("FleetHealthLocal")({
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),
}) {}