<?php

namespace App\Controller;

use App\Entity\Skill;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Request;
use OpenApi\Attributes as OAT;
use Symfony\Component\Validator\Validator\ValidatorInterface;
use Symfony\Component\Security\Http\Attribute\IsGranted;
use App\Service\ApiFrontendService;

class ApiSkillsController extends AbstractController
{
    private ApiFrontendService $apiFrontendService;
    public function __construct(EntityManagerInterface $entityManager, ValidatorInterface $validator) {
        $this->apiFrontendService = new ApiFrontendService($entityManager, $validator);
    }
    /**
     * Список навыков
     */
    #[OAT\Get(
        path: '/api/skills',
        security: ['X-AUTH-TOKEN'],
        operationId: 'app_api_skill',
        description: 'Список всех навыков',
        tags: ['Skills'],
        responses: [
            new OAT\Response(
                response: 200,
                description: 'All skills',
                content: new OAT\JsonContent(
                    type: 'array',
                    items: new OAT\Items(ref: "#/components/schemas/Skill")
                )
            ),
        ]
    )]
    #[IsGranted('ROLE_USER')]
    #[Route('/api/skills', name: 'app_api_skill', methods: ['GET'])]
    public function index(): JsonResponse
    {
        return $this->apiFrontendService->getAllEntity('App\Entity\Skill');
    }

    /**
     * Создание навыка.
     */
    #[OAT\Post(
        path: '/api/skills',
        security: ['X-AUTH-TOKEN'],
        operationId: 'app_api_skill_create',
        description: 'Заведение нового навыка',
        tags: ['Skills'],
        parameters: [
            new OAT\RequestBody(
                required: true,
                content: new OAT\JsonContent(ref: "#/components/schemas/Skill")
                   
            )],
        responses: [
            new OAT\Response(
                response: 200,
                description: 'Entity созданного навыка',
                content: new OAT\JsonContent(
                    type: 'array',
                    items: new OAT\Items(ref: "#/components/schemas/Skill")
                )
            ),
        ]
    )
    ]
    #[IsGranted('ROLE_USER')]
    #[Route('/api/skills', name: 'app_api_skill_create', methods: ['POST'])]
    public function create(Request $request, EntityManagerInterface $em, ValidatorInterface $validator): JsonResponse
    {
        $rq = json_decode($request->getContent());
        $skill = new Skill();
        $skill->setTitle($rq->title);
       
        $errors = $validator->validate($skill);
        if (count($errors) > 0) {
            return new JsonResponse([
                'errors' => array_map(function ($error) {
                    return [
                        'property' => $error->getPropertyPath(),
                        'message' => $error->getMessage()
                    ];
                }, iterator_to_array($errors))
            ]);
        }
        $em->getRepository(Skill::class)->save($skill, true);

        return new JsonResponse([
            'data' => $skill->asArray(),
            'errors' => []
        ]);
    }

    /**
     * Редактирование навыка.
     */
    #[OAT\Put(
        path: '/api/skills/{id}',
        security: ['X-AUTH-TOKEN'],
        operationId: 'app_api_skill_edit',
        description: 'Редактирование навыка',
        tags: ['Skills'],
        parameters: [
            new OAT\RequestBody(
                required: true,
                content: new OAT\JsonContent(ref: "#/components/schemas/Skill")
                   
            )],
        responses: [
            new OAT\Response(
                response: 200,
                description: 'Entity навыка',
                content: new OAT\JsonContent(
                    type: 'array',
                    items: new OAT\Items(ref: "#/components/schemas/Skill")
                )
            ),
        ]
    )]
    #[IsGranted('ROLE_USER')]
    #[Route('/api/skills/{id}', name: 'app_api_skill_edit', methods: ['PUT'])]
    public function editDepartament(int $id, Request $request, EntityManagerInterface $em, ValidatorInterface $validator): JsonResponse
    {
        $rq = json_decode($request->getContent());
        $repo = $em->getRepository(Skill::class);
        $departament = $repo->findOneBy([
            'id' => $id
        ]);
        if(!$departament) {
            return new JsonResponse([
                'errors' => ['Invalid ID']
            ]);
        }
        $departament->setTitle($rq->title);
        $errors = $validator->validate($departament);
        if (count($errors) > 0) {
            return new JsonResponse([
                'errors' => array_map(function ($error) {
                    return [
                        'property' => $error->getPropertyPath(),
                        'message' => $error->getMessage()
                    ];
                }, iterator_to_array($errors))
            ]);
        }
        $repo->save($departament, true);
        
        return new JsonResponse([
            'data' => $departament->asArray(),
            'errors' => []
        ]);
    }

    /**
     * Получение навыка по ID
     */
    #[OAT\Get(
        path: '/api/skills/{id}',
        description: 'Получение навыка по ID',
        tags: ['Skills'],
        responses: [
            new OAT\Response(
                response: 200,
                description: 'Departament entity',
                content: new OAT\JsonContent(ref: "#/components/schemas/Skill")
            ),
        ]
    )]
    #[IsGranted('ROLE_USER')]
    #[Route('/api/skills/{id}', methods: ['GET'])]
    public function get(int $id): JsonResponse
    {
        return $this->apiFrontendService->getEntityById('App\Entity\Skill', $id);
    }
}

