feat: changed backend-pg to backend

backend/src/server/routes/v2/identity-org-router.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+
+import { IdentitiesSchema, IdentityOrgMembershipsSchema, OrgRolesSchema } from "@app/db/schemas";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+
+export const registerIdentityOrgRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    method: "GET",
+    url: "/:orgId/identity-memberships",
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]),
+    schema: {
+      params: z.object({
+        orgId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          identityMemberships: IdentityOrgMembershipsSchema.merge(
+            z.object({
+              customRole: OrgRolesSchema.pick({
+                id: true,
+                name: true,
+                slug: true,
+                permissions: true,
+                description: true
+              }).optional(),
+              identity: IdentitiesSchema.pick({ name: true, id: true, authMethod: true })
+            })
+          ).array()
+        })
+      }
+    },
+    handler: async (req) => {
+      const identityMemberships = await server.services.identity.listOrgIdentities({
+        actor: req.permission.type,
+        actorId: req.permission.id,
+        orgId: req.params.orgId
+      });
+      return { identityMemberships };
+    }
+  });
+};

backend/src/server/routes/v2/identity-project-router.ts

@@ -0,0 +1,133 @@
+import { z } from "zod";
+
+import {
+  IdentitiesSchema,
+  IdentityProjectMembershipsSchema,
+  ProjectMembershipRole,
+  ProjectRolesSchema
+} from "@app/db/schemas";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+
+export const registerIdentityProjectRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    method: "POST",
+    url: "/:projectId/identity-memberships/:identityId",
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]),
+    schema: {
+      params: z.object({
+        projectId: z.string().trim(),
+        identityId: z.string().trim()
+      }),
+      body: z.object({
+        role: z.string().trim().min(1).default(ProjectMembershipRole.NoAccess)
+      }),
+      response: {
+        200: z.object({
+          identityMembership: IdentityProjectMembershipsSchema
+        })
+      }
+    },
+    handler: async (req) => {
+      const identityMembership = await server.services.identityProject.createProjectIdentity({
+        actor: req.permission.type,
+        actorId: req.permission.id,
+        identityId: req.params.identityId,
+        projectId: req.params.projectId,
+        role: req.body.role
+      });
+      return { identityMembership };
+    }
+  });
+
+  server.route({
+    method: "PATCH",
+    url: "/:projectId/identity-memberships/:identityId",
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]),
+    schema: {
+      params: z.object({
+        projectId: z.string().trim(),
+        identityId: z.string().trim()
+      }),
+      body: z.object({
+        role: z.string().trim().min(1).default(ProjectMembershipRole.NoAccess)
+      }),
+      response: {
+        200: z.object({
+          identityMembership: IdentityProjectMembershipsSchema
+        })
+      }
+    },
+    handler: async (req) => {
+      const identityMembership = await server.services.identityProject.updateProjectIdentity({
+        actor: req.permission.type,
+        actorId: req.permission.id,
+        identityId: req.params.identityId,
+        projectId: req.params.projectId,
+        role: req.body.role
+      });
+      return { identityMembership };
+    }
+  });
+
+  server.route({
+    method: "DELETE",
+    url: "/:projectId/identity-memberships/:identityId",
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]),
+    schema: {
+      params: z.object({
+        projectId: z.string().trim(),
+        identityId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          identityMembership: IdentityProjectMembershipsSchema
+        })
+      }
+    },
+    handler: async (req) => {
+      const identityMembership = await server.services.identityProject.deleteProjectIdentity({
+        actor: req.permission.type,
+        actorId: req.permission.id,
+        identityId: req.params.identityId,
+        projectId: req.params.projectId
+      });
+      return { identityMembership };
+    }
+  });
+
+  server.route({
+    method: "GET",
+    url: "/:projectId/identity-memberships",
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]),
+    schema: {
+      params: z.object({
+        projectId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          identityMemberships: IdentityProjectMembershipsSchema.merge(
+            z.object({
+              customRole: ProjectRolesSchema.pick({
+                id: true,
+                name: true,
+                slug: true,
+                permissions: true,
+                description: true
+              }).optional(),
+              identity: IdentitiesSchema.pick({ name: true, id: true, authMethod: true })
+            })
+          ).array()
+        })
+      }
+    },
+    handler: async (req) => {
+      const identityMemberships = await server.services.identityProject.listProjectIdentities({
+        actor: req.permission.type,
+        actorId: req.permission.id,
+        projectId: req.params.projectId
+      });
+      return { identityMemberships };
+    }
+  });
+};

