Refactor backend to import/export syntax and update deps

.github/workflows/deploy_backend.yml

@@ -19,6 +19,13 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 17
+        cache: yarn
+        cache-dependency-path: '**/yarn.lock'
+    - run: yarn install --immutable
+    - run: yarn build
     - id: auth
       uses: google-github-actions/auth@v0
       with:

crabfit-backend/.eslintrc.js

@@ -0,0 +1,50 @@
+module.exports = {
+  'env': {
+    'es2021': true,
+    'node': true
+  },
+  'extends': 'eslint:recommended',
+  'overrides': [
+  ],
+  'parserOptions': {
+    'ecmaVersion': 'latest',
+    'sourceType': 'module'
+  },
+  'rules': {
+    'indent': [
+      'error',
+      2
+    ],
+    'linebreak-style': [
+      'error',
+      'unix'
+    ],
+    'quotes': [
+      'error',
+      'single'
+    ],
+    'semi': [
+      'error',
+      'never'
+    ],
+    'eqeqeq': 2,
+    'no-return-await': 1,
+    'no-var': 2,
+    'prefer-const': 1,
+    'yoda': 2,
+    'no-trailing-spaces': 1,
+    'eol-last': [1, 'always'],
+    'no-unused-vars': [
+      1,
+      {
+        'args': 'all',
+        'argsIgnorePattern': '^_',
+        'ignoreRestSiblings': true
+      },
+    ],
+    'arrow-parens': [
+      'error',
+      'as-needed'
+    ],
+  }
+}

crabfit-backend/.gcloudignore

@@ -6,3 +6,7 @@
 .env
 
 node_modules/
+.parcel-cache
+res
+routes
+swagger.yaml

crabfit-backend/.gitignore

@@ -1,11 +1,7 @@
-/node_modules
-
-.DS_Store
+node_modules
+dist
+.parcel-cache
 .env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
 
 npm-debug.log*
 yarn-debug.log*

crabfit-backend/cron.yaml

@@ -3,10 +3,6 @@ cron:
     url: /tasks/cleanup
     schedule: every monday 09:00
     target: api
-  - description: "clean up old events without a visited date"
-    url: /tasks/legacyCleanup
-    schedule: every tuesday 09:00
-    target: api
   - description: "remove people with an event id that no longer exists"
     url: /tasks/removeOrphans
     schedule: 1st wednesday of month 09:00

crabfit-backend/index.js

@@ -1,61 +1,61 @@
-require('dotenv').config();
+import { config } from 'dotenv'
+import { Datastore } from '@google-cloud/datastore'
+import express from 'express'
+import cors from 'cors'
 
-const { Datastore } = require('@google-cloud/datastore');
-const express = require('express');
-const cors = require('cors');
+import packageJson from './package.json'
 
-const package = require('./package.json');
+import {
+  stats,
+  getEvent,
+  createEvent,
+  getPeople,
+  createPerson,
+  login,
+  updatePerson,
+  taskCleanup,
+  taskRemoveOrphans,
+} from './routes'
 
-const stats = require('./routes/stats');
-const getEvent = require('./routes/getEvent');
-const createEvent = require('./routes/createEvent');
-const getPeople = require('./routes/getPeople');
-const createPerson = require('./routes/createPerson');
-const login = require('./routes/login');
-const updatePerson = require('./routes/updatePerson');
+config()
 
-const taskCleanup = require('./routes/taskCleanup');
-const taskLegacyCleanup = require('./routes/taskLegacyCleanup');
-const taskRemoveOrphans = require('./routes/taskRemoveOrphans');
-
-const app = express();
-const port = 8080;
+const app = express()
+const port = 8080
 const corsOptions = {
-	origin: process.env.NODE_ENV === 'production' ? 'https://crab.fit' : 'http://localhost:5173',
-};
+  origin: process.env.NODE_ENV === 'production' ? 'https://crab.fit' : 'http://localhost:5173',
+}
 
 const datastore = new Datastore({
-	keyFilename: process.env.GOOGLE_APPLICATION_CREDENTIALS,
-});
+  keyFilename: process.env.GOOGLE_APPLICATION_CREDENTIALS,
+})
 
