Add Meetup calendar datasource

Author: chromy

src/configuration.ts

@@ -43,6 +43,10 @@ const Config = t.strict({
   ),
   GOOGLE_SERVICE_ACCOUNT_KEY_JSON: tt.NonEmptyString, // Don't default so we don't accidentally disable.
   TROUBLE_TICKET_SHEET: t.string,
+  MEETUP_ICAL_URL: withDefaultIfEmpty(
+    t.string,
+    'https://www.meetup.com/makespace/events/ical/'
+  ),
 });
 
 export type Config = t.TypeOf<typeof Config>;

src/dependencies.ts

@@ -12,6 +12,7 @@ import {
   SheetDataTable,
   TroubleTicketDataTable,
 } from './sync-worker/google/sheet-data-table';
+import {MeetupEventRow} from './sync-worker/db/get-meetup-events';
 
 export type Dependencies = {
   commitEvent: (
@@ -49,4 +50,5 @@ export type Dependencies = {
   getTroubleTicketData: (
     from: O.Option<Date>
   ) => TE.TaskEither<string, O.Option<TroubleTicketDataTable['rows']>>;
+  getMeetupEvents: () => TE.TaskEither<string, ReadonlyArray<MeetupEventRow>>;
 };

src/http/calendar-ics-handler.ts

@@ -0,0 +1,96 @@
+import {RequestHandler} from 'express';
+import {StatusCodes} from 'http-status-codes';
+import {Dependencies} from '../dependencies';
+import * as E from 'fp-ts/Either';
+import {MeetupEventRow} from '../sync-worker/db/get-meetup-events';
+
+const formatICalDate = (timestamp: number): string => {
+  const date = new Date(timestamp);
+  return date
+    .toISOString()
+    .replace(/[-:]/g, '')
+    .replace(/\.\d{3}/, '');
+};
+
+const escapeICalText = (text: string): string =>
+  text
+    .replace(/\\/g, '\\\\')
+    .replace(/;/g, '\\;')
+    .replace(/,/g, '\\,')
+    .replace(/\n/g, '\\n');
+
+const foldLine = (line: string): string => {
+  const maxLength = 75;
+  if (line.length <= maxLength) {
+    return line;
+  }
+  const parts: string[] = [];
+  let remaining = line;
+  while (remaining.length > 0) {
+    if (parts.length === 0) {
+      parts.push(remaining.slice(0, maxLength));
+      remaining = remaining.slice(maxLength);
+    } else {
+      // Continuation lines start with a space
+      parts.push(' ' + remaining.slice(0, maxLength - 1));
+      remaining = remaining.slice(maxLength - 1);
+    }
+  }
+  return parts.join('\r\n');
+};
+
+const generateICalendar = (
+  events: ReadonlyArray<MeetupEventRow>
+): string => {
+  const lines: string[] = [
+    'BEGIN:VCALENDAR',
+    'VERSION:2.0',
+    'PRODID:-//MakeSpace//Members App//EN',
+    'CALSCALE:GREGORIAN',
+    'METHOD:PUBLISH',
+    'X-WR-CALNAME:MakeSpace Events',
+  ];
+
+  for (const event of events) {
+    lines.push('BEGIN:VEVENT');
+    lines.push(foldLine(`UID:${event.uid}`));
+    lines.push(`DTSTART:${formatICalDate(event.dtstart)}`);
+    lines.push(`DTEND:${formatICalDate(event.dtend)}`);
+    lines.push(foldLine(`SUMMARY:${escapeICalText(event.summary)}`));
+    if (event.description) {
+      lines.push(foldLine(`DESCRIPTION:${escapeICalText(event.description)}`));
+    }
+    if (event.location) {
+      lines.push(foldLine(`LOCATION:${escapeICalText(event.location)}`));
+    }
+    if (event.url) {
+      lines.push(foldLine(`URL:${event.url}`));
+    }
+    lines.push('END:VEVENT');
+  }
+
+  lines.push('END:VCALENDAR');
+  return lines.join('\r\n');
+};
+
+export const calendarIcsHandler =
+  (deps: Dependencies): RequestHandler =>
+  async (req, res) => {
+    const events = await deps.getMeetupEvents()();
+
+    if (E.isLeft(events)) {
+      deps.logger.error('Failed to get Meetup events: %s', events.left);
+      return res
+        .status(StatusCodes.INTERNAL_SERVER_ERROR)
+        .send('Failed to load calendar');
+    }
+
+    const icalContent = generateICalendar(events.right);
+
+    res.setHeader('Content-Type', 'text/calendar; charset=utf-8');
+    res.setHeader(
+      'Content-Disposition',
+      'attachment; filename="makespace-events.ics"'
+    );
+    return res.status(StatusCodes.OK).send(icalContent);
+  };

src/http/index.ts

@@ -1,4 +1,5 @@
 export {queryToHandler} from './query-to-handler';
 export {commandToHandlers} from './command-to-handlers';
 export {ping} from './ping';
+export {calendarIcsHandler} from './calendar-ics-handler';
 export {createRouter} from './router';

src/init-dependencies/init-dependencies.ts

@@ -14,6 +14,7 @@ import {initSharedReadModel} from '../read-models/shared-state';
 import {lastSync} from '../sync-worker/db/last_sync';
 import {getSheetData} from '../sync-worker/db/get_sheet_data';
 import {getTroubleTicketData} from '../sync-worker/db/get_trouble_ticket_data';
+import {getMeetupEvents} from '../sync-worker/db/get-meetup-events';
 
 export const initLogger = (conf: Config) => {
   let loggerOptions: LoggerOptions;
@@ -83,6 +84,7 @@ export const initDependencies = (
       googleDB,
       O.fromNullable(conf.TROUBLE_TICKET_SHEET)
     ),
+    getMeetupEvents: getMeetupEvents(googleDB),
     // getPassedQuizResults: getPassedQuizResults(dbClient),
     // getFailedQuizResults: getFailedQuizResults(dbClient),
   };

src/routes.ts

@@ -4,7 +4,7 @@ import {commands, sendEmailCommands} from './commands';
 import * as queries from './queries';
 import {Route, get} from './types/route';
 import {authRoutes} from './authentication';
-import {queryToHandler, commandToHandlers, ping} from './http';
+import {queryToHandler, commandToHandlers, ping, calendarIcsHandler} from './http';
 import {emailHandler} from './http/email-handler';
 
 export const initRoutes = (
@@ -89,6 +89,7 @@ export const initRoutes = (
     ),
     email('owner-agreement-invite', sendEmailCommands.ownerAgreementInvite),
     get('/ping', ping),
+    get('/calendar.ics', calendarIcsHandler(deps)),
     query('/db', queries.db),
     query('/debug/dump-shared-db/json', queries.dumpSharedDbAsJson),
     query('/debug/dump-shared-db/buffer', queries.dumpSharedDbAsBuffer),

src/sync-worker/db/clear-meetup-events.ts

@@ -0,0 +1,14 @@
+import {Client} from '@libsql/client';
+import * as TE from 'fp-ts/TaskEither';
+import {pipe} from 'fp-ts/lib/function';
+
+export const clearMeetupEvents =
+  (googleDB: Client) => (): TE.TaskEither<string, void> =>
+    pipe(
+      TE.tryCatch(
+        () => googleDB.execute('DELETE FROM meetup_event_data'),
+        reason =>
+          `Failed to clear meetup events: ${(reason as Error).message}`
+      ),
+      TE.map(() => {})
+    );

src/sync-worker/db/get-meetup-events.ts

@@ -0,0 +1,29 @@
+import {Client} from '@libsql/client';
+import * as TE from 'fp-ts/TaskEither';
+import {pipe} from 'fp-ts/lib/function';
+
+export type MeetupEventRow = {
+  uid: string;
+  summary: string;
+  description: string | null;
+  location: string | null;
+  dtstart: number;
+  dtend: number;
+  url: string | null;
+  cached_at: number;
+};
+
+export const getMeetupEvents =
+  (googleDB: Client) => (): TE.TaskEither<string, ReadonlyArray<MeetupEventRow>> =>
+    pipe(
+      TE.tryCatch(
+        async () => {
+          const result = await googleDB.execute(
+            'SELECT uid, summary, description, location, dtstart, dtend, url, cached_at FROM meetup_event_data ORDER BY dtstart ASC'
+          );
+          return result.rows as unknown as MeetupEventRow[];
+        },
+        reason =>
+          `Failed to get meetup events: ${(reason as Error).message}`
+      )
+    );

src/sync-worker/db/store-meetup-events.ts

@@ -0,0 +1,39 @@
+import {Client} from '@libsql/client';
+import * as TE from 'fp-ts/TaskEither';
+import * as RA from 'fp-ts/ReadonlyArray';
+import {pipe} from 'fp-ts/lib/function';
+import {inspect} from 'node:util';
+import {MeetupEvent} from '../meetup/fetch-meetup-ical';
+
+export const storeMeetupEvents =
+  (googleDB: Client) =>
+  (data: ReadonlyArray<MeetupEvent>): TE.TaskEither<string, void> =>
+    pipe(
+      data,
+      RA.map(event =>
+        TE.tryCatch(
+          () =>
+            googleDB.execute({
+              sql: `INSERT OR REPLACE INTO meetup_event_data(
+                uid, summary, description, location, dtstart, dtend, url, cached_at
+              ) VALUES (
+                $uid, $summary, $description, $location, $dtstart, $dtend, $url, $cached_at
+              )`,
+              args: {
+                $uid: event.uid,
+                $summary: event.summary,
+                $description: event.description,
+                $location: event.location,
+                $dtstart: event.dtstart.getTime(),
+                $dtend: event.dtend.getTime(),
+                $url: event.url,
+                $cached_at: Date.now(),
+              },
+            }),
+          reason =>
+            `Failed to insert meetup event '${inspect(event)}': ${(reason as Error).message}`
+        )
+      ),
+      TE.sequenceArray,
+      TE.map(() => {})
+    );

src/sync-worker/dependencies.ts

@@ -7,6 +7,7 @@ import {
   SheetDataTable,
   TroubleTicketDataTable,
 } from './google/sheet-data-table';
+import {MeetupEvent} from './meetup/fetch-meetup-ical';
 import {ReadonlyRecord} from 'fp-ts/lib/ReadonlyRecord';
 import {UUID} from 'io-ts-types';
 import {DomainEvent, Email, Failure, ResourceVersion} from '../types';
@@ -58,4 +59,8 @@ export interface SyncWorkerDependencies {
       version: ResourceVersion;
     }
   >;
+  storeMeetupEvents: (
+    data: ReadonlyArray<MeetupEvent>
+  ) => TE.TaskEither<string, void>;
+  clearMeetupEvents: () => TE.TaskEither<string, void>;
 }