From 3612a8a86d7aefd68d03381d360affa015089c1d Mon Sep 17 00:00:00 2001
From: ton1c <sembl1@ya.ru>
Date: Wed, 29 Jan 2025 01:50:26 +0300
Subject: [PATCH] working on validator

---
 server/src/middleware/logger.ts |  4 ++--
 shared/utils/api.ts             | 19 +++++++++++++------
 shared/utils/option.ts          | 28 +++++++++++++---------------
 shared/utils/result.ts          | 32 ++++++++++++++++++++++++++++++--
 4 files changed, 58 insertions(+), 25 deletions(-)

diff --git a/server/src/middleware/logger.ts b/server/src/middleware/logger.ts
index 8e3555b..20ede98 100644
--- a/server/src/middleware/logger.ts
+++ b/server/src/middleware/logger.ts
@@ -1,9 +1,9 @@
 import { Middleware } from "@lib/router.ts";
 
 const loggerMiddleware: Middleware = async (c, next) => {
-    console.log(c.req.method, c.path);
+    console.log("", c.req.method, c.path);
     await next();
-    console.log(c.res.status);
+    console.log("", c.res.status, "\n");
 };
 
 export default loggerMiddleware;
diff --git a/shared/utils/api.ts b/shared/utils/api.ts
index 6a845a0..54e9f12 100644
--- a/shared/utils/api.ts
+++ b/shared/utils/api.ts
@@ -1,11 +1,18 @@
-interface LoginRequest {
-    password: string;
+import { Result } from "@shared/utils/result.ts";
+
+class ValidationError extends BaseError {
+    code = "ValidationError";
+    constructor(msg: string) {
+        super(msg);
+    }
 }
 
-interface LoginResponse {
-    err: "InvalidPassword" | "InvalidInput";
+class ClientApi<Req, Res> {
+    constructor(path: string, method: string) {}
+    validate(res: Response): ResultAsync<Res> {
+        const body = await res.json();
+    }
 }
 
-class Api<Req, Res> {
-    makeRequest();
+class ServerApi<Req, Res> {
 }
diff --git a/shared/utils/option.ts b/shared/utils/option.ts
index 7149c7b..ce550f5 100644
--- a/shared/utils/option.ts
+++ b/shared/utils/option.ts
@@ -1,4 +1,6 @@
-import { err, ok } from "@shared/utils/result.ts";
+import { err, ok, Result } from "@shared/utils/result.ts";
+
+type OptionJSON<T> = { tag: "some"; value: T } | { tag: "none" };
 
 interface IOption<T> {
     /**
@@ -64,7 +66,6 @@ interface IOption<T> {
      * ```
      * @param {Function} The function `fn` that takes the value inside the `Option<T>` and returns a new `Option<U>`.
      * @returns {Option<U>} A new `Option<U>` wrapping the result of the flatMap operation.
-     *
      */
     flatMap<U>(fn: (value: T) => Option<U>): Option<U>;
 
@@ -136,6 +137,8 @@ interface IOption<T> {
     toBoolean(): boolean;
 
     okOrElse<E>(errFn: () => E): Result<T, E>;
+
+    toJSON(): OptionJSON<T>;
 }
 
 /**
@@ -211,17 +214,14 @@ export class Some<T> implements IOption<T> {
         return some(this.value);
     }
 
-    toJSON() {
-        return {
-            //_tag: this._tag,
-            value: this.value,
-        };
-    }
-
     toString() {
         return `Some(${this.value})`;
     }
 
+    toJSON(): OptionJSON<T> {
+        return { tag: "some", value: this.value };
+    }
+
     toNullable(): T | null {
         return this.value;
     }
@@ -307,16 +307,14 @@ export class None<T> implements IOption<T> {
         return none();
     }
 
-    toJSON() {
-        return {
-            _tag: this._tag,
-        };
-    }
-
     toString() {
         return `None`;
     }
 
+    toJSON(): OptionJSON<T> {
+        return { tag: "none" };
+    }
+
     toNullable(): T | null {
         return null;
     }
diff --git a/shared/utils/result.ts b/shared/utils/result.ts
index b85b4b0..4140f79 100644
--- a/shared/utils/result.ts
+++ b/shared/utils/result.ts
@@ -1,9 +1,8 @@
-import { some } from "@shared/utils/option.ts";
+import { none, some } from "@shared/utils/option.ts";
 import { None, type Option, Some } from "@shared/utils/option.ts";
 import { errAsync, okAsync, ResultAsync } from "@shared/utils/resultasync.ts";
 
 type ResultJSON<T, E> = { tag: "ok"; value: T } | { tag: "err"; error: E };
-
 //#region Ok, Err and Result
 interface IResult<T, E> {
     isOk(): this is Ok<T, E>;
@@ -14,6 +13,7 @@ interface IResult<T, E> {
     unwrap(): T;
     unwrapOr<U>(defaultValue: U): T | U;
     unwrapOrElse<U>(fn: () => U): T | U;
+    unwrapErr(): Option<E>;
     match<A, B = A>(ok: (value: T) => A, err: (error: E) => B): A | B;
     map<U>(fn: (value: T) => U): Result<U, E>;
     mapAsync<U>(fn: (value: T) => Promise<U>): ResultAsync<U, E>;
@@ -89,6 +89,10 @@ export class Ok<T, E> implements IResult<T, E> {
         return this.value;
     }
 
+    unwrapErr(): Option<E> {
+        return none;
+    }
+
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     match<A, B = A>(ok: (value: T) => A, err: (error: E) => B): A | B {
         return ok(this.value);
@@ -219,6 +223,9 @@ export class Err<T, E> implements IResult<T, E> {
     unwrapOrElse<U>(fn: () => U): T | U {
         return fn();
     }
+    unwrapErr(): Option<E> {
+        return some(this.error);
+    }
     match<A, B = A>(ok: (value: T) => A, err: (error: E) => B): A | B {
         return err(this.error);
     }
@@ -369,6 +376,27 @@ export type FlattenResult<R> = R extends Result<infer T, infer E>
     : R
     : never;
 
+type ExtractError<R extends Result<unknown, unknown>> = R extends
+    Result<unknown, infer E> ? E : never;
+
+type CollectedErrors<R extends Result<unknown, unknown>[]> = ExtractError<
+    R[number]
+>;
+
+function collectErrors<R extends Result<any, any>[]>(
+    ...results: R
+): CollectedErrors<R>[] {
+    const errors: CollectedErrors<R>[] = [];
+
+    for (const result of results) {
+        if (result.isErr()) {
+            errors.push(result.error);
+        }
+    }
+
+    return errors;
+}
+
 class FailedToParseResult extends Error {
     constructor(json: string) {
         super(`Failed to parse ${json} as result`);