Move to nodejs and also lots of significant refactoring that should've been broken up but idgaf

3 files changed, 21 insertions, 31 deletions

diff --git a/u/server/filter/index.ts b/u/server/filter/index.ts
index 62a584d..75168c7 100644
--- a/u/server/filter/index.ts
+++ b/u/server/filter/index.ts
@@ -27,7 +27,7 @@ export interface RequestFilter<
     Err extends PenguenoError = PenguenoError,
     RIn = ITraceable<PenguenoRequest, ServerTrace>,
 > {
-    (req: RIn): Promise<IEither<Err, T>>;
+    (req: RIn): IEither<Err, T> | Promise<IEither<Err, T>>;
 }
 
 export * from './method.js';
diff --git a/u/server/filter/json.ts b/u/server/filter/json.ts
index 527d483..bc53d47 100644
--- a/u/server/filter/json.ts
+++ b/u/server/filter/json.ts
@@ -15,30 +15,22 @@ export interface JsonTransformer<R, ParsedJson = unknown> {
     (json: ITraceable<ParsedJson, ServerTrace>): IEither<PenguenoError, R>;
 }
 
-const ParseJsonMetric = Metric.fromName('JsonParse');
+const ParseJsonMetric = Metric.fromName('JsonParse').asResult();
 export const jsonModel =
     <MessageT>(jsonTransformer: JsonTransformer<MessageT>): RequestFilter<MessageT> =>
     (r: ITraceable<PenguenoRequest, ServerTrace>) =>
         r
-            .bimap(TraceUtil.withFunctionTrace(jsonModel))
-            .bimap(TraceUtil.withMetricTrace(ParseJsonMetric))
+            .flatMap(TraceUtil.withFunctionTrace(jsonModel))
+            .flatMap(TraceUtil.withMetricTrace(ParseJsonMetric))
             .map((j) =>
-                Either.fromFailableAsync<Error, MessageT>(<Promise<MessageT>>j.get().json()).then((either) =>
+                Either.fromFailableAsync<Error, MessageT>(<Promise<MessageT>>j.get().req.json()).then((either) =>
                     either.mapLeft((errReason) => {
-                        j.trace.addTrace(LogLevel.WARN).trace(errReason);
+                        j.trace.traceScope(LogLevel.WARN).trace(errReason);
                         return new PenguenoError('seems to be invalid JSON (>//<) can you fix?', 400);
                     }),
                 ),
             )
-            .peek(
-                TraceUtil.promiseify((traceableEither) =>
-                    traceableEither
-                        .get()
-                        .fold(({ isLeft }) =>
-                            traceableEither.trace.trace(ParseJsonMetric[isLeft ? 'failure' : 'success']),
-                        ),
-                ),
-            )
+            .flatMapAsync(TraceUtil.promiseify(TraceUtil.traceResultingEither(ParseJsonMetric)))
             .map(
                 TraceUtil.promiseify((traceableEitherJson) =>
                     traceableEitherJson
diff --git a/u/server/filter/method.ts b/u/server/filter/method.ts
index 5ca5716..7d6aa76 100644
--- a/u/server/filter/method.ts
+++ b/u/server/filter/method.ts
@@ -1,5 +1,7 @@
 import {
     Either,
+    HttpMethod,
+    IEither,
     type ITraceable,
     LogLevel,
     PenguenoError,
@@ -9,24 +11,20 @@ import {
     TraceUtil,
 } from '@emprespresso/pengueno';
 
-type HttpMethod = 'POST' | 'GET' | 'HEAD' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
-
 export const requireMethod =
     (methods: Array<HttpMethod>): RequestFilter<HttpMethod> =>
     (req: ITraceable<PenguenoRequest, ServerTrace>) =>
         req
-            .bimap(TraceUtil.withFunctionTrace(requireMethod))
-            .move(Promise.resolve(req.get()))
-            .map(
-                TraceUtil.promiseify((t) => {
-                    const { method: _method } = t.get();
-                    const method = <HttpMethod>_method;
-                    if (!methods.includes(method)) {
-                        const msg = "that's not how you pet me (⋟﹏⋞)~";
-                        t.trace.addTrace(LogLevel.WARN).trace(msg);
-                        return Either.left<PenguenoError, HttpMethod>(new PenguenoError(msg, 405));
-                    }
-                    return Either.right<PenguenoError, HttpMethod>(method);
-                }),
-            )
+            .flatMap(TraceUtil.withFunctionTrace(requireMethod))
+            .map((t): IEither<PenguenoError, HttpMethod> => {
+                const {
+                    req: { method },
+                } = t.get();
+                if (!methods.includes(method)) {
+                    const msg = "that's not how you pet me (⋟﹏⋞)~";
+                    t.trace.traceScope(LogLevel.WARN).trace(msg);
+                    return Either.left(new PenguenoError(msg, 405));
+                }
+                return Either.right(method);
+            })
             .get();