autonomous.contact/public/api/rooms/:room_id/events/index.ts

import lurid from '@andyburke/lurid';
import { get_session, get_user, PRECHECK_TABLE, require_user } from '../../../../../utils/prechecks.ts';
import { ROOM, ROOMS } from '../../../../../models/room.ts';
import * as CANNED_RESPONSES from '../../../../../utils/canned_responses.ts';
import { EVENT, get_events_collection_for_room } from '../../../../../models/event.ts';
import parse_body from '../../../../../utils/bodyparser.ts';
import { FSDB_COLLECTION, FSDB_SEARCH_OPTIONS, WALK_ENTRY } from '@andyburke/fsdb';
import * as path from '@std/path';

export const PRECHECKS: PRECHECK_TABLE = {};

// GET /api/rooms/:room_id/events - get room events
// query parameters:
//   partial_id: the partial id subset you would like to match (remember, lurids are lexigraphically sorted)
PRECHECKS.GET = [get_session, get_user, require_user, async (_req: Request, meta: Record<string, any>): Promise<Response | undefined> => {
	const room_id: string = meta.params?.room_id?.toLowerCase().trim() ?? '';

	// lurid is 49 chars as we use them, eg: "also-play-flow-want-form-wide-thus-work-burn-same"
	const room: ROOM | null = room_id.length === 49 ? await ROOMS.get(room_id) : null;

	if (!room) {
		return CANNED_RESPONSES.not_found();
	}

	meta.room = room;
	const room_is_public: boolean = meta.room.permissions.read.length === 0;
	const user_has_read_for_room = room_is_public || meta.room.permissions.read.includes(meta.user.id);
	const room_events_are_public = meta.room.permissions.read_events.length === 0;
	const user_has_read_events_for_room = user_has_read_for_room &&
		(room_events_are_public || meta.room.permissions.read_events.includes(meta.user.id));

	if (!user_has_read_events_for_room) {
		return CANNED_RESPONSES.permission_denied();
	}
}];
export async function GET(request: Request, meta: Record<string, any>): Promise<Response> {
	const events: FSDB_COLLECTION<EVENT> = get_events_collection_for_room(meta.room.id);

	const sorts = events.sorts;
	const sort_name: string = meta.query.sort ?? 'newest';
	const key = sort_name as keyof typeof sorts;
	const sort: any = sorts[key];
	if (!sort) {
		return Response.json({
			error: {
				message: 'You must specify a sort: newest, oldest, latest, stalest',
				cause: 'invalid_sort'
			}
		}, {
			status: 400
		});
	}

	const options: FSDB_SEARCH_OPTIONS<EVENT> = {
		...(meta.query ?? {}),
		limit: Math.min(parseInt(meta.query?.limit ?? '10'), 1_000),
		sort,
		filter: (entry: WALK_ENTRY<EVENT>) => {
			const [event_id, event_type] = path.basename(entry.path).replace(/\.json$/i, '').split(':');

			if (meta.query.after_id && event_id <= meta.query.after_id) {
				return false;
			}

			if (meta.query.before_id && event_id >= meta.query.before_id) {
				return false;
			}

			if (meta.query.type && event_type !== meta.query.type) {
				return false;
			}

			return true;
		}
	};

	const headers = {
		'Cache-Control': 'no-cache, must-revalidate'
	};

	const results = (await events.all(options))
		.map((entry: WALK_ENTRY<EVENT>) => entry.load())
		.sort((lhs_item: EVENT, rhs_item: EVENT) => rhs_item.timestamps.created.localeCompare(lhs_item.timestamps.created));

	// long-polling support
	if (results.length === 0 && meta.query.wait) {
		return new Promise((resolve, reject) => {
			function on_create(create_event: any) {
				results.push(create_event.item);
				clearTimeout(timeout);
				events.off('create', on_create);

				return resolve(Response.json(results, {
					status: 200,
					headers
				}));
			}

			const timeout = setTimeout(() => {
				events.off('create', on_create);
				return resolve(Response.json(results, {
					status: 200,
					headers
				}));
			}, 60_000); // 60 seconds
			events.on('create', on_create);
			request.signal.addEventListener('abort', () => {
				events.off('create', on_create);
				clearTimeout(timeout);
				reject(new Error('request aborted'));
			});
			Deno.addSignalListener('SIGINT', () => {
				events.off('create', on_create);
				clearTimeout(timeout);
				return resolve(Response.json(results, {
					status: 200,
					headers
				}));
			});
		});
	}

	return Response.json(results, {
		status: 200,
		headers
	});
}

// POST /api/rooms/:room_id/events - Create an event
PRECHECKS.POST = [get_session, get_user, require_user, async (_req: Request, meta: Record<string, any>): Promise<Response | undefined> => {
	const room_id: string = meta.params?.room_id?.toLowerCase().trim() ?? '';

	// lurid is 49 chars as we use them, eg: "also-play-flow-want-form-wide-thus-work-burn-same"
	const room: ROOM | null = room_id.length === 49 ? await ROOMS.get(room_id) : null;

	if (!room) {
		return CANNED_RESPONSES.not_found();
	}

	meta.room = room;
	const room_is_public: boolean = meta.room.permissions.read.length === 0;
	const user_has_read_for_room = room_is_public || meta.room.permissions.read.includes(meta.user.id);
	const room_events_are_publicly_writable = meta.room.permissions.write_events.length === 0;
	const user_has_write_events_for_room = user_has_read_for_room &&
		(room_events_are_publicly_writable || meta.room.permissions.write_events.includes(meta.user.id));

	if (!user_has_write_events_for_room) {
		return CANNED_RESPONSES.permission_denied();
	}
}];
export async function POST(req: Request, meta: Record<string, any>): Promise<Response> {
	try {
		const events: FSDB_COLLECTION<EVENT> = get_events_collection_for_room(meta.room.id);

		const now = new Date().toISOString();

		const body = await parse_body(req);
		const event: EVENT = {
			type: 'unknown',
			...body,
			creator_id: meta.user.id,
			timestamps: {
				created: now,
				updated: now
			}
		};

		event.id = `${lurid()}:${event.type}`;

		await events.create(event);

		return Response.json(event, {
			status: 201
		});
	} catch (error) {
		return Response.json({
			error: {
				message: (error as Error).message ?? 'Unknown Error!',
				cause: (error as Error).cause ?? 'unknown'
			}
		}, { status: 500 });
	}
}