DONE

services/NotesService.js

@@ -0,0 +1,182 @@
+//const data = require('../repositories/data.json')
+import * as path from 'path'
+import * as fs from 'fs'
+
+class NotesService {
+  dbPath
+  db
+  limit
+
+  constructor () {
+
+    this.dbPath = path.resolve('./repositories/data.json')
+
+    try {
+      const data = fs.readFileSync(this.dbPath, 'utf8')
+      this.db = JSON.parse(data || '[]')
+    } catch (e) {
+      this.db = []
+    }
+
+    this.limit = 7
+
+  }
+
+  /**
+   * USE AT FINAL STAGE BEFORE RETURN FROM THE METHOD TO AVOID HELTER SKELTER IN THE RESULT
+   *
+   * @param result
+   * @param query
+   * @returns {*|{result: null, data: *[], query: null, message: string, type: string, status: string}}
+   * @private
+   */
+  _composeResponse (result, query) {
+
+    const response = {
+      code: 200,
+      status: 'Accepted',
+      message: `The database contains ${this.db.length} notes`,
+      result: `Matched ${result.length} note(s)`,
+      query: query,
+      type: 'Completed',
+      data: [],
+    }
+
+    if (result.length === 1) {
+      response.data = result[0]
+    } else if (result.length > 1) {
+      response.data = result
+    } else {
+      response.code = 404
+      response.type = 'Warning'
+    }
+
+    return response
+  }
+
+  /**
+   *
+   * @param id
+   * @returns {*|{result: null, data: *[], query: null, message: string, type: string, status: string}}
+   */
+  getSingle (id) {
+    //, returned LIMIT ${this.limit} ORDER BY id DESC
+    const note = this.db.filter(el => el.id === +id)
+    return this._composeResponse(note, `id = ${id} LIMIT 1`)
+  }
+
+  /**
+   *
+   * @returns {*|{result: null, data: *[], query: null, message: string, type: string, status: string}}
+   */
+  get getNotes () {
+    const notes = this.db.sort((a, b) => new Date(a.created_at) > new Date(b.created_at) ? -1 : 1)
+    return this._composeResponse(notes.slice(0, this.limit), `ORDER BY created_at DESC LIMIT ` + this.limit)
+  }
+
+  /**
+   *
+   * @param id
+   * @returns {Promise<*|{result: null, data: *[], query: null, message: string, type: string, status: string}>}
+   */
+  async deleteNote (id) {
+    const deletedNote = this.db.filter(note => note.id === +id)
+
+    if (deletedNote.length === 1) {
+      this.db = this.db.filter(note => note.id !== +id)
+      await this.saveDatabase()
+    }
+
+    return this._composeResponse(deletedNote, `DELETED FROM db WHERE id = ${id}`)
+  }
+
+  /**
+   *
+   * @param data
+   * @returns {Promise<*|{result: null, data: *[], query: null, message: string, type: string, status: string}>}
+   */
+  async insertNote( data ){
+
+    const notes = this.db.sort((a, b) => new Date(a.id) > new Date(b.id) ? -1 : 1)
+    data.id = ( notes.length >= 1 ) ? notes[0].id + 1 : 1
+    this.db.push(data)
+    await this.saveDatabase()
+
+    return this._composeResponse([data], `INSERT INTO database SET id = ${data.id} (AI)`)
+  }
+
+  /**
+   *
+   * @param data
+   * @returns {Promise<*|{result: null, data: *[], query: null, message: string, type: string, status: string}>}
+   */
+  async updateNote( data ){
+
+    const noteExists = this.db.find(note => note.id === +data.id)
+
+    if( noteExists ){
+      noteExists.title = data.title
+      noteExists.content = data.content
+      noteExists.category = data.category
+      noteExists.archive = data.archive
+      noteExists.updated_at = data.updated_at
+
+      await this.saveDatabase()
+      return this._composeResponse([noteExists], `UPDATED WHERE id = ${data.id}`)
+    }
+
+    return this._composeResponse([], `UPDATED WHERE id = ${data.id}`)
+
+
+  }
+
+  /**
+   *
+   * @returns {Promise<void>}
+   */
+  async saveDatabase () {
+    try {
+      await fs.promises.writeFile(this.dbPath, JSON.stringify(this.db, null, 2), { encoding: 'utf-8' })
+    } catch (e) {
+      console.error(e)
+    }
+  }
+
+  /**
+   *
+   * @returns {{result: string, data: {}, query: string, message: string, status: string}}
+   */
+  get getStats () {
+
+    const stats = {}
+    const cats = [...new Set(this.db.map(item => item.category))]
+
+    if (typeof cats[0] !== 'undefined') {
+      const isArchive = this.db.map(item => {
+        const container = {}
+        container[item.category] = item.archive
+        return container
+      })
+
+      cats.forEach((cat, i) => {
+        stats[cat] = {
+          total: this.db.filter(el => el.category === cat).length,
+          archived: isArchive.filter(el => el[cat] === true).length,
+          active: isArchive.filter(el => el[cat] === false).length,
+        }
+      })
+    }
+
+    return {
+      code: 200,
+      status: 'Accepted',
+      message: `The database contains ${this.db.length} notes`,
+      result: `Aggregated data statistics`,
+      query: `GROUP BY categories, (active|archived)`,
+      type: 'Completed',
+      data: stats,
+    }
+  }
+}
+
+export default NotesService

services/ValidationService.js

@@ -0,0 +1,32 @@
+import { setResp400 } from '../helpers/http.js'
+import { extractProps } from '../helpers/utils.js'
+import {webFields} from '../repositories/schema.js'
+
+/**
+ *
+ * @param schema
+ * @returns {(function(*, *, *): Promise<*|undefined>)|*}
+ */
+export const id = (schema) => async (req, res, next) => {
+
+  let objToValidate
+
+  if (req.method === 'POST' || req.method === 'PATCH') {
+
+    if (req.method === 'PATCH'){
+      webFields.id = null
+    }
+
+    objToValidate = extractProps(webFields, req.body)
+  }else{
+    const { id } = req.params
+    objToValidate = id
+  }
+
+  try {
+    req.validatedData = await schema.validate(objToValidate)
+    next()
+  } catch (error) {
+    return res.status(400).json(setResp400(error.name || null, error.message || null  ))
+  }
+}