-app.use(express.json());
-app.use((req, res, next) => {
-	req.datastore = datastore;
+app.use(express.json())
+app.use((req, _res, next) => {
+  req.datastore = datastore
   req.types = {
     event: process.env.NODE_ENV === 'production' ? 'Event' : 'DevEvent',
     person: process.env.NODE_ENV === 'production' ? 'Person' : 'DevPerson',
     stats: process.env.NODE_ENV === 'production' ? 'Stats' : 'DevStats',
-  };
-	next();
-});
-app.options('*', cors(corsOptions));
-app.use(cors(corsOptions));
+  }
+  next()
+})
+app.options('*', cors(corsOptions))
+app.use(cors(corsOptions))
 
-app.get('/', (req, res) => res.send(`Crabfit API v${package.version}`));
+app.get('/', (_req, res) => res.send(`Crabfit API v${packageJson.version}`))
 
-app.get('/stats', stats);
-app.get('/event/:eventId', getEvent);
-app.post('/event', createEvent);
-app.get('/event/:eventId/people', getPeople);
-app.post('/event/:eventId/people', createPerson);
-app.post('/event/:eventId/people/:personName', login);
-app.patch('/event/:eventId/people/:personName', updatePerson);
+app.get('/stats', stats)
+app.get('/event/:eventId', getEvent)
+app.post('/event', createEvent)
+app.get('/event/:eventId/people', getPeople)
+app.post('/event/:eventId/people', createPerson)
+app.post('/event/:eventId/people/:personName', login)
+app.patch('/event/:eventId/people/:personName', updatePerson)
 
 // Tasks
-app.get('/tasks/cleanup', taskCleanup);
-app.get('/tasks/legacyCleanup', taskLegacyCleanup);
-app.get('/tasks/removeOrphans', taskRemoveOrphans);
+app.get('/tasks/cleanup', taskCleanup)
+app.get('/tasks/removeOrphans', taskRemoveOrphans)
 
 app.listen(port, () => {
-	console.log(`Crabfit API listening at http://localhost:${port} in ${process.env.NODE_ENV === 'production' ? 'prod' : 'dev'} mode`)
-});
+  console.log(`Crabfit API listening at http://localhost:${port} in ${process.env.NODE_ENV === 'production' ? 'prod' : 'dev'} mode`)
+})

crabfit-backend/package.json

@@ -1,24 +1,33 @@
 {
   "name": "crabfit-backend",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "API for Crabfit",
-  "main": "index.js",
   "author": "Ben Grant",
   "license": "GPL-3.0-only",
   "private": true,
+  "source": "index.js",
+  "main": "dist/index.js",
   "engines": {
-    "node": ">=10.0.0"
+    "node": ">=12.0.0"
   },
   "scripts": {
-    "start": "node index.js"
+    "build:dev": "NODE_ENV=development parcel build --no-cache",
+    "dev": "rm -rf .parcel-cache dist && NODE_ENV=development nodemon --exec \"yarn build:dev && yarn start\" --watch routes --watch res --watch index.js",
+    "build": "parcel build",
+    "start": "node ./dist/index.js"
   },
   "dependencies": {
-    "@google-cloud/datastore": "^6.3.1",
+    "@google-cloud/datastore": "^7.0.0",
     "bcrypt": "^5.0.1",
     "cors": "^2.8.5",
-    "dayjs": "^1.10.4",
-    "dotenv": "^8.2.0",
-    "express": "^4.17.1",
+    "dayjs": "^1.11.5",
+    "dotenv": "^16.0.1",
+    "express": "^4.18.1",
     "punycode": "^2.1.1"
+  },
+  "devDependencies": {
+    "eslint": "^8.22.0",
+    "nodemon": "^2.0.19",
+    "parcel": "^2.7.0"
   }
 }

crabfit-backend/routes/createEvent.js

@@ -1,81 +1,84 @@
-const dayjs = require('dayjs');
-const punycode = require('punycode/');
+import dayjs from 'dayjs'
+import punycode from 'punycode/'
 
-const adjectives = require('../res/adjectives.json');
-const crabs = require('../res/crabs.json');
+import adjectives from '../res/adjectives.json'
+import crabs from '../res/crabs.json'
 
-const capitalize = string => string.charAt(0).toUpperCase() + string.slice(1);
+const capitalize = string => string.charAt(0).toUpperCase() + string.slice(1)
 
 // Generate a random name based on an adjective and a crab species
