@systemfsoftware/effect-daemon-spec 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,338 @@
+import { Cause, Context, Duration, Effect, Layer, Metric, Option, Schedule, Schema, Scope, Stream } from "effect";
+
+//#region src/backoff.d.ts
+declare const cappedBackoff: (base: Duration.DurationInput, cap: Duration.DurationInput) => Schedule.Schedule<Duration.Duration>;
+//#endregion
+//#region src/daemon-health.schema.d.ts
+declare const DynamicLimitExceeded_base: Schema.TaggedErrorClass<DynamicLimitExceeded, "DynamicLimitExceeded", {
+  readonly _tag: Schema.tag<"DynamicLimitExceeded">;
+} & {
+  limit: Schema.filter<typeof Schema.Int>;
+}>;
+declare class DynamicLimitExceeded extends DynamicLimitExceeded_base {}
+//#endregion
+//#region src/daemon-health.d.ts
+interface DaemonHealth {
+  readonly name: string;
+  readonly ready: Effect.Latch;
+  readonly healthy: Effect.Latch;
+  readonly paused: Effect.Latch;
+}
+interface SupervisorHealth {
+  readonly name: string;
+  readonly ready: Effect.Latch;
+  readonly healthy: Effect.Latch;
+  readonly paused: Effect.Latch;
+  readonly children: ReadonlyArray<DaemonHealth | SupervisorHealth>;
+}
+interface DynamicHandle<Args, R = never> {
+  readonly health: SupervisorHealth;
+  readonly startChild: (args: Args) => Effect.Effect<ChildRef, DynamicLimitExceeded, R>;
+  readonly stopChild: (ref: Pick<ChildRef, 'id'>) => Effect.Effect<void>;
+  readonly count: Effect.Effect<number>;
+}
+type ChildRef = {
+  readonly id: number;
+  readonly removed: Effect.Effect<void>;
+};
+//#endregion
+//#region src/daemon-metrics.d.ts
+declare const supervisorRestartsCounter: Metric.Metric.Counter<number>;
+declare const supervisorExhaustionsCounter: Metric.Metric.Counter<number>;
+declare const supervisorChildrenGauge: Metric.Metric.Gauge<number>;
+declare const healthStateGauge: Metric.Metric.Gauge<number>;
+//#endregion
+//#region src/daemon-policy.schema.d.ts
+declare const IntensityConfig: Schema.Struct<{
+  restarts: Schema.filter<typeof Schema.Int>;
+  window: typeof Schema.DurationFromSelf;
+}>;
+type IntensityConfig = typeof IntensityConfig.Type;
+declare const IntensityTypeId: unique symbol;
+type IntensityTypeId = typeof IntensityTypeId;
+declare const BoundedIntensity_base: Schema.TaggedClass<BoundedIntensity, "Bounded", {
+  readonly _tag: Schema.tag<"Bounded">;
+} & Readonly<{
+  restarts: Schema.filter<typeof Schema.Int>;
+  window: typeof Schema.DurationFromSelf;
+}>>;
+declare class BoundedIntensity extends BoundedIntensity_base {
+  readonly [IntensityTypeId]: symbol;
+}
+declare const UnboundedIntensity_base: Schema.TaggedClass<UnboundedIntensity, "Unbounded", {
+  readonly _tag: Schema.tag<"Unbounded">;
+}>;
+declare class UnboundedIntensity extends UnboundedIntensity_base {
+  readonly [IntensityTypeId]: symbol;
+}
+declare const Intensity: Schema.Union<[typeof BoundedIntensity, typeof UnboundedIntensity]>;
+type Intensity = typeof Intensity.Type;
+declare const ChildPolicyConfig_base: Schema.Class<ChildPolicyConfig, {
+  restart: Schema.optional<Schema.Literal<["permanent", "transient", "temporary"]>>;
+  intensity: Schema.optional<Schema.Struct<{
+    restarts: Schema.filter<typeof Schema.Int>;
+    window: typeof Schema.DurationFromSelf;
+  }>>;
+}, Schema.Struct.Encoded<{
+  restart: Schema.optional<Schema.Literal<["permanent", "transient", "temporary"]>>;
+  intensity: Schema.optional<Schema.Struct<{
+    restarts: Schema.filter<typeof Schema.Int>;
+    window: typeof Schema.DurationFromSelf;
+  }>>;
+}>, never, {
+  readonly intensity?: {
+    readonly restarts: number;
+    readonly window: import("effect/Duration").Duration;
+  } | undefined;
+} & {
+  readonly restart?: "permanent" | "temporary" | "transient" | undefined;
+}, {}, {}>;
+declare class ChildPolicyConfig extends ChildPolicyConfig_base {}
+declare const LockPolicyConfig_base: Schema.Class<LockPolicyConfig, {
+  mode: Schema.optional<Schema.Literal<["none", "required", "optional"]>>;
+  key: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+  mode: Schema.optional<Schema.Literal<["none", "required", "optional"]>>;
+  key: Schema.optional<typeof Schema.String>;
+}>, never, {
+  readonly key?: string | undefined;
+} & {
+  readonly mode?: "none" | "optional" | "required" | undefined;
+}, {}, {}>;
+declare class LockPolicyConfig extends LockPolicyConfig_base {}
+declare const TickPolicyConfig_base: Schema.Class<TickPolicyConfig, {
+  spanName: Schema.optional<typeof Schema.String>;
+  tickTimeout: typeof Schema.DurationFromSelf;
+  startLogLevel: Schema.optional<Schema.Literal<["debug", "info"]>>;
+}, Schema.Struct.Encoded<{
+  spanName: Schema.optional<typeof Schema.String>;
+  tickTimeout: typeof Schema.DurationFromSelf;
+  startLogLevel: Schema.optional<Schema.Literal<["debug", "info"]>>;
+}>, never, {
+  readonly spanName?: string | undefined;
+} & {
+  readonly startLogLevel?: "debug" | "info" | undefined;
+} & {
+  readonly tickTimeout: import("effect/Duration").Duration;
+}, {}, {}>;
+declare class TickPolicyConfig extends TickPolicyConfig_base {}
+//#endregion
+//#region src/daemon-reporter.d.ts
+interface DaemonReporterService {
+  readonly onRestart: (name: string, cause: Cause.Cause<never>) => Effect.Effect<void>;
+  readonly onExhausted: (name: string, cause: Cause.Cause<never>) => Effect.Effect<void>;
+}
+declare const DaemonReporter_base: Context.TagClass<DaemonReporter, "@systemfsoftware/effect-daemon-spec/daemon-reporter/DaemonReporter", DaemonReporterService>;
+declare class DaemonReporter extends DaemonReporter_base {
+  static readonly Noop: Layer.Layer<DaemonReporter>;
+}
+//#endregion
+//#region src/supervision-preset.d.ts
+interface SupervisionPolicy {
+  readonly intensity: Intensity;
+  readonly backoff: Schedule.Schedule<Duration.Duration>;
+  readonly cooldown: Duration.DurationInput;
+}
+interface SupervisionConfig {
+  readonly backoffBase: Duration.DurationInput;
+  readonly intensity: Intensity;
+  readonly cooldown: Duration.DurationInput;
+}
+declare const LeaderConfig_base: Context.ReferenceClass<LeaderConfig, "@systemfsoftware/effect-daemon-spec/LeaderConfig", SupervisionConfig>;
+declare class LeaderConfig extends LeaderConfig_base {}
+declare const WorkerConfig_base: Context.ReferenceClass<WorkerConfig, "@systemfsoftware/effect-daemon-spec/WorkerConfig", SupervisionConfig>;
+declare class WorkerConfig extends WorkerConfig_base {}
+declare const TaskConfig_base: Context.ReferenceClass<TaskConfig, "@systemfsoftware/effect-daemon-spec/TaskConfig", SupervisionConfig>;
+declare class TaskConfig extends TaskConfig_base {}
+declare const Supervision: {
+  readonly leader: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+  readonly worker: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+  readonly task: (budget: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+  readonly custom: (policy: SupervisionPolicy) => Effect.Effect<SupervisionPolicy>;
+};
+//#endregion
+//#region src/daemon-spec.d.ts
+declare const WorkerTypeId: unique symbol;
+type WorkerTypeId = typeof WorkerTypeId;
+declare const SupervisorTypeId: unique symbol;
+type SupervisorTypeId = typeof SupervisorTypeId;
+declare const DynamicSpecTypeId: unique symbol;
+type DynamicSpecTypeId = typeof DynamicSpecTypeId;
+type LockConfig = {
+  mode: 'none';
+} | {
+  mode: 'optional';
+  key: string;
+} | {
+  mode: 'required';
+  key: string;
+  acquireRetryBackoff: Schedule.Schedule<Duration.Duration>;
+};
+interface TickPolicyHooks {
+  readonly spanAttributes?: Effect.Effect<Record<string, string | number | boolean>>;
+  readonly innerRetry?: Schedule.Schedule<unknown>;
+  readonly trackDuration?: Metric.Metric.Histogram<Duration.Duration>;
+}
+interface ReporterPolicyHooks {
+  readonly onRestart?: (cause: Cause.Cause<never>) => Effect.Effect<void>;
+  readonly onExhausted?: (cause: Cause.Cause<never>) => Effect.Effect<void>;
+}
+type PollLoop<E, R> = {
+  readonly _tag: 'Poll';
+  readonly gate: Effect.Effect<Option.Option<Effect.Effect<void, E, R>>, E, R>;
+  readonly interval: Duration.DurationInput;
+};
+type StreamLoop<E, R> = {
+  readonly _tag: 'Stream';
+  readonly stream: Stream.Stream<unknown, E, R>;
+};
+type SubscriptionLoop<E, R> = {
+  readonly _tag: 'Subscription';
+  readonly acquire: Effect.Effect<void, E, R>;
+};
+type LoopShape<E, R> = PollLoop<E, R> | StreamLoop<E, R> | SubscriptionLoop<E, R>;
+interface Worker<E, R, L extends LockConfig = LockConfig> {
+  readonly [WorkerTypeId]: WorkerTypeId;
+  readonly name: string;
+  readonly loop: LoopShape<E, R>;
+  readonly child: typeof ChildPolicyConfig.Type;
+  readonly tick: typeof TickPolicyConfig.Type;
+  readonly tickHooks: TickPolicyHooks;
+  readonly lock: L;
+}
+interface Supervisor<E, R, L extends LockConfig = LockConfig> {
+  readonly [SupervisorTypeId]: SupervisorTypeId;
+  readonly name: string;
+  readonly strategy: 'one_for_one' | 'one_for_all' | 'rest_for_one';
+  readonly children: ReadonlyArray<Worker<E, R> | Supervisor<E, R>>;
+  readonly supervision: Effect.Effect<SupervisionPolicy>;
+  readonly lock: L;
+  readonly reporter: ReporterPolicyHooks;
+}
+interface DynamicSpec<E, R, Args> {
+  readonly [DynamicSpecTypeId]: DynamicSpecTypeId;
+  readonly name: string;
+  readonly child: (args: Args) => Worker<E, R>;
+  readonly maxChildren: number;
+}
+type Child<E, R> = Worker<E, R> | Supervisor<E, R>;
+declare const isWorker: <E, R>(x: Child<E, R>) => x is Worker<E, R>;
+declare const isSupervisor: <E, R>(x: Child<E, R>) => x is Supervisor<E, R>;
+//#endregion
+//#region src/daemon.d.ts
+interface CommonOpts<L extends LockConfig> {
+  readonly name: string;
+  readonly child?: typeof ChildPolicyConfig.Type;
+  readonly tick: typeof TickPolicyConfig.Type;
+  readonly tickHooks?: TickPolicyHooks;
+  readonly lock: L;
+}
+type PollOpts<A, E, R, L extends LockConfig> = CommonOpts<L> & {
+  readonly interval: Duration.DurationInput;
+} & ({
+  readonly prereq?: undefined;
+  readonly work: Effect.Effect<A, E, R>;
+} | {
+  readonly prereq: Effect.Effect<Option.Option<A>, E, R>;
+  readonly work: (data: A) => Effect.Effect<void, E, R>;
+});
+declare const poll: <A, E, R, L extends LockConfig>(opts: PollOpts<A, E, R, L>) => Worker<E, R, L>;
+declare const stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
+  readonly stream: Stream.Stream<A, E, R>;
+}) => Worker<E, R, L>;
+declare const subscription: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
+  readonly acquire: Effect.Effect<A, E, R>;
+}) => Worker<E, R, L>;
+declare const Daemon: {
+  readonly poll: <A, E, R, L extends LockConfig>(opts: PollOpts<A, E, R, L>) => Worker<E, R, L>;
+  readonly stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
+    readonly stream: Stream.Stream<A, E, R>;
+  }) => Worker<E, R, L>;
+  readonly subscription: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
+    readonly acquire: Effect.Effect<A, E, R>;
+  }) => Worker<E, R, L>;
+};
+//#endregion
+//#region src/leader-lock.schema.d.ts
+declare const LeaderLockNotAcquired_base: Schema.TaggedErrorClass<LeaderLockNotAcquired, "LeaderLockNotAcquired", {
+  readonly _tag: Schema.tag<"LeaderLockNotAcquired">;
+} & {
+  key: typeof Schema.String;
+}>;
+declare class LeaderLockNotAcquired extends LeaderLockNotAcquired_base {}
+declare const LeaderLockInfraError_base: Schema.TaggedErrorClass<LeaderLockInfraError, "LeaderLockInfraError", {
+  readonly _tag: Schema.tag<"LeaderLockInfraError">;
+} & {
+  key: typeof Schema.String;
+  cause: typeof Schema.Unknown;
+}>;
+declare class LeaderLockInfraError extends LeaderLockInfraError_base {}
+type LeaderLockAcquireError = LeaderLockNotAcquired | LeaderLockInfraError;
+//#endregion
+//#region src/leader-lock.d.ts
+interface LeaderLockService {
+  readonly withLock: <A, E, R>(key: string, self: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E | LeaderLockInfraError, R>;
+}
+declare const LeaderLock_base: Context.TagClass<LeaderLock, "@systemfsoftware/effect-daemon-spec/leader-lock/LeaderLock", LeaderLockService>;
+declare class LeaderLock extends LeaderLock_base {
+  static readonly Noop: Layer.Layer<LeaderLock>;
+}
+interface LeaderLockOptions {
+  readonly key: string;
+  readonly mode: 'required' | 'optional';
+}
+declare const withLeaderLock: {
+  (options: LeaderLockOptions): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | void, E | LeaderLockAcquireError, R | LeaderLock>;
+  <A, E, R>(self: Effect.Effect<A, E, R>, options: LeaderLockOptions): Effect.Effect<A | void, E | LeaderLockAcquireError, R | LeaderLock>;
+};
+//#endregion
+//#region src/lock-primitive.schema.d.ts
+declare const LockPrimitiveError_base: Schema.TaggedErrorClass<LockPrimitiveError, "LockPrimitiveError", {
+  readonly _tag: Schema.tag<"LockPrimitiveError">;
+} & {
+  key: typeof Schema.String;
+  cause: typeof Schema.Unknown;
+}>;
+declare class LockPrimitiveError extends LockPrimitiveError_base {}
+//#endregion
+//#region src/lock-primitive.d.ts
+interface LockPrimitiveService {
+  readonly tryAcquire: (key: string) => Effect.Effect<boolean, LockPrimitiveError, Scope.Scope>;
+}
+declare const LockPrimitive_base: Context.TagClass<LockPrimitive, "@systemfsoftware/effect-daemon-spec/lock-primitive/LockPrimitive", LockPrimitiveService>;
+declare class LockPrimitive extends LockPrimitive_base {}
+declare const LeaderLockFromPrimitive: Layer.Layer<LeaderLock, never, LockPrimitive>;
+//#endregion
+//#region src/run.d.ts
+declare function worker<E, R>(w: Worker<E, R, {
+  mode: 'none';
+}>): Effect.Effect<DaemonHealth, never, R | DaemonReporter | Scope.Scope>;
+declare function worker<E, R>(w: Worker<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
+declare function supervisor<E, R>(s: Supervisor<E, R, {
+  mode: 'none';
+}>): Effect.Effect<SupervisorHealth, never, R | DaemonReporter | Scope.Scope>;
+declare function supervisor<E, R>(s: Supervisor<E, R, LockConfig>): Effect.Effect<SupervisorHealth, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
+declare const run: {
+  readonly worker: typeof worker;
+  readonly supervisor: typeof supervisor;
+  readonly dynamic: <E, R, Args>(spec: DynamicSpec<E, R, Args>) => Effect.Effect<DynamicHandle<Args, R | LeaderLock | DaemonReporter | Scope.Scope>, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
+};
+//#endregion
+//#region src/supervisor.d.ts
+interface SupervisorOpts<E, R, L extends LockConfig> {
+  readonly name: string;
+  readonly children: ReadonlyArray<Child<E, R>>;
+  readonly supervision: Effect.Effect<SupervisionPolicy>;
+  readonly lock: L;
+  readonly reporter?: ReporterPolicyHooks;
+}
+declare const oneForOne: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
+declare const oneForAll: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
+declare const restForOne: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
+declare const dynamic: <E, R, Args>(opts: {
+  readonly name: string;
+  readonly child: (args: Args) => Worker<E, R>;
+  readonly maxChildren?: number;
+}) => DynamicSpec<E, R, Args>;
+//#endregion
+export { BoundedIntensity, Child, ChildPolicyConfig, ChildRef, CommonOpts, Daemon, DaemonHealth, DaemonReporter, DaemonReporterService, DynamicHandle, DynamicLimitExceeded, DynamicSpec, DynamicSpecTypeId, Intensity, IntensityConfig, IntensityTypeId, LeaderConfig, LeaderLock, type LeaderLockAcquireError, LeaderLockFromPrimitive, LeaderLockInfraError, LeaderLockNotAcquired, LeaderLockOptions, LeaderLockService, LockConfig, LockPolicyConfig, LockPrimitive, LockPrimitiveError, LockPrimitiveService, LoopShape, PollLoop, PollOpts, ReporterPolicyHooks, StreamLoop, SubscriptionLoop, Supervision, SupervisionConfig, SupervisionPolicy, Supervisor, SupervisorHealth, type SupervisorOpts, SupervisorTypeId, TaskConfig, TickPolicyConfig, TickPolicyHooks, UnboundedIntensity, Worker, WorkerConfig, WorkerTypeId, cappedBackoff, dynamic, healthStateGauge, isSupervisor, isWorker, oneForAll, oneForOne, poll, restForOne, run, stream, subscription, supervisor, supervisorChildrenGauge, supervisorExhaustionsCounter, supervisorRestartsCounter, withLeaderLock, worker };