From 1ab20482ab37d7962c8e69701163270e687df3ca Mon Sep 17 00:00:00 2001
From: Elizabeth Alexander Hunt <me@liz.coffee>
Date: Thu, 15 May 2025 23:39:29 -0700
Subject: more snapshot

---
 u/fn/either.ts              | 31 +++++++++++++++++++++++++------
 u/process/run.ts            |  4 ++--
 u/server/activity/health.ts | 18 ++++++++++--------
 u/server/activity/mod.ts    |  2 ++
 u/server/filter/json.ts     |  3 ++-
 u/server/filter/method.ts   |  3 ++-
 u/server/mod.ts             |  1 +
 7 files changed, 44 insertions(+), 18 deletions(-)

(limited to 'u')

diff --git a/u/fn/either.ts b/u/fn/either.ts
index 12240d0..916bb71 100644
--- a/u/fn/either.ts
+++ b/u/fn/either.ts
@@ -5,37 +5,56 @@ export interface IEither<E, T> {
     errBranch: Mapper<E, Ee>,
     okBranch: Mapper<T, Tt>,
   ) => IEither<Ee, Tt>;
-  flatMap: <Tt>(mapper: Mapper<T, IEither<E, Tt>>) => IEither<E, Tt>;
+  moveRight: <Tt>(t: Tt) => IEither<E, Tt>;
   mapRight: <Tt>(mapper: Mapper<T, Tt>) => IEither<E, Tt>;
   mapLeft: <Ee>(mapper: Mapper<E, Ee>) => IEither<Ee, T>;
+  flatMap: <Tt>(mapper: Mapper<T, IEither<E, Tt>>) => IEither<E, Tt>;
+  flatMapAsync: <Tt>(
+    mapper: Mapper<T, Promise<IEither<E, Tt>>>,
+  ) => Promise<IEither<E, Tt>>;
 }
 
 export class Either<E, T> implements IEither<E, T> {
   private constructor(private readonly err?: E, private readonly ok?: T) {}
 
+  public moveRight<Tt>(
+    t: Tt,
+  ) {
+    return this.mapRight(() => t);
+  }
+
   public mapBoth<Ee, Tt>(
     errBranch: Mapper<E, Ee>,
     okBranch: Mapper<T, Tt>,
   ): Either<Ee, Tt> {
-    if (this.err) return Either.left(errBranch(this.err));
+    if (this.err !== undefined) return Either.left(errBranch(this.err));
     return Either.right(okBranch(this.ok!));
   }
 
   public flatMap<Tt>(mapper: Mapper<T, Either<E, Tt>>): Either<E, Tt> {
-    if (this.ok) return mapper(this.ok);
+    if (this.ok !== undefined) return mapper(this.ok);
     return Either.left<E, Tt>(this.err!);
   }
 
   public mapRight<Tt>(mapper: Mapper<T, Tt>): IEither<E, Tt> {
-    if (this.ok) return Either.right(mapper(this.ok));
+    if (this.ok !== undefined) return Either.right(mapper(this.ok));
     return Either.left<E, Tt>(this.err!);
   }
 
-  public mapLeft<Ee>(mapper: Mapper<E, Ee>) {
-    if (this.err) return Either.left<Ee, T>(mapper(this.err));
+  public mapLeft<Ee>(mapper: Mapper<E, Ee>): IEither<Ee, T> {
+    if (this.err !== undefined) return Either.left<Ee, T>(mapper(this.err));
     return Either.right<Ee, T>(this.ok!);
   }
 
+  public async flatMapAsync<Tt>(
+    mapper: Mapper<T, Promise<IEither<E, Tt>>>,
+  ): Promise<IEither<E, Tt>> {
+    if (this.err !== undefined) {
+      return Promise.resolve(Either.left<E, Tt>(this.err));
+    }
+    return await mapper(this.ok!).catch((err) => Either.left<E, Tt>(err as E));
+  }
+
   static left<E, T>(e: E) {
     return new Either<E, T>(e);
   }
diff --git a/u/process/run.ts b/u/process/run.ts
index 670f567..cbf8c65 100644
--- a/u/process/run.ts
+++ b/u/process/run.ts
@@ -14,8 +14,8 @@ type CommandOutputDecoded = {
 };
 
 export class ProcessError extends Error {}
-export const getStdout = (
-  c: ITraceable<Command>,
+export const getStdout = <Trace>(
+  c: ITraceable<Command, Trace>,
   options: Deno.CommandOptions = {},
 ): Promise<IEither<ProcessError, string>> =>
   c.bimap(TraceUtil.withFunctionTrace(getStdout))
diff --git a/u/server/activity/health.ts b/u/server/activity/health.ts
index bf1f52c..7ee6629 100644
--- a/u/server/activity/health.ts
+++ b/u/server/activity/health.ts
@@ -1,25 +1,27 @@
 import {
-  Either,
-  getRequiredEnv,
-  getStdout,
+  type IEither,
   type ITraceable,
   LogLevel,
   type Mapper,
   TraceUtil,
 } from "@emprespresso/pengueno";
 
-type HealthCheckInput = "healthy?";
-type HealthCheckOutput = "healthy!";
+export enum HealthCheckInput {
+  CHECK,
+}
+export enum HealthCheckOutput {
+  YAASQUEEN,
+}
 
-const HealthCheckActivity = <Trace>(
+export const HealthCheckActivity = <Trace>(
   check: Mapper<
     ITraceable<HealthCheckInput, Trace>,
-    Promise<Either<Error, HealthCheckOutput>>
+    Promise<IEither<Error, HealthCheckOutput>>
   >,
 ) =>
 (req: ITraceable<Request, Trace>) =>
   req.bimap(TraceUtil.withFunctionTrace(HealthCheckActivity))
-    .flatMap((r) => r.move(<HealthCheckInput> "healthy?"))
+    .flatMap((r) => r.move(HealthCheckInput.CHECK))
     .map(check)
     .map(TraceUtil.promiseify(({ item: health, trace }) => {
       health.mapBoth((e) => {
diff --git a/u/server/activity/mod.ts b/u/server/activity/mod.ts
index 6908c26..9d05d3c 100644
--- a/u/server/activity/mod.ts
+++ b/u/server/activity/mod.ts
@@ -6,3 +6,5 @@ export class r200 extends Response {
 
 export interface IActivity<Trace> extends RequestFilter<r200, Trace> {
 }
+
+export * from "./health.ts";
diff --git a/u/server/filter/json.ts b/u/server/filter/json.ts
index 3f11915..f8e4607 100644
--- a/u/server/filter/json.ts
+++ b/u/server/filter/json.ts
@@ -29,4 +29,5 @@ export const json = <BodyT, Trace, JsonT = unknown>(
             return new Response(err.message, { status: 400 });
           })
       ),
-    ).item;
+    )
+    .item;
diff --git a/u/server/filter/method.ts b/u/server/filter/method.ts
index 2bf45a0..a1401b4 100644
--- a/u/server/filter/method.ts
+++ b/u/server/filter/method.ts
@@ -34,4 +34,5 @@ export const requireMethod =
         }
 
         return Either.right<Response, HttpMethod>(method);
-      })).item;
+      }))
+      .item;
diff --git a/u/server/mod.ts b/u/server/mod.ts
index 556771d..52b26e2 100644
--- a/u/server/mod.ts
+++ b/u/server/mod.ts
@@ -1 +1,2 @@
 export * from "./filter/mod.ts";
+export * from "./activity/mod.ts";
-- 
cgit v1.2.3-70-g09d2