-const generateName = () => {
-	return `${capitalize(adjectives[Math.floor(Math.random() * adjectives.length)])} ${crabs[Math.floor(Math.random() * crabs.length)]} Crab`;
-};
+const generateName = () =>
+  `${capitalize(adjectives[Math.floor(Math.random() * adjectives.length)])} ${crabs[Math.floor(Math.random() * crabs.length)]} Crab`
 
 // Generate a slug for the crab fit
 const generateId = name => {
-	let id = punycode.encode(name.trim().toLowerCase()).trim().replace(/[^A-Za-z0-9 ]/g, '').replace(/\s+/g, '-');
+  let id = punycode.encode(name.trim().toLowerCase()).trim().replace(/[^A-Za-z0-9 ]/g, '').replace(/\s+/g, '-')
   if (id.replace(/-/g, '') === '') {
-    id = generateName().trim().toLowerCase().replace(/[^A-Za-z0-9 ]/g, '').replace(/\s+/g, '-');
+    id = generateName().trim().toLowerCase().replace(/[^A-Za-z0-9 ]/g, '').replace(/\s+/g, '-')
   }
-	const number = Math.floor(100000 + Math.random() * 900000);
-	return `${id}-${number}`;
-};
+  const number = Math.floor(100000 + Math.random() * 900000)
+  return `${id}-${number}`
+}
 
-module.exports = async (req, res) => {
-	const { event } = req.body;
+const createEvent = async (req, res) => {
+  const { event } = req.body
 
-	try {
-		const name = event.name.trim() === '' ? generateName() : event.name.trim();
-		let eventId = generateId(name);
-		const currentTime = dayjs().unix();
+  try {
+    const name = event.name.trim() === '' ? generateName() : event.name.trim()
+    let eventId = generateId(name)
+    const currentTime = dayjs().unix()
 
     // Check if the event ID already exists, and if so generate a new one
-    let eventResult;
+    let eventResult
     do {
       const query = req.datastore.createQuery(req.types.event)
         .select('__key__')
-        .filter('__key__', req.datastore.key([req.types.event, eventId]));
+        .filter('__key__', req.datastore.key([req.types.event, eventId]))
 
-      eventResult = (await req.datastore.runQuery(query))[0][0];
+      eventResult = (await req.datastore.runQuery(query))[0][0]
 
       if (eventResult !== undefined) {
-        eventId = generateId(name);
+        eventId = generateId(name)
       }
-    } while (eventResult !== undefined);
+    } while (eventResult !== undefined)
 
     const entity = {
-			key: req.datastore.key([req.types.event, eventId]),
-			data: {
-				name: name,
-				created: currentTime,
-				times: event.times,
-				timezone: event.timezone,
-			},
-		};
+      key: req.datastore.key([req.types.event, eventId]),
+      data: {
+        name: name,
+        created: currentTime,
+        times: event.times,
+        timezone: event.timezone,
+      },
+    }
 
-		await req.datastore.insert(entity);
+    await req.datastore.insert(entity)
 
-		res.status(201).send({
-			id: eventId,
-			name: name,
-			created: currentTime,
-			times: event.times,
+    res.status(201).send({
+      id: eventId,
+      name: name,
+      created: currentTime,
+      times: event.times,
       timezone: event.timezone,
-		});
+    })
 
     // Update stats
-    let eventCountResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'eventCount'])))[0] || null;
+    const eventCountResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'eventCount'])))[0] || null
     if (eventCountResult) {
-      eventCountResult.value++;
-      await req.datastore.upsert(eventCountResult);
+      await req.datastore.upsert({
+        ...eventCountResult,
+        value: eventCountResult.value + 1,
+      })
     } else {
-  		await req.datastore.insert({
-  			key: req.datastore.key([req.types.stats, 'eventCount']),
-  			data: { value: 1 },
-  		});
+      await req.datastore.insert({
+        key: req.datastore.key([req.types.stats, 'eventCount']),
+        data: { value: 1 },
+      })
     }
-	} catch (e) {
-		console.error(e);
-		res.sendStatus(400);
-	}
-};
+  } catch (e) {
+    console.error(e)
+    res.sendStatus(400)
+  }
+}
+
+export default createEvent

crabfit-backend/routes/createPerson.js

@@ -1,61 +1,65 @@
-const dayjs = require('dayjs');
-const bcrypt = require('bcrypt');
+import dayjs from 'dayjs'
+import bcrypt from 'bcrypt'
 
