Merge pull request #2 from calcom/feat/with-transpile-modules

feat: adds module transpiling so api can require @calcom/prisma
This commit is contained in:
Agusti Fernandez authored and GitHub committed 2022-03-25 23:28:02 +01:00
commit f80f23d3c3
23 files changed
+448 -26

No files matched your search

+3
View File
@@ -39,3 +39,6 @@ We aim to provide a fully tested API for our peace of mind, this is accomplished
Since this will only support an API, we redirect the requests to root to the /api folder.
We also added a redirect for future-proofing API versioning when we might need it, without having to resort to dirty hacks like a v1/v2 folders with lots of duplicated code, instead we redirect /api/v*/:rest to /api/:rest?version=*
The priority is the booking-related API routes so people can build their own booking flow, then event type management routes, then availability management routes etc
+16
View File
@@ -0,0 +1,16 @@
import { withValidation } from "next-validations";
import { z } from "zod";
const schemaApiKey = z
.object({
expiresAt: z.string().transform((date: string) => new Date(date)).optional(), // default is 30 days
note: z.string().min(1).optional(),
})
.strict(); // Adding strict so that we can disallow passing in extra fields
const withValidApiKey = withValidation({
schema: schemaApiKey,
type: "Zod",
mode: "body",
});
export { schemaApiKey, withValidApiKey };
+20
View File
@@ -0,0 +1,20 @@
import { withValidation } from "next-validations";
import { z } from "zod";
// Extracted out as utility function so can be reused
// at different endpoints that require this validation.
const schemaQueryId = z
.object({
// since nextjs parses query params as strings,
// we need to cast them to numbers using z.transform() and parseInt()
id: z.string()
})
.strict();
const withValidQueryIdString = withValidation({
schema: schemaQueryId,
type: "Zod",
mode: "query",
});
export { schemaQueryId, withValidQueryIdString };
+2 -2
View File
@@ -14,10 +14,10 @@ const schemaQueryId = z
})
.strict();
const withValidQueryId = withValidation({
const withValidQueryIdTransformParseInt = withValidation({
schema: schemaQueryId,
type: "Zod",
mode: "query",
});
export { schemaQueryId, withValidQueryId };
export { schemaQueryId, withValidQueryIdTransformParseInt };
+62
View File
@@ -0,0 +1,62 @@
import { withValidation } from "next-validations";
import { schemaEventType } from "./eventType";
// import { schemaCredential } from "./credential";
// import { schemaMembership } from "./membership";
// import { schemaBooking } from "./booking";
// import { schemaSchedule } from "./schedule";
// import { schemaSelectedCalendar } from "./selectedCalendar";
// import { schemaAvailability } from "./availability";
// import { schemaWebhook } from "./webhook";
import { z } from "zod";
import { schemaApiKey } from "./apiKey";
const schemaUser = z
.object({
username: z.string().min(3),
name: z.string().min(3),
email: z.string().email(), // max is a full day.
emailVerified: z.date().optional(),
password: z.string().optional(),
bio: z.string().min(3).optional(),
avatar: z.string().optional(),
timeZone: z.string().default("Europe/London"),
weekStart: z.string().default("Sunday"),
bufferTime: z.number().default(0),
hideBranding: z.boolean().default(false),
theme: z.string().optional(),
trialEndsAt: z.date().optional(),
eventTypes: z.array((schemaEventType)).optional(),
// credentials: z.array((schemaCredentials)).optional(),
// teams: z.array((schemaMembership)).optional(),
// bookings: z.array((schemaBooking)).optional(),
// schedules: z.array((schemaSchedule)).optional(),
defaultScheduleId: z.number().optional(),
// selectedCalendars: z.array((schemaSelectedCalendar)).optional(),
completedOnboarding: z.boolean().default(false),
locale: z.string().optional(),
timeFormat: z.number().optional().default(12),
twoFactorEnabled: z.boolean().default(false),
twoFactorSecret: z.string().optional(),
identityProvider: z.enum(["CAL", "SAML", "GOOGLE"]).optional().default("CAL"),
identityProviderId: z.string().optional(),
// availavility: z.array((schemaAvailavility)).optional(),
invitedTo: z.number().optional(),
plan: z.enum(['FREE', 'TRIAL', 'PRO']).default("TRIAL"),
// webhooks: z.array((schemaWebhook)).optional(),
brandColor: z.string().default("#292929"),
darkBrandColor: z.string().default("#fafafa"),
// destinationCalendar: z.instanceof(schemaEventType).optional(), // FIXME: instanceof doesnt work here
away: z.boolean().default(false),
metadata: z.object({}).optional(),
verified: z.boolean().default(false),
apiKeys: z.array((schemaApiKey)).optional(),
})
.strict(); // Adding strict so that we can disallow passing in extra fields
const withValidUser = withValidation({
schema: schemaUser,
type: "Zod",
mode: "body",
});
export { schemaUser, withValidUser };
+10 -2
View File
@@ -1,4 +1,12 @@
module.exports = {
// https://www.npmjs.com/package/next-transpile-modules
// This makes our @calcom/prisma package from the monorepo to be transpiled and usable by API
const withTM = require("next-transpile-modules")([
"@calcom/prisma",
]);
// use something like withPlugins([withTM], {}) if more plugins added later.
module.exports = withTM({
async rewrites() {
return [
// This redirects requests recieved at / the root to the /api/ folder.
@@ -13,4 +21,4 @@ module.exports = {
},
];
},
};
});
+2 -1
View File
@@ -31,9 +31,10 @@
"node-mocks-http": "^1.11.0"
},
"dependencies": {
"typescript": "^4.6.3",
"next": "^12.1.0",
"next-transpile-modules": "^9.0.0",
"next-validations": "^0.1.11",
"typescript": "^4.6.3",
"zod": "^3.14.2"
}
}
+34
View File
@@ -0,0 +1,34 @@
import prisma from "@calcom/prisma";
import { NextApiRequest, NextApiResponse } from "next";
import { schemaQueryId, withValidQueryIdString } from "@lib/validations/queryIdString";
type ResponseData = {
message?: string;
error?: unknown;
};
export async function apiKey(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
const { query, method } = req;
const safe = await schemaQueryId.safeParse(query);
if (safe.success) {
if (method === "DELETE") {
// DELETE WILL DELETE THE EVENT TYPE
prisma.apiKey
.delete({ where: { id: safe.data.id } })
.then(() => {
// We only remove the api key from the database if there's an existing resource.
res.status(200).json({ message: `api-key with id: ${safe.data.id} deleted successfully` });
})
.catch((error) => {
// This catches the error thrown by prisma.apiKey.delete() if the resource is not found.
res.status(400).json({ message: `Resource with id:${safe.data.id} was not found`, error: error });
});
} else {
// Reject any other HTTP method than POST
res.status(405).json({ message: "Only DELETE Method allowed in /api-keys/[id]/delete endpoint" });
}
}
}
export default withValidQueryIdString(apiKey);
+37
View File
@@ -0,0 +1,37 @@
import prisma from "@calcom/prisma";
import { ApiKey } from "@calcom/prisma/client";
import type { NextApiRequest, NextApiResponse } from "next";
import { schemaApiKey, withValidApiKey } from "@lib/validations/apiKey";
import { schemaQueryId, withValidQueryIdString } from "@lib/validations/queryIdString";
type ResponseData = {
data?: ApiKey;
message?: string;
error?: unknown;
};
export async function editApiKey(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
const { query, body, method } = req;
const safeQuery = await schemaQueryId.safeParse(query);
const safeBody = await schemaApiKey.safeParse(body);
if (method === "PATCH") {
if (safeQuery.success && safeBody.success) {
await prisma.apiKey.update({
where: { id: safeQuery.data.id },
data: safeBody.data,
}).then(apiKey => {
res.status(200).json({ data: apiKey });
}).catch(error => {
res.status(404).json({ message: `Event type with ID ${safeQuery.data.id} not found and wasn't updated`, error })
});
}
} else {
// Reject any other HTTP method than POST
res.status(405).json({ message: "Only PATCH Method allowed for updating apiKey-types" });
}
}
export default withValidQueryIdString(withValidApiKey(editApiKey));
+31
View File
@@ -0,0 +1,31 @@
import prisma from "@calcom/prisma";
import { ApiKey } from "@calcom/prisma/client";
import type { NextApiRequest, NextApiResponse } from "next";
import { schemaQueryId, withValidQueryIdString } from "@lib/validations/queryIdString";
type ResponseData = {
data?: ApiKey;
message?: string;
error?: unknown;
};
export async function apiKey(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
const { query, method } = req;
const safe = await schemaQueryId.safeParse(query);
if (safe.success) {
if (method === "GET") {
const apiKey = await prisma.apiKey.findUnique({ where: { id: safe.data.id } });
if (apiKey) res.status(200).json({ data: apiKey });
if (!apiKey) res.status(404).json({ message: "Event type not found" });
} else {
// Reject any other HTTP method than POST
res.status(405).json({ message: "Only GET Method allowed" });
}
}
}
export default withValidQueryIdString(apiKey);
+19
View File
@@ -0,0 +1,19 @@
import prisma from "@calcom/prisma";
import { ApiKey } from "@calcom/prisma/client";import type { NextApiRequest, NextApiResponse } from "next";
type ResponseData = {
data?: ApiKey[];
error?: unknown;
};
export default async function apiKey(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
try {
const apiKeys = await prisma.apiKey.findMany({});
res.status(200).json({ data: { ...apiKeys } });
} catch (error) {
console.log(error);
// FIXME: Add zod for validation/error handling
res.status(400).json({ error: error });
}
}
+37
View File
@@ -0,0 +1,37 @@
import prisma from "@calcom/prisma";
import { ApiKey } from "@calcom/prisma/client";import type { NextApiRequest, NextApiResponse } from "next";
import { schemaApiKey, withValidApiKey } from "@lib/validations/apiKey";
type ResponseData = {
data?: ApiKey;
message?: string;
error?: string;
};
async function createApiKey(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
const { body, method } = req;
if (method === "POST") {
const safe = schemaApiKey.safeParse(body);
if (safe.success && safe.data) {
await prisma.apiKey
.create({
data: {
...safe.data, user: { connect: { id: 1 } }
}
})
.then((apiKey) => res.status(201).json({ data: apiKey }))
.catch((error) => {
console.log(error);
res.status(400).json({ message: "Could not create apiKey", error: error })
}
)
}
} else {
// Reject any other HTTP method than POST
res.status(405).json({ error: "Only POST Method allowed" });
}
}
export default withValidApiKey(createApiKey);
+4 -4
View File
@@ -1,9 +1,9 @@
import { PrismaClient } from "@prisma/client";
import prisma from "@calcom/prisma";
import type { NextApiRequest, NextApiResponse } from "next";
import { schemaQueryId, withValidQueryId } from "@lib/validations/queryIdTransformParseInt";
import { schemaQueryId, withValidQueryIdTransformParseInt } from "@lib/validations/queryIdTransformParseInt";
const prisma = new PrismaClient();
type ResponseData = {
message?: string;
@@ -33,4 +33,4 @@ export async function eventType(req: NextApiRequest, res: NextApiResponse<Respon
}
}
export default withValidQueryId(eventType);
export default withValidQueryIdTransformParseInt(eventType);
+5 -5
View File
@@ -1,10 +1,10 @@
import { PrismaClient, EventType } from "@prisma/client";
import prisma from "@calcom/prisma";
import { EventType } from "@calcom/prisma/client";
import type { NextApiRequest, NextApiResponse } from "next";
import { schemaEventType, withValidEventType } from "@lib/validations/eventType";
import { schemaQueryId, withValidQueryId } from "@lib/validations/queryIdTransformParseInt";
const prisma = new PrismaClient();
import { schemaQueryId, withValidQueryIdTransformParseInt } from "@lib/validations/queryIdTransformParseInt";
type ResponseData = {
data?: EventType;
@@ -34,4 +34,4 @@ export async function editEventType(req: NextApiRequest, res: NextApiResponse<Re
}
}
export default withValidQueryId(withValidEventType(editEventType));
export default withValidQueryIdTransformParseInt(withValidEventType(editEventType));
+5 -5
View File
@@ -1,9 +1,9 @@
import { PrismaClient, EventType } from "@prisma/client";
import prisma from "@calcom/prisma";
import { EventType } from "@calcom/prisma/client";
import type { NextApiRequest, NextApiResponse } from "next";
import { schemaQueryId, withValidQueryId } from "@lib/validations/queryIdTransformParseInt";
const prisma = new PrismaClient();
import { schemaQueryId, withValidQueryIdTransformParseInt } from "@lib/validations/queryIdTransformParseInt";
type ResponseData = {
data?: EventType;
@@ -28,4 +28,4 @@ export async function eventType(req: NextApiRequest, res: NextApiResponse<Respon
}
export default withValidQueryId(eventType);
export default withValidQueryIdTransformParseInt(eventType);
+4 -4
View File
@@ -1,7 +1,7 @@
import { PrismaClient, EventType } from "@prisma/client";
import type { NextApiRequest, NextApiResponse } from "next";
import prisma from "@calcom/prisma";
import { EventType } from "@calcom/prisma/client";import type { NextApiRequest, NextApiResponse } from "next";
const prisma = new PrismaClient();
type ResponseData = {
data?: EventType[];
error?: unknown;
@@ -9,7 +9,7 @@ type ResponseData = {
export default async function eventType(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
try {
const eventTypes = await prisma.eventType.findMany({ where: { id: Number(req.query.eventTypeId) } });
const eventTypes = await prisma.eventType.findMany();
res.status(200).json({ data: { ...eventTypes } });
} catch (error) {
console.log(error);
+3 -3
View File
@@ -1,9 +1,9 @@
import { PrismaClient, EventType } from "@prisma/client";
import type { NextApiRequest, NextApiResponse } from "next";
import prisma from "@calcom/prisma";
import { EventType } from "@calcom/prisma/client";import type { NextApiRequest, NextApiResponse } from "next";
import { schemaEventType, withValidEventType } from "@lib/validations/eventType";
const prisma = new PrismaClient();
type ResponseData = {
data?: EventType;
message?: string;
+36
View File
@@ -0,0 +1,36 @@
import prisma from "@calcom/prisma";
import type { NextApiRequest, NextApiResponse } from "next";
import { schemaQueryId, withValidQueryIdTransformParseInt } from "@lib/validations/queryIdTransformParseInt";
type ResponseData = {
message?: string;
error?: unknown;
};
export async function user(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
const { query, method } = req;
const safe = await schemaQueryId.safeParse(query);
if (safe.success) {
if (method === "DELETE") {
// DELETE WILL DELETE THE EVENT TYPE
prisma.user
.delete({ where: { id: safe.data.id } })
.then(() => {
// We only remove the user type from the database if there's an existing resource.
res.status(200).json({ message: `user-type with id: ${safe.data.id} deleted successfully` });
})
.catch((error) => {
// This catches the error thrown by prisma.user.delete() if the resource is not found.
res.status(400).json({ message: `Resource with id:${safe.data.id} was not found`, error: error });
});
} else {
// Reject any other HTTP method than POST
res.status(405).json({ message: "Only DELETE Method allowed in /user-types/[id]/delete endpoint" });
}
}
}
export default withValidQueryIdTransformParseInt(user);
+37
View File
@@ -0,0 +1,37 @@
import prisma from "@calcom/prisma";
import { User } from "@calcom/prisma/client";
import type { NextApiRequest, NextApiResponse } from "next";
import { schemaUser, withValidUser } from "@lib/validations/user";
import { schemaQueryId, withValidQueryIdTransformParseInt } from "@lib/validations/queryIdTransformParseInt";
type ResponseData = {
data?: User;
message?: string;
error?: unknown;
};
export async function editUser(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
const { query, body, method } = req;
const safeQuery = await schemaQueryId.safeParse(query);
const safeBody = await schemaUser.safeParse(body);
if (method === "PATCH") {
if (safeQuery.success && safeBody.success) {
await prisma.user.update({
where: { id: safeQuery.data.id },
data: safeBody.data,
}).then(user => {
res.status(200).json({ data: user });
}).catch(error => {
res.status(404).json({ message: `Event type with ID ${safeQuery.data.id} not found and wasn't updated`, error })
});
}
} else {
// Reject any other HTTP method than POST
res.status(405).json({ message: "Only PATCH Method allowed for updating user-types" });
}
}
export default withValidQueryIdTransformParseInt(withValidUser(editUser));
+31
View File
@@ -0,0 +1,31 @@
import prisma from "@calcom/prisma";
import { User } from "@calcom/prisma/client";
import type { NextApiRequest, NextApiResponse } from "next";
import { schemaQueryId, withValidQueryIdTransformParseInt } from "@lib/validations/queryIdTransformParseInt";
type ResponseData = {
data?: User;
message?: string;
error?: unknown;
};
export async function user(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
const { query, method } = req;
const safe = await schemaQueryId.safeParse(query);
if (safe.success) {
if (method === "GET") {
const user = await prisma.user.findUnique({ where: { id: safe.data.id } });
if (user) res.status(200).json({ data: user });
if (!user) res.status(404).json({ message: "Event type not found" });
} else {
// Reject any other HTTP method than POST
res.status(405).json({ message: "Only GET Method allowed" });
}
}
}
export default withValidQueryIdTransformParseInt(user);
+19
View File
@@ -0,0 +1,19 @@
import prisma from "@calcom/prisma";
import { User } from "@calcom/prisma/client";import type { NextApiRequest, NextApiResponse } from "next";
type ResponseData = {
data?: User[];
error?: unknown;
};
export default async function user(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
try {
const users = await prisma.user.findMany();
res.status(200).json({ data: { ...users } });
} catch (error) {
console.log(error);
// FIXME: Add zod for validation/error handling
res.status(400).json({ error: error });
}
}
+29
View File
@@ -0,0 +1,29 @@
import prisma from "@calcom/prisma";
import { User } from "@calcom/prisma/client";import type { NextApiRequest, NextApiResponse } from "next";
import { schemaUser, withValidUser } from "@lib/validations/user";
type ResponseData = {
data?: User;
message?: string;
error?: string;
};
async function createUser(req: NextApiRequest, res: NextApiResponse<ResponseData>) {
const { body, method } = req;
if (method === "POST") {
const safe = schemaUser.safeParse(body);
if (safe.success && safe.data) {
await prisma.user
.create({ data: safe.data })
.then((user) => res.status(201).json({ data: user }))
.catch((error) => res.status(400).json({ message: "Could not create user type", error: error }));
}
} else {
// Reject any other HTTP method than POST
res.status(405).json({ error: "Only POST Method allowed" });
}
}
export default withValidUser(createUser);
+2
View File
@@ -21,7 +21,9 @@
"jsx": "preserve",
"paths": {
"@api/*": ["pages/api/*"],
"@prisma/client/*": ["@calcom/prisma/client/*"],
"@lib/*": ["lib/*"]
},
},
"include": [