cal.pub0.org/packages/app-store/tandemvideo/lib/VideoApiAdapter.ts

170 lines
5.4 KiB
TypeScript

import type { Prisma } from "@prisma/client";
import { handleErrorsJson, handleErrorsRaw } from "@calcom/lib/errors";
import { HttpError } from "@calcom/lib/http-error";
import prisma from "@calcom/prisma";
import type { CalendarEvent } from "@calcom/types/Calendar";
import type { CredentialPayload } from "@calcom/types/Credential";
import type { PartialReference } from "@calcom/types/EventManager";
import type { VideoApiAdapter, VideoCallData } from "@calcom/types/VideoApiAdapter";
import getAppKeysFromSlug from "../../_utils/getAppKeysFromSlug";
interface TandemToken {
expires_in?: number;
expiry_date: number;
refresh_token: string;
token_type: "Bearer";
access_token: string;
}
interface ITandemRefreshToken {
expires_in?: number;
expiry_date?: number;
access_token: string;
refresh_token: string;
}
interface ITandemCreateMeetingResponse {
data: {
id: string;
event_link: string;
};
}
let client_id = "";
let client_secret = "";
let base_url = "";
const tandemAuth = async (credential: CredentialPayload) => {
const appKeys = await getAppKeysFromSlug("tandem");
if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
if (typeof appKeys.client_secret === "string") client_secret = appKeys.client_secret;
if (typeof appKeys.base_url === "string") base_url = appKeys.base_url;
if (!client_id) throw new HttpError({ statusCode: 400, message: "Tandem client_id missing." });
if (!client_secret) throw new HttpError({ statusCode: 400, message: "Tandem client_secret missing." });
if (!base_url) throw new HttpError({ statusCode: 400, message: "Tandem base_url missing." });
const credentialKey = credential.key as unknown as TandemToken;
const isTokenValid = (token: TandemToken) => token && token.access_token && token.expiry_date < Date.now();
const refreshAccessToken = async (refreshToken: string) => {
const result = await fetch(`${base_url}/api/v1/oauth/v2/token`, {
method: "POST",
body: new URLSearchParams({
client_id,
client_secret,
code: refreshToken,
}),
});
const responseBody = await handleErrorsJson<ITandemRefreshToken>(result);
// set expiry date as offset from current time.
responseBody.expiry_date = Math.round(Date.now() + (responseBody.expires_in || 0) * 1000);
delete responseBody.expires_in;
// Store new tokens in database.
await prisma.credential.update({
where: {
id: credential.id,
},
data: {
key: responseBody as unknown as Prisma.InputJsonValue,
},
});
credentialKey.expiry_date = responseBody.expiry_date;
credentialKey.access_token = responseBody.access_token;
credentialKey.refresh_token = responseBody.refresh_token;
return credentialKey.access_token;
};
return {
getToken: () =>
!isTokenValid(credentialKey)
? Promise.resolve(credentialKey.access_token)
: refreshAccessToken(credentialKey.refresh_token),
};
};
const TandemVideoApiAdapter = (credential: CredentialPayload): VideoApiAdapter => {
const auth = tandemAuth(credential);
const _parseDate = (date: string) => {
return Date.parse(date) / 1000;
};
const _translateEvent = (event: CalendarEvent, param: string): string => {
return JSON.stringify({
[param]: {
title: event.title,
starts_at: _parseDate(event.startTime),
ends_at: _parseDate(event.endTime),
description: event.description || "",
conference_solution: "tandem",
type: 3,
},
});
};
const _translateResult = (result: ITandemCreateMeetingResponse) => {
return {
type: "tandem_video",
id: result.data.id as string,
password: "",
url: result.data.event_link,
};
};
return {
/** Tandem doesn't need to return busy times, so we return empty */
getAvailability: () => {
return Promise.resolve([]);
},
createMeeting: async (event: CalendarEvent): Promise<VideoCallData> => {
const accessToken = await (await auth).getToken();
const result = await fetch(`${base_url}/api/v1/meetings`, {
method: "POST",
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": "application/json",
},
body: _translateEvent(event, "meeting"),
});
const responseBody = await handleErrorsJson<ITandemCreateMeetingResponse>(result);
return Promise.resolve(_translateResult(responseBody));
},
deleteMeeting: async (uid: string): Promise<void> => {
const accessToken = await (await auth).getToken();
await fetch(`${base_url}/api/v1/meetings/${uid}`, {
method: "DELETE",
headers: {
Authorization: `Bearer ${accessToken}`,
},
}).then(handleErrorsRaw);
return Promise.resolve();
},
updateMeeting: async (bookingRef: PartialReference, event: CalendarEvent): Promise<VideoCallData> => {
const accessToken = await (await auth).getToken();
const result = await fetch(`${base_url}/api/v1/meetings/${bookingRef.meetingId}`, {
method: "PUT",
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": "application/json",
},
body: _translateEvent(event, "updates"),
});
const responseBody = await handleErrorsJson<ITandemCreateMeetingResponse>(result);
return Promise.resolve(_translateResult(responseBody));
},
};
};
export default TandemVideoApiAdapter;