-module.exports = async (req, res) => {
-	const { eventId } = req.params;
-	const { person } = req.body;
+const createPerson = async (req, res) => {
+  const { eventId } = req.params
+  const { person } = req.body
 
-	try {
-		const event = (await req.datastore.get(req.datastore.key([req.types.event, eventId])))[0];
-		const query = req.datastore.createQuery(req.types.person)
-			.filter('eventId', eventId)
-			.filter('name', person.name);
-		let personResult = (await req.datastore.runQuery(query))[0][0];
+  try {
+    const event = (await req.datastore.get(req.datastore.key([req.types.event, eventId])))[0]
+    const query = req.datastore.createQuery(req.types.person)
+      .filter('eventId', eventId)
+      .filter('name', person.name)
+    const personResult = (await req.datastore.runQuery(query))[0][0]
 
-		if (event) {
-			if (person && personResult === undefined) {
-				const currentTime = dayjs().unix();
+    if (event) {
+      if (person && personResult === undefined) {
+        const currentTime = dayjs().unix()
 
-				// If password
-				let hash = null;
-				if (person.password) {
-					hash = await bcrypt.hash(person.password, 10);
-				}
+        // If password
+        let hash = null
+        if (person.password) {
+          hash = await bcrypt.hash(person.password, 10)
+        }
 
-				const entity = {
-					key: req.datastore.key(req.types.person),
-					data: {
-						name: person.name.trim(),
-						password: hash,
-						eventId: eventId,
-						created: currentTime,
-						availability: [],
-					},
-				};
+        const entity = {
+          key: req.datastore.key(req.types.person),
+          data: {
+            name: person.name.trim(),
+            password: hash,
+            eventId: eventId,
+            created: currentTime,
+            availability: [],
+          },
+        }
 
-				await req.datastore.insert(entity);
+        await req.datastore.insert(entity)
 
-				res.sendStatus(201);
+        res.sendStatus(201)
 
         // Update stats
-        let personCountResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'personCount'])))[0] || null;
+        const personCountResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'personCount'])))[0] || null
         if (personCountResult) {
-          personCountResult.value++;
-          await req.datastore.upsert(personCountResult);
+          await req.datastore.upsert({
+            ...personCountResult,
+            value: personCountResult.value + 1,
+          })
         } else {
-      		await req.datastore.insert({
-      			key: req.datastore.key([req.types.stats, 'personCount']),
-      			data: { value: 1 },
-      		});
+          await req.datastore.insert({
+            key: req.datastore.key([req.types.stats, 'personCount']),
+            data: { value: 1 },
+          })
         }
-			} else {
-				res.sendStatus(400);
-			}
-		} else {
-			res.sendStatus(404);
-		}
-	} catch (e) {
-		console.error(e);
-		res.sendStatus(400);
-	}
-};
+      } else {
+        res.sendStatus(400)
+      }
+    } else {
+      res.sendStatus(404)
+    }
+  } catch (e) {
+    console.error(e)
+    res.sendStatus(400)
+  }
+}
+
+export default createPerson

crabfit-backend/routes/getEvent.js

@@ -1,25 +1,29 @@
-const dayjs = require('dayjs');
+import dayjs from 'dayjs'
 
-module.exports = async (req, res) => {
-	const { eventId } = req.params;
+const getEvent = async (req, res) => {
+  const { eventId } = req.params
 
-	try {
-		let event = (await req.datastore.get(req.datastore.key([req.types.event, eventId])))[0];
+  try {
+    const event = (await req.datastore.get(req.datastore.key([req.types.event, eventId])))[0]
 
-		if (event) {
-			res.send({
-				id: eventId,
-				...event,
-			});
+    if (event) {
+      res.send({
+        id: eventId,
+        ...event,
+      })
 
       // Update last visited time
-      event.visited = dayjs().unix();
-      await req.datastore.upsert(event);
-		} else {
-			res.sendStatus(404);
-		}
-	} catch (e) {
-		console.error(e);
-		res.sendStatus(404);
-	}
-};
+      await req.datastore.upsert({
+        ...event,
+        visited: dayjs().unix()
+      })
+    } else {
+      res.sendStatus(404)
+    }
+  } catch (e) {
+    console.error(e)
+    res.sendStatus(404)
+  }
+}
+
+export default getEvent