backend/src/server/routes/v2/index.ts

@@ -0,0 +1,27 @@
+import { registerIdentityOrgRouter } from "./identity-org-router";
+import { registerIdentityProjectRouter } from "./identity-project-router";
+import { registerMfaRouter } from "./mfa-router";
+import { registerOrgRouter } from "./organization-router";
+import { registerProjectRouter } from "./project-router";
+import { registerServiceTokenRouter } from "./service-token-router";
+import { registerUserRouter } from "./user-router";
+
+export const registerV2Routes = async (server: FastifyZodProvider) => {
+  await server.register(registerMfaRouter, { prefix: "/auth" });
+  await server.register(registerUserRouter, { prefix: "/users" });
+  await server.register(registerServiceTokenRouter, { prefix: "/service-token" });
+  await server.register(
+    async (orgRouter) => {
+      await orgRouter.register(registerOrgRouter);
+      await orgRouter.register(registerIdentityOrgRouter);
+    },
+    { prefix: "/organizations" }
+  );
+  await server.register(
+    async (projectServer) => {
+      projectServer.register(registerProjectRouter);
+      projectServer.register(registerIdentityProjectRouter);
+    },
+    { prefix: "/workspace" }
+  );
+};

backend/src/server/routes/v2/mfa-router.ts

@@ -0,0 +1,92 @@
+import jwt, { JwtPayload } from "jsonwebtoken";
+import { z } from "zod";
+
+import { getConfig } from "@app/lib/config/env";
+import { AuthTokenType } from "@app/services/auth/auth-type";
+
+export const registerMfaRouter = async (server: FastifyZodProvider) => {
+  const cfg = getConfig();
+
+  server.decorateRequest("mfa", null);
+  server.addHook("preParsing", async (req, res) => {
+    const authorizationHeader = req.headers.authorization;
+
+    if (!authorizationHeader || !authorizationHeader.startsWith("Bearer ")) {
+      res.status(401).send({ error: "Missing bearer token" });
+      return res;
+    }
+    const token = authorizationHeader.split(" ")[1];
+    if (!token) {
+      res.status(401).send({ error: "Missing bearer token" });
+      return res;
+    }
+
+    const decodedToken = jwt.verify(token, cfg.AUTH_SECRET) as JwtPayload;
+    if (decodedToken.authTokenType !== AuthTokenType.MFA_TOKEN)
+      throw new Error("Unauthorized access");
+
+    const user = await server.store.user.findById(decodedToken.userId);
+    if (!user) throw new Error("User not found");
+    req.mfa = { userId: user.id, user };
+  });
+
+  server.route({
+    url: "/mfa/send",
+    method: "POST",
+    schema: {
+      response: {
+        200: z.object({
+          message: z.string()
+        })
+      }
+    },
+    handler: async (req) => {
+      await server.services.login.resendMfaToken(req.mfa.userId);
+      return { message: "Successfully send new mfa code" };
+    }
+  });
+
+  server.route({
+    url: "/mfa/verify",
+    method: "POST",
+    schema: {
+      body: z.object({
+        mfaToken: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          encryptionVersion: z.number().default(1).nullable().optional(),
+          protectedKey: z.string().nullable(),
+          protectedKeyIV: z.string().nullable(),
+          protectedKeyTag: z.string().nullable(),
+          publicKey: z.string(),
+          encryptedPrivateKey: z.string(),
+          iv: z.string(),
+          tag: z.string(),
+          token: z.string()
+        })
+      }
+    },
+    handler: async (req, res) => {
+      const userAgent = req.headers["user-agent"];
+      if (!userAgent) throw new Error("user agent header is required");
+      const appCfg = getConfig();
+
+      const { user, token } = await server.services.login.verifyMfaToken({
+        userAgent,
+        ip: req.realIp,
+        userId: req.mfa.userId,
+        mfaToken: req.body.mfaToken
+      });
+
+      res.setCookie("jid", token.refresh, {
+        httpOnly: true,
+        path: "/",
+        sameSite: "strict",
+        secure: appCfg.HTTPS_ENABLED
+      });
+
+      return { token: token.access, ...user };
+    }
+  });
+};

