blsmedia/sign
2
0
Fork 0
Code Issues Packages Releases Activity

wip: refresh design

Browse Source
This commit is contained in:
Mythie
2023-06-09 18:21:18 +10:00
parent 76b2fb5edd
commit 159bcade7b
432 changed files with 19640 additions and 29359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
apps/web/pages/api/auth/[...nextauth].ts
View File

@@ -1,91 +0,0 @@
import { ErrorCode } from "@documenso/lib/auth";
import { verifyPassword } from "@documenso/lib/auth";
import prisma from "@documenso/prisma";
import NextAuth, { Session } from "next-auth";
import CredentialsProvider from "next-auth/providers/credentials";
import GitHubProvider from "next-auth/providers/github";
export default NextAuth({
secret: process.env.AUTH_SECRET,
pages: {
signIn: "/login",
signOut: "/login",
error: "/auth/error", // Error code passed in query string as ?error=
verifyRequest: "/auth/verify-request", // (used for check email message)
},
providers: [
CredentialsProvider({
id: "credentials",
name: "Documenso.com Login",
type: "credentials",
credentials: {
email: {
label: "Email Address",
type: "email",
placeholder: "john.doe@example.com",
},
password: {
label: "Password",
type: "password",
placeholder: "Select a password. Here is some inspiration: https://xkcd.com/936/",
},
},
async authorize(credentials: any) {
if (!credentials) {
console.error("Credential missing in authorize()");
throw new Error(ErrorCode.InternalServerError);
}
const user = await prisma.user.findUnique({
where: {
email: credentials.email.toLowerCase(),
},
select: {
id: true,
email: true,
password: true,
name: true,
},
});
if (!user) {
throw new Error(ErrorCode.UserNotFound);
}
if (!user.password) {
throw new Error(ErrorCode.UserMissingPassword);
}
const isCorrectPassword = await verifyPassword(credentials.password, user.password);
if (!isCorrectPassword) {
throw new Error(ErrorCode.IncorrectPassword);
}
return {
id: user.id,
email: user.email,
name: user.name,
};
},
}),
],
callbacks: {
async jwt({ token, user, account }) {
return {
...token,
};
},
async session({ session, token }) {
const documensoSession: Session = {
...session,
user: {
...session.user,
},
};
documensoSession.expires;
return documensoSession;
},
},
});

56
apps/web/pages/api/auth/signup.ts
View File

@@ -1,56 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { hashPassword } from "@documenso/lib/auth";
import { defaultHandler, defaultResponder } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
import { IdentityProvider } from "@prisma/client";
async function postHandler(req: NextApiRequest, res: NextApiResponse) {
const { email, password, source } = req.body;
const cleanEmail = email.toLowerCase();
if (!cleanEmail || !/.+@.+/.test(cleanEmail)) {
res.status(400).json({ message: "Invalid email" });
return;
}
if (!password || password.trim().length < 7) {
return res.status(400).json({
message: "Password should be at least 7 characters long.",
});
}
// User already exists if email already exists
const existingUser = await prisma.user.findFirst({
where: {
email: cleanEmail,
},
});
if (existingUser) {
const message: string = "This email is already registered.";
return res.status(409).json({ message });
}
const hashedPassword = await hashPassword(password);
await prisma.user.upsert({
where: { email: cleanEmail },
update: {
password: hashedPassword,
emailVerified: new Date(Date.now()),
identityProvider: IdentityProvider.DOCUMENSO,
},
create: {
email: cleanEmail,
password: hashedPassword,
identityProvider: IdentityProvider.DOCUMENSO,
source: source,
},
});
res.status(201).end();
}
export default defaultHandler({
POST: Promise.resolve({ default: defaultResponder(postHandler) }),
});

95
apps/web/pages/api/documents/[id].ts
View File