crabfit-backend/routes/getPeople.js

@@ -1,20 +1,20 @@
-module.exports = async (req, res) => {
-	const { eventId } = req.params;
+const getPeople = async (req, res) => {
+  const { eventId } = req.params
 
-	try {
-		const query = req.datastore.createQuery(req.types.person).filter('eventId', eventId);
-		let people = (await req.datastore.runQuery(query))[0];
-		people = people.map(person => ({
-			name: person.name,
-			availability: person.availability,
-			created: person.created,
-		}));
+  try {
+    const query = req.datastore.createQuery(req.types.person).filter('eventId', eventId)
+    let people = (await req.datastore.runQuery(query))[0]
+    people = people.map(person => ({
+      name: person.name,
+      availability: person.availability,
+      created: person.created,
+    }))
 
-		res.send({
-			people,
-		});
-	} catch (e) {
-		console.error(e);
-		res.sendStatus(404);
-	}
-};
+    res.send({ people })
+  } catch (e) {
+    console.error(e)
+    res.sendStatus(404)
+  }
+}
+
+export default getPeople

crabfit-backend/routes/index.js

@@ -0,0 +1,10 @@
+export { default as stats } from './stats'
+export { default as getEvent } from './getEvent'
+export { default as createEvent } from './createEvent'
+export { default as getPeople } from './getPeople'
+export { default as createPerson } from './createPerson'
+export { default as login } from './login'
+export { default as updatePerson } from './updatePerson'
+
+export { default as taskCleanup } from './taskCleanup'
+export { default as taskRemoveOrphans } from './taskRemoveOrphans'

crabfit-backend/routes/login.js

@@ -1,33 +1,35 @@
-const bcrypt = require('bcrypt');
+import bcrypt from 'bcrypt'
 
-module.exports = async (req, res) => {
-	const { eventId, personName } = req.params;
-	const { person } = req.body;
+const login = async (req, res) => {
+  const { eventId, personName } = req.params
+  const { person } = req.body
 
-	try {
-		const query = req.datastore.createQuery(req.types.person)
-			.filter('eventId', eventId)
-			.filter('name', personName);
-		let personResult = (await req.datastore.runQuery(query))[0][0];
+  try {
+    const query = req.datastore.createQuery(req.types.person)
+      .filter('eventId', eventId)
+      .filter('name', personName)
+    const personResult = (await req.datastore.runQuery(query))[0][0]
 
-		if (personResult) {
-			if (personResult.password) {
-				const passwordsMatch = person && person.password && await bcrypt.compare(person.password, personResult.password);
-				if (!passwordsMatch) {
-					return res.status(401).send('Incorrect password');
-				}
-			}
+    if (personResult) {
+      if (personResult.password) {
+        const passwordsMatch = person && person.password && await bcrypt.compare(person.password, personResult.password)
+        if (!passwordsMatch) {
+          return res.status(401).send('Incorrect password')
+        }
+      }
 
-			res.send({
-				name: personName,
-				availability: personResult.availability,
-				created: personResult.created,
-			});
-		} else {
-			res.sendStatus(404);
-		}
-	} catch (e) {
-		console.error(e);
-		res.sendStatus(404);
-	}
-};
+      res.send({
+        name: personName,
+        availability: personResult.availability,
+        created: personResult.created,
+      })
+    } else {
+      res.sendStatus(404)
+    }
+  } catch (e) {
+    console.error(e)
+    res.sendStatus(404)
+  }
+}
+
+export default login

crabfit-backend/routes/stats.js

@@ -1,27 +1,29 @@
-const package = require('../package.json');
+import packageJson from '../package.json'
 
-module.exports = async (req, res) => {
-	let eventCount = null;
-	let personCount = null;
+const stats = async (req, res) => {
+  let eventCount = null
+  let personCount = null
 
   try {
-		const eventResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'eventCount'])))[0] || null;
-		const personResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'personCount'])))[0] || null;
+    const eventResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'eventCount'])))[0] || null
+    const personResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'personCount'])))[0] || null
 
     if (eventResult) {
-      eventCount = eventResult.value;
+      eventCount = eventResult.value
     }
     if (personResult) {
-      personCount = personResult.value;
+      personCount = personResult.value
     }
 
