commit 6e2d8cdba743b3fd9ce437f0ff8c654943ed12fb · dunkirk.sh/smokie

+21 -10

src/features/api/index.ts

···

       1
       1
        
       import { recentTakes, takesPerUser } from "./routes/recentTakes";

     

       2
       2
        
       import video from "./routes/video";

     

       3
       3
       +
       import { handleApiError } from "../../libs/apiError";

     

       3
       4
        
       

     

       4
       5
        
       export { default as video } from "./routes/video";

     

       5
       6
        
       

     

       6
       7
        
       export async function apiRouter(url: URL) {

     

       7
       7
       -
       	const path = url.pathname.split("/")[2];

     

       8
       8
       +
       	try {

     

       9
       9
       +
       		const path = url.pathname.split("/")[2];

     

       8
       10
        
       

     

       9
       9
       -
       	switch (path) {

     

       10
       10
       -
       		case "video":

     

       11
       11
       -
       			return video(url);

     

       12
       12
       -
       		case "recentTakes":

     

       13
       13
       -
       			return recentTakes();

     

       14
       14
       -
       		case "takesPerUser":

     

       15
       15
       -
       			return takesPerUser(url.pathname.split("/")[3] as string);

     

       16
       16
       -
       		default:

     

       17
       17
       -
       			return new Response("404 Not Found", { status: 404 });

     

       11
       11
       +
       		switch (path) {

     

       12
       12
       +
       			case "video":

     

       13
       13
       +
       				return await video(url);

     

       14
       14
       +
       			case "recentTakes":

     

       15
       15
       +
       				return await recentTakes();

     

       16
       16
       +
       			case "takesPerUser":

     

       17
       17
       +
       				return await takesPerUser(url.pathname.split("/")[3] as string);

     

       18
       18
       +
       			default:

     

       19
       19
       +
       				return new Response(

     

       20
       20
       +
       					JSON.stringify({ error: "Route not found" }),

     

       21
       21
       +
       					{

     

       22
       22
       +
       						status: 404,

     

       23
       23
       +
       						headers: { "Content-Type": "application/json" },

     

       24
       24
       +
       					},

     

       25
       25
       +
       				);

     

       26
       26
       +
       		}

     

       27
       27
       +
       	} catch (error) {

     

       28
       28
       +
       		return handleApiError(error, "apiRouter");

     

       18
       29
        
       	}

     

       19
       30
        
       }

+94 -85

src/features/api/routes/recentTakes.ts

···

       1
       1
        
       import { eq, desc, and } from "drizzle-orm";

     

       2
       2
        
       import { db } from "../../../libs/db";

     

       3
       3
        
       import { takes as takesTable } from "../../../libs/schema";

     

       4
       4
       +
       import { handleApiError } from "../../../libs/apiError";

     

       4
       5
        
       

     

       5
       6
        
       export async function recentTakes(): Promise<Response> {

     

       6
       6
       -
       	const recentTakes = await db

     

       7
       7
       -
       		.select()

     

       8
       8
       -
       		.from(takesTable)

     

       9
       9
       -
       		.where(eq(takesTable.status, "approved"))

     

       10
       10
       -
       		.orderBy(desc(takesTable.completedAt))

     

       11
       11
       -
       		.limit(40);

     

       7
       7
       +
       	try {

     

       8
       8
       +
       		const recentTakes = await db

     

       9
       9
       +
       			.select()

     

       10
       10
       +
       			.from(takesTable)

     

       11
       11
       +
       			.where(eq(takesTable.status, "approved"))

     

       12
       12
       +
       			.orderBy(desc(takesTable.completedAt))

     

       13
       13
       +
       			.limit(40);

     

       14
       14
       +
       

     

       15
       15
       +
       		if (recentTakes.length === 0) {

     

       16
       16
       +
       			return new Response(

     

       17
       17
       +
       				JSON.stringify({

     

       18
       18
       +
       					takes: [],

     

       19
       19
       +
       				}),

     

       20
       20
       +
       				{

     

       21
       21
       +
       					headers: {

     

       22
       22
       +
       						"Content-Type": "application/json",

     

       23
       23
       +
       					},

     

       24
       24
       +
       				},

     

       25
       25
       +
       			);

     

       26
       26
       +
       		}

     

       27
       27
       +
       

     

       28
       28
       +
       		const takes = recentTakes.map((take) => ({

     

       29
       29
       +
       			id: take.id,

     

       30
       30
       +
       			userId: take.userId,

     

       31
       31
       +
       			description: take.description,

     

       32
       32
       +
       			completedAt: take.completedAt,

     

       33
       33
       +
       			status: take.status,

     

       34
       34
       +
       			mp4Url: take.takeUrl,

     

       35
       35
       +
       			elapsedTime: take.elapsedTimeMs,

     

       36
       36
       +
       		}));

     

       12
       37
        
       

     

       13
       13
       -
       	if (recentTakes.length === 0) {

     

       14
       38
        
       		return new Response(

     

       15
       39
        
       			JSON.stringify({

     

       16
       16
       -
       				takes: [],

     

       40
       40
       +
       				takes,

     

       17
       41
        
       			}),

     

       18
       42
        
       			{

     

       19
       43
        
       				headers: {

     
···

       21
       45
        
       				},

     

       22
       46
        
       			},

     

       23
       47
        
       		);

     

       48
       48
       +
       	} catch (error) {

     

       49
       49
       +
       		return handleApiError(error, "recentTakes");

     

       24
       50
        
       	}

     

       25
       25
       -
       

     

       26
       26
       -
       	const takes = recentTakes.map((take) => ({

     

       27
       27
       -
       		id: take.id,

     

       28
       28
       -
       		userId: take.userId,

     

       29
       29
       -
       		description: take.description,

     

       30
       30
       -
       		completedAt: take.completedAt,

     

       31
       31
       -
       		status: take.status,

     

       32
       32
       -
       		mp4Url: take.takeUrl,

     

       33
       33
       -
       		elapsedTime: take.elapsedTimeMs,

     

       34
       34
       -
       	}));

     

       35
       35
       -
       

     

       36
       36
       -
       	return new Response(

     

       37
       37
       -
       		JSON.stringify({

     

       38
       38
       -
       			takes,

     

       39
       39
       -
       		}),

     

       40
       40
       -
       		{

     

       41
       41
       -
       			headers: {

     

       42
       42
       -
       				"Content-Type": "application/json",

     

       43
       43
       -
       			},

     

       44
       44
       -
       		},

     

       45
       45
       -
       	);

     

       46
       51
        
       }

     

       47
       52
        
       

     

       48
       53
        
       export async function takesPerUser(userId: string): Promise<Response> {

     

       49
       49
       -
       	const rawTakes = await db

     

       50
       50
       -
       		.select()

     

       51
       51
       -
       		.from(takesTable)

     

       52
       52
       -
       		.where(and(eq(takesTable.userId, userId)))

     

       53
       53
       -
       		.orderBy(desc(takesTable.completedAt));

     

       54
       54
       +
       	try {

     

       55
       55
       +
       		const rawTakes = await db

     

       56
       56
       +
       			.select()

     

       57
       57
       +
       			.from(takesTable)

     

       58
       58
       +
       			.where(and(eq(takesTable.userId, userId)))

     

       59
       59
       +
       			.orderBy(desc(takesTable.completedAt));

     

       54
       60
        
       

     

       55
       55
       -
       	const takes = rawTakes.map((take) => ({

     

       56
       56
       -
       		id: take.id,

     

       57
       57
       -
       		description: take.description,

     

       58
       58
       -
       		completedAt: take.completedAt,

     

       59
       59
       -
       		status: take.status,

     

       60
       60
       -
       		mp4Url: take.takeUrl,

     

       61
       61
       -
       		elapsedTime: take.elapsedTimeMs,

     

       62
       62
       -
       	}));

     

       61
       61
       +
       		const takes = rawTakes.map((take) => ({

     

       62
       62
       +
       			id: take.id,

     

       63
       63
       +
       			description: take.description,

     

       64
       64
       +
       			completedAt: take.completedAt,

     

       65
       65
       +
       			status: take.status,

     

       66
       66
       +
       			mp4Url: take.takeUrl,

     

       67
       67
       +
       			elapsedTime: take.elapsedTimeMs,

     

       68
       68
       +
       		}));

     

       63
       69
        
       

     

       64
       64
       -
       	const approvedTakes = rawTakes.reduce((acc, take) => {

     

       65
       65
       -
       		if (take.status !== "approved") return acc;

     

       66
       66
       -
       		const multiplier = Number.parseFloat(take.multiplier || "1.0");

     

       67
       67
       -
       		return Number(

     

       68
       68
       -
       			(

     

       69
       69
       -
       				acc +

     

       70
       70
       -
       				(take.elapsedTimeMs * multiplier) / (1000 * 60 * 60)

     

       71
       71
       -
       			).toFixed(1),

     

       72
       72
       -
       		);

     

       73
       73
       -
       	}, 0);

     

       70
       70
       +
       		const approvedTakes = rawTakes.reduce((acc, take) => {

     

       71
       71
       +
       			if (take.status !== "approved") return acc;

     

       72
       72
       +
       			const multiplier = Number.parseFloat(take.multiplier || "1.0");

     

       73
       73
       +
       			return Number(

     

       74
       74
       +
       				(

     

       75
       75
       +
       					acc +

     

       76
       76
       +
       					(take.elapsedTimeMs * multiplier) / (1000 * 60 * 60)

     

       77
       77
       +
       				).toFixed(1),

     

       78
       78
       +
       			);

     

       79
       79
       +
       		}, 0);

     

       74
       80
        
       

     

       75
       75
       -
       	const waitingTakes = rawTakes.reduce((acc, take) => {

     

       76
       76
       -
       		if (take.status !== "waitingUpload" && take.status !== "uploaded")

     

       77
       77
       -
       			return acc;

     

       78
       78
       -
       		const multiplier = Number.parseFloat(take.multiplier || "1.0");

     

       79
       79
       -
       		return Number(

     

       80
       80
       -
       			(

     

       81
       81
       -
       				acc +

     

       82
       82
       -
       				(take.elapsedTimeMs * multiplier) / (1000 * 60 * 60)

     

       83
       83
       -
       			).toFixed(1),

     

       84
       84
       -
       		);

     

       85
       85
       -
       	}, 0);

     

       81
       81
       +
       		const waitingTakes = rawTakes.reduce((acc, take) => {

     

       82
       82
       +
       			if (take.status !== "waitingUpload" && take.status !== "uploaded")

     

       83
       83
       +
       				return acc;

     

       84
       84
       +
       			const multiplier = Number.parseFloat(take.multiplier || "1.0");

     

       85
       85
       +
       			return Number(

     

       86
       86
       +
       				(

     

       87
       87
       +
       					acc +

     

       88
       88
       +
       					(take.elapsedTimeMs * multiplier) / (1000 * 60 * 60)

     

       89
       89
       +
       				).toFixed(1),

     

       90
       90
       +
       			);

     

       91
       91
       +
       		}, 0);

     

       86
       92
        
       

     

       87
       87
       -
       	const rejectedTakes = rawTakes.reduce((acc, take) => {

     

       88
       88
       -
       		if (take.status !== "rejected") return acc;

     

       89
       89
       -
       		const multiplier = Number.parseFloat(take.multiplier || "1.0");

     

       90
       90
       -
       		return Number(

     

       91
       91
       -
       			(

     

       92
       92
       -
       				acc +

     

       93
       93
       -
       				(take.elapsedTimeMs * multiplier) / (1000 * 60 * 60)

     

       94
       94
       -
       			).toFixed(1),

     

       95
       95
       -
       		);

     

       96
       96
       -
       	}, 0);

     

       93
       93
       +
       		const rejectedTakes = rawTakes.reduce((acc, take) => {

     

       94
       94
       +
       			if (take.status !== "rejected") return acc;

     

       95
       95
       +
       			const multiplier = Number.parseFloat(take.multiplier || "1.0");

     

       96
       96
       +
       			return Number(

     

       97
       97
       +
       				(

     

       98
       98
       +
       					acc +

     

       99
       99
       +
       					(take.elapsedTimeMs * multiplier) / (1000 * 60 * 60)

     

       100
       100
       +
       				).toFixed(1),

     

       101
       101
       +
       			);

     

       102
       102
       +
       		}, 0);

     

       97
       103
        
       

     

       98
       98
       -
       	return new Response(

     

       99
       99
       -
       		JSON.stringify({

     

       100
       100
       -
       			approvedTakes,

     

       101
       101
       -
       			waitingTakes,

     

       102
       102
       -
       			rejectedTakes,

     

       103
       103
       -
       			takes,

     

       104
       104
       -
       		}),

     

       105
       105
       -
       		{

     

       106
       106
       -
       			headers: {

     

       107
       107
       -
       				"Content-Type": "application/json",

     

       104
       104
       +
       		return new Response(

     

       105
       105
       +
       			JSON.stringify({

     

       106
       106
       +
       				approvedTakes,

     

       107
       107
       +
       				waitingTakes,

     

       108
       108
       +
       				rejectedTakes,

     

       109
       109
       +
       				takes,

     

       110
       110
       +
       			}),

     

       111
       111
       +
       			{

     

       112
       112
       +
       				headers: {

     

       113
       113
       +
       					"Content-Type": "application/json",

     

       114
       114
       +
       				},

     

       108
       115
        
       			},

     

       109
       109
       -
       		},

     

       110
       110
       -
       	);

     

       116
       116
       +
       		);

     

       117
       117
       +
       	} catch (error) {

     

       118
       118
       +
       		return handleApiError(error, "takesPerUser");

     

       119
       119
       +
       	}

     

       111
       120
        
       }

+36 -25

src/features/api/routes/video.ts

···

       1
       1
       +
       import { handleApiError } from "../../../libs/apiError";

     

       1
       2
        
       import { db } from "../../../libs/db";

     

       2
       3
        
       import { takes as takesTable } from "../../../libs/schema";

     

       3
       4
        
       import { eq, and } from "drizzle-orm";

     

       4
       5
        
       

     

       5
       6
        
       export default async function getVideo(url: URL): Promise<Response> {

     

       6
       6
       -
       	const videoId = url.pathname.split("/")[2];

     

       7
       7
       -
       	const thumbnail = url.pathname.split("/")[3] === "thumbnail";

     

       7
       7
       +
       	try {

     

       8
       8
       +
       		const videoId = url.pathname.split("/")[2];

     

       9
       9
       +
       		const thumbnail = url.pathname.split("/")[3] === "thumbnail";

     

       8
       10
        
       

     

       9
       9
       -
       	if (!videoId) {

     

       10
       10
       -
       		return new Response("Invalid video id", { status: 400 });

     

       11
       11
       -
       	}

     

       11
       11
       +
       		if (!videoId) {

     

       12
       12
       +
       			return new Response(JSON.stringify({ error: "Invalid video id" }), {

     

       13
       13
       +
       				status: 400,

     

       14
       14
       +
       				headers: { "Content-Type": "application/json" },

     

       15
       15
       +
       			});

     

       16
       16
       +
       		}

     

       12
       17
        
       

     

       13
       13
       -
       	const video = await db

     

       14
       14
       -
       		.select()

     

       15
       15
       -
       		.from(takesTable)

     

       16
       16
       -
       		.where(eq(takesTable.id, videoId));

     

       18
       18
       +
       		const video = await db

     

       19
       19
       +
       			.select()

     

       20
       20
       +
       			.from(takesTable)

     

       21
       21
       +
       			.where(eq(takesTable.id, videoId));

     

       17
       22
        
       

     

       18
       18
       -
       	if (video.length === 0) {

     

       19
       19
       -
       		return new Response("Video not found", { status: 404 });

     

       20
       20
       -
       	}

     

       23
       23
       +
       		if (video.length === 0) {

     

       24
       24
       +
       			return new Response(JSON.stringify({ error: "Video not found" }), {

     

       25
       25
       +
       				status: 404,

     

       26
       26
       +
       				headers: { "Content-Type": "application/json" },

     

       27
       27
       +
       			});

     

       28
       28
       +
       		}

     

       21
       29
        
       

     

       22
       22
       -
       	const videoData = video[0];

     

       30
       30
       +
       		const videoData = video[0];

     

       23
       31
        
       

     

       24
       24
       -
       	if (thumbnail) {

     

       25
       25
       -
       		return Response.redirect(

     

       26
       26
       -
       			`https://cachet.dunkirk.sh/users/${videoData?.userId}/r`,

     

       27
       27
       -
       		);

     

       28
       28
       -
       	}

     

       32
       32
       +
       		if (thumbnail) {

     

       33
       33
       +
       			return Response.redirect(

     

       34
       34
       +
       				`https://cachet.dunkirk.sh/users/${videoData?.userId}/r`,

     

       35
       35
       +
       			);

     

       36
       36
       +
       		}

     

       29
       37
        
       

     

       30
       30
       -
       	return new Response(

     

       31
       31
       -
       		`<!DOCTYPE html>

     

       38
       38
       +
       		return new Response(

     

       39
       39
       +
       			`<!DOCTYPE html>

     

       32
       40
        
               <html>

     

       33
       41
        
               <head>

     

       34
       42
        
               <title>Video Player</title>

     
···

       68
       76
        
               </div>

     

       69
       77
        
               </body>

     

       70
       78
        
               </html>`,

     

       71
       71
       -
       		{

     

       72
       72
       -
       			headers: {

     

       73
       73
       -
       				"Content-Type": "text/html",

     

       79
       79
       +
       			{

     

       80
       80
       +
       				headers: {

     

       81
       81
       +
       					"Content-Type": "text/html",

     

       82
       82
       +
       				},

     

       74
       83
        
       			},

     

       75
       75
       -
       		},

     

       76
       76
       -
       	);

     

       84
       84
       +
       		);

     

       85
       85
       +
       	} catch (error) {

     

       86
       86
       +
       		return handleApiError(error, "getVideo");

     

       87
       87
       +
       	}

     

       77
       88
        
       }

-2

src/features/takes/services/notifications.ts

···

       133
       133
        
       				.set({ notifiedLowTime: true })

     

       134
       134
        
       				.where(eq(takesTable.id, take.id));

     

       135
       135
        
       

     

       136
       136
       -
       			console.log("Sending low time warning to user");

     

       137
       137
       -
       

     

       138
       136
        
       			try {

     

       139
       137
        
       				await slackApp.client.chat.postMessage({

     

       140
       138
        
       					channel: take.userId,

+110 -74

src/features/takes/setup/actions.ts

···

       1
       1
        
       import { slackApp } from "../../../index";

     

       2
       2
        
       import { db } from "../../../libs/db";

     

       3
       3
       +
       import { blog } from "../../../libs/Logger";

     

       3
       4
        
       import { takes as takesTable } from "../../../libs/schema";

     

       4
       5
        
       import handleHelp from "../handlers/help";

     

       5
       6
        
       import { handleHistory } from "../handlers/history";

     
···

       12
       13
        
       import upload from "../services/upload";

     

       13
       14
        
       import type { MessageResponse } from "../types";

     

       14
       15
        
       import { getDescriptionBlocks, getEditDescriptionBlocks } from "../ui/blocks";

     

       16
       16
       +
       import * as Sentry from "@sentry/bun";

     

       15
       17
        
       

     

       16
       18
        
       export default function setupActions() {

     

       17
       19
        
       	// Handle button actions

     

       18
       20
        
       	slackApp.action(/^takes_(\w+)$/, async ({ payload, context }) => {

     

       19
       19
       -
       		const userId = payload.user.id;

     

       20
       20
       -
       		const channelId = context.channelId || "";

     

       21
       21
       -
       		const actionId = payload.actions[0]?.action_id as string;

     

       22
       22
       -
       		const command = actionId.replace("takes_", "");

     

       23
       23
       -
       		const descriptionInput = payload.state.values.note_block?.note_input;

     

       21
       21
       +
       		try {

     

       22
       22
       +
       			const userId = payload.user.id;

     

       23
       23
       +
       			const channelId = context.channelId || "";

     

       24
       24
       +
       			const actionId = payload.actions[0]?.action_id as string;

     

       25
       25
       +
       			const command = actionId.replace("takes_", "");

     

       26
       26
       +
       			const descriptionInput =

     

       27
       27
       +
       				payload.state.values.note_block?.note_input;

     

       24
       28
        
       

     

       25
       25
       -
       		let response: MessageResponse | undefined;

     

       29
       29
       +
       			let response: MessageResponse | undefined;

     

       26
       30
        
       

     

       27
       27
       -
       		const activeTake = await getActiveTake(userId);

     

       31
       31
       +
       			const activeTake = await getActiveTake(userId);

     

       28
       32
        
       

     

       29
       29
       -
       		// Route to the appropriate handler function

     

       30
       30
       -
       		switch (command) {

     

       31
       31
       -
       			case "start": {

     

       32
       32
       -
       				if (activeTake.length > 0) {

     

       33
       33
       -
       					if (context.respond) {

     

       34
       34
       -
       						response = await handleStatus(userId);

     

       33
       33
       +
       			// Route to the appropriate handler function

     

       34
       34
       +
       			switch (command) {

     

       35
       35
       +
       				case "start": {

     

       36
       36
       +
       					if (activeTake.length > 0) {

     

       37
       37
       +
       						if (context.respond) {

     

       38
       38
       +
       							response = await handleStatus(userId);

     

       39
       39
       +
       						}

     

       40
       40
       +
       					} else {

     

       41
       41
       +
       						if (!descriptionInput?.value?.trim()) {

     

       42
       42
       +
       							response = getDescriptionBlocks(

     

       43
       43
       +
       								"Please enter a note for your session.",

     

       44
       44
       +
       							);

     

       45
       45
       +
       						} else {

     

       46
       46
       +
       							response = await handleStart(

     

       47
       47
       +
       								userId,

     

       48
       48
       +
       								channelId,

     

       49
       49
       +
       								descriptionInput?.value?.trim(),

     

       50
       50
       +
       							);

     

       51
       51
       +
       						}

     

       35
       52
        
       					}

     

       36
       36
       -
       				} else {

     

       37
       37
       -
       					if (!descriptionInput?.value?.trim()) {

     

       38
       38
       -
       						response = getDescriptionBlocks(

     

       39
       39
       -
       							"Please enter a note for your session.",

     

       53
       53
       +
       					break;

     

       54
       54
       +
       				}

     

       55
       55
       +
       				case "pause":

     

       56
       56
       +
       					response = await handlePause(userId);

     

       57
       57
       +
       					break;

     

       58
       58
       +
       				case "resume":

     

       59
       59
       +
       					response = await handleResume(userId);

     

       60
       60
       +
       					break;

     

       61
       61
       +
       				case "stop":

     

       62
       62
       +
       					response = await handleStop(userId);

     

       63
       63
       +
       					break;

     

       64
       64
       +
       				case "edit": {

     

       65
       65
       +
       					if (!activeTake.length && context.respond) {

     

       66
       66
       +
       						await context.respond({

     

       67
       67
       +
       							text: "You don't have an active takes session to edit!",

     

       68
       68
       +
       							response_type: "ephemeral",

     

       69
       69
       +
       						});

     

       70
       70
       +
       						return;

     

       71
       71
       +
       					}

     

       72
       72
       +
       

     

       73
       73
       +
       					if (!descriptionInput) {

     

       74
       74
       +
       						response = getEditDescriptionBlocks(

     

       75
       75
       +
       							activeTake[0]?.description || "",

     

       40
       76
        
       						);

     

       77
       77
       +
       					} else if (descriptionInput.value?.trim()) {

     

       78
       78
       +
       						const takeToUpdate = activeTake[0];

     

       79
       79
       +
       						if (!takeToUpdate) return;

     

       80
       80
       +
       

     

       81
       81
       +
       						// Update the note for the active session

     

       82
       82
       +
       						await db.update(takesTable).set({

     

       83
       83
       +
       							description: descriptionInput.value.trim(),

     

       84
       84
       +
       						});

     

       85
       85
       +
       

     

       86
       86
       +
       						response = await handleStatus(userId);

     

       41
       87
        
       					} else {

     

       42
       42
       -
       						response = await handleStart(

     

       43
       43
       -
       							userId,

     

       44
       44
       -
       							channelId,

     

       45
       45
       -
       							descriptionInput?.value?.trim(),

     

       88
       88
       +
       						response = getEditDescriptionBlocks(

     

       89
       89
       +
       							"",

     

       90
       90
       +
       							"Please enter a note for your session.",

     

       46
       91
        
       						);

     

       47
       92
        
       					}

     

       48
       48
       -
       				}

     

       49
       49
       -
       				break;

     

       50
       50
       -
       			}

     

       51
       51
       -
       			case "pause":

     

       52
       52
       -
       				response = await handlePause(userId);

     

       53
       53
       -
       				break;

     

       54
       54
       -
       			case "resume":

     

       55
       55
       -
       				response = await handleResume(userId);

     

       56
       56
       -
       				break;

     

       57
       57
       -
       			case "stop":

     

       58
       58
       -
       				response = await handleStop(userId);

     

       59
       59
       -
       				break;

     

       60
       60
       -
       			case "edit": {

     

       61
       61
       -
       				if (!activeTake.length && context.respond) {

     

       62
       62
       -
       					await context.respond({

     

       63
       63
       -
       						text: "You don't have an active takes session to edit!",

     

       64
       64
       -
       						response_type: "ephemeral",

     

       65
       65
       -
       					});

     

       66
       66
       -
       					return;

     

       93
       93
       +
       					break;

     

       67
       94
        
       				}

     

       68
       95
        
       

     

       69
       69
       -
       				if (!descriptionInput) {

     

       70
       70
       -
       					response = getEditDescriptionBlocks(

     

       71
       71
       -
       						activeTake[0]?.description || "",

     

       72
       72
       -
       					);

     

       73
       73
       -
       				} else if (descriptionInput.value?.trim()) {

     

       74
       74
       -
       					const takeToUpdate = activeTake[0];

     

       75
       75
       -
       					if (!takeToUpdate) return;

     

       76
       76
       -
       

     

       77
       77
       -
       					// Update the note for the active session

     

       78
       78
       -
       					await db.update(takesTable).set({

     

       79
       79
       -
       						description: descriptionInput.value.trim(),

     

       80
       80
       -
       					});

     

       81
       81
       -
       

     

       96
       96
       +
       				case "status":

     

       82
       97
        
       					response = await handleStatus(userId);

     

       83
       83
       -
       				} else {

     

       84
       84
       -
       					response = getEditDescriptionBlocks(

     

       85
       85
       -
       						"",

     

       86
       86
       -
       						"Please enter a note for your session.",

     

       87
       87
       -
       					);

     

       88
       88
       -
       				}

     

       89
       89
       -
       				break;

     

       98
       98
       +
       					break;

     

       99
       99
       +
       				case "history":

     

       100
       100
       +
       					response = await handleHistory(userId);

     

       101
       101
       +
       					break;

     

       102
       102
       +
       				default:

     

       103
       103
       +
       					response = await handleHelp();

     

       104
       104
       +
       					break;

     

       90
       105
        
       			}

     

       91
       106
        
       

     

       92
       92
       -
       			case "status":

     

       93
       93
       -
       				response = await handleStatus(userId);

     

       94
       94
       -
       				break;

     

       95
       95
       -
       			case "history":

     

       96
       96
       -
       				response = await handleHistory(userId);

     

       97
       97
       -
       				break;

     

       98
       98
       -
       			default:

     

       99
       99
       -
       				response = await handleHelp();

     

       100
       100
       -
       				break;

     

       101
       101
       -
       		}

     

       107
       107
       +
       			// Send the response

     

       108
       108
       +
       			if (response && context.respond) {

     

       109
       109
       +
       				await context.respond(response);

     

       110
       110
       +
       			}

     

       111
       111
       +
       		} catch (error) {

     

       112
       112
       +
       			if (error instanceof Error)

     

       113
       113
       +
       				blog(

     

       114
       114
       +
       					`Error in \`${payload.actions[0]?.action_id}\` action: ${error.message}`,

     

       115
       115
       +
       					"error",

     

       116
       116
       +
       				);

     

       102
       117
        
       

     

       103
       103
       -
       		// Send the response

     

       104
       104
       -
       		if (response && context.respond) {

     

       105
       105
       -
       			await context.respond(response);

     

       118
       118
       +
       			// Capture the error in Sentry

     

       119
       119
       +
       			Sentry.captureException(error, {

     

       120
       120
       +
       				extra: {

     

       121
       121
       +
       					actionId: payload.actions[0]?.action_id,

     

       122
       122
       +
       					userId: payload.user.id,

     

       123
       123
       +
       					channelId: context.channelId,

     

       124
       124
       +
       				},

     

       125
       125
       +
       			});

     

       126
       126
       +
       

     

       127
       127
       +
       			// Respond with error message to user

     

       128
       128
       +
       			if (context.respond) {

     

       129
       129
       +
       				await context.respond({

     

       130
       130
       +
       					text: "An error occurred while processing your request. Please stand by while we try to put out the fire.",

     

       131
       131
       +
       					response_type: "ephemeral",

     

       132
       132
       +
       				});

     

       133
       133
       +
       			}

     

       106
       134
        
       		}

     

       107
       135
        
       	});

     

       108
       136
        
       

     

       109
       137
        
       	// setup the upload actions

     

       110
       110
       -
       	upload();

     

       138
       138
       +
       	try {

     

       139
       139
       +
       		upload();

     

       140
       140
       +
       	} catch (error) {

     

       141
       141
       +
       		Sentry.captureException(error, {

     

       142
       142
       +
       			extra: {

     

       143
       143
       +
       				context: "upload setup",

     

       144
       144
       +
       			},

     

       145
       145
       +
       		});

     

       146
       146
       +
       	}

     

       111
       147
        
       }

+104 -76

src/features/takes/setup/commands.ts

···

       13
       13
        
       } from "../services/notifications";

     

       14
       14
        
       import type { MessageResponse } from "../types";

     

       15
       15
        
       import { getDescriptionBlocks, getEditDescriptionBlocks } from "../ui/blocks";

     

       16
       16
       +
       import * as Sentry from "@sentry/bun";

     

       17
       17
       +
       import { blog } from "../../../libs/Logger";

     

       16
       18
        
       

     

       17
       19
        
       export default function setupCommands() {

     

       18
       20
        
       	// Main command handler

     

       19
       21
        
       	slackApp.command(

     

       20
       22
        
       		environment === "dev" ? "/takes-dev" : "/takes",

     

       21
       23
        
       		async ({ payload, context }): Promise<void> => {

     

       22
       22
       -
       			const userId = payload.user_id;

     

       23
       23
       -
       			const channelId = payload.channel_id;

     

       24
       24
       -
       			const text = payload.text || "";

     

       25
       25
       -
       			const args = text.trim().split(/\s+/);

     

       26
       26
       -
       			let subcommand = args[0]?.toLowerCase() || "";

     

       24
       24
       +
       			try {

     

       25
       25
       +
       				const userId = payload.user_id;

     

       26
       26
       +
       				const channelId = payload.channel_id;

     

       27
       27
       +
       				const text = payload.text || "";

     

       28
       28
       +
       				const args = text.trim().split(/\s+/);

     

       29
       29
       +
       				let subcommand = args[0]?.toLowerCase() || "";

     

       27
       30
        
       

     

       28
       28
       -
       			// Check for active takes session

     

       29
       29
       -
       			const activeTake = await getActiveTake(userId);

     

       31
       31
       +
       				// Check for active takes session

     

       32
       32
       +
       				const activeTake = await getActiveTake(userId);

     

       30
       33
        
       

     

       31
       31
       -
       			// Check for paused session if no active one

     

       32
       32
       -
       			const pausedTakeCheck =

     

       33
       33
       -
       				activeTake.length === 0 ? await getPausedTake(userId) : [];

     

       34
       34
       +
       				// Check for paused session if no active one

     

       35
       35
       +
       				const pausedTakeCheck =

     

       36
       36
       +
       					activeTake.length === 0 ? await getPausedTake(userId) : [];

     

       34
       37
        
       

     

       35
       35
       -
       			// Run checks for expired or about-to-expire sessions

     

       36
       36
       -
       			await expirePausedSessions();

     

       37
       37
       -
       			await checkActiveSessions();

     

       38
       38
       +
       				// Run checks for expired or about-to-expire sessions

     

       39
       39
       +
       				await expirePausedSessions();

     

       40
       40
       +
       				await checkActiveSessions();

     

       38
       41
        
       

     

       39
       39
       -
       			// Default to status if we have an active or paused session and no command specified

     

       40
       40
       -
       			if (

     

       41
       41
       -
       				subcommand === "" &&

     

       42
       42
       -
       				(activeTake.length > 0 || pausedTakeCheck.length > 0)

     

       43
       43
       -
       			) {

     

       44
       44
       -
       				subcommand = "status";

     

       45
       45
       -
       			} else if (subcommand === "") {

     

       46
       46
       -
       				subcommand = "help";

     

       47
       47
       -
       			}

     

       42
       42
       +
       				// Default to status if we have an active or paused session and no command specified

     

       43
       43
       +
       				if (

     

       44
       44
       +
       					subcommand === "" &&

     

       45
       45
       +
       					(activeTake.length > 0 || pausedTakeCheck.length > 0)

     

       46
       46
       +
       				) {

     

       47
       47
       +
       					subcommand = "status";

     

       48
       48
       +
       				} else if (subcommand === "") {

     

       49
       49
       +
       					subcommand = "help";

     

       50
       50
       +
       				}

     

       48
       51
        
       

     

       49
       49
       -
       			let response: MessageResponse | undefined;

     

       52
       52
       +
       				let response: MessageResponse | undefined;

     

       50
       53
        
       

     

       51
       51
       -
       			// Special handling for start command to show modal

     

       52
       52
       -
       			if (subcommand === "start" && !activeTake.length) {

     

       53
       53
       -
       				response = getDescriptionBlocks();

     

       54
       54
       -
       			}

     

       54
       54
       +
       				// Special handling for start command to show modal

     

       55
       55
       +
       				if (subcommand === "start" && !activeTake.length) {

     

       56
       56
       +
       					response = getDescriptionBlocks();

     

       57
       57
       +
       				}

     

       58
       58
       +
       

     

       59
       59
       +
       				// Route to the appropriate handler function

     

       60
       60
       +
       				switch (subcommand) {

     

       61
       61
       +
       					case "start": {

     

       62
       62
       +
       						if (args.length < 2) {

     

       63
       63
       +
       							response = getDescriptionBlocks();

     

       64
       64
       +
       							break;

     

       65
       65
       +
       						}

     

       55
       66
        
       

     

       56
       56
       -
       			// Route to the appropriate handler function

     

       57
       57
       -
       			switch (subcommand) {

     

       58
       58
       -
       				case "start": {

     

       59
       59
       -
       					if (args.length < 2) {

     

       60
       60
       -
       						response = getDescriptionBlocks();

     

       61
       61
       -
       						break;

     

       62
       62
       -
       					}

     

       67
       67
       +
       						const descriptionInput = args.slice(1).join(" ");

     

       63
       68
        
       

     

       64
       64
       -
       					const descriptionInput = args.slice(1).join(" ");

     

       69
       69
       +
       						if (!descriptionInput.trim()) {

     

       70
       70
       +
       							response = getDescriptionBlocks(

     

       71
       71
       +
       								"Please enter a note for your session.",

     

       72
       72
       +
       							);

     

       73
       73
       +
       							break;

     

       74
       74
       +
       						}

     

       65
       75
        
       

     

       66
       66
       -
       					if (!descriptionInput.trim()) {

     

       67
       67
       -
       						response = getDescriptionBlocks(

     

       68
       68
       -
       							"Please enter a note for your session.",

     

       76
       76
       +
       						response = await handleStart(

     

       77
       77
       +
       							userId,

     

       78
       78
       +
       							channelId,

     

       79
       79
       +
       							descriptionInput,

     

       69
       80
        
       						);

     

       70
       81
        
       						break;

     

       71
       82
        
       					}

     

       83
       83
       +
       					case "pause":

     

       84
       84
       +
       						response = await handlePause(userId);

     

       85
       85
       +
       						break;

     

       86
       86
       +
       					case "resume":

     

       87
       87
       +
       						response = await handleResume(userId);

     

       88
       88
       +
       						break;

     

       89
       89
       +
       					case "stop":

     

       90
       90
       +
       						response = await handleStop(userId, args);

     

       91
       91
       +
       						break;

     

       92
       92
       +
       					case "edit":

     

       93
       93
       +
       						response = getEditDescriptionBlocks(

     

       94
       94
       +
       							activeTake[0]?.description || "",

     

       95
       95
       +
       						);

     

       96
       96
       +
       						break;

     

       97
       97
       +
       					case "status":

     

       98
       98
       +
       						response = await handleStatus(userId);

     

       99
       99
       +
       						break;

     

       100
       100
       +
       					case "history":

     

       101
       101
       +
       						response = await handleHistory(userId);

     

       102
       102
       +
       						break;

     

       103
       103
       +
       					case "help":

     

       104
       104
       +
       						response = await handleHelp();

     

       105
       105
       +
       						break;

     

       106
       106
       +
       					default:

     

       107
       107
       +
       						response = await handleHelp();

     

       108
       108
       +
       						break;

     

       109
       109
       +
       				}

     

       72
       110
        
       

     

       73
       73
       -
       					response = await handleStart(

     

       74
       74
       -
       						userId,

     

       75
       75
       -
       						channelId,

     

       76
       76
       -
       						descriptionInput,

     

       77
       77
       -
       					);

     

       78
       78
       -
       					break;

     

       111
       111
       +
       				if (!response) {

     

       112
       112
       +
       					throw new Error("No response received from handler");

     

       79
       113
        
       				}

     

       80
       80
       -
       				case "pause":

     

       81
       81
       -
       					response = await handlePause(userId);

     

       82
       82
       -
       					break;

     

       83
       83
       -
       				case "resume":

     

       84
       84
       -
       					response = await handleResume(userId);

     

       85
       85
       -
       					break;

     

       86
       86
       -
       				case "stop":

     

       87
       87
       -
       					response = await handleStop(userId, args);

     

       88
       88
       -
       					break;

     

       89
       89
       -
       				case "edit":

     

       90
       90
       -
       					response = getEditDescriptionBlocks(

     

       91
       91
       -
       						activeTake[0]?.description || "",

     

       114
       114
       +
       

     

       115
       115
       +
       				if (context.respond) {

     

       116
       116
       +
       					await context.respond(response);

     

       117
       117
       +
       				}

     

       118
       118
       +
       			} catch (error) {

     

       119
       119
       +
       				if (error instanceof Error)

     

       120
       120
       +
       					blog(

     

       121
       121
       +
       						`Error in \`${payload.command}\` command: ${error.message}`,

     

       122
       122
       +
       						"error",

     

       92
       123
        
       					);

     

       93
       93
       -
       					break;

     

       94
       94
       -
       				case "status":

     

       95
       95
       -
       					response = await handleStatus(userId);

     

       96
       96
       -
       					break;

     

       97
       97
       -
       				case "history":

     

       98
       98
       -
       					response = await handleHistory(userId);

     

       99
       99
       -
       					break;

     

       100
       100
       -
       				case "help":

     

       101
       101
       -
       					response = await handleHelp();

     

       102
       102
       -
       					break;

     

       103
       103
       -
       				default:

     

       104
       104
       -
       					response = await handleHelp();

     

       105
       105
       -
       					break;

     

       106
       106
       -
       			}

     

       124
       124
       +
       

     

       125
       125
       +
       				// Capture the error in Sentry

     

       126
       126
       +
       				Sentry.captureException(error, {

     

       127
       127
       +
       					extra: {

     

       128
       128
       +
       						command: payload.command,

     

       129
       129
       +
       						userId: payload.user_id,

     

       130
       130
       +
       						channelId: payload.channel_id,

     

       131
       131
       +
       						text: payload.text,

     

       132
       132
       +
       					},

     

       133
       133
       +
       				});

     

       107
       134
        
       

     

       108
       108
       -
       			if (context.respond)

     

       109
       109
       -
       				await context.respond(

     

       110
       110
       -
       					response || {

     

       111
       111
       -
       						text: "An error occurred while processing your request.",

     

       135
       135
       +
       				// Respond with error message to user

     

       136
       136
       +
       				if (context.respond) {

     

       137
       137
       +
       					await context.respond({

     

       138
       138
       +
       						text: "An error occurred while processing your request. Please be patent while we try to put out the fire.",

     

       112
       139
        
       						response_type: "ephemeral",

     

       113
       113
       -
       					},

     

       114
       114
       -
       				);

     

       140
       140
       +
       					});

     

       141
       141
       +
       				}

     

       142
       142
       +
       			}

     

       115
       143
        
       		},

     

       116
       144
        
       	);

     

       117
       145
        
       }

+39 -5

src/features/takes/setup/notifications.ts

···

       1
       1
       +
       import * as Sentry from "@sentry/bun";

     

       1
       2
        
       import TakesConfig from "../../../libs/config";

     

       3
       3
       +
       import { blog } from "../../../libs/Logger";

     

       2
       4
        
       import {

     

       3
       5
        
       	checkActiveSessions,

     

       4
       6
        
       	expirePausedSessions,

     

       5
       7
        
       } from "../services/notifications";

     

       6
       8
        
       

     

       7
       9
        
       export default function setupNotifications() {

     

       8
       8
       -
       	const notificationInterval = TakesConfig.NOTIFICATIONS.CHECK_INTERVAL;

     

       9
       9
       -
       	setInterval(async () => {

     

       10
       10
       -
       		await checkActiveSessions();

     

       11
       11
       -
       		await expirePausedSessions();

     

       12
       12
       -
       	}, notificationInterval);

     

       10
       10
       +
       	try {

     

       11
       11
       +
       		const notificationInterval = TakesConfig.NOTIFICATIONS.CHECK_INTERVAL;

     

       12
       12
       +
       

     

       13
       13
       +
       		setInterval(async () => {

     

       14
       14
       +
       			try {

     

       15
       15
       +
       				await checkActiveSessions();

     

       16
       16
       +
       				await expirePausedSessions();

     

       17
       17
       +
       			} catch (error) {

     

       18
       18
       +
       				if (error instanceof Error)

     

       19
       19
       +
       					blog(

     

       20
       20
       +
       						`Error in notifications check: ${error.message}`,

     

       21
       21
       +
       						"error",

     

       22
       22
       +
       					);

     

       23
       23
       +
       				Sentry.captureException(error, {

     

       24
       24
       +
       					extra: {

     

       25
       25
       +
       						context: "notifications check",

     

       26
       26
       +
       						checkInterval: notificationInterval,

     

       27
       27
       +
       					},

     

       28
       28
       +
       					tags: {

     

       29
       29
       +
       						type: "notification_check",

     

       30
       30
       +
       					},

     

       31
       31
       +
       				});

     

       32
       32
       +
       			}

     

       33
       33
       +
       		}, notificationInterval);

     

       34
       34
       +
       	} catch (error) {

     

       35
       35
       +
       		if (error instanceof Error)

     

       36
       36
       +
       			blog(`Error setting up notifications: ${error.message}`, "error");

     

       37
       37
       +
       		Sentry.captureException(error, {

     

       38
       38
       +
       			extra: {

     

       39
       39
       +
       				context: "notifications setup",

     

       40
       40
       +
       			},

     

       41
       41
       +
       			tags: {

     

       42
       42
       +
       				type: "notification_setup",

     

       43
       43
       +
       			},

     

       44
       44
       +
       		});

     

       45
       45
       +
       		throw error; // Re-throw to prevent the app from starting with broken notifications

     

       46
       46
       +
       	}

     

       13
       47
        
       }

src/index.ts

···

       15
       15
        
       	"SLACK_BOT_TOKEN",

     

       16
       16
        
       	"SLACK_SIGNING_SECRET",

     

       17
       17
        
       	"SLACK_REVIEW_CHANNEL",

     

       18
       18
       +
       	"SLACK_LOG_CHANNEL",

     

       19
       19
       +
       	"SLACK_SPAM_CHANNEL",

     

       18
       20
        
       	"SLACK_USER_TOKEN",

     

       19
       21
        
       	"API_URL",

     

       20
       22
        
       	"SENTRY_DSN",

+89 -41

src/libs/Logger.ts

···

       1
       1
        
       import { slackClient } from "../index";

     

       2
       2
       -
       

     

       3
       2
        
       import Bottleneck from "bottleneck";

     

       4
       3
        
       import Queue from "./queue";

     

       5
       5
       -
       

     

       6
       4
        
       import colors from "colors";

     

       5
       5
       +
       import * as Sentry from "@sentry/bun";

     

       7
       6
        
       import type {

     

       8
       7
        
       	ChatPostMessageRequest,

     

       9
       8
        
       	ChatPostMessageResponse,

     
···

       16
       15
        
       

     

       17
       16
        
       const messageQueue = new Queue();

     

       18
       17
        
       

     

       19
       19
       -
       function sendMessage(

     

       18
       18
       +
       async function sendMessage(

     

       20
       19
        
       	message: ChatPostMessageRequest,

     

       21
       20
        
       ): Promise<ChatPostMessageResponse> {

     

       22
       22
       -
       	return limiter.schedule(() => slackClient.chat.postMessage(message));

     

       21
       21
       +
       	try {

     

       22
       22
       +
       		return await limiter.schedule(() =>

     

       23
       23
       +
       			slackClient.chat.postMessage(message),

     

       24
       24
       +
       		);

     

       25
       25
       +
       	} catch (error) {

     

       26
       26
       +
       		Sentry.captureException(error, {

     

       27
       27
       +
       			extra: { channel: message.channel, text: message.text },

     

       28
       28
       +
       			tags: { type: "slack_message_error" },

     

       29
       29
       +
       		});

     

       30
       30
       +
       		console.error("Failed to send Slack message:", error);

     

       31
       31
       +
       		throw error;

     

       32
       32
       +
       	}

     

       23
       33
        
       }

     

       24
       34
        
       

     

       25
       35
        
       async function slog(

     
···

       29
       39
        
       		channel: string;

     

       30
       40
        
       	},

     

       31
       41
        
       ): Promise<void> {

     

       32
       32
       -
       	const message: ChatPostMessageRequest = {

     

       33
       33
       -
       		channel: location?.channel || process.env.SLACK_LOG_CHANNEL || "",

     

       34
       34
       -
       		thread_ts: location?.thread_ts,

     

       35
       35
       -
       		text: logMessage.substring(0, 2500),

     

       36
       36
       -
       		blocks: [

     

       37
       37
       -
       			{

     

       38
       38
       -
       				type: "section",

     

       39
       39
       -
       				text: {

     

       40
       40
       -
       					type: "mrkdwn",

     

       41
       41
       -
       					text: logMessage

     

       42
       42
       -
       						.split("\n")

     

       43
       43
       -
       						.map((a) => `> ${a}`)

     

       44
       44
       -
       						.join("\n"),

     

       45
       45
       -
       				},

     

       46
       46
       -
       			},

     

       47
       47
       -
       			{

     

       48
       48
       -
       				type: "context",

     

       49
       49
       -
       				elements: [

     

       50
       50
       -
       					{

     

       42
       42
       +
       	try {

     

       43
       43
       +
       		const channel = location?.channel || process.env.SLACK_LOG_CHANNEL;

     

       44
       44
       +
       

     

       45
       45
       +
       		if (!channel) {

     

       46
       46
       +
       			throw new Error("No Slack channel specified for logging");

     

       47
       47
       +
       		}

     

       48
       48
       +
       

     

       49
       49
       +
       		const message: ChatPostMessageRequest = {

     

       50
       50
       +
       			channel,

     

       51
       51
       +
       			thread_ts: location?.thread_ts,

     

       52
       52
       +
       			text: logMessage.substring(0, 2500),

     

       53
       53
       +
       			blocks: [

     

       54
       54
       +
       				{

     

       55
       55
       +
       					type: "section",

     

       56
       56
       +
       					text: {

     

       51
       57
        
       						type: "mrkdwn",

     

       52
       52
       -
       						text: `${new Date().toString()}`,

     

       58
       58
       +
       						text: logMessage

     

       59
       59
       +
       							.split("\n")

     

       60
       60
       +
       							.map((a) => `> ${a}`)

     

       61
       61
       +
       							.join("\n"),

     

       53
       62
        
       					},

     

       54
       54
       -
       				],

     

       55
       55
       -
       			},

     

       56
       56
       -
       		],

     

       57
       57
       -
       	};

     

       63
       63
       +
       				},

     

       64
       64
       +
       				{

     

       65
       65
       +
       					type: "context",

     

       66
       66
       +
       					elements: [

     

       67
       67
       +
       						{

     

       68
       68
       +
       							type: "mrkdwn",

     

       69
       69
       +
       							text: `${new Date().toString()}`,

     

       70
       70
       +
       						},

     

       71
       71
       +
       					],

     

       72
       72
       +
       				},

     

       73
       73
       +
       			],

     

       74
       74
       +
       		};

     

       58
       75
        
       

     

       59
       59
       -
       	messageQueue.enqueue(() => sendMessage(message));

     

       76
       76
       +
       		messageQueue.enqueue(() => sendMessage(message));

     

       77
       77
       +
       	} catch (error) {

     

       78
       78
       +
       		Sentry.captureException(error, {

     

       79
       79
       +
       			extra: { logMessage, location, channel: location?.channel },

     

       80
       80
       +
       			tags: { type: "slog_error" },

     

       81
       81
       +
       		});

     

       82
       82
       +
       		console.error("Failed to queue Slack log message:", error);

     

       83
       83
       +
       	}

     

       60
       84
        
       }

     

       61
       85
        
       

     

       62
       86
        
       type LogType = "info" | "start" | "cron" | "error";

     

       63
       87
        
       

     

       64
       64
       -
       export async function clog(logMessage: string, type: LogType): Promise<void> {

     

       88
       88
       +
       type LogMetadata = {

     

       89
       89
       +
       	error?: Error;

     

       90
       90
       +
       	context?: string;

     

       91
       91
       +
       	additional?: Record<string, unknown>;

     

       92
       92
       +
       };

     

       93
       93
       +
       

     

       94
       94
       +
       export async function clog(

     

       95
       95
       +
       	logMessage: string,

     

       96
       96
       +
       	type: LogType,

     

       97
       97
       +
       	metadata?: LogMetadata,

     

       98
       98
       +
       ): Promise<void> {

     

       99
       99
       +
       	const timestamp = new Date().toISOString();

     

       100
       100
       +
       	const formattedMessage = `[${timestamp}] ${logMessage}`;

     

       101
       101
       +
       

     

       65
       102
        
       	switch (type) {

     

       66
       103
        
       		case "info":

     

       67
       67
       -
       			console.log(colors.blue(logMessage));

     

       104
       104
       +
       			console.log(colors.blue(formattedMessage));

     

       68
       105
        
       			break;

     

       69
       106
        
       		case "start":

     

       70
       70
       -
       			console.log(colors.green(logMessage));

     

       107
       107
       +
       			console.log(colors.green(formattedMessage));

     

       71
       108
        
       			break;

     

       72
       109
        
       		case "cron":

     

       73
       73
       -
       			console.log(colors.magenta(`[CRON]: ${logMessage}`));

     

       110
       110
       +
       			console.log(colors.magenta(`[CRON]: ${formattedMessage}`));

     

       74
       111
        
       			break;

     

       75
       75
       -
       		case "error":

     

       76
       76
       -
       			console.error(

     

       77
       77
       -
       				colors.red.bold(

     

       78
       78
       -
       					`Yo <@S0790GPRA48> deres an error \n\n [ERROR]: ${logMessage}`,

     

       79
       79
       -
       				),

     

       112
       112
       +
       		case "error": {

     

       113
       113
       +
       			const errorMessage = colors.red.bold(

     

       114
       114
       +
       				`Yo <@S0790GPRA48> deres an error \n\n [ERROR]: ${formattedMessage}`,

     

       80
       115
        
       			);

     

       116
       116
       +
       			console.error(errorMessage);

     

       81
       117
        
       			break;

     

       118
       118
       +
       		}

     

       82
       119
        
       		default:

     

       83
       83
       -
       			console.log(logMessage);

     

       120
       120
       +
       			console.log(formattedMessage);

     

       84
       121
        
       	}

     

       85
       122
        
       }

     

       86
       123
        
       

     
···

       91
       128
        
       		thread_ts?: string;

     

       92
       129
        
       		channel: string;

     

       93
       130
        
       	},

     

       131
       131
       +
       	metadata?: LogMetadata,

     

       94
       132
        
       ): Promise<void> {

     

       95
       95
       -
       	slog(logMessage, location);

     

       96
       96
       -
       	clog(logMessage, type);

     

       133
       133
       +
       	try {

     

       134
       134
       +
       		await Promise.all([

     

       135
       135
       +
       			slog(logMessage, location),

     

       136
       136
       +
       			clog(logMessage, type, metadata),

     

       137
       137
       +
       		]);

     

       138
       138
       +
       	} catch (error) {

     

       139
       139
       +
       		console.error("Failed to log message:", error);

     

       140
       140
       +
       		Sentry.captureException(error, {

     

       141
       141
       +
       			extra: { logMessage, type, location, metadata },

     

       142
       142
       +
       			tags: { type: "blog_error" },

     

       143
       143
       +
       		});

     

       144
       144
       +
       	}

     

       97
       145
        
       }

     

       98
       146
        
       

     

       99
       147
        
       export { clog as default, slog };

+28

src/libs/apiError.ts

···

       1
       1
       +
       import * as Sentry from "@sentry/bun";

     

       2
       2
       +
       

     

       3
       3
       +
       export interface ApiError {

     

       4
       4
       +
       	message: string;

     

       5
       5
       +
       	status: number;

     

       6
       6
       +
       }

     

       7
       7
       +
       

     

       8
       8
       +
       export function handleApiError(error: unknown, context: string): Response {

     

       9
       9
       +
       	if (error instanceof Error) {

     

       10
       10
       +
       		Sentry.captureException(error, {

     

       11
       11
       +
       			extra: { context },

     

       12
       12
       +
       			tags: { type: "api_error" },

     

       13
       13
       +
       		});

     

       14
       14
       +
       

     

       15
       15
       +
       		return new Response(JSON.stringify({ error: error.message }), {

     

       16
       16
       +
       			status: 500,

     

       17
       17
       +
       			headers: { "Content-Type": "application/json" },

     

       18
       18
       +
       		});

     

       19
       19
       +
       	}

     

       20
       20
       +
       

     

       21
       21
       +
       	return new Response(

     

       22
       22
       +
       		JSON.stringify({ error: "An unexpected error occurred" }),

     

       23
       23
       +
       		{

     

       24
       24
       +
       			status: 500,

     

       25
       25
       +
       			headers: { "Content-Type": "application/json" },

     

       26
       26
       +
       		},

     

       27
       27
       +
       	);

     

       28
       28
       +
       }