@@ -1,95 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { getDocument } from "@documenso/lib/query";
import { defaultHandler, defaultResponder, getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
import { addDigitalSignature } from "@documenso/signing/addDigitalSignature";
import { Document as PrismaDocument } from "@prisma/client";
async function getHandler(req: NextApiRequest, res: NextApiResponse) {
const { id: documentId } = req.query;
const { token: recipientToken } = req.query;
if (!documentId) {
return res.status(400).send("Missing parameter documentId.");
}
let user = null;
let recipient = null;
if (recipientToken) {
// Request from signing page without login
recipient = await prisma.recipient.findFirst({
where: {
token: recipientToken?.toString(),
},
include: {
Document: { include: { User: true } },
},
});
user = recipient?.Document.User;
} else {
// Request from editor with valid user login
user = await getUserFromToken(req, res);
}
if (!user) return res.status(401).end();
let document: PrismaDocument | null = null;
if (recipientToken) {
document = await prisma.document.findFirst({
where: { id: recipient?.Document?.id },
});
} else {
document = await getDocument(+documentId, req, res);
}
if (!document) res.status(404).end(`No document with id ${documentId} found.`);
const signaturesCount = await prisma.signature.count({
where: {
Field: {
documentId: document?.id,
},
},
});
let signedDocumentAsBase64 = document?.document || "";
// No need to add a signature, if no one signed yet.
if (signaturesCount > 0) {
signedDocumentAsBase64 = await addDigitalSignature(document?.document || "");
}
const buffer: Buffer = Buffer.from(signedDocumentAsBase64, "base64");
res.setHeader("Content-Type", "application/pdf");
res.setHeader("Content-Length", buffer.length);
res.setHeader("Content-Disposition", `attachment; filename=${document?.title}`);
return res.status(200).send(buffer);
}
async function deleteHandler(req: NextApiRequest, res: NextApiResponse) {
const user = await getUserFromToken(req, res);
const { id: documentId } = req.query;
if (!user) return;
if (!documentId) {
res.status(400).send("Missing parameter documentId.");
return;
}
await prisma.document
.delete({
where: {
id: +documentId,
},
})
.then(() => {
res.status(200).end();
});
}
export default defaultHandler({
GET: Promise.resolve({ default: defaultResponder(getHandler) }),
DELETE: Promise.resolve({ default: defaultResponder(deleteHandler) }),
});

32
apps/web/pages/api/documents/[id]/fields/[fid].ts
View File

@@ -1,32 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { getDocument } from "@documenso/lib/query";
import { defaultHandler, defaultResponder, getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
import { FieldType, Document as PrismaDocument } from "@prisma/client";
import short from "short-uuid";
async function deleteHandler(req: NextApiRequest, res: NextApiResponse) {
const user = await getUserFromToken(req, res);
const { fid: fieldId } = req.query;
const body: {
id: number;
type: FieldType;
page: number;
position: { x: number; y: number };
} = req.body;
if (!user) return;
if (!fieldId) {
res.status(400).send("Missing parameter fieldId.");
return;
}
await prisma.field.delete({ where: { id: +fieldId } });
return res.status(200).end();
}
export default defaultHandler({
DELETE: Promise.resolve({ default: defaultResponder(deleteHandler) }),
});

101
apps/web/pages/api/documents/[id]/fields/index.ts
View File

@@ -1,101 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { getDocument } from "@documenso/lib/query";
import { defaultHandler, defaultResponder, getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
import { FieldType, Document as PrismaDocument } from "@prisma/client";
async function getHandler(req: NextApiRequest, res: NextApiResponse) {
const user = await getUserFromToken(req, res);
const { id: documentId } = req.query;
const body: {
id: number;
type: FieldType;
page: number;
position: { x: number; y: number };
} = req.body;
if (!user) return;
if (!documentId) {
res.status(400).send("Missing parameter documentId.");
return;
}
// todo entity ownerships checks
const fields = await prisma.field.findMany({
where: { documentId: +documentId },
include: { Recipient: true },
});
return res.status(200).end(JSON.stringify(fields));
}
async function postHandler(req: NextApiRequest, res: NextApiResponse) {
const { token: recipientToken } = req.query;
let user = null;
if (!recipientToken) user = await getUserFromToken(req, res);
if (!user && !recipientToken) return res.status(401).end();
const body: {
id: number;
type: FieldType;
page: number;
positionX: number;
positionY: number;
Recipient: { id: number };
customText: string;
} = req.body;
const { id: documentId } = req.query;
if (!documentId) {
return res.status(400).send("Missing parameter documentId.");
}
if (recipientToken) {
const recipient = await prisma.recipient.findFirst({
where: { token: recipientToken?.toString() },
});
if (!recipient || recipient?.documentId !== +documentId)
return res.status(401).send("Recipient does not have access to this document.");
}
if (user) {
const document: PrismaDocument = await getDocument(+documentId, req, res);
// todo entity ownerships checks
if (document.userId !== user.id) {
return res.status(401).send("User does not have access to this document.");
}
}
const field = await prisma.field.upsert({
where: {
id: +body.id,
},
update: {
positionX: +body.positionX,
positionY: +body.positionY,
customText: body.customText,
},
create: {
documentId: +documentId,
type: body.type,
page: +body.page,
inserted: false,
positionX: +body.positionX,
positionY: +body.positionY,
customText: body.customText,
recipientId: body.Recipient.id,
},
include: {
Recipient: true,
},
});
return res.status(201).end(JSON.stringify(field));
}
export default defaultHandler({
GET: Promise.resolve({ default: defaultResponder(getHandler) }),
POST: Promise.resolve({ default: defaultResponder(postHandler) }),
});

29
apps/web/pages/api/documents/[id]/recipients/[rid].ts
View File

@@ -1,29 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { getDocument } from "@documenso/lib/query";
import { defaultHandler, defaultResponder, getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
import { Document as PrismaDocument } from "@prisma/client";
import short from "short-uuid";
async function deleteHandler(req: NextApiRequest, res: NextApiResponse) {
const user = await getUserFromToken(req, res);
const { id: documentId, rid: recipientId } = req.query;
const body = req.body;
if (!recipientId) {
res.status(400).send("Missing parameter recipientId.");
return;
}
await prisma.recipient.delete({
where: {
id: +recipientId,
},
});
return res.status(200).end();
}
export default defaultHandler({
DELETE: Promise.resolve({ default: defaultResponder(deleteHandler) }),
});

48
apps/web/pages/api/documents/[id]/recipients/index.ts
View File

@@ -1,48 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { getDocument } from "@documenso/lib/query";
import { defaultHandler, defaultResponder, getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
import { Document as PrismaDocument } from "@prisma/client";
import short from "short-uuid";
async function postHandler(req: NextApiRequest, res: NextApiResponse) {
const user = await getUserFromToken(req, res);
const { id: documentId } = req.query;
const body: { name: string; email: string; id: string } = req.body;
if (!user) return;
if (!documentId) {
res.status(400).send("Missing parameter documentId.");
return;
}
const document: PrismaDocument = await getDocument(+documentId, req, res);
// todo entity ownerships checks
if (document.userId !== user.id) {
return res.status(401).send("User does not have access to this document.");
}
const recipient = await prisma.recipient.upsert({
where: {
id: +body.id,
},
update: {
email: body.email.toString(),
name: body.name.toString(),
},
create: {
documentId: +documentId,
email: body.email.toString(),
name: body.name.toString(),
token: short.generate().toString(),
},
});
return res.status(200).end(JSON.stringify(recipient));
}
export default defaultHandler({
POST: Promise.resolve({ default: defaultResponder(postHandler) }),
});

72
apps/web/pages/api/documents/[id]/send.ts
View File

@@ -1,72 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { sendSigningRequest } from "@documenso/lib/mail";
import { getDocument } from "@documenso/lib/query";
import { defaultHandler, defaultResponder, getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
import { Document as PrismaDocument, SendStatus } from "@prisma/client";
async function postHandler(req: NextApiRequest, res: NextApiResponse) {
try {
const user = await getUserFromToken(req, res);
const { id: documentId } = req.query;
const { resendTo: resendTo = [] } = req.body;
if (!user) {
return res.status(401).send("Unauthorized");
}
if (!documentId) {
return res.status(400).send("Missing parameter documentId.");
}
const document: PrismaDocument = await getDocument(+documentId, req, res);
if (!document) {
res.status(404).end(`No document with id ${documentId} found.`);
}
let recipientCondition: any = {
documentId: +documentId,
sendStatus: SendStatus.NOT_SENT,
};
if (resendTo.length) {
recipientCondition = {
documentId: +documentId,
id: { in: resendTo },
};
}
const recipients = await prisma.recipient.findMany({
where: {
...recipientCondition,
},
});
if (!recipients.length) {
return res.status(200).send(recipients.length);
}
let sentRequests = 0;
await Promise.all(
recipients.map(async (recipient) => {
await sendSigningRequest(recipient, document, user);
sentRequests++;
})
);
if (sentRequests === recipients.length) {
return res.status(200).send(recipients.length);
}
return res.status(502).end("Could not send request for signing.");
} catch (err) {
return res.status(502).end("Could not send request for signing.");
}
}
export default defaultHandler({
POST: Promise.resolve({ default: defaultResponder(postHandler) }),
});

191
apps/web/pages/api/documents/[id]/sign.ts
View File

@@ -1,191 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { sendSigningDoneMail } from "@documenso/lib/mail";
import { getDocument } from "@documenso/lib/query";
import { defaultHandler, defaultResponder } from "@documenso/lib/server";
import { insertImageInPDF, insertTextInPDF } from "@documenso/pdf";
import prisma from "@documenso/prisma";
import { DocumentStatus, SigningStatus } from "@prisma/client";
import { FieldType, Document as PrismaDocument } from "@prisma/client";
async function postHandler(req: NextApiRequest, res: NextApiResponse) {
const { token: recipientToken } = req.query;
const { signatures: signaturesFromBody }: { signatures: any[] } = req.body;
if (!recipientToken) {
return res.status(401).send("Missing recipient token.");
}
// The recipient who received the signing request
const recipient = await prisma.recipient.findFirstOrThrow({
where: { token: recipientToken?.toString() },
});
if (!recipient) {
return res.status(401).send("Recipient not found.");
}
const document: PrismaDocument = await prisma.document.findFirstOrThrow({
where: {
id: recipient.documentId,
},
include: {
Recipient: {
orderBy: {
id: "asc",
},
},
Field: { include: { Recipient: true, Signature: true } },
},
});
if (!document) res.status(404).end(`No document found.`);
let documentWithInserts = document.document;
for (const signature of signaturesFromBody) {
if (!signature.signatureImage && !signature.typedSignature) {
documentWithInserts = document.document;
throw new Error("Can't save invalid signature.");
}
await saveSignature(signature);
const signedField = await prisma.field.findFirstOrThrow({
where: { id: signature.fieldId },
include: { Signature: true },
});
await insertSignatureInDocument(signedField);
}
await prisma.recipient.update({
where: {
id: recipient.id,
},
data: {
signingStatus: SigningStatus.SIGNED,
signedAt: new Date(),
},
});
const unsignedRecipients = await prisma.recipient.findMany({
where: {
documentId: recipient.documentId,
signingStatus: SigningStatus.NOT_SIGNED,
},
});
const signedRecipients = await prisma.recipient.findMany({
where: {
documentId: recipient.documentId,
signingStatus: SigningStatus.SIGNED,
},
});
// Don't check for inserted, because currently no "sign again" scenarios exist and
// this is probably the expected behaviour in unclean states.
const nonSignatureFields = await prisma.field.findMany({
where: {
documentId: document.id,
type: { in: [FieldType.DATE, FieldType.TEXT] },
recipientId: { in: signedRecipients.map((r) => r.id) },
},
include: {
Recipient: true,
}
});
// Insert fields other than signatures
for (const field of nonSignatureFields) {
documentWithInserts = await insertTextInPDF(
documentWithInserts,
field.type === FieldType.DATE
? new Intl.DateTimeFormat("en-US", {
month: "long",
day: "numeric",
year: "numeric",
}).format(field.Recipient?.signedAt ?? new Date())
: field.customText || "",
field.positionX,
field.positionY,
field.page,
false
);
await prisma.field.update({
where: {
id: field.id,
},
data: {
inserted: true,
},
});
}
await prisma.document.update({
where: {
id: recipient.documentId,
},
data: {
document: documentWithInserts,
status: unsignedRecipients.length > 0 ? DocumentStatus.PENDING : DocumentStatus.COMPLETED,
},
});
if (unsignedRecipients.length === 0) {
const documentOwner = await prisma.user.findFirstOrThrow({
where: { id: document.userId },
select: { email: true, name: true },
});
document.document = documentWithInserts;
if (documentOwner) await sendSigningDoneMail(document, documentOwner);
for (const signer of signedRecipients) {
await sendSigningDoneMail(document, signer);
}
}
return res.status(200).end();
async function insertSignatureInDocument(signedField: any) {
if (signedField?.Signature?.signatureImageAsBase64) {
documentWithInserts = await insertImageInPDF(
documentWithInserts,
signedField.Signature ? signedField.Signature?.signatureImageAsBase64 : "",
signedField.positionX,
signedField.positionY,
signedField.page
);
} else if (signedField?.Signature?.typedSignature) {
documentWithInserts = await insertTextInPDF(
documentWithInserts,
signedField.Signature.typedSignature,
signedField.positionX,
signedField.positionY,
signedField.page
);
} else {
documentWithInserts = document.document;
throw new Error("Invalid signature could not be inserted.");
}
}
async function saveSignature(signature: any) {
await prisma.signature.upsert({
where: {
fieldId: signature.fieldId,
},
update: {},
create: {
recipientId: recipient.id,
fieldId: signature.fieldId,
signatureImageAsBase64: signature.signatureImage ? signature.signatureImage : null,
typedSignature: signature.typedSignature ? signature.typedSignature : null,
},
});
}
}
export default defaultHandler({
POST: Promise.resolve({ default: defaultResponder(postHandler) }),
});

70
apps/web/pages/api/documents/index.ts
View File

@@ -1,70 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { getDocumentsForUserFromToken } from "@documenso/lib/query";
import { defaultHandler, defaultResponder } from "@documenso/lib/server";
import { getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
import formidable from "formidable";
import { isSubscribedServer } from "@documenso/lib/stripe";
export const config = {
api: {
bodyParser: false,
},
};
async function postHandler(req: NextApiRequest, res: NextApiResponse) {
const form = formidable();
const user = await getUserFromToken(req, res);
if (!user) {
return res.status(401).end();
};
const isSubscribed = await isSubscribedServer(req);
if (!isSubscribed) {
throw new Error("User is not subscribed.");
}
form.parse(req, async (err, fields, files) => {
if (err) throw err;
const uploadedDocument: any = files["document"];
const title = uploadedDocument[0].originalFilename;
const path = uploadedDocument[0].filepath;
const fs = require("fs");
const buffer = fs.readFileSync(path);
const documentAsBase64EncodedString = buffer.toString("base64");
await prisma
.$transaction([
prisma.document.create({
data: {
title: title,
userId: user?.id,
document: documentAsBase64EncodedString,
},
}),
])
.then((document) => {
return res.status(201).send(document[0].id);
})
.catch((err) => {
throw err;
});
});
}
async function getHandler(req: NextApiRequest, res: NextApiResponse) {
const user = await getUserFromToken(req, res);
if (!user) return;
const documents = await getDocumentsForUserFromToken({ req: req, res: res });
return res.status(200).json(documents);
}
export default defaultHandler({
GET: Promise.resolve({ default: defaultResponder(getHandler) }),
POST: Promise.resolve({ default: defaultResponder(postHandler) }),
});

15
apps/web/pages/api/health.ts
View File

@@ -1,15 +0,0 @@
import type { NextApiRequest, NextApiResponse } from "next";
import { defaultHandler, defaultResponder } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
// Return a healthy 200 status code for uptime monitoring and render.com zero-downtime-deploy
async function getHandler(req: NextApiRequest, res: NextApiResponse) {
// Some generic database access to make sure the service is healthy.
const users = await prisma.user.findFirst();
return res.status(200).json({ message: "Api up and running :)" });
}
export default defaultHandler({
GET: Promise.resolve({ default: defaultResponder(getHandler) }),
});

1
apps/web/pages/api/stripe/checkout-session.ts
View File

@@ -1 +0,0 @@
export { checkoutSessionHandler as default } from '@documenso/lib/stripe/handlers/checkout-session'

1
apps/web/pages/api/stripe/portal-session.ts
View File

@@ -1 +0,0 @@
export { portalSessionHandler as default } from "@documenso/lib/stripe/handlers/portal-session";

1
apps/web/pages/api/stripe/subscription.ts
View File

@@ -1 +0,0 @@
export { getSubscriptionHandler as default } from '@documenso/lib/stripe/handlers/get-subscription'

5
apps/web/pages/api/stripe/webhook.ts
View File

@@ -1,5 +0,0 @@
export const config = {
api: { bodyParser: false },
};
export { webhookHandler as default } from "@documenso/lib/stripe/handlers/webhook";

23
apps/web/pages/api/test-sign/[id].ts
View File

@@ -1,23 +0,0 @@
import { NextApiRequest, NextApiResponse } from "next";
import { getDocument } from "@documenso/lib/query";
import { defaultHandler, defaultResponder, getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
import { addDigitalSignature } from "@documenso/signing/addDigitalSignature";
import { Document as PrismaDocument } from "@prisma/client";
// todo remove before launch
async function getHandler(req: NextApiRequest, res: NextApiResponse) {
const documentId = req.query.id || 1;
const document: PrismaDocument = await getDocument(+documentId, req, res);
const signedDocument = await addDigitalSignature(document.document);
res.setHeader("Content-Type", "application/pdf");
res.setHeader("Content-Length", signedDocument.length);
res.setHeader("Content-Disposition", `attachment; filename=${document.title}`);
return res.status(200).send(signedDocument);
}
export default defaultHandler({
GET: Promise.resolve({ default: defaultResponder(getHandler) }),
});

53
apps/web/pages/api/users/index.ts
View File

@@ -1,53 +0,0 @@
import type { NextApiRequest, NextApiResponse } from "next";
import { hashPassword } from "@documenso/lib/auth";
import { defaultHandler, defaultResponder, getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
async function postHandler(req: NextApiRequest, res: NextApiResponse) {
const { method, body } = req;
if (!body.email) {
return res.status(400).json({ message: "Email cannot be empty." });
}
let newUser: any;
newUser = await prisma.user
.create({
data: { email: body.email },
})
.then(async () => {
return res.status(201).send(newUser);
});
}
async function patchHandler(req: NextApiRequest, res: NextApiResponse) {
const user = await getUserFromToken(req, res);
if (!user) return;
const updatedUser = req.body;
let password: string | undefined = undefined;
if (typeof updatedUser.password === "string" && updatedUser.password.length >= 6) {
password = await hashPassword(updatedUser.password);
}
await prisma.user
.update({
where: {
id: user.id,
},
data: {
name: updatedUser.name,
password,
},
})
.then(() => {
return res.status(200).end();
});
}
export default defaultHandler({
POST: Promise.resolve({ default: defaultResponder(postHandler) }),
PATCH: Promise.resolve({ default: defaultResponder(patchHandler) }),
});

23
apps/web/pages/api/users/me.ts
View File

@@ -1,23 +0,0 @@
import type { NextApiRequest, NextApiResponse } from "next";
import { defaultHandler, defaultResponder, getUserFromToken } from "@documenso/lib/server";
import prisma from "@documenso/prisma";
async function getHandler(req: NextApiRequest, res: NextApiResponse) {
const user = await getUserFromToken(req, res);
if (!user) return;
return prisma.user.findFirstOrThrow({
where: {
id: user.id,
},
select: {
email: true,
name: true,
},
});
}
export default defaultHandler({
GET: Promise.resolve({ default: defaultResponder(getHandler) }),
});