-	} catch (e) {
-		console.error(e);
-	}
+  } catch (e) {
+    console.error(e)
+  }
 
   res.send({
     eventCount,
     personCount,
-    version: package.version,
-  });
-};
+    version: packageJson.version,
+  })
+}
+
+export default stats

crabfit-backend/routes/taskCleanup.js

@@ -1,46 +1,48 @@
-const dayjs = require('dayjs');
+import dayjs from 'dayjs'
 
-module.exports = async (req, res) => {
+const taskCleanup = async (req, res) => {
   if (req.header('X-Appengine-Cron') === undefined) {
-    return res.status(400).send('This task can only be run from a cron job');
+    return res.status(400).send('This task can only be run from a cron job')
   }
-  
-  const threeMonthsAgo = dayjs().subtract(3, 'month').unix();
 
-  console.log(`Running cleanup task at ${dayjs().format('h:mma D MMM YYYY')}`);
+  const threeMonthsAgo = dayjs().subtract(3, 'month').unix()
 
-	try {
+  console.log(`Running cleanup task at ${dayjs().format('h:mma D MMM YYYY')}`)
+
+  try {
     // Fetch events that haven't been visited in over 3 months
-    const eventQuery = req.datastore.createQuery(req.types.event).filter('visited', '<', threeMonthsAgo);
-		let oldEvents = (await req.datastore.runQuery(eventQuery))[0];
+    const eventQuery = req.datastore.createQuery(req.types.event).filter('visited', '<', threeMonthsAgo)
+    const oldEvents = (await req.datastore.runQuery(eventQuery))[0]
 
-		if (oldEvents && oldEvents.length > 0) {
-      let oldEventIds = oldEvents.map(e => e[req.datastore.KEY].name);
-      console.log(`Found ${oldEventIds.length} events to remove`);
+    if (oldEvents && oldEvents.length > 0) {
+      const oldEventIds = oldEvents.map(e => e[req.datastore.KEY].name)
+      console.log(`Found ${oldEventIds.length} events to remove`)
 
       // Fetch availabilities linked to the events discovered
-      let peopleDiscovered = 0;
-      await Promise.all(oldEventIds.map(async (eventId) => {
-        const peopleQuery = req.datastore.createQuery(req.types.person).filter('eventId', eventId);
-    		let oldPeople = (await req.datastore.runQuery(peopleQuery))[0];
+      let peopleDiscovered = 0
+      await Promise.all(oldEventIds.map(async eventId => {
+        const peopleQuery = req.datastore.createQuery(req.types.person).filter('eventId', eventId)
+        const oldPeople = (await req.datastore.runQuery(peopleQuery))[0]
 
         if (oldPeople && oldPeople.length > 0) {
-          peopleDiscovered += oldPeople.length;
-          await req.datastore.delete(oldPeople.map(person => person[req.datastore.KEY]));
+          peopleDiscovered += oldPeople.length
+          await req.datastore.delete(oldPeople.map(person => person[req.datastore.KEY]))
         }
-      }));
+      }))
 
-      await req.datastore.delete(oldEvents.map(event => event[req.datastore.KEY]));
+      await req.datastore.delete(oldEvents.map(event => event[req.datastore.KEY]))
 
-      console.log(`Cleanup successful: ${oldEventIds.length} events and ${peopleDiscovered} people removed`);
+      console.log(`Cleanup successful: ${oldEventIds.length} events and ${peopleDiscovered} people removed`)
 
-			res.sendStatus(200);
-		} else {
-      console.log(`Found 0 events to remove, ending cleanup`);
-			res.sendStatus(404);
-		}
-	} catch (e) {
-		console.error(e);
-		res.sendStatus(404);
-	}
-};
+      res.sendStatus(200)
+    } else {
+      console.log('Found 0 events to remove, ending cleanup')
+      res.sendStatus(404)
+    }
+  } catch (e) {
+    console.error(e)
+    res.sendStatus(404)
+  }
+}
+
+export default taskCleanup

crabfit-backend/routes/taskLegacyCleanup.js