backend/src/server/routes/v2/organization-router.ts

@@ -0,0 +1,151 @@
+import { z } from "zod";
+
+import {
+  OrganizationsSchema,
+  OrgMembershipsSchema,
+  UserEncryptionKeysSchema,
+  UsersSchema
+} from "@app/db/schemas";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { ActorType, AuthMode } from "@app/services/auth/auth-type";
+
+export const registerOrgRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    method: "GET",
+    url: "/:organizationId/memberships",
+    schema: {
+      params: z.object({
+        organizationId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          users: OrgMembershipsSchema.merge(
+            z.object({
+              user: UsersSchema.pick({
+                email: true,
+                firstName: true,
+                lastName: true,
+                id: true
+              }).merge(UserEncryptionKeysSchema.pick({ publicKey: true }))
+            })
+          )
+            .omit({ createdAt: true, updatedAt: true })
+            .array()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY, AuthMode.IDENTITY_ACCESS_TOKEN]),
+    handler: async (req) => {
+      if (req.auth.actor !== ActorType.USER) return;
+
+      const users = await server.services.org.findAllOrgMembers(
+        req.permission.id,
+        req.params.organizationId
+      );
+      return { users };
+    }
+  });
+
+  server.route({
+    method: "PATCH",
+    url: "/:organizationId/memberships/:membershipId",
+    schema: {
+      params: z.object({ organizationId: z.string().trim(), membershipId: z.string().trim() }),
+      body: z.object({
+        role: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          membership: OrgMembershipsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY, AuthMode.IDENTITY_ACCESS_TOKEN]),
+    handler: async (req) => {
+      if (req.auth.actor !== ActorType.USER) return;
+
+      const membership = await server.services.org.updateOrgMembership({
+        userId: req.permission.id,
+        role: req.body.role,
+        orgId: req.params.organizationId,
+        membershipId: req.params.membershipId
+      });
+      return { membership };
+    }
+  });
+
+  server.route({
+    method: "DELETE",
+    url: "/:organizationId/memberships/:membershipId",
+    schema: {
+      params: z.object({ organizationId: z.string().trim(), membershipId: z.string().trim() }),
+      response: {
+        200: z.object({
+          membership: OrgMembershipsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY, AuthMode.IDENTITY_ACCESS_TOKEN]),
+    handler: async (req) => {
+      if (req.auth.actor !== ActorType.USER) return;
+
+      const membership = await server.services.org.deleteOrgMembership({
+        userId: req.permission.id,
+        orgId: req.params.organizationId,
+        membershipId: req.params.membershipId
+      });
+      return { membership };
+    }
+  });
+
+  server.route({
+    method: "POST",
+    url: "/",
+    schema: {
+      body: z.object({
+        name: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          organization: OrganizationsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      if (req.auth.actor !== ActorType.USER) return;
+
+      const organization = await server.services.org.createOrganization(
+        req.permission.id,
+        req.auth.user.email,
+        req.body.name
+      );
+      return { organization };
+    }
+  });
+
+  server.route({
+    method: "DELETE",
+    url: "/:organizationId",
+    schema: {
+      params: z.object({
+        organizationId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          organization: OrganizationsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      if (req.auth.actor !== ActorType.USER) return;
+
+      const organization = await server.services.org.deleteOrganizationById(
+        req.permission.id,
+        req.params.organizationId
+      );
+      return { organization };
+    }
+  });
+};

backend/src/server/routes/v2/project-router.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+
+import { ProjectKeysSchema } from "@app/db/schemas";
+import { EventType } from "@app/ee/services/audit-log/audit-log-types";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+
+export const registerProjectRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    url: "/:workspaceId/encrypted-key",
+    method: "GET",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      response: {
+        200: ProjectKeysSchema.merge(
+          z.object({
+            sender: z.object({
+              publicKey: z.string()
+            })
+          })
+        )
+      }
+    },
+    onResponse: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const key = await server.services.projectKey.getLatestProjectKey({
+        actor: req.permission.type,
+        actorId: req.permission.id,
+        projectId: req.params.workspaceId
+      });
+
+      await server.services.auditLog.createAuditLog({
+        ...req.auditLogInfo,
+        projectId: req.params.workspaceId,
+        event: {
+          type: EventType.GET_WORKSPACE_KEY,
+          metadata: {
+            keyId: key.id
+          }
+        }
+      });
+
+      return key;
+    }
+  });
+};

backend/src/server/routes/v2/service-token-router.ts

@@ -0,0 +1,121 @@
+import { z } from "zod";
+
+import { ServiceTokensSchema } from "@app/db/schemas";
+import { EventType } from "@app/ee/services/audit-log/audit-log-types";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+
+export const sanitizedServiceTokenSchema = ServiceTokensSchema.omit({
+  secretHash: true,
+  encryptedKey: true,
+  iv: true,
+  tag: true
+});
+
+export const registerServiceTokenRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    url: "/",
+    method: "GET",
+    onRequest: verifyAuth([AuthMode.SERVICE_TOKEN]),
+    schema: {
+      response: {
+        200: ServiceTokensSchema.merge(z.object({ workspace: z.string() }))
+      }
+    },
+    handler: async (req) => {
+      const serviceTokenData = await server.services.serviceToken.getServiceToken({
+        actorId: req.permission.id,
+        actor: req.permission.type
+      });
+      return { ...serviceTokenData, workspace: serviceTokenData.projectId };
+    }
+  });
+
+  server.route({
+    url: "/",
+    method: "POST",
+    onRequest: verifyAuth([AuthMode.JWT]),
+    schema: {
+      body: z.object({
+        name: z.string().trim(),
+        workspaceId: z.string().trim(),
+        scopes: z
+          .object({
+            environment: z.string().trim(),
+            secretPath: z.string().trim()
+          })
+          .array()
+          .min(1),
+        encryptedKey: z.string().trim(),
+        iv: z.string().trim(),
+        tag: z.string().trim(),
+        expiresIn: z.number().nullable(),
+        permissions: z.enum(["read", "write"]).array()
+      }),
+      response: {
+        200: z.object({
+          serviceToken: z.string(),
+          serviceTokenData: sanitizedServiceTokenSchema
+        })
+      }
+    },
+    handler: async (req) => {
+      const { serviceToken, token } = await server.services.serviceToken.createServiceToken({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        ...req.body,
+        projectId: req.body.workspaceId
+      });
+
+      await server.services.auditLog.createAuditLog({
+        ...req.auditLogInfo,
+        projectId: serviceToken.projectId,
+        event: {
+          type: EventType.CREATE_SERVICE_TOKEN,
+          metadata: {
+            name: serviceToken.name,
+            scopes: req.body.scopes
+          }
+        }
+      });
+      return { serviceToken: token, serviceTokenData: serviceToken };
+    }
+  });
+
+  server.route({
+    url: "/:serviceTokenId",
+    method: "DELETE",
+    onRequest: verifyAuth([AuthMode.JWT]),
+    schema: {
+      params: z.object({
+        serviceTokenId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          serviceTokenData: sanitizedServiceTokenSchema
+        })
+      }
+    },
+    handler: async (req) => {
+      const serviceTokenData = await server.services.serviceToken.deleteServiceToken({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        id: req.params.serviceTokenId
+      });
+
+      await server.services.auditLog.createAuditLog({
+        ...req.auditLogInfo,
+        projectId: serviceTokenData.projectId,
+        event: {
+          type: EventType.DELETE_SERVICE_TOKEN,
+          metadata: {
+            name: serviceTokenData.name,
+            scopes: serviceTokenData.scopes as Array<{ environment: string; secretPath: string }>
+          }
+        }
+      });
+
+      return { serviceTokenData };
+    }
+  });
+};