<?php
namespace App\Service;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Validator\Validator\ValidatorInterface;

/**
 * Frontend сервис для унификации ответов JSON
 */
class ApiFrontendService
{
    private EntityManagerInterface $entityManager;
    private ValidatorInterface $validator;
    
    public function __construct(EntityManagerInterface $entityManager, ValidatorInterface $validator)
    {
        $this->entityManager = $entityManager;
        $this->validator = $validator;
    }

    /**
     * Получение Entity по Entity.ID
     * @return JsonResponse(Entity[])
     */
    public function getAllEntity(string $className): JsonResponse
    {
        return new JsonResponse(
            array_map(function($entity) {
                return $entity->asArray();
            }, $this->entityManager->getRepository($className)->findAll())
        );
    }

    /**
     * Получение Entity по критерию
     * @return JsonResponse(Entity[])
     */
    public function getEntityListByCriteria(string $className, array $criteria): JsonResponse
    {
        return new JsonResponse(
            array_map(function($entity) {
                return $entity->asArray();
            }, $this->entityManager->getRepository($className)->findBy($criteria))
        );
    }

    /**
     * Получение Entity по наличию memberValue в memberProp 
     * @return JsonResponse(Entity[])
     */
    public function getEntityMembersColllection(string $className, string $propName, int $memberValue): JsonResponse
    {
        $members = $this->entityManager->getRepository($className)->createQueryBuilder('e')
            ->where(':memeber_value MEMBER OF e.'.$propName)
            ->setParameter('memeber_value', $memberValue)
            ->getQuery()
            ->getResult();
        if(!$members) {
            return new JsonResponse(null, 200);
        }
        return new JsonResponse(array_map(function($entity) {
            return $entity->asArray();
        }, $members));
    }

    /**
     * Получение Entity по Entity.ID
     * @return JsonResponse(Entity)
     */
    public function getEntityById(string $className, int $id): JsonResponse
    {
        $entity = $this->entityManager->getRepository($className)->findOneBy([
            'id' => $id
        ]);
        if (!$entity) {
            return new JsonResponse(null, 404);
        }
        return new JsonResponse($entity->asArray());
    }

    /**
     * Сохранние сущности
     * @return JsonResponse(Entity|Errors[{property:string,message:string}])
     */
    public function saveEntity(string $className, $entity): JsonResponse
    {
        $errors = $this->validator->validate($entity);

        if (count($errors) > 0) {
            return new JsonResponse([
                'errors' => array_map(function ($error) {
                    return [
                        'property' => $error->getPropertyPath(),
                        'message' => $error->getMessage()
                    ];
                }, iterator_to_array($errors))
            ], 400);
        }
        
        $this->entityManager->getRepository($className)->save($entity, true);

        return new JsonResponse($entity->asArray(), 200);
    }
}

import { ref } from 'vue'
import { defineStore } from 'pinia'
import http from '@/http';
export const useUsersStore = defineStore('users', () => {
    /**
     * Список пользователей
     */
    const list = ref([] as any[]);

    /**
     * Загрузка списка пользователей
     * @returns Promise<AxiosResponse> with Users[] entity
     */
    const fetchList = async function fetchList():Promise<any[]> {
        const response = await http.get('/api/users');
        if(response.status === 200 && response.data) {
            list.value = response.data;
        }
        return response.data;
    };

    /**
     * Получение профиля пользователя по ID
     * @param id User.id
     * @returns Promise<AxiosResponse> with User entity
     */
    const fetchUser = async function fetchUser(id:number):Promise<any> {
        return await http.get(`/api/user/${id}`);
    };
    
    /**
     * Создание нового пользователя
     * @param user object
     * @returns Promise<AxiosResponse> with User entity
     */
    const create = async (user:any):Promise<any> => await http.post('/api/users/new', user);

    /**
     * Редактирование пользователя
     * @param id number
     * @param user object
     * @returns Promise<AxiosResponse> with User entity
     */
    const update = async (id:number, user:any):Promise<any> => await http.put(`/api/users/${id}`, user);

    /**
     * Фильтр по пользователю
     * @param id number userId
     * @returns Users[]
     */
    const getUserById = (id:Number) => {
        return list.value.filter(u => u.id === id)[0];
    }

  return { list, fetchList, fetchUser, create, update, getUserById }
});

Список резюме: