Add ESLint, Prettier, and pre-commit checks

.babelrc

@@ -1,11 +1,12 @@
 {
-  "presets": [
-    "next/babel"
-  ],
+  "presets": ["next/babel"],
   "plugins": [
-    ["styled-components", {
-      "displayName": false,
-      "ssr": true
-    }]
+    [
+      "styled-components",
+      {
+        "displayName": false,
+        "ssr": true
+      }
+    ]
   ]
 }

.husky/pre-commit

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+yarn lint-staged

.prettierignore

@@ -0,0 +1,11 @@
+.next
+node_modules
+coverage
+dist
+build
+out
+test-results
+public/static
+.yarn
+.pnp.*
+yarn.lock

.prettierrc.json

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "all",
+  "arrowParens": "avoid",
+  "printWidth": 120
+}

README.md

@@ -22,7 +22,6 @@ In addition to the software requirements, you need access to the following APIs:
 - [Discogs](https://www.discogs.com/applications/edit) for searching and getting release info
 - [Last.fm](https://www.last.fm/api/account/create) for authentication and scrobbling data
 
-
 ### Installing
 
 First you need to clone the repository from github:
@@ -85,6 +84,7 @@ yarn test
 ```
 
 You can also use watch-mode and display the current test coverage:
+
 ```
 yarn test:watch
 yarm test:coverage
@@ -110,7 +110,7 @@ yarn start
 
 ## Authors
 
-* **Daniel Puscher** - *Initial work* - [dpuscher](https://github.com/dpuscher)
+- **Daniel Puscher** - _Initial work_ - [dpuscher](https://github.com/dpuscher)
 
 See also the list of [contributors](https://github.com/dpuscher/code-scrobble/contributors) who participated in this project.
 

app/__mocks__/redis.ts

@@ -2,10 +2,10 @@
 
 const store = new Map();
 
-const mockGet = jest.fn(async (key) => store.get(key) || null);
+const mockGet = jest.fn(async key => store.get(key) || null);
 const mockSet = jest.fn(async (key, value) => {
   store.set(key, value);
-  return 'OK';
+  return "OK";
 });
 const mockConnect = jest.fn(async () => {});
 const mockOn = jest.fn();

app/cache.ts

@@ -1,11 +1,10 @@
-import { createClient } from 'redis';
+import { createClient } from "redis";
 
 const client = createClient({ url: process.env.REDISCLOUD_URL });
 client.connect().catch(console.error);
-client.on('error', console.error);
+client.on("error", console.error);
 
-export const set = (key: string, value: unknown, ttl = 86400) =>
-  client.set(key, JSON.stringify(value), { EX: ttl });
+export const set = (key: string, value: unknown, ttl = 86400) => client.set(key, JSON.stringify(value), { EX: ttl });
 
 export const get = async <T = unknown>(key: string): Promise<T> => {
   const value = await client.get(key);

app/discogs.ts

@@ -1,10 +1,10 @@
-import orderBy from 'lodash/orderBy';
-import pick from 'lodash/pick';
-import find from 'lodash/find';
-import * as Cache from './cache';
+import orderBy from "lodash/orderBy";
+import pick from "lodash/pick";
+import find from "lodash/find";
+import * as Cache from "./cache";
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
-const DiscogsClient = require('disconnect').Client;
+const DiscogsClient = require("disconnect").Client;
 
 interface DiscogsError {
   statusCode: number;
@@ -71,19 +71,17 @@ const Database = new DiscogsClient({
 const convertTimecode = (timecode: string | undefined): number => {
   if (!timecode) return 0;
   return timecode
-    .split(':')
-    .map(n => (parseInt(n, 10) || 0))
+    .split(":")
+    .map(n => parseInt(n, 10) || 0)
     .reverse()
-    .map((n, i) => n * (60 ** i))
+    .map((n, i) => n * 60 ** i)
     .reduce((pv, cv) => pv + cv);
 };
 
 const normalizeTracklist = (tracks: DiscogsTrack[]): DiscogsTrack[] => {
   const vinylPositionRegex = /^[A-Z]-?[0-9]+$/;
   // eslint-disable-next-line no-underscore-dangle
-  let tracklist = tracks
-    .filter(track => track.type_ === 'track')
-    .filter(track => !/video/i.test(track.position));
+  let tracklist = tracks.filter(track => track.type_ === "track").filter(track => !/video/i.test(track.position));
 
   // Remove Bonus CDs from vinyl releases:
   if (tracklist.length && vinylPositionRegex.test(tracklist[0].position)) {
@@ -97,67 +95,70 @@ const normalizeTracklist = (tracks: DiscogsTrack[]): DiscogsTrack[] => {
 };
 
 const getBarcode = (data: DiscogsIdentifier[] = []): string | undefined =>
-  (find(data, { type: 'Barcode' }) || {}).value;
+  (find(data, { type: "Barcode" }) || {}).value;
 
 const buildRelease = (id: number, data: DiscogsData): ReleaseData => ({
   id,
-  artist: (data.artists || []).map(a => a.name).join(', '),
+  artist: (data.artists || []).map(a => a.name).join(", "),
   title: data.title,
   image: data?.images?.[0]?.uri,
   url: data.uri,
   year: data.year,
-  tracks: normalizeTracklist(data.tracklist || [])
-    .map((track, index) => ({
-      title: track.title,
-      trackNumber: index + 1,
-      duration: convertTimecode(track.duration),
-    })),
+  tracks: normalizeTracklist(data.tracklist || []).map((track, index) => ({
+    title: track.title,
+    trackNumber: index + 1,
+    duration: convertTimecode(track.duration),
+  })),
   barcode: getBarcode(data.identifiers),
 });
 
 export const barcode = (barcodeValue: string): Promise<number | undefined> =>
-  new Promise((resolve) => {
+  new Promise(resolve => {
     const cacheKey = `barcode--${barcodeValue}`;
 
     Cache.get<number>(cacheKey)
-      .then((result) => {
+      .then(result => {
         resolve(result);
       })
       .catch(() => {
-        Database.search(undefined, { barcode: barcodeValue, type: 'release' }, (err: DiscogsError, data: { results: DiscogsSearchResult[] }) => {
-          if (err || !data || !data.results || !data.results.length) {
-            return resolve(undefined);
-          }
-          const results = orderBy(
-            data.results,
-            ['community.have', 'community.want'],
-            ['desc', 'desc'],
-          ) as DiscogsSearchResult[];
+        Database.search(
+          undefined,
+          { barcode: barcodeValue, type: "release" },
+          (err: DiscogsError, data: { results: DiscogsSearchResult[] }) => {
+            if (err || !data || !data.results || !data.results.length) {
+              return resolve(undefined);
+            }
+            const results = orderBy(
+              data.results,
+              ["community.have", "community.want"],
+              ["desc", "desc"],
+            ) as DiscogsSearchResult[];
 
-          Cache.set(cacheKey, results[0].id);
+            Cache.set(cacheKey, results[0].id);
 
-          return resolve(results[0].id);
-        });
+            return resolve(results[0].id);
+          },
+        );
       });
   });
 
 export const search = (query: string): Promise<SearchResult[] | undefined> =>
-  new Promise((resolve) => {
+  new Promise(resolve => {
     const cacheKey = `search--${query}`;
 
     Cache.get<SearchResult[]>(cacheKey)
-      .then((results) => {
+      .then(results => {
         resolve(results);
       })
       .catch(() => {
         // eslint-disable-next-line consistent-return
-        Database.search(query, { type: 'release' }, (err: DiscogsError, data: { results: any[] }) => {
+        Database.search(query, { type: "release" }, (err: DiscogsError, data: { results: any[] }) => {
           if (err || !data || !data.results || !data.results.length) {
             return resolve(undefined);
           }
 
           const results: SearchResult[] = data.results.map(result =>
-            pick(result, ['id', 'title', 'thumb', 'country', 'year', 'format', 'uri']),
+            pick(result, ["id", "title", "thumb", "country", "year", "format", "uri"]),
           );
 
           Cache.set(cacheKey, results);
@@ -174,7 +175,7 @@ export const getRelease = (id: number): Promise<ReleaseData> =>
         if (err.statusCode === 404) {
           Database.getMaster(id, (masterErr: DiscogsError, masterData: DiscogsData) => {
             if (masterErr || !masterData) {
-              reject(masterErr || new Error('No data returned from Discogs'));
+              reject(masterErr || new Error("No data returned from Discogs"));
             } else {
               resolve(buildRelease(id, masterData));
             }
@@ -183,7 +184,7 @@ export const getRelease = (id: number): Promise<ReleaseData> =>
           reject(err);
         }
       } else if (!data) {
-        reject(new Error('No data returned from Discogs'));
+        reject(new Error("No data returned from Discogs"));
       } else {
         resolve(buildRelease(id, data));
       }

app/lastfm.ts

@@ -1,5 +1,5 @@
 // eslint-disable-next-line @typescript-eslint/no-require-imports
-const LastFMApi = require('lastfmapi');
+const LastFMApi = require("lastfmapi");
 
 interface ScrobbleTrack {
   album: string;
@@ -28,7 +28,7 @@ const getScrobble = (data: ReleaseForScrobble): ScrobbleTrack[] => {
   let nextTimestamp = Math.floor(Date.now() / 1000);
   const trackData: ScrobbleTrack[] = [];
 
-  data.tracks.forEach((track) => {
+  data.tracks.forEach(track => {
     trackData.push({
       album: data.title,
       artist: data.artist,
@@ -44,27 +44,21 @@ const getScrobble = (data: ReleaseForScrobble): ScrobbleTrack[] => {
 
 export const scrobbleTracks = (username: string, key: string, data: ReleaseForScrobble): Promise<unknown> =>
   new Promise((resolve, reject) => {
-    createApiClient(username, key).track.scrobble(
-      getScrobble(data),
-      (err: unknown, scrobbles: unknown) => {
-        if (err) reject(err);
-        resolve(scrobbles);
-      },
-    );
+    createApiClient(username, key).track.scrobble(getScrobble(data), (err: unknown, scrobbles: unknown) => {
+      if (err) reject(err);
+      resolve(scrobbles);
+    });
   });
 
 export interface LastFMUserData {
   url: string;
-  image?: Array<{ '#text': string }>;
+  image?: Array<{ "#text": string }>;
 }
 
 export const getUserData = (username: string, key: string): Promise<LastFMUserData> =>
   new Promise((resolve, reject) => {
-    createApiClient(username, key).user.getInfo(
-      null,
-      (err: unknown, userData: unknown) => {
-        if (err) reject(err);
-        resolve(userData as LastFMUserData);
-      },
-    );
+    createApiClient(username, key).user.getInfo(null, (err: unknown, userData: unknown) => {
+      if (err) reject(err);
+      resolve(userData as LastFMUserData);
+    });
   });

app/models/release.ts

@@ -1,6 +1,6 @@
-import mongoose, { Schema, HydratedDocument, Model } from 'mongoose';
-import pick from 'lodash/pick';
-import * as Discogs from '../discogs';
+import mongoose, { Schema, HydratedDocument, Model } from "mongoose";
+import pick from "lodash/pick";
+import * as Discogs from "../discogs";
 
 interface ITrack {
   title: string;
@@ -27,7 +27,10 @@ interface IReleaseMethods {
 
 interface IReleaseModel extends Model<IRelease, object, IReleaseMethods> {
   createFromDiscogs(id: number, barcode?: string): Promise<HydratedDocument<IRelease, IReleaseMethods>>;
-  firstOrCreate(param: { id?: string | number; barcode?: string }): Promise<HydratedDocument<IRelease, IReleaseMethods> | null>;
+  firstOrCreate(param: {
+    id?: string | number;
+    barcode?: string;
+  }): Promise<HydratedDocument<IRelease, IReleaseMethods> | null>;
 }
 
 const releaseSchema = new Schema<IRelease, IReleaseModel, IReleaseMethods>(
@@ -41,11 +44,13 @@ const releaseSchema = new Schema<IRelease, IReleaseModel, IReleaseMethods>(
     image: String,
     url: String,
     year: String,
-    tracks: [{
-      title: String,
-      trackNumber: Number,
-      duration: Number,
-    }],
+    tracks: [
+      {
+        title: String,
+        trackNumber: Number,
+        duration: Number,
+      },
+    ],
     barcode: String,
   },
   { timestamps: true },
@@ -60,7 +65,7 @@ releaseSchema.methods.toJSON = function toJSON() {
     image: this.image,
     url: this.url,
     year: this.year,
-    tracks: this.tracks.map((track: ITrack) => pick(track, ['title', 'trackNumber', 'duration'])),
+    tracks: this.tracks.map((track: ITrack) => pick(track, ["title", "trackNumber", "duration"])),
   };
 };
 
@@ -82,7 +87,7 @@ releaseSchema.methods.updateFromDiscogs = async function updateFromDiscogs() {
 };
 
 releaseSchema.statics.createFromDiscogs = async function createFromDiscogs(id: number, barcodeValue?: string) {
-  const release = new (this)({ id });
+  const release = new this({ id });
   if (barcodeValue) release.barcode = barcodeValue;
   await release.updateFromDiscogs();
   return release;
@@ -92,12 +97,13 @@ releaseSchema.statics.firstOrCreate = async function firstOrCreate(param: { id?:
   const release = await this.findOne(param).exec();
   if (!release) {
     const paramId = param.id ? Number(param.id) : undefined;
-    const id = paramId || await Discogs.barcode(param.barcode);
+    const id = paramId || (await Discogs.barcode(param.barcode));
     if (!id) return null;
 
     try {
       return await this.createFromDiscogs(id, param.barcode);
-    } catch (err: any) { // eslint-disable-line @typescript-eslint/no-explicit-any
+    } catch (err: any) {
+      // eslint-disable-line @typescript-eslint/no-explicit-any
       if (err.code === 11000) {
         return this.findOne({ id }).exec();
       }
@@ -113,7 +119,7 @@ releaseSchema.statics.firstOrCreate = async function firstOrCreate(param: { id?:
   return release;
 };
 
-const Release = (mongoose.models.Release as IReleaseModel) ||
-  mongoose.model<IRelease, IReleaseModel>('Release', releaseSchema);
+const Release =
+  (mongoose.models.Release as IReleaseModel) || mongoose.model<IRelease, IReleaseModel>("Release", releaseSchema);
 
 export default Release;