improve

packages/common/src/models/index.ts

@@ -1 +1,2 @@
 export * from "./users";
+export * from "./lang";

packages/common/src/models/lang.ts

@@ -0,0 +1,6 @@
+export const SUPPORTED_LANGS = ["fr", "en"];
+export type SupportedLangs = (typeof SUPPORTED_LANGS)[number];
+
+export function isSupportedLang(obj: unknown): obj is SupportedLangs {
+  return (SUPPORTED_LANGS as unknown[]).includes(obj);
+}

packages/common/src/models/users/user.ts

@@ -5,12 +5,22 @@ export enum UserTypeEnum {
   Professional = "professional",
 }
 
-export const userParser = z.object({
+const userParser = z.object({
   id: z.string({ message: "inavlid user id" }),
   firstName: z.string({ message: "invalid user first name" }),
   lastName: z.string({ message: "invalid last name" }),
   email: z.string().email({ message: "invalid email" }),
-  type: z.nativeEnum(UserTypeEnum, { message: "invalid user type" }),
+  //type: z.nativeEnum(UserTypeEnum, { message: "invalid user type" }),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  deletedAt: z.date().optional(),
+});
+
+export const createUserParser = userParser.pick({
+  firstName: true,
+  lastName: true,
+  email: true,
 });
 
 export type User = z.infer<typeof userParser>;
+export type CreateUser = z.infer<typeof createUserParser>;

packages/common/src/utils/index.ts

@@ -1 +1,2 @@
 export * from "./common";
+export * from "./result";

packages/common/src/utils/result.ts

@@ -0,0 +1,32 @@
+export type Result<S, E> = ResSuccess<S> | ResError<E>;
+
+export const Result = {
+  success<S>(data: S): Result<S, never> {
+    return new ResSuccess(data);
+  },
+  error<E>(error: E): Result<never, E> {
+    return new ResError(error);
+  },
+} as const;
+
+interface BaseResult<S, E> {
+  map<T>(f: (s: S) => T): Result<T, E>;
+}
+class ResSuccess<S> implements BaseResult<S, never> {
+  readonly ok: true = true;
+
+  constructor(readonly data: S) {}
+
+  map<T>(f: (t: S) => T): Result<T, never> {
+    return new ResSuccess(f(this.data));
+  }
+}
+class ResError<E> implements BaseResult<never, E> {
+  readonly ok: false = false;
+
+  constructor(readonly err: E) {}
+
+  map<T>(): Result<T, E> {
+    return this as Result<T, E>;
+  }
+}