@@ -1,68 +0,0 @@
-const dayjs = require('dayjs');
-
-module.exports = async (req, res) => {
-  if (req.header('X-Appengine-Cron') === undefined) {
-    return res.status(400).send('This task can only be run from a cron job');
-  }
-  
-  const threeMonthsAgo = dayjs().subtract(3, 'month').unix();
-
-  console.log(`Running LEGACY cleanup task at ${dayjs().format('h:mma D MMM YYYY')}`);
-
-	try {
-    // Fetch events that haven't been visited in over 3 months
-    const eventQuery = req.datastore.createQuery(req.types.event).order('created');
-		let oldEvents = (await req.datastore.runQuery(eventQuery))[0];
-
-    oldEvents = oldEvents.filter(event => !event.hasOwnProperty('visited'));
-
-		if (oldEvents && oldEvents.length > 0) {
-      console.log(`Found ${oldEvents.length} events that were missing a visited date`);
-
-      // Filter events that are older than 3 months and missing a visited date
-      oldEvents = oldEvents.filter(event => event.created < threeMonthsAgo);
-
-      if (oldEvents && oldEvents.length > 0) {
-        let oldEventIds = oldEvents.map(e => e[req.datastore.KEY].name);
-
-        // Fetch availabilities linked to the events discovered
-        let eventsRemoved = 0;
-        let peopleRemoved = 0;
-        await Promise.all(oldEventIds.map(async (eventId) => {
-          const peopleQuery = req.datastore.createQuery(req.types.person).filter('eventId', eventId);
-      		let oldPeople = (await req.datastore.runQuery(peopleQuery))[0];
-
-          let deleteEvent = true;
-          if (oldPeople && oldPeople.length > 0) {
-            oldPeople.forEach(person => {
-              if (person.created >= threeMonthsAgo) {
-                deleteEvent = false;
-              }
-            });
-          }
-          if (deleteEvent) {
-            if (oldPeople && oldPeople.length > 0) {
-              peopleRemoved += oldPeople.length;
-              await req.datastore.delete(oldPeople.map(person => person[req.datastore.KEY]));
-            }
-            eventsRemoved++;
-            await req.datastore.delete(req.datastore.key([req.types.event, eventId]));
-          }
-        }));
-
-        console.log(`Legacy cleanup successful: ${eventsRemoved} events and ${peopleRemoved} people removed`);
-
-  			res.sendStatus(200);
-    	} else {
-        console.log('Found 0 events that are older than 3 months and missing a visited date, ending LEGACY cleanup');
-    		res.sendStatus(404);
-    	}
-		} else {
-      console.error('Found no events that are missing a visited date, ending LEGACY cleanup [DISABLE ME!]');
-			res.sendStatus(404);
-		}
-	} catch (e) {
-		console.error(e);
-		res.sendStatus(404);
-	}
-};

crabfit-backend/routes/taskRemoveOrphans.js

@@ -1,46 +1,48 @@
-const dayjs = require('dayjs');
+import dayjs from 'dayjs'
 
