Move server directory outside of frontend src

server/controllers/album-artists.controller.ts

@@ -0,0 +1,45 @@
+import { Request, Response } from 'express';
+import { ApiSuccess, getSuccessResponse } from '@/utils';
+import { service } from '@services/index';
+import { validation, TypedRequest } from '@validations/index';
+
+const getList = async (req: Request, res: Response) => {
+  const { take, skip, serverFolderIds } = req.query;
+  const albumArtists = await service.albumArtists.findMany(req, {
+    serverFolderIds: String(serverFolderIds),
+    skip: Number(skip),
+    take: Number(take),
+    user: req.authUser,
+  });
+
+  const success = ApiSuccess.ok({
+    data: albumArtists.data,
+    paginationItems: {
+      skip: Number(skip),
+      take: Number(take),
+      totalEntries: albumArtists.totalEntries,
+      url: req.originalUrl,
+    },
+  });
+
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const getDetail = async (
+  req: TypedRequest<typeof validation.albumArtists.detail>,
+  res: Response
+) => {
+  const { id } = req.params;
+  const albumArtist = await service.albumArtists.findById({
+    id,
+    user: req.authUser,
+  });
+
+  const success = ApiSuccess.ok({ data: albumArtist });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+export const albumArtistsController = {
+  getDetail,
+  getList,
+};

server/controllers/albums.controller.ts

@@ -0,0 +1,102 @@
+import { Response } from 'express';
+import { ApiSuccess, getSuccessResponse } from '@/utils';
+import { toApiModel } from '@helpers/api-model';
+import { service } from '@services/index';
+import { TypedRequest, validation } from '@validations/index';
+
+const getDetail = async (
+  req: TypedRequest<typeof validation.albums.detail>,
+  res: Response
+) => {
+  const { albumId } = req.params;
+
+  const album = await service.albums.findById(req.authUser, { id: albumId });
+
+  const success = ApiSuccess.ok({
+    data: toApiModel.albums({ items: [album], user: req.authUser })[0],
+  });
+
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const getList = async (
+  req: TypedRequest<typeof validation.albums.list>,
+  res: Response
+) => {
+  const { serverId } = req.params;
+  const { take, skip, serverUrlId } = req.query;
+
+  const albums = await service.albums.findMany({
+    ...req.query,
+    serverId,
+    skip: Number(skip),
+    take: Number(take),
+    user: req.authUser,
+  });
+
+  const serverUrl = serverUrlId
+    ? await service.servers.findServerUrlById({
+        id: serverUrlId,
+      })
+    : undefined;
+
+  const success = ApiSuccess.ok({
+    data: toApiModel.albums({
+      items: albums.data,
+      serverUrl: serverUrl?.url,
+      user: req.authUser,
+    }),
+    paginationItems: {
+      skip: Number(skip),
+      take: Number(take),
+      totalEntries: albums.totalEntries,
+      url: req.originalUrl,
+    },
+  });
+
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const getDetailSongList = async (
+  req: TypedRequest<typeof validation.albums.list>,
+  res: Response
+) => {
+  const { serverId } = req.params;
+  const { take, skip, serverUrlId } = req.query;
+
+  const albums = await service.albums.findMany({
+    ...req.query,
+    serverId,
+    skip: Number(skip),
+    take: Number(take),
+    user: req.authUser,
+  });
+
+  const serverUrl = serverUrlId
+    ? await service.servers.findServerUrlById({
+        id: serverUrlId,
+      })
+    : undefined;
+
+  const success = ApiSuccess.ok({
+    data: toApiModel.albums({
+      items: albums.data,
+      serverUrl: serverUrl?.url,
+      user: req.authUser,
+    }),
+    paginationItems: {
+      skip: Number(skip),
+      take: Number(take),
+      totalEntries: albums.totalEntries,
+      url: req.originalUrl,
+    },
+  });
+
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+export const albumsController = {
+  getDetail,
+  getDetailSongList,
+  getList,
+};

server/controllers/artists.controller.ts

@@ -0,0 +1,50 @@
+import { Response } from 'express';
+import { ApiSuccess, getSuccessResponse } from '@/utils';
+import { service } from '@services/index';
+import { validation, TypedRequest } from '@validations/index';
+
+const getDetail = async (
+  req: TypedRequest<typeof validation.artists.detail>,
+  res: Response
+) => {
+  const { id } = req.params;
+
+  const artist = await service.artists.findById({
+    id,
+    user: req.authUser,
+  });
+
+  const success = ApiSuccess.ok({ data: artist });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const getList = async (
+  req: TypedRequest<typeof validation.artists.list>,
+  res: Response
+) => {
+  const { take, skip, serverFolderId } = req.query;
+
+  // const artists = await service.artists.findMany(req, {
+  //   serverFolderIds: String(serverFolderIds),
+  //   skip: Number(skip),
+  //   take: Number(take),
+  //   user: req.authUser,
+  // });
+
+  // const success = ApiSuccess.ok({
+  //   data: artists,
+  //   paginationItems: {
+  //     skip: Number(skip),
+  //     take: Number(take),
+  //     totalEntries,
+  //     url: req.originalUrl,
+  //   },
+  // });
+
+  // return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+export const artistsController = {
+  getDetail,
+  getList,
+};

server/controllers/auth.controller.ts

@@ -0,0 +1,67 @@
+import { Request, Response } from 'express';
+import { ApiSuccess, getSuccessResponse } from '@/utils';
+import { toApiModel } from '@helpers/api-model';
+import { service } from '@services/index';
+import { validation, TypedRequest } from '@validations/index';
+import packageJson from '../package.json';
+
+const login = async (
+  req: TypedRequest<typeof validation.auth.login>,
+  res: Response
+) => {
+  const { username } = req.body;
+  const user = await service.auth.login({ username });
+
+  const success = ApiSuccess.ok({ data: toApiModel.users([user])[0] });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const register = async (
+  req: TypedRequest<typeof validation.auth.register>,
+  res: Response
+) => {
+  const { username, password } = req.body;
+  const user = await service.auth.register({
+    password,
+    username,
+  });
+
+  const success = ApiSuccess.ok({ data: toApiModel.users([user])[0] });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const logout = async (req: Request, res: Response) => {
+  await service.auth.logout({
+    user: req.authUser,
+  });
+
+  const success = ApiSuccess.noContent({ data: {} });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const ping = async (_req: Request, res: Response) => {
+  return res.status(200).json(
+    getSuccessResponse({
+      data: {
+        description: packageJson.description,
+        name: packageJson.name,
+        version: packageJson.version,
+      },
+      statusCode: 200,
+    })
+  );
+};
+
+const refresh = async (
+  req: TypedRequest<typeof validation.auth.refresh>,
+  res: Response
+) => {
+  const refresh = await service.auth.refresh({
+    refreshToken: req.body.refreshToken,
+  });
+
+  const success = ApiSuccess.ok({ data: refresh });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+export const authController = { login, logout, ping, refresh, register };

server/controllers/index.ts

@@ -0,0 +1,17 @@
+import { albumArtistsController } from './album-artists.controller';
+import { albumsController } from './albums.controller';
+import { artistsController } from './artists.controller';
+import { authController } from './auth.controller';
+import { serversController } from './servers.controller';
+import { songsController } from './songs.controller';
+import { usersController } from './users.controller';
+
+export const controller = {
+  albumArtists: albumArtistsController,
+  albums: albumsController,
+  artists: artistsController,
+  auth: authController,
+  servers: serversController,
+  songs: songsController,
+  users: usersController,
+};

server/controllers/servers.controller.ts

@@ -0,0 +1,177 @@
+import { Response } from 'express';
+import { ApiSuccess, getSuccessResponse } from '@/utils';
+import { toApiModel } from '@helpers/api-model';
+import { service } from '@services/index';
+import { TypedRequest, validation } from '@validations/index';
+
+const getServerDetail = async (
+  req: TypedRequest<typeof validation.servers.detail>,
+  res: Response
+) => {
+  const { serverId } = req.params;
+  const data = await service.servers.findById(req.authUser, { id: serverId });
+  const success = ApiSuccess.ok({ data: toApiModel.servers([data]) });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const getServerList = async (
+  req: TypedRequest<typeof validation.servers.list>,
+  res: Response
+) => {
+  const data = await service.servers.findMany(req.authUser);
+  const success = ApiSuccess.ok({ data: toApiModel.servers(data) });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const deleteServer = async (
+  req: TypedRequest<typeof validation.servers.deleteServer>,
+  res: Response
+) => {
+  const { serverId } = req.params;
+  await service.servers.deleteById({ id: serverId });
+  const success = ApiSuccess.noContent({ data: null });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const createServer = async (
+  req: TypedRequest<typeof validation.servers.create>,
+  res: Response
+) => {
+  const remoteServerLoginRes = await service.servers.remoteServerLogin(
+    req.body
+  );
+
+  const data = await service.servers.create({
+    name: req.body.name,
+    ...remoteServerLoginRes,
+  });
+
+  const success = ApiSuccess.ok({ data: toApiModel.servers([data])[0] });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const updateServer = async (
+  req: TypedRequest<typeof validation.servers.update>,
+  res: Response
+) => {
+  const { serverId } = req.params;
+  const { username, password, name, legacy, type, url } = req.body;
+
+  if (type && username && password && url) {
+    const remoteServerLoginRes = await service.servers.remoteServerLogin({
+      legacy,
+      password,
+      type,
+      url,
+      username,
+    });
+
+    const data = await service.servers.update(
+      { id: serverId },
+      { name, ...remoteServerLoginRes }
+    );
+
+    const success = ApiSuccess.ok({ data: toApiModel.servers([data])[0] });
+    return res.status(success.statusCode).json(getSuccessResponse(success));
+  }
+
+  const data = await service.servers.update({ id: serverId }, { name, url });
+  const success = ApiSuccess.ok({ data: toApiModel.servers([data])[0] });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const refreshServer = async (
+  req: TypedRequest<typeof validation.servers.refresh>,
+  res: Response
+) => {
+  const { serverId } = req.params;
+  const data = await service.servers.refresh({ id: serverId });
+
+  const success = ApiSuccess.ok({ data: toApiModel.servers([data])[0] });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const scanServer = async (
+  req: TypedRequest<typeof validation.servers.scan>,
+  res: Response
+) => {
+  const { serverId } = req.params;
+  const { serverFolderId } = req.body;
+
+  const data = await service.servers.fullScan({
+    id: serverId,
+    serverFolderId,
+  });
+
+  const success = ApiSuccess.ok({ data });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const createServerUrl = async (
+  req: TypedRequest<typeof validation.servers.createUrl>,
+  res: Response
+) => {
+  const { serverId } = req.params;
+  const { url } = req.body;
+
+  const data = await service.servers.createUrl({
+    serverId,
+    url,
+  });
+
+  const success = ApiSuccess.ok({ data });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const deleteServerUrl = async (
+  req: TypedRequest<typeof validation.servers.deleteUrl>,
+  res: Response
+) => {
+  const { urlId } = req.params;
+
+  await service.servers.deleteUrlById({
+    id: urlId,
+  });
+
+  const success = ApiSuccess.noContent({ data: null });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const enableServerUrl = async (
+  req: TypedRequest<typeof validation.servers.enableUrl>,
+  res: Response
+) => {
+  const { serverId, urlId } = req.params;
+
+  await service.servers.enableUrlById(req.authUser, {
+    id: urlId,
+    serverId,
+  });
+
+  const success = ApiSuccess.noContent({ data: null });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const disableServerUrl = async (
+  req: TypedRequest<typeof validation.servers.disableUrl>,
+  res: Response
+) => {
+  await service.servers.disableUrlById(req.authUser);
+
+  const success = ApiSuccess.noContent({ data: null });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+export const serversController = {
+  createServer,
+  createServerUrl,
+  deleteServer,
+  deleteServerUrl,
+  disableServerUrl,
+  enableServerUrl,
+  getServerDetail,
+  getServerList,
+  refreshServer,
+  scanServer,
+  updateServer,
+};

server/controllers/songs.controller.ts

@@ -0,0 +1,33 @@
+import { Request, Response } from 'express';
+
+const getSongList = async (req: Request, res: Response) => {
+  const { serverId } = req.params;
+  const { take, skip, serverFolderId } = req.query;
+
+  // const songs = await songsService.findMany(req, {
+  //   serverFolderIds: String(serverFolderId),
+  //   serverId,
+  //   skip: Number(skip),
+  //   take: Number(take),
+  //   user: req.authUser,
+  // });
+
+  // const success = ApiSuccess.ok({
+  //   // data: toRes.songs(songs.data, req.authUser),
+  //   data: songs.data,
+  //   paginationItems: {
+  //     skip: Number(skip),
+  //     take: Number(take),
+  //     totalEntries: songs.totalEntries,
+  //     url: req.originalUrl,
+  //   },
+  // });
+
+  return {};
+
+  // return res.status(data.statusCode).json(getSuccessResponse(data));
+};
+
+export const songsController = {
+  getSongList,
+};

server/controllers/users.controller.ts

@@ -0,0 +1,22 @@
+import { Request, Response } from 'express';
+import { ApiSuccess, getSuccessResponse } from '@/utils';
+import { toApiModel } from '@helpers/api-model';
+import { service } from '@services/index';
+
+const getUserDetail = async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const user = await service.users.findById(req.authUser, { id });
+  const success = ApiSuccess.ok({ data: toApiModel.users([user])[0] });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+const getUserList = async (_req: Request, res: Response) => {
+  const users = await service.users.findMany();
+  const success = ApiSuccess.ok({ data: toApiModel.users(users) });
+  return res.status(success.statusCode).json(getSuccessResponse(success));
+};
+
+export const usersController = {
+  getUserDetail,
+  getUserList,
+};