Lint with eslint

Author: AlphaHydrae

.github/workflows/build.yml

@@ -25,6 +25,10 @@ jobs:
         run: |
           npm ci
 
+      - name: Analyze the code
+        run: |
+          npm run lint
+
       - name: Check source code formatting
         run: |
           npm run format

app.js

@@ -2,10 +2,10 @@ import cors from 'cors';
 import express from 'express';
 import createError from 'http-errors';
 import log4js from 'log4js';
-import { join as joinPath } from 'path';
+import { join as joinPath } from 'node:path';
 
-import { root } from './config.js';
 import router from './app/routes.js';
+import { root } from './config.js';
 
 export function createApplication(config, db) {
   const app = express();
@@ -33,10 +33,11 @@ export function createApplication(config, db) {
   // Allow cross origin requests (if enabled).
   if (config.cors) {
     const corsOptions = {};
-    if (config.corsOrigins.length) {
+    if (config.corsOrigins.length !== 0) {
       corsOptions.origin = config.corsOrigins;
     }
 
+    // eslint-disable-next-line sonarjs/cors
     app.use(cors(corsOptions));
   }
 
@@ -52,7 +53,13 @@ export function createApplication(config, db) {
   });
 
   // Global error handler
-  app.use((err, req, res, next) => {
+  app.use(createGlobalErrorHandler(config, logger));
+
+  return app;
+}
+
+function createGlobalErrorHandler(config, logger) {
+  return (err, req, res, _next) => {
     logger.warn(err);
 
     // Set locals, only providing error in development.
@@ -63,9 +70,7 @@ export function createApplication(config, db) {
     // Render the error page.
     res.status(err.status || 500);
     res.render('error');
-  });
-
-  return app;
+  };
 }
 
 function provideDefaultLocals(config) {

app/express.js

@@ -1,7 +1,6 @@
 export function route(func) {
-  return (req, res, next) => {
-    return Promise.resolve()
+  return (req, res, next) =>
+    Promise.resolve()
       .then(() => func(req, res, next))
       .catch(next);
-  };
 }

app/share/share.middlewares.js

@@ -2,7 +2,7 @@ import { createComment, getComments } from '../../db.js';
 import { route } from '../express.js';
 import { getValidationErrors } from '../validation.js';
 
-export const sharePage = route(async (req, res) => {
+export const sharePage = route((req, res) => {
   res.render('share/share', {
     pageTitle: 'Share your experience'
   });
@@ -11,7 +11,8 @@ export const sharePage = route(async (req, res) => {
 export const share = route(async (req, res) => {
   const errors = getValidationErrors(req.body, 'comment');
   if (errors) {
-    return res.redirect('/');
+    res.redirect('/');
+    return;
   }
 
   const { name, text } = req.body;
@@ -31,8 +32,11 @@ export const listComments = route(async (req, res) => {
 
   res.send(
     comments
-      .sort((a, b) => b.date.valueOf() - a.date.valueOf())
-      .map(commentToJson)
+      .sort(
+        (firstComment, secondComment) =>
+          secondComment.date.valueOf() - firstComment.date.valueOf()
+      )
+      .map(comment => commentToJson(comment))
   );
 });
 

app/validation.js

@@ -1,8 +1,8 @@
 import Ajv from 'ajv';
 import ajvErrors from 'ajv-errors';
 import glob from 'fast-glob';
-import { readFile } from 'fs/promises';
-import { basename, join as joinPath } from 'path';
+import { readFile } from 'node:fs/promises';
+import { basename, join as joinPath } from 'node:path';
 
 import { root } from '../config.js';
 
@@ -14,18 +14,24 @@ ajvErrors(ajv);
 
 export async function loadSchemas(config) {
   const logger = config.createLogger('validation');
-  for (const file of await findSchemas(logger)) {
-    const { name, schema } = await loadSchema(file);
-    ajv.addSchema(schema, name);
-    logger.trace(`Loaded "${name}" JSON schema from ${file}`);
-  }
+
+  const files = await findSchemas(logger);
+  await Promise.all(
+    files.map(async file => {
+      const { name, schema } = await loadSchema(file);
+      ajv.addSchema(schema, name);
+      logger.trace(`Loaded "${name}" JSON schema from ${file}`);
+    })
+  );
 }
 
 export function getValidationErrors(data, schemaName) {
   const validate = getSchema(schemaName);
   if (!validate(data)) {
     return validate.errors;
   }
+
+  return undefined;
 }
 
 async function findSchemas(logger) {
@@ -50,7 +56,7 @@ function getSchema(name) {
 }
 
 async function loadSchema(file) {
-  const schemaName = basename(file).replace(/\..*$/, '');
+  const schemaName = basename(file).replace(/\.schema\.json$/u, '');
   if (ajv.getSchema(schemaName)) {
     throw new Error(
       `JSON schema ${schemaName} (from file ${file}) has already been defined`

bin.js

@@ -3,9 +3,10 @@ import chalk from 'chalk';
 
 import start from './start.js';
 
-Promise.resolve()
-  .then(start)
-  .catch(err => {
-    console.error(chalk.red(err.stack));
-    process.exit(1);
-  });
+try {
+  await start();
+} catch (err) {
+  // eslint-disable-next-line no-console
+  console.error(chalk.red(err.stack));
+  process.exit(1);
+}

config.js

@@ -1,39 +1,45 @@
 import { identity, isInteger } from 'lodash-es';
 import log4js from 'log4js';
-import { dirname, resolve as resolvePath } from 'path';
-import { fileURLToPath } from 'url';
+import { dirname, resolve as resolvePath } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const logLevels = ['FATAL', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE'];
 
 export const root = dirname(fileURLToPath(import.meta.url));
 
+// eslint-disable-next-line max-lines-per-function
 export async function loadConfig() {
   await loadDotenv();
 
-  const env = process.env.NODE_ENV ?? 'development';
+  const environment = process.env.NODE_ENV ?? 'development';
 
   const dbFile = resolvePath(
     root,
-    parseEnvString('REVPROD_DB_FILE', 'db.json')
+    parseEnvironmentString('REVPROD_DB_FILE', 'db.json')
   );
 
-  const host = parseEnvString('REVPROD_LISTEN_HOST', '0.0.0.0');
-  const port = parseEnvPort('REVPROD_LISTEN_PORT', 3000);
+  const host = parseEnvironmentString('REVPROD_LISTEN_HOST', '0.0.0.0');
+  const port = parseEnvironmentPort('REVPROD_LISTEN_PORT', 3000);
 
-  const logLevel = parseEnvEnum(
+  const logLevel = parseEnvironmentEnum(
     'REVPROD_LOG_LEVEL',
     logLevels,
-    env === 'production' ? 'DEBUG' : 'TRACE',
+    environment === 'production' ? 'DEBUG' : 'TRACE',
     value => value.toUpperCase()
   );
 
-  const cors = parseEnvBoolean('REVPROD_CORS', false);
-  const corsOrigins = parseEnvString('REVPROD_CORS_ORIGINS', [], origins =>
-    origins.split(',')
+  const cors = parseEnvironmentBoolean('REVPROD_CORS', false);
+  const corsOrigins = parseEnvironmentString(
+    'REVPROD_CORS_ORIGINS',
+    [],
+    origins => origins.split(',')
   );
 
-  const title = parseEnvString('REVPROD_TITLE', 'The Revolutionary Product');
-  const landingPageBaseUrl = parseEnvString(
+  const title = parseEnvironmentString(
+    'REVPROD_TITLE',
+    'The Revolutionary Product'
+  );
+  const landingPageBaseUrl = parseEnvironmentString(
     'REVPROD_LANDING_PAGE_BASE_URL',
     ''
   );
@@ -45,20 +51,20 @@ export async function loadConfig() {
   }
 
   const logger = createLogger('config');
-  logger.info(`Environment: ${env}`);
+  logger.info(`Environment: ${environment}`);
   logger.info(`Log level: ${logLevel}`);
   logger.info(`CORS enabled: ${cors}`);
   logger.info(
     `CORS allowed origins: ${
-      corsOrigins.length ? corsOrigins.join(', ') : 'all'
+      corsOrigins.length === 0 ? 'all' : corsOrigins.join(', ')
     }`
   );
 
   return {
     // Paths
     dbFile,
     // Environment,
-    env,
+    env: environment,
     // Server
     host,
     port,
@@ -77,7 +83,7 @@ async function loadDotenv() {
   let dotenv;
   try {
     dotenv = await import('dotenv');
-  } catch (err) {
+  } catch {
     // Ignore
   }
 
@@ -86,40 +92,45 @@ async function loadDotenv() {
   }
 }
 
-function getEnvString(varName, required = true) {
-  const value = process.env[varName];
+function getEnvironmentString(variableName, required = true) {
+  const value = process.env[variableName];
   if (required && value === undefined) {
-    throw new Error(`$${varName} is required`);
+    throw new Error(`$${variableName} is required`);
   }
 
   return value;
 }
 
-function parseEnvBoolean(varName, defaultValue) {
-  const value = getEnvString(varName, defaultValue === undefined);
+function parseEnvironmentBoolean(variableName, defaultValue) {
+  const value = getEnvironmentString(variableName, defaultValue === undefined);
   if (value === undefined) {
     return defaultValue;
-  } else if (value.match(/^(?:1|y|yes|t|true)$/u)) {
+  } else if (/^(?:1|y|yes|t|true)$/u.text(value)) {
     return true;
-  } else if (value.match(/^(?:0|n|no|f|false)$/u)) {
+  } else if (/^(?:0|n|no|f|false)$/u.test(value)) {
     return false;
-  } else {
-    throw new Error(
-      `$${varName} must be a boolean, but its value is ${JSON.stringify(value)}`
-    );
   }
+
+  throw new Error(
+    `$${variableName} must be a boolean, but its value is ${JSON.stringify(value)}`
+  );
 }
 
-function parseEnvEnum(varName, allowedValues, defaultValue, coerce = identity) {
-  const value = getEnvString(varName, defaultValue === undefined);
+function parseEnvironmentEnum(
+  variableName,
+  allowedValues,
+  defaultValue,
+  coerce = identity
+) {
+  const value = getEnvironmentString(variableName, defaultValue === undefined);
   if (value === undefined) {
     return defaultValue;
   }
 
   const coerced = coerce(value);
   if (!allowedValues.includes(coerced)) {
     throw new Error(
-      `$${varName} must be one of ${allowedValues
+      `$${variableName} must be one of ${allowedValues
         .map(allowed => JSON.stringify(allowed))
         .join(', ')}, but its value is ${JSON.stringify(coerced)}`
     );
@@ -128,20 +139,20 @@ function parseEnvEnum(varName, allowedValues, defaultValue, coerce = identity) {
   return coerced;
 }
 
-function parseEnvInt(varName, defaultValue, min, max) {
-  const value = getEnvString(varName, defaultValue === undefined);
+function parseEnvironmentInt(variableName, defaultValue, min, max) {
+  const value = getEnvironmentString(variableName, defaultValue === undefined);
   if (value === undefined) {
     return defaultValue;
   }
 
-  const parsed = parseInt(value, 10);
+  const parsed = Number.parseInt(value, 10);
   if (
     !isInteger(parsed) ||
     (min !== undefined && value < min) ||
     (max !== undefined && value > max)
   ) {
     throw new Error(
-      `$${varName} must be an integer between ${min ?? '-Infinity'} and ${
+      `$${variableName} must be an integer between ${min ?? '-Infinity'} and ${
         max ?? 'Infinity'
       }, but its value is ${JSON.stringify(value)}`
     );
@@ -150,12 +161,12 @@ function parseEnvInt(varName, defaultValue, min, max) {
   return parsed;
 }
 
-function parseEnvPort(varName, defaultValue) {
-  return parseEnvInt(varName, defaultValue, 1, 65_535);
+function parseEnvironmentPort(variableName, defaultValue) {
+  return parseEnvironmentInt(variableName, defaultValue, 1, 65_535);
 }
 
-function parseEnvString(varName, defaultValue, coerce = identity) {
-  const value = getEnvString(varName, defaultValue === undefined);
+function parseEnvironmentString(variableName, defaultValue, coerce = identity) {
+  const value = getEnvironmentString(variableName, defaultValue === undefined);
   if (value === undefined) {
     return defaultValue;
   }