no-copy-frontend/src/app/actions/auth.ts

'use server'

import { SignupFormSchema, loginFormSchema, localDevelopmentUrl } from '@/app/actions/definitions';
import { createSession, deleteSession, getSessionData } from '@/app/actions/session';
import { redirect } from 'next/navigation';

const API_BASE_URL = process.env.NODE_ENV === 'development'
	? localDevelopmentUrl
	: 'http://app:8080';

export async function logout() {
	const token = await getSessionData('token');

	try {
		await fetch(`${API_BASE_URL}/v1/api/auth/logout`, {
			method: 'POST',
			headers: {
				"Content-Type": "application/json",
				"Accept": "application/json",
				"Authorization": `Bearer ${token}`,
			}
		});
	} catch (error) {
		throw error;
	}

	await deleteSession();
	redirect('/login');
}

export async function authorization(
	state: {
		previousState: {
			email: string;
		}
		error: Record<string, string>
	} | undefined,
	formData: FormData,
) {
	const email = formData.get('email') as string || '';
	const password = formData.get('password');

	/* для теста */
	if (email === "test" && password === "test") {
		await createSession("1111", "test");
		redirect('/pages/dashboard');
	}
	/* для теста */

	const validatedFields = loginFormSchema.safeParse({
		email,
		password
	})

	if (!validatedFields.success) {
		const errors: Record<string, string> = {}
		JSON.parse(validatedFields.error.message).forEach((obj: {
			message: string,
			path: string
		}) => {
			if (errors[obj.path[0]]) {
				errors[obj.path[0]] = `${errors[obj.path[0]]} ${obj.message}`;
			} else {
				errors[obj.path[0]] = obj.message;
			}
		});

		return {
			previousState: {
				email
			},
			error: errors
		};
	}

	try {
		const { email, password } = validatedFields.data;
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 20001,
				message_body: {
					email: email,
					password: password
				}
			}),
			headers: {
				"Content-Type": "application/json",
				"Accept": "application/json"
			}
		});
		if (response.ok) {
			let parsed = await response.json();
			if (parsed.message_desc === 'Operation successful') {
				await createSession(parsed.message_body.token, email);
			} else {
				throw (`${parsed.message_code}`);
			}
		} else {
			throw ('request-ended-with-an-error');
		}

	} catch (error) {
		const errors: Record<string, string> = {}

		switch (error) {
			case '2':
				errors['server'] = 'password-does-not-match'
				break;

			case '4':
				errors['server'] = 'email-not-found'
				break;

			default:
				errors['server'] = 'request-ended-with-an-error'
				break;
		}

		if (error) {
			return {
				previousState: {
					email,
					password
				},
				error: errors
			};
		}
		throw error;
	}

	redirect('/pages/dashboard');
}

type FormState = {
	previousState: {
		fullName: string;
		email: string;
		password: string;
		confirm_password: string;
		phone: string;
		companyName: string;
		agree: string;
	}
	error: Record<string, string>
};

export async function registration(
	state: FormState | undefined,
	formData: FormData,
): Promise<FormState> {
	const fullName = formData.get('fullName') as string || '';
	const email = formData.get('email') as string || '';
	const password = formData.get('password') as string || '';
	const confirm_password = formData.get('confirm_password') as string || '';
	const phone = formData.get('phone') as string || '';
	const companyName = formData.get('companyName') as string || '';
	const agree = formData.get('agree') as string || '';

	const validatedFields = SignupFormSchema.safeParse({
		fullName,
		email,
		phone: phone.replace(/[-\(\)\s]/g, ''),
		password,
		confirm_password,
		agree,
	});

	if (!validatedFields.success) {
		const errors: Record<string, string> = {}
		JSON.parse(validatedFields.error.message).forEach((obj: {
			message: string,
			path: string
		}) => {
			if (errors[obj.path[0]]) {
				errors[obj.path[0]] = `${errors[obj.path[0]]}&${obj.message}`;
			} else {
				errors[obj.path[0]] = obj.message;
			}
		});

		return {
			previousState: {
				fullName,
				email,
				password,
				confirm_password,
				phone,
				companyName,
				agree
			},
			error: errors
		};
	}

	try {
		const { fullName, email, password, phone } = validatedFields.data;
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 20002,
				message_body: {
					fullName: fullName,
					email,
					phone: phone,
					password,
					companyName: companyName,
				}
			}),
			headers: {
				"Content-Type": "application/json",
				"Accept": "application/json"
			}
		});

		if (response.ok) {
			let parsed = await response.json() as {
				message_desc: string,
				message_body: { token: string },
				message_code: string
			};
			if (parsed.message_desc === 'Operation successful') {
				await createSession(parsed.message_body.token, email);
			} else {
				console.log('error');
				/* console.log(parsed.message_body); */
				/* throw (`${parsed.message_code.fieldErrors}`); */
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}
	} catch (error: unknown) {
		if (error) {
			const typedError = error as any;
			const errors: Record<string, string> = {};
			console.log(typedError);
			console.log(typedError.message_body);

			switch (typedError.message_code) {
				case 1:
					errors['server'] = 'email-or-already-registered'
					break;

				case 2:
					typedError.message_body.fieldErrors.forEach((obj: {
						code: string,
						field: string
					}) => {
						if (errors[obj.field]) {
							errors[obj.field] = `${errors[obj.field]}&${obj.code.replaceAll('.', '-')}`;
						} else {
							errors[obj.field] = obj.code.replaceAll('.', '-');
						}
					});
					break;

				default:
					errors['server'] = 'request-ended-with-an-error'
					break;
			}

			return {
				previousState: {
					fullName,
					email,
					password,
					confirm_password,
					phone,
					companyName,
					agree
				},
				error: errors
			};
		}
		console.log('finale error');
		console.log(error);
		throw error;
	}

	redirect('/pages/dashboard');
}