backend/src/server/routes/v2/user-router.ts

@@ -0,0 +1,230 @@
+import { z } from "zod";
+
+import {
+  AuthTokenSessionsSchema,
+  OrganizationsSchema,
+  UserEncryptionKeysSchema,
+  UsersSchema
+} from "@app/db/schemas";
+import { ApiKeysSchema } from "@app/db/schemas/api-keys";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMethod, AuthMode } from "@app/services/auth/auth-type";
+
+export const registerUserRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    url: "/me/mfa",
+    method: "PATCH",
+    schema: {
+      body: z.object({
+        isMfaEnabled: z.boolean()
+      }),
+      response: {
+        200: z.object({
+          user: UsersSchema
+        })
+      }
+    },
+    preHandler: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const user = await server.services.user.toggleUserMfa(req.permission.id, req.body.isMfaEnabled);
+      return { user };
+    }
+  });
+
+  server.route({
+    url: "/me/name",
+    method: "PATCH",
+    schema: {
+      body: z.object({
+        firstName: z.string().trim(),
+        lastName: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          user: UsersSchema
+        })
+      }
+    },
+    preHandler: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const user = await server.services.user.updateUserName(
+        req.permission.id,
+        req.body.firstName,
+        req.body.lastName
+      );
+      return { user };
+    }
+  });
+
+  server.route({
+    url: "/me/auth-methods",
+    method: "PUT",
+    schema: {
+      body: z.object({
+        authMethods: z.nativeEnum(AuthMethod).array().min(1)
+      }),
+      response: {
+        200: z.object({
+          user: UsersSchema
+        })
+      }
+    },
+    preHandler: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const user = await server.services.user.updateAuthMethods(
+        req.permission.id,
+        req.body.authMethods
+      );
+      return { user };
+    }
+  });
+
+  server.route({
+    method: "GET",
+    url: "/me/organizations",
+    schema: {
+      response: {
+        200: z.object({
+          organizations: OrganizationsSchema.array()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const organizations = await server.services.org.findAllOrganizationOfUser(req.permission.id);
+      return { organizations };
+    }
+  });
+
+  server.route({
+    method: "GET",
+    url: "/me/api-keys",
+    schema: {
+      response: {
+        200: ApiKeysSchema.omit({ secretHash: true }).array()
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const apiKeys = await server.services.apiKey.getMyApiKeys(req.permission.id);
+      return apiKeys;
+    }
+  });
+
+  server.route({
+    method: "POST",
+    url: "/me/api-keys",
+    schema: {
+      body: z.object({
+        name: z.string().trim(),
+        expiresIn: z.number()
+      }),
+      response: {
+        200: z.object({
+          apiKey: z.string(),
+          apiKeyData: ApiKeysSchema.omit({ secretHash: true })
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const apiKeys = await server.services.apiKey.createApiKey(
+        req.permission.id,
+        req.body.name,
+        req.body.expiresIn
+      );
+      return apiKeys;
+    }
+  });
+
+  server.route({
+    method: "DELETE",
+    url: "/me/api-keys/:apiKeyDataId",
+    schema: {
+      params: z.object({
+        apiKeyDataId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          apiKeyData: ApiKeysSchema.omit({ secretHash: true })
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const apiKeyData = await server.services.apiKey.deleteApiKey(
+        req.permission.id,
+        req.params.apiKeyDataId
+      );
+      return { apiKeyData };
+    }
+  });
+
+  server.route({
+    method: "GET",
+    url: "/me/sessions",
+    schema: {
+      response: {
+        200: AuthTokenSessionsSchema.array()
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const sessions = await server.services.authToken.getTokenSessionByUser(req.permission.id);
+      return sessions;
+    }
+  });
+
+  server.route({
+    method: "DELETE",
+    url: "/me/sessions",
+    schema: {
+      response: {
+        200: z.object({
+          message: z.string()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      await server.services.authToken.revokeAllMySessions(req.permission.id);
+      return {
+        message: "Successfully revoked all sessions"
+      };
+    }
+  });
+
+  server.route({
+    method: "GET",
+    url: "/me",
+    schema: {
+      response: {
+        200: z.object({
+          user: UsersSchema.merge(UserEncryptionKeysSchema.omit({ verifier: true }))
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const user = await server.services.user.getMe(req.permission.id);
+      return { user };
+    }
+  });
+
+  server.route({
+    method: "DELETE",
+    url: "/me",
+    schema: {
+      response: {
+        200: z.object({
+          user: UsersSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const user = await server.services.user.deleteMe(req.permission.id);
+      return { user };
+    }
+  });
+};