feat(tariff/privilege): remove handlers & docs

src/handlers/account/index.ts

@@ -81,3 +81,57 @@ export const setAccountRole = async (request: SetAccountRoleRequest, reply: Fast
 
   return account;
 };
+
+export const removeAccount = async (request: FastifyRequest, reply: FastifyReply) => {
+  if (!Types.ObjectId.isValid(request.user.id)) {
+    reply.status(400);
+    return new Error("invalid user id");
+  }
+
+  const account = await AccountModel.findOneAndUpdate(
+    { userId: request.user.id },
+    { $set: { isDeleted: true, deletedAt: new Date() } }
+  ).lean();
+
+  if (!account) {
+    reply.status(404);
+    return new Error("account not found");
+  }
+
+  return account;
+};
+
+export const deleteAccount = async (request: FastifyRequest, reply: FastifyReply) => {
+  if (!Types.ObjectId.isValid(request.user.id)) {
+    reply.status(400);
+    return new Error("invalid user id");
+  }
+
+  const account = await AccountModel.findByIdAndDelete({ userId: request.user.id }).lean();
+
+  if (!account) {
+    reply.status(404);
+    return new Error("account not found");
+  }
+
+  return account;
+};
+
+export const restoreAccount = async (request: FastifyRequest, reply: FastifyReply) => {
+  if (!Types.ObjectId.isValid(request.user.id)) {
+    reply.status(400);
+    return new Error("invalid user id");
+  }
+
+  const account = await AccountModel.findOneAndUpdate(
+    { userId: request.user.id },
+    { $set: { isDeleted: false } }
+  ).lean();
+
+  if (!account) {
+    reply.status(404);
+    return new Error("account not found");
+  }
+
+  return account;
+};

src/handlers/privilege/index.ts

@@ -11,6 +11,7 @@ import type {
   RegisterPrivilegeRequest,
   GetPrivilegeRequest,
   RegisterPrivilegiesRequest,
+  RemovePrivilegeRequest,
 } from "./types";
 
 export const registerPrivilegies = async (request: RegisterPrivilegiesRequest, reply: FastifyReply) => {
@@ -182,6 +183,32 @@ export const replacePrivilege = async (request: RegisterPrivilegeRequest, reply:
     updatedAt: new Date(),
   });
 
+  return Promise.all(replacePrivilegeRequests);
+};
+
+export const removePrivilege = async (request: GetPrivilegeRequest, reply: FastifyReply) => {
+  const [requestParams, error] = validateEmptyFields(request.params || {}, ["privilegeId"]);
+
+  if (error) {
+    reply.status(400);
+    return error;
+  }
+
+  if (!Types.ObjectId.isValid(requestParams.privilegeId)) {
+    reply.status(400);
+    return new Error("invalid id");
+  }
+
+  const privilege = await PrivilegeModel.findOneAndUpdate(
+    { privilegeId: requestParams.privilegeId },
+    { $set: { isDeleted: true, deletedAt: new Date() } }
+  );
+
+  if (!privilege) {
+    reply.status(404);
+    return new Error("privilege not found");
+  }
+
   return privilege;
 };
 
@@ -229,21 +256,21 @@ export const replacePrivilegies = async (request: RegisterPrivilegiesRequest, re
   return Promise.all(replacePrivilegeRequests);
 };
 