-module.exports = async (req, res) => {
+const taskRemoveOrphans = async (req, res) => {
   if (req.header('X-Appengine-Cron') === undefined) {
-    return res.status(400).send('This task can only be run from a cron job');
+    return res.status(400).send('This task can only be run from a cron job')
   }
 
-  const threeMonthsAgo = dayjs().subtract(3, 'month').unix();
+  const threeMonthsAgo = dayjs().subtract(3, 'month').unix()
 
-  console.log(`Running orphan removal task at ${dayjs().format('h:mma D MMM YYYY')}`);
+  console.log(`Running orphan removal task at ${dayjs().format('h:mma D MMM YYYY')}`)
 
-	try {
+  try {
     // Fetch people that are older than 3 months
-    const peopleQuery = req.datastore.createQuery(req.types.person).filter('created', '<', threeMonthsAgo);
-		let oldPeople = (await req.datastore.runQuery(peopleQuery))[0];
+    const peopleQuery = req.datastore.createQuery(req.types.person).filter('created', '<', threeMonthsAgo)
+    const oldPeople = (await req.datastore.runQuery(peopleQuery))[0]
 
-		if (oldPeople && oldPeople.length > 0) {
-      console.log(`Found ${oldPeople.length} people older than 3 months, checking for events`);
+    if (oldPeople && oldPeople.length > 0) {
+      console.log(`Found ${oldPeople.length} people older than 3 months, checking for events`)
 
       // Fetch events linked to the people discovered
-      let peopleWithoutEvents = 0;
-      await Promise.all(oldPeople.map(async (person) => {
-        let event = (await req.datastore.get(req.datastore.key([req.types.event, person.eventId])))[0];
+      let peopleWithoutEvents = 0
+      await Promise.all(oldPeople.map(async person => {
+        const event = (await req.datastore.get(req.datastore.key([req.types.event, person.eventId])))[0]
 
         if (!event) {
-          peopleWithoutEvents++;
-          await req.datastore.delete(person[req.datastore.KEY]);
+          peopleWithoutEvents++
+          await req.datastore.delete(person[req.datastore.KEY])
         }
-      }));
+      }))
 
       if (peopleWithoutEvents > 0) {
-        console.log(`Orphan removal successful: ${oldEventIds.length} events and ${peopleDiscovered} people removed`);
-        res.sendStatus(200);
+        console.log(`Orphan removal successful: ${peopleWithoutEvents} people removed`)
+        res.sendStatus(200)
       } else {
-        console.log(`Found 0 people without events, ending orphan removal`);
-  			res.sendStatus(404);
+        console.log('Found 0 people without events, ending orphan removal')
+        res.sendStatus(404)
       }
-		} else {
-      console.log(`Found 0 people older than 3 months, ending orphan removal`);
-			res.sendStatus(404);
-		}
-	} catch (e) {
-		console.error(e);
-		res.sendStatus(404);
-	}
-};
+    } else {
+      console.log('Found 0 people older than 3 months, ending orphan removal')
+      res.sendStatus(404)
+    }
+  } catch (e) {
+    console.error(e)
+    res.sendStatus(404)
+  }
+}
+
+export default taskRemoveOrphans

crabfit-backend/routes/updatePerson.js

@@ -1,37 +1,40 @@
-const bcrypt = require('bcrypt');
+import bcrypt from 'bcrypt'
 
-module.exports = async (req, res) => {
-	const { eventId, personName } = req.params;
-	const { person } = req.body;
+const updatePerson = async (req, res) => {
+  const { eventId, personName } = req.params
+  const { person } = req.body
 
-	try {
-		const query = req.datastore.createQuery(req.types.person)
-			.filter('eventId', eventId)
-			.filter('name', personName);
-		let personResult = (await req.datastore.runQuery(query))[0][0];
+  try {
+    const query = req.datastore.createQuery(req.types.person)
+      .filter('eventId', eventId)
+      .filter('name', personName)
+    const personResult = (await req.datastore.runQuery(query))[0][0]
 
-		if (personResult) {
-			if (person && person.availability) {
-				if (personResult.password) {
-					const passwordsMatch = person.password && await bcrypt.compare(person.password, personResult.password);
-					if (!passwordsMatch) {
-						return res.status(401).send('Incorrect password');
-					}
-				}
+    if (personResult) {
+      if (person && person.availability) {
+        if (personResult.password) {
+          const passwordsMatch = person.password && await bcrypt.compare(person.password, personResult.password)
+          if (!passwordsMatch) {
+            return res.status(401).send('Incorrect password')
+          }
+        }
 
-				personResult.availability = person.availability;
+        await req.datastore.upsert({
+          ...personResult,
+          availability: person.availability,
+        })
 
-				await req.datastore.upsert(personResult);
+        res.sendStatus(200)
+      } else {
+        res.sendStatus(400)
+      }
+    } else {
+      res.sendStatus(404)
+    }
+  } catch (e) {
+    console.error(e)
+    res.sendStatus(400)
+  }
+}
 
-				res.sendStatus(200);
-			} else {
-				res.sendStatus(400);
-			}
-		} else {
-			res.sendStatus(404);
-		}
-	} catch (e) {
-		console.error(e);
-		res.sendStatus(400);
-	}
-};
+export default updatePerson

crabfit-backend/swagger.yaml

@@ -230,19 +230,6 @@ paths:
           description: "Not found"
         400:
           description: "Not called from a cron job"
-  "/tasks/legacyCleanup":
-    get:
-      summary: "Delete events inactive for more than 3 months that don't have a visited date"
-      operationId: "taskLegacyCleanup"
-      tags:
-        - tasks
-      responses:
-        200:
-          description: "OK"
-        404:
-          description: "Not found"
-        400:
-          description: "Not called from a cron job"
   "/tasks/removeOrphans":
     get:
       summary: "Deletes people if the event they were created under no longer exists"