Add login

src/entities/game/game.ts

@@ -1,4 +1,4 @@
-import { HTTPService } from "@/shared/http/httpService";
+import { HTTPService } from "@/shared/utils/http";
 import { gameCardsSchema, GameCardType } from "./schemas/gameCard";
 import { gameSchema, GameType } from "./schemas/game";
 

src/entities/game/schemas/gameCard.ts

@@ -1,35 +1,35 @@
 import { z } from "zod";
 
 export const gameCardSchema = z
-  .object({
-    id: z.number(),
-    title: z.string().min(3),
-    cover: z.string().optional(),
-    description: z.string().optional(),
-    version: z.string().optional(),
-  })
-  .transform((card) => {
-    return {
-      ...card,
-      cover: card.cover
-        ? process.env.NEXT_PUBLIC_COVER_FULL_URL + "/" + card.cover
-        : undefined,
-      cover_preview: card.cover
-        ? process.env.NEXT_PUBLIC_COVER_PREVIEW_URL + "/" + card.cover
-        : undefined,
-    };
-  });
+	.object({
+		id: z.number().positive(),
+		title: z.string().min(3),
+		cover: z.string().optional(),
+		description: z.string().optional(),
+		version: z.string().optional(),
+	})
+	.transform((card) => {
+		return {
+			...card,
+			cover: card.cover
+				? process.env.NEXT_PUBLIC_COVER_FULL_URL + "/" + card.cover
+				: undefined,
+			cover_preview: card.cover
+				? process.env.NEXT_PUBLIC_COVER_PREVIEW_URL + "/" + card.cover
+				: undefined,
+		};
+	});
 export type GameCardType = z.infer<typeof gameCardSchema>;
 
 export const isGameCard = (a: any): a is GameCardType => {
-  return gameCardSchema.safeParse(a).success;
+	return gameCardSchema.safeParse(a).success;
 };
 
 export const gameCardsSchema = z.array(z.any()).transform((a) => {
-  const cards: GameCardType[] = [];
-  a.forEach((e) => {
-    if (isGameCard(e)) cards.push(gameCardSchema.parse(e));
-    else console.error("GameCard parse error - ", e);
-  });
-  return cards;
+	const cards: GameCardType[] = [];
+	a.forEach((e) => {
+		if (isGameCard(e)) cards.push(gameCardSchema.parse(e));
+		else console.error("GameCard parse error - ", e);
+	});
+	return cards;
 });

src/entities/user/index.ts

@@ -0,0 +1,16 @@
+import {
+	loginFormSchema,
+	loginFormFieldNames,
+	LoginForm,
+} from "./schemas/auth";
+import { userSchema, User } from "./schemas/user";
+import { UserService } from "./user";
+
+export {
+	loginFormSchema,
+	loginFormFieldNames,
+	UserService,
+	userSchema,
+	type User,
+	type LoginForm,
+};

src/entities/user/schemas/auth.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { userSchema } from "./user";
+
+export const loginFormSchema = z.object({
+	username: z.string().min(3, "Логин слишком короткий"),
+	password: z.string().min(3, "Пароль слишком короткий"),
+});
+export const loginFormFieldNames = {
+	username: "Логин",
+	password: "Пароль",
+};
+export type LoginForm = z.infer<typeof loginFormSchema>;
+
+export const tokenResponseSchema = z
+	.object({
+		access_token: z.string(),
+		token_type: z.string(),
+	})
+	.transform((tokenResponse) => tokenResponse.access_token);
+export type TokenResponse = z.infer<typeof tokenResponseSchema>;
+
+export const tokenDataSchema = userSchema.merge(
+	z.object({
+		expire: z
+			.string()
+			.min(1)
+			.transform((d) => new Date(d)),
+	})
+);
+export type TokenData = z.infer<typeof tokenDataSchema>;

src/entities/user/schemas/user.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const userSchema = z.object({
+	id: z.number().positive(),
+	name: z.string().min(3),
+	email: z.string().min(3),
+});
+export type User = z.infer<typeof userSchema>;

src/entities/user/user.ts

@@ -0,0 +1,48 @@
+import { HTTPService } from "@/shared/utils/http";
+import {
+	LoginForm,
+	TokenData,
+	tokenDataSchema,
+	TokenResponse,
+	tokenResponseSchema,
+} from "./schemas/auth";
+import { jwtDecode } from "jwt-decode";
+import Cookies from "js-cookie";
+
+export abstract class UserService {
+	public static async Login(loginForm: LoginForm) {
+		const accessToken = await HTTPService.post<TokenResponse>(
+			"/auth",
+			new URLSearchParams(Object.entries(loginForm)),
+			tokenResponseSchema,
+			{
+				"Content-Type": "application/x-www-form-urlencoded",
+			}
+		);
+		if (accessToken) {
+			const tokenData = this.DecodeToken(accessToken);
+			if (tokenData) {
+				Cookies.set("access-token", accessToken, {
+					secure: true,
+					expires: tokenData.expire,
+				});
+				return tokenData;
+			}
+		}
+	}
+
+	public static IdentifyYourself(): TokenData | undefined {
+		const token = Cookies.get("access-token");
+		if (token) {
+			return this.DecodeToken(token);
+		}
+	}
+
+	public static DecodeToken(token: string): TokenData | undefined {
+		const tokenPayload = jwtDecode(token);
+		const parseResult = tokenDataSchema.safeParse(tokenPayload);
+		if (parseResult.success) {
+			return parseResult.data;
+		} else console.error("JWT payload broken - " + parseResult.error);
+	}
+}