-export const removePrivilege = async (request: GetPrivilegeRequest, reply: FastifyReply) => {
+export const removePrivilege = async (request: RemovePrivilegeRequest, reply: FastifyReply) => {
-  const [requestParams, error] = validateEmptyFields(request.params || {}, ["privilegeId"]);
+  const [{ privilegeId }, error] = validateEmptyFields(request.body || {}, ["privilegeId"]);
 
   if (error) {
     reply.status(400);
     return error;
   }
 
-  if (!Types.ObjectId.isValid(requestParams.privilegeId)) {
+  if (!Types.ObjectId.isValid(privilegeId)) {
     reply.status(400);
     return new Error("invalid id");
   }
 
   const privilege = await PrivilegeModel.findOneAndUpdate(
-    { privilegeId: requestParams.privilegeId },
+    { privilegeId },
     { $set: { isDeleted: true, deletedAt: new Date() } }
   );
 
@@ -254,3 +281,26 @@ export const removePrivilege = async (request: GetPrivilegeRequest, reply: Fasti
 
   return privilege;
 };
+
+export const restorePrivilege = async (request: RemovePrivilegeRequest, reply: FastifyReply) => {
+  const [{ privilegeId }, error] = validateEmptyFields(request.body || {}, ["privilegeId"]);
+
+  if (error) {
+    reply.status(400);
+    return error;
+  }
+
+  if (!Types.ObjectId.isValid(privilegeId)) {
+    reply.status(400);
+    return new Error("invalid id");
+  }
+
+  const privilege = await PrivilegeModel.findOneAndUpdate({ privilegeId }, { $set: { isDeleted: false } });
+
+  if (!privilege) {
+    reply.status(404);
+    return new Error("privilege not found");
+  }
+
+  return privilege;
+};

src/handlers/privilege/types.ts

@@ -31,3 +31,9 @@ export type GetPrivilegeRequest = FastifyRequest<{
     privilegeId?: string;
   };
 }>;
+
+export type RemovePrivilegeRequest = FastifyRequest<{
+  Body?: {
+    privilegeId?: string;
+  };
+}>;

src/handlers/tariff/index.ts

@@ -9,7 +9,7 @@ import { validateTariff } from "./helpers";
 import type { FastifyReply } from "fastify";
 
 import type { Privilege } from "@/types/models/privilege.type";
-import type { CreateTariffRequest, GetTariffRequest, ReplaceTariffRequest } from "./types";
+import type { CreateTariffRequest, GetTariffRequest, ReplaceTariffRequest, RemoveTariffRequest } from "./types";
 
 export const getTariffs = async () => TariffModel.find({}).lean();
 
@@ -127,3 +127,74 @@ export const replaceTariff = async (request: ReplaceTariffRequest, reply: Fastif
 
   return tariff;
 };
+
+export const removeTariff = async (request: RemoveTariffRequest, reply: FastifyReply) => {
+  const [{ id }, error] = validateEmptyFields(request.body || {}, ["id"]);
+
+  if (error) {
+    reply.status(400);
+    return error;
+  }
+
+  if (!Types.ObjectId.isValid(id)) {
+    reply.status(400);
+    return new Error("invalid id");
+  }
+
+  const tariff = await TariffModel.findByIdAndUpdate(id, {
+    $set: { isDeleted: true, deletedAt: new Date() },
+  }).lean();
+
+  if (!tariff) {
+    reply.status(404);
+    return new Error("tariff not found");
+  }
+
+  return tariff;
+};
+
+export const deleteTariff = async (request: RemoveTariffRequest, reply: FastifyReply) => {
+  const [{ id }, error] = validateEmptyFields(request.body || {}, ["id"]);
+
+  if (error) {
+    reply.status(400);
+    return error;
+  }
+
+  if (!Types.ObjectId.isValid(id)) {
+    reply.status(400);
+    return new Error("invalid id");
+  }
+
+  const tariff = await TariffModel.findByIdAndDelete(id).lean();
+
+  if (!tariff) {
+    reply.status(404);
+    return new Error("tariff not found");
+  }
+
+  return tariff;
+};
+
+export const restoreTariff = async (request: RemoveTariffRequest, reply: FastifyReply) => {
+  const [{ id }, error] = validateEmptyFields(request.body || {}, ["id"]);
+
+  if (error) {
+    reply.status(400);
+    return error;
+  }
+
+  if (!Types.ObjectId.isValid(id)) {
+    reply.status(400);
+    return new Error("invalid id");
+  }
+
+  const tariff = await TariffModel.findByIdAndUpdate(id, { $set: { isDeleted: false } }).lean();
+
+  if (!tariff) {
+    reply.status(404);
+    return new Error("tariff not found");
+  }
+
+  return tariff;
+};

src/handlers/tariff/types.ts

@@ -7,6 +7,12 @@ export type GetTariffRequest = FastifyRequest<{
   };
 }>;
 
+export type RemoveTariffRequest = FastifyRequest<{
+  Body?: {
+    id?: string;
+  };
+}>;
+
 export type CreateTariffRequest = FastifyRequest<{
   Body?: TariffMessage;
 }>;

src/routes/account.routes.ts

@@ -1,13 +1,32 @@
 import { Router } from "@/server/router";
 
-import { createAccount, getAccount, setAccountRole, getAllAccounts } from "@/handlers/account";
+import {
+  createAccount,
+  getAccount,
+  setAccountRole,
+  getAllAccounts,
+  deleteAccount,
+  removeAccount,
+  restoreAccount,
+} from "@/handlers/account";
 import { verifyUser } from "@/handlers/auth/middleware";
 
-import { createAccountSchema, getAccountSchema, setAccountRoleSchema, getAccountsSchema } from "@/swagger/account";
+import {
+  createAccountSchema,
+  getAccountSchema,
+  setAccountRoleSchema,
+  getAccountsSchema,
+  removeAccountSchema,
+  restoreAccountSchema,
+  deleteAccountSchema,
+} from "@/swagger/account";
 
 export const setAccountRoutes = (router: Router): void => {
   router.get("/", getAllAccounts, { schema: getAccountsSchema });
   router.get("/:userId", getAccount, { schema: getAccountSchema });
   router.post("/", createAccount, { preHandler: [verifyUser], schema: createAccountSchema });
-  router.post("/role", setAccountRole, { preHandler: [verifyUser], schema: setAccountRoleSchema });
+  router.post("/restore", restoreAccount, { preHandler: [verifyUser], schema: restoreAccountSchema });
+  router.patch("/role", setAccountRole, { preHandler: [verifyUser], schema: setAccountRoleSchema });
+  router.delete("/", removeAccount, { preHandler: [verifyUser], schema: removeAccountSchema });
+  router.delete("/delete", deleteAccount, { preHandler: [verifyUser], schema: deleteAccountSchema });
 };

src/routes/privilege.routes.ts

@@ -10,6 +10,7 @@ import {
   registerPrivilegies,
   removePrivilege,
   replacePrivilegies,
+  restorePrivilege,
 } from "@/handlers/privilege";
 
 import {
@@ -22,6 +23,7 @@ import {
   replacePrivilegeSchema,
   replacePrivilegiesSchema,
   removePrivilegeSchema,
+  restorePrivilegeSchema,
 } from "@/swagger/privilege";
 
 export const setPrivilegeRoutes = (router: Router): void => {
@@ -31,6 +33,7 @@ export const setPrivilegeRoutes = (router: Router): void => {
   router.get("/service/:serviceKey", getServicePrivilegies, { schema: getServicePrivilegiesSchema });
   router.post("/", registerPrivilege, { schema: registerPrivilegeSchema });
   router.post("/many", registerPrivilegies, { schema: registerPrivilegiesSchema });
+  router.post("/restore/", restorePrivilege, { schema: restorePrivilegeSchema });
   router.put("/", replacePrivilege, { schema: replacePrivilegeSchema });
   router.put("/many", replacePrivilegies, { schema: replacePrivilegiesSchema });
   router.delete("/", removePrivilege, { schema: removePrivilegeSchema });

src/routes/tariff.routes.ts

@@ -1,13 +1,32 @@
 import { Router } from "@/server/router";
 
-import { createTariff, replaceTariff, getTariff, getTariffs } from "@/handlers/tariff";
+import {
+  createTariff,
+  replaceTariff,
+  getTariff,
+  getTariffs,
+  removeTariff,
+  restoreTariff,
+  deleteTariff,
+} from "@/handlers/tariff";
 import { verifyUser } from "@/handlers/auth/middleware";
 
-import { getTariffSchema, getTariffsSchema, createTariffsSchema, replaceTariffsSchema } from "@/swagger/tariff";
+import {
+  getTariffSchema,
+  getTariffsSchema,
+  createTariffsSchema,
+  replaceTariffsSchema,
+  removeTariffsSchema,
+  restoreTariffsSchema,
+  deleteTariffsSchema,
+} from "@/swagger/tariff";
 
 export const setTariffRoutes = (router: Router): void => {
-  router.get("/:id", getTariff, { schema: getTariffSchema });
   router.get("/", getTariffs, { schema: getTariffsSchema });
+  router.get("/:id", getTariff, { schema: getTariffSchema });
   router.post("/", createTariff, { preHandler: [verifyUser], schema: createTariffsSchema });
+  router.post("/restore", restoreTariff, { preHandler: [verifyUser], schema: restoreTariffsSchema });
   router.put("/:id", replaceTariff, { preHandler: [verifyUser], schema: replaceTariffsSchema });
+  router.delete("/", removeTariff, { preHandler: [verifyUser], schema: removeTariffsSchema });
+  router.delete("/delete", deleteTariff, { preHandler: [verifyUser], schema: deleteTariffsSchema });
 };

src/swagger/account/index.ts

@@ -1,5 +1,11 @@
 import { getAccountParams, setAccountRoleBody } from "./inputs";
-import { getAccountResponse, createAccountResponse, setAccountRoleResponse, getAccountsResponse } from "./responses";
+import {
+  getAccountResponse,
+  createAccountResponse,
+  setAccountRoleResponse,
+  getAccountsResponse,
+  removeRoleResponse,
+} from "./responses";
 
 import type { SwaggerSchema } from "@/types/swagger.type";
 
@@ -32,3 +38,27 @@ export const setAccountRoleSchema: SwaggerSchema = {
   response: setAccountRoleResponse,
   security: [{ bearer: [] }],
 };
+
+export const removeAccountSchema: SwaggerSchema = {
+  summary: "Удаление аккаунта",
+  description: "Помечает аккаунт удалённым, но не удаляет его из БД",
+  tags: ["account"],
+  response: removeRoleResponse,
+  security: [{ bearer: [] }],
+};
+
+export const deleteAccountSchema: SwaggerSchema = {
+  summary: "Удаление аккаунта",
+  description: "Удаляет аккаунт из БД окончательно",
+  tags: ["account"],
+  response: removeRoleResponse,
+  security: [{ bearer: [] }],
+};
+
+export const restoreAccountSchema: SwaggerSchema = {
+  summary: "Восстановление аккаунта",
+  description: "Восстанавливает аккаунт, который не был удалён окончательно",
+  tags: ["account"],
+  response: removeRoleResponse,
+  security: [{ bearer: [] }],
+};

src/swagger/account/responses.ts

@@ -31,3 +31,10 @@ export const setAccountRoleResponse: Record<string, SwaggerMessage> = {
   401: swaggerError(401, "invalid token"),
   404: swaggerError(404, "user not found"),
 };
+
+export const removeRoleResponse: Record<string, SwaggerMessage> = {
+  200: account,
+  400: swaggerError(400, "invalid user id"),
+  401: swaggerError(401, "invalid token"),
+  404: swaggerError(404, "user not found"),
+};

src/swagger/privilege/index.ts

@@ -75,3 +75,10 @@ export const removePrivilegeSchema: SwaggerSchema = {
   body: getPrivilegeParams,
   response: removePrivilegeResponse,
 };
+
+export const restorePrivilegeSchema: SwaggerSchema = {
+  summary: "Восстановление привилегии",
+  tags: ["privilege"],
+  body: getPrivilegeParams,
+  response: removePrivilegeResponse,
+};

src/swagger/tariff/index.ts

@@ -1,5 +1,11 @@
 import { getTariffParams, tariffBody, replaceTariffParams } from "./inputs";
-import { getTariffReponse, getTariffsReponse, createTariffReponse, replaceTariffReponse } from "./responses";
+import {
+  getTariffReponse,
+  getTariffsReponse,
+  createTariffReponse,
+  replaceTariffReponse,
+  removeTariffReponse,
+} from "./responses";
 
 import type { SwaggerSchema } from "@/types/swagger.type";
 
@@ -23,6 +29,7 @@ export const createTariffsSchema: SwaggerSchema = {
   security: [{ bearer: [] }],
   response: createTariffReponse,
 };
+
 export const replaceTariffsSchema: SwaggerSchema = {
   summary: "Замена тарифа",
   tags: ["tariff"],
@@ -31,3 +38,29 @@ export const replaceTariffsSchema: SwaggerSchema = {
   security: [{ bearer: [] }],
   response: replaceTariffReponse,
 };
+
+export const removeTariffsSchema: SwaggerSchema = {
+  summary: "Удаление тарифа",
+  description: "Помечает тариф удалённым, но не удаляет его из БД",
+  tags: ["tariff"],
+  body: getTariffParams,
+  security: [{ bearer: [] }],
+  response: removeTariffReponse,
+};
+
+export const deleteTariffsSchema: SwaggerSchema = {
+  summary: "Удаление тарифа",
+  description: "Удаляет тариф из БД окончательно",
+  tags: ["tariff"],
+  body: getTariffParams,
+  security: [{ bearer: [] }],
+  response: removeTariffReponse,
+};
+
+export const restoreTariffsSchema: SwaggerSchema = {
+  summary: "Восстановление тарифа",
+  tags: ["tariff"],
+  body: getTariffParams,
+  security: [{ bearer: [] }],
+  response: removeTariffReponse,
+};

src/swagger/tariff/responses.ts

@@ -21,11 +21,20 @@ export const getTariffsReponse: Record<string, SwaggerMessage> = {
 export const createTariffReponse: Record<string, SwaggerMessage> = {
   200: tariff,
   400: swaggerError(400, "invalid 'price' value"),
+  401: swaggerError(400, "invalid user id"),
   404: swaggerError(404, "privilege with id <privilegeId> not found"),
 };
 
 export const replaceTariffReponse: Record<string, SwaggerMessage> = {
   200: tariff,
   400: swaggerError(400, "invalid id"),
+  401: swaggerError(400, "invalid user id"),
+  404: swaggerError(404, "tariff not found"),
+};
+
+export const removeTariffReponse: Record<string, SwaggerMessage> = {
+  200: tariff,
+  400: swaggerError(400, "invalid id"),
+  401: swaggerError(400, "invalid user id"),
   404: swaggerError(404, "tariff not found"),
 };