app_vue2/services/connection/connection.ts

import { NuxtAxiosInstance } from '@nuxtjs/axios'
import { AxiosRequestConfig } from 'axios'
import { AnyJson, DataPersisterArgs, DataProviderArgs } from '~/types/interfaces'
import { HTTP_METHOD } from '~/types/enums'

/**
 * @category Services/connection
 * @class Connection
 * Classe Wrapper du connecteur de requete (Axios dans notre cas)
 */
class Connection {
  static connector:NuxtAxiosInstance;

  /**
   * Initialisation du connecteur (Axios dans notre cas)
   * @param {NuxtAxiosInstance} connector
   */
  static initConnector (connector: NuxtAxiosInstance) {
    Connection.connector = connector
  }

  /**
   * Main méthode qui apperlera les méthode privées correspondantes (getItem, getCollection, put, post, delete)
   * @param {HTTP_METHOD} method de requetage
   * @param {string} url
   * @param {DataProviderArgs|DataPersisterArgs} args
   * @return {Promise<any>}
   */
  invoke (method: HTTP_METHOD, url: string, args:DataProviderArgs|DataPersisterArgs): Promise<any> {
    switch (method) {
      case HTTP_METHOD.GET:
        if (args.id) { return this.getItem(url, args.id, args.progress) } else { return this.getCollection(url, args.progress) }

      case HTTP_METHOD.PUT:
        if (this.isArgsIsDataPersisterArgs(args)) {
          if (!args.data) { throw new Error('data not found') }

          return this.put(url, args.id, args.data, args.progress)
        } else { throw new Error('args not a dataPersisterArgs') }

      case HTTP_METHOD.DELETE:
        return this.deleteItem(url, args.id, args.progress)
    }

    throw new Error('Method unknown')
  }

  /**
   * GET Item : préparation de la config pour la récupération d'un item
   * @param {string} url
   * @param {number} id
   * @param {boolean} progress
   * @return {Promise<any>}
   */
  private getItem (url: string, id: number, progress: boolean = true): Promise<any> {
    const config:AxiosRequestConfig = {
      url: `${url}/${id}`,
      method: HTTP_METHOD.GET,
      progress
    }
    return this.request(config)
  }

  /**
   * Get collection : préparation de la config pour la récupération d'une collection d'items
   * @param {string} url
   * @param {boolean} progress
   * @return {Promise<any>}
   */
  private getCollection (url: string, progress: boolean = true): Promise<any> {
    const config:AxiosRequestConfig = {
      url: `${url}`,
      method: HTTP_METHOD.GET,
      progress
    }
    return this.request(config)
  }

  /**
   * Put : préparation de la config pour la mise à jour d'un item
   * @param {string} url
   * @param {number} id
   * @param {AnyJson} data
   * @param {boolean} progress
   * @return {Promise<any>}
   */
  private put (url: string, id: number, data: AnyJson, progress: boolean = true): Promise<any> {
    const config:AxiosRequestConfig = {
      url: `${url}/${id}`,
      method: HTTP_METHOD.PUT,
      data,
      progress
    }
    return this.request(config)
  }

  /**
   * DELETE Item : préparation de la config pour la suppression d'un item
   * @param {string} url
   * @param {number} id
   * @param {boolean} progress
   * @return {Promise<any>}
   */
  private deleteItem (url: string, id: number, progress: boolean = true): Promise<any> {
    const config:AxiosRequestConfig = {
      url: `${url}/${id}`,
      method: HTTP_METHOD.DELETE,
      progress
    }
    return this.request(config)
  }

  /**
   * Exécution de la requete
   * @param {AxiosRequestConfig} config
   * @return {Promise<any>}
   */
  private async request (config:AxiosRequestConfig): Promise<any> {
    return await Connection.connector.$request(config)
  }

  /**
   * Test si l'argument est bien de type DataPersister
   * @param args
   */
  private isArgsIsDataPersisterArgs (args:DataProviderArgs|DataPersisterArgs): args is DataPersisterArgs {
    return (args as DataPersisterArgs).data !== undefined
  }
}

export default Connection