refactor data managers and data processors

services/connection/connection.ts

@@ -1,6 +1,6 @@
 import { NuxtAxiosInstance } from '@nuxtjs/axios'
 import { AxiosRequestConfig } from 'axios'
-import { AnyJson, DataPersisterArgs, DataProviderArgs } from '~/types/interfaces'
+import { AnyJson, DataPersisterArgs, DataProviderArgs, UrlArgs } from '~/types/interfaces'
 import { HTTP_METHOD } from '~/types/enums'
 
 /**
@@ -27,13 +27,13 @@ class Connection {
    * @param {DataProviderArgs|DataPersisterArgs} args
    * @return {Promise<any>}
    */
-  public static invoke (method: HTTP_METHOD, url: string, args: DataProviderArgs | DataPersisterArgs): Promise<any> {
+  public static invoke (method: HTTP_METHOD, url: string, args: UrlArgs): Promise<any> {
     switch (method) {
       case HTTP_METHOD.GET:
         if (args.id) {
-          return Connection.getItem(url, args.id, args.progress)
+          return Connection.getItem(url, args.id, args.showProgress)
         } else {
-          return Connection.getCollection(url, args.progress)
+          return Connection.getCollection(url, args.showProgress)
         }
 
       case HTTP_METHOD.PUT:
@@ -43,10 +43,10 @@ class Connection {
         if (!args.data) {
           throw new Error('*args* has no data')
         }
-        return Connection.put(url, args.id, args.data, args.progress)
+        return Connection.put(url, args.id, args.data, args.showProgress)
 
       case HTTP_METHOD.DELETE:
-        return Connection.deleteItem(url, args.id, args.progress)
+        return Connection.deleteItem(url, args.id, args.showProgress)
     }
 
     throw new Error('Unknown connection method was invoked')

services/connection/dataManager.ts

@@ -3,11 +3,12 @@ import { UrlArgs } from '~/types/interfaces'
 import Connection from '~/services/connection/connection'
 import Hookable from '~/services/hooks/hookable'
 import { HTTP_METHOD, QUERY_TYPE } from '~/types/enums'
+import ApiError from '~/services/utils/apiError'
 
 /**
  * Base class for data providers, persisters or deleters
  */
-class DataManager extends Hookable {
+class DataManager extends Hookable implements DataManager {
   protected ctx!: Context
   protected arguments!: UrlArgs
   protected defaultArguments: object = {
@@ -24,14 +25,30 @@ class DataManager extends Hookable {
     this.ctx = ctx
   }
 
+  /**
+   * Exécute la requête et retourne la réponse désérialisée
+   * @param _args
+   */
+  // eslint-disable-next-line require-await
+  protected async _invoke (_args: UrlArgs): Promise<any> {
+    throw new Error('Not implemented')
+  }
+
   /**
    * Exécute la requête
    * @param args
    */
   public async invoke (args: UrlArgs): Promise<any> {
-    args = { ...this.defaultArguments, ...args }
-    DataManager.startLoading(args)
+    this.arguments = { ...this.defaultArguments, ...args }
+    DataManager.startLoading(this.arguments)
+
     await this.triggerHooks(args)
+
+    try {
+      return this._invoke(args)
+    } catch (error) {
+      throw new ApiError(error.response.status, error.response.data.detail)
+    }
   }
 
   /**
@@ -51,7 +68,7 @@ class DataManager extends Hookable {
    * @param method
    * @param args
    */
-  protected static sendRequest (url: string, method: HTTP_METHOD, args: UrlArgs): Promise<any> {
+  protected static request (url: string, method: HTTP_METHOD, args: UrlArgs): Promise<any> {
     return Connection.invoke(method, url, args)
   }
 }

services/connection/urlBuilder.ts

@@ -16,7 +16,7 @@ class UrlBuilder {
    * @param {UrlArgs} args
    * @return {string}
    */
-  public static invoke (args: UrlArgs): string {
+  public static build (args: UrlArgs): string {
     switch (args.type) {
       case QUERY_TYPE.DEFAULT:
         return UrlBuilder.getDefaultUrl(args.url)

services/dataDeleter/dataDeleter.ts

@@ -1,29 +1,23 @@
 import { DataDeleterArgs } from '~/types/interfaces'
 import DataManager from '~/services/connection/dataManager'
-import ApiError from '~/services/utils/apiError'
 import { repositoryHelper } from '~/services/store/repository'
 
 /**
  * Le DataDeleter a pour rôle de supprimer des enregistrements via l'API Opentalent
  */
 class DataDeleter extends DataManager {
+  protected arguments!: DataDeleterArgs
+
   /**
    * Exécute la requête
-   * @param args
    */
-  public async invoke (args: DataDeleterArgs): Promise<any> {
-    this.arguments = args
-    try {
-      await super.invoke(args)
-
-      // const url = ConstructUrl.invoke(this.arguments)
-      // const response = await Connection.invoke(HTTP_METHOD.DELETE, url, this.arguments)
-      if (this.arguments.model) {
-        repositoryHelper.deleteItem(this.arguments.model, this.arguments.id)
-      }
-    } catch (error) {
-      throw new ApiError(error.response.status, error.response.data.detail)
+  protected async _invoke (): Promise<any> {
+    // const url = ConstructUrl.invoke(this.arguments)
+    // const response = await Connection.invoke(HTTP_METHOD.DELETE, url, this.arguments)
+    if (this.arguments.model) {
+      await repositoryHelper.deleteItem(this.arguments.model, this.arguments.id)
     }
+    return null
   }
 }
 

services/dataPersister/dataPersister.ts

@@ -2,32 +2,33 @@ import { AnyJson, DataPersisterArgs, DataProviderArgs } from '~/types/interfaces
 import UrlBuilder from '~/services/connection/urlBuilder'
 import { DENORMALIZER_TYPE, HTTP_METHOD } from '~/types/enums'
 import Serializer from '~/services/serializer/serializer'
-import ApiError from '~/services/utils/apiError'
 import DataProvider from '~/services/dataProvider/dataProvider'
 import DataManager from '~/services/connection/dataManager'
 
 /**
- * Le DataPersisteer a pour rôle de mettre à jour les données via de l'API Opentalent
+ * Le DataPersister a pour rôle de mettre à jour les données via de l'API Opentalent
+ *
+ * Il sérialise les données et les envoie à l'API sous la forme d'une requête
+ * PUT ou POST, selon les cas. Il fait ensuite appel au DataProvider pour traiter la
+ * réponse de l'API et la retourner.
  */
 class DataPersister extends DataManager {
+  protected arguments!: DataPersisterArgs
+
   /**
    * Exécute la requête et retourne la réponse désérialisée
-   * @param args
    */
-  public async invoke (args: DataPersisterArgs): Promise<any> {
-    try {
-      await super.invoke(args)
-
-      args.data = Serializer.normalize(args)
+  protected async _invoke (): Promise<any> {
+    this.arguments.data = Serializer.normalize(this.arguments)
 
-      const url = UrlBuilder.invoke(args)
+    const url = UrlBuilder.build(this.arguments)
+    const response = await DataPersister.request(
+      url,
+      this.arguments.id ? HTTP_METHOD.PUT : HTTP_METHOD.POST,
+      this.arguments
+    )
 
-      const response = await DataPersister.sendRequest(url, args.id ? HTTP_METHOD.PUT : HTTP_METHOD.POST, args)
-
-      await this.provideResponse(response, args)
-    } catch (error) {
-      throw new ApiError(error.response.status, error.response.data.detail)
-    }
+    return await this.provideResponse(response, this.arguments)
   }
 
   /**
@@ -50,8 +51,7 @@ class DataPersister extends DataManager {
       id: args.id,
       rootId: args.rootId
     }
-
-    return await dataProvider.provide(deserializedResponse, dataProviderArgs)
+    return await dataProvider.process(deserializedResponse, dataProviderArgs)
   }
 }
 

services/dataProvider/dataProvider.ts

@@ -1,16 +1,22 @@
 import { AnyJson, DataProviderArgs } from '~/types/interfaces'
 import { DENORMALIZER_TYPE, HTTP_METHOD, QUERY_TYPE } from '~/types/enums'
-import { providers } from '~/services/dataProvider/provider/_import'
+import { processors } from '~/services/dataProvider/processor/_import'
 import UrlBuilder from '~/services/connection/urlBuilder'
 import Serializer from '~/services/serializer/serializer'
-import ApiError from '~/services/utils/apiError'
 import DataManager from '~/services/connection/dataManager'
 
 /**
  * Le DataProvider a pour rôle de fournir des données issues de l'API Opentalent
+ *
+ * Pour cela, le DataProvider envoie une requête GET, récupérer la réponse de l'API,
+ * puis la désérialiser.
+ * Enfin, il va itérer sur les différents Processor disponibles, jusqu'à trouver
+ * un processeur adapté à la requête. Ce processeur va mettre en forme la réponse qui est enfin
+ * retournée par le DataProvider.
  */
 class DataProvider extends DataManager {
   protected progress: boolean = false
+  protected arguments!: DataProviderArgs
   protected defaultArguments: object = {
     type: QUERY_TYPE.MODEL,
     showProgress: false
@@ -18,34 +24,30 @@ class DataProvider extends DataManager {
 
   /**
    * Exécute la requête et retourne la réponse désérialisée
-   * @param args
    */
-  public async invoke (args: DataProviderArgs): Promise<any> {
-    try {
-      await super.invoke(args)
-
-      const url = UrlBuilder.invoke(args)
-
-      const response = await DataProvider.sendRequest(url, HTTP_METHOD.GET, args)
+  protected async _invoke (): Promise<any> {
+    const url = UrlBuilder.build(this.arguments)
+    const response = await DataProvider.request(url, HTTP_METHOD.GET, this.arguments)
+    const data = await Serializer.denormalize(response, DENORMALIZER_TYPE.HYDRA)
 
-      const deserializeResponse = await Serializer.denormalize(response, DENORMALIZER_TYPE.HYDRA)
+    return await this.process(data, this.arguments)
+  }
 
-      return await this.provide(deserializeResponse, args)
-    } catch (error) {
-      throw new ApiError(500, error)
-    }
+  public async process (data: AnyJson, args: DataProviderArgs) {
+    const postProcessor = this.getProcessor(args)
+    return await postProcessor.process(data)
   }
 
   /**
    * Iterate over the available providers and invoke
    * the first one that support the given args
-   * @param data
    * @param args
    */
-  public provide (data: AnyJson, args: DataProviderArgs): any {
-    for (const Provider of providers) {
-      if (Provider.support(args)) {
-        return new Provider(this.ctx, args).invoke(data)
+  private getProcessor (args: DataProviderArgs): any {
+    for (const processor of processors) {
+      if (processor.support(args)) {
+        // eslint-disable-next-line new-cap
+        return new processor(this.ctx, args)
       }
     }
   }

services/dataProvider/processor/_import.ts

@@ -0,0 +1,9 @@
+import ModelProcessor from '~/services/dataProvider/processor/modelProcessor'
+import EnumProcessor from '~/services/dataProvider/processor/enumProcessor'
+import DefaultProcessor from '~/services/dataProvider/processor/defaultProcessor'
+
+export const processors = [
+  DefaultProcessor,
+  ModelProcessor,
+  EnumProcessor
+]

services/dataProvider/processor/baseProcessor.ts

@@ -0,0 +1,34 @@
+import { Context } from '@nuxt/types/app'
+import { AnyJson, DataProviderArgs } from '~/types/interfaces'
+import Hookable from '~/services/hooks/hookable'
+
+class BaseProcessor extends Hookable {
+  protected arguments!: DataProviderArgs;
+  protected ctx!: Context;
+
+  constructor (ctx: Context, args: DataProviderArgs) {
+    super()
+    this.arguments = args
+    this.ctx = ctx
+  }
+
+  /**
+   * Is the given argument a supported model
+   * @param _args
+   */
+  public static support (_args: DataProviderArgs): boolean {
+    throw new Error('Not implemented')
+  }
+
+  /**
+   * Process and return the given data to the Provider
+   *
+   * @param _data
+   */
+  // eslint-disable-next-line require-await
+  public async process (_data: AnyJson): Promise<any> {
+    throw new Error('Not implemented')
+  }
+}
+
+export default BaseProcessor

services/dataProvider/processor/defaultProcessor.ts

@@ -0,0 +1,24 @@
+import { AnyJson, DataProviderArgs, Processor } from '~/types/interfaces'
+import BaseProcessor from '~/services/dataProvider/processor/baseProcessor'
+import { QUERY_TYPE } from '~/types/enums'
+
+class DefaultProcessor extends BaseProcessor implements Processor {
+  /**
+   * Is the given argument a supported model
+   * @param args
+   */
+  public static support (args: DataProviderArgs): boolean {
+    return args.type === QUERY_TYPE.DEFAULT
+  }
+
+  /**
+   *
+   * @param data
+   */
+  // eslint-disable-next-line require-await
+  async process (data: AnyJson): Promise<any> {
+    return data
+  }
+}
+
+export default DefaultProcessor

services/dataProvider/provider/enumProvider.ts → services/dataProvider/processor/enumProcessor.ts

@@ -1,16 +1,24 @@
 import * as _ from 'lodash'
-import { AnyJson, DataProviderArgs, EnumChoice, EnumChoices, Provider } from '~/types/interfaces'
-import BaseProvider from '~/services/dataProvider/provider/baseProvider'
+import { AnyJson, DataProviderArgs, EnumChoice, EnumChoices, Processor } from '~/types/interfaces'
+import BaseProcessor from '~/services/dataProvider/processor/baseProcessor'
 import { QUERY_TYPE } from '~/types/enums'
 
-class EnumProvider extends BaseProvider implements Provider {
+class EnumProcessor extends BaseProcessor implements Processor {
 
   /**
-   * Exécute la requête et retourne la réponse désérialisée
+   * Is the given argument a supported model
+   * @param args
+   */
+  public static support (args:DataProviderArgs): boolean {
+    return args.type === QUERY_TYPE.ENUM
+  }
+
+  /**
+   *
    * @param data
    */
   // eslint-disable-next-line require-await
-  async invoke (data: AnyJson): Promise<any> {
+  async process (data: AnyJson): Promise<any> {
     const enums: EnumChoices = []
 
     _.each(data.items, (item, key) => {
@@ -20,7 +28,7 @@ class EnumProvider extends BaseProvider implements Provider {
       }
       enums.push(entry)
     })
-    return EnumProvider.sortEnum(enums)
+    return EnumProcessor.sortEnum(enums)
   }
 
   /**
@@ -35,14 +43,6 @@ class EnumProvider extends BaseProvider implements Provider {
       return 0
     })
   }
-
-  /**
-   * Is the given argument a supported model
-   * @param args
-   */
-  static support (args:DataProviderArgs): boolean {
-    return args.type === QUERY_TYPE.ENUM
-  }
 }
 
-export default EnumProvider
+export default EnumProcessor

services/dataProvider/provider/modelProvider.ts → services/dataProvider/processor/modelProcessor.ts

@@ -1,32 +1,32 @@
 import * as _ from 'lodash'
-import { AnyJson, DataProviderArgs, Provider } from '~/types/interfaces'
-import BaseProvider from '~/services/dataProvider/provider/baseProvider'
+import { AnyJson, DataProviderArgs, Processor } from '~/types/interfaces'
+import BaseProcessor from '~/services/dataProvider/processor/baseProcessor'
 import { QUERY_TYPE } from '~/types/enums'
 import { repositoryHelper } from '~/services/store/repository'
 
-class ModelProvider extends BaseProvider implements Provider {
+class ModelProcessor extends BaseProcessor implements Processor {
+  /**
+   * Is the given argument a supported model
+   * @param args
+   */
+  public static support (args: DataProviderArgs): boolean {
+    return args.type === QUERY_TYPE.MODEL
+  }
+
   /**
    * Exécute la requête et retourne la réponse désérialisée
    * @param data
    */
-  async invoke (data: AnyJson): Promise<any> {
+  async process (data: AnyJson): Promise<any> {
     if (typeof this.arguments.model === 'undefined') {
       throw new TypeError('model must be defined')
     }
 
     data.originalState = _.cloneDeep(data)
-    repositoryHelper.persist(this.arguments.model, data)
+    await repositoryHelper.persist(this.arguments.model, data)
 
-    await this.postHook()
-  }
-
-  /**
-   * Is the given argument a supported model
-   * @param args
-   */
-  static support (args: DataProviderArgs): boolean {
-    return args.type === QUERY_TYPE.MODEL
+    return data
   }
 }
 
-export default ModelProvider
+export default ModelProcessor

services/dataProvider/provider/_import.ts

@@ -1,9 +0,0 @@
-import ModelProvider from '~/services/dataProvider/provider/modelProvider'
-import EnumProvider from '~/services/dataProvider/provider/enumProvider'
-import DefaultProvider from '~/services/dataProvider/provider/defaultProvider'
-
-export const providers = [
-  DefaultProvider,
-  ModelProvider,
-  EnumProvider
-]

services/dataProvider/provider/baseProvider.ts

@@ -1,47 +0,0 @@
-import { Context } from '@nuxt/types/app'
-import { hooks } from '~/services/dataProvider/provider/hook/_import'
-import { DataProviderArgs } from '~/types/interfaces'
-
-class BaseProvider {
-  protected arguments!: DataProviderArgs;
-  protected ctx!: Context;
-
-  constructor (ctx: Context, args: DataProviderArgs) {
-    this.arguments = args
-    this.ctx = ctx
-  }
-
-  /**
-   * Is the given argument a supported model
-   * @param _args
-   */
-  static support (_args: DataProviderArgs): boolean {
-    throw new Error('Need to be implement into static method')
-  }
-
-  /**
-   * Iterate over the available hooks and return
-   * the first one that support the given args
-   */
-  async postHook () {
-    for (const Hook of BaseProvider.sortedHooks()) {
-      if (Hook.support(this.arguments)) {
-        await new Hook().invoke(this.arguments)
-      }
-    }
-  }
-
-  /**
-   * Sort the available hooks by priority
-   * @private
-   */
-  public static sortedHooks (): Iterable<any> {
-    return hooks.sort(function (a, b) {
-      if (a.priority > b.priority) { return 1 }
-      if (a.priority < b.priority) { return -1 }
-      return 0
-    })
-  }
-}
-
-export default BaseProvider

services/dataProvider/provider/defaultProvider.ts

@@ -1,24 +0,0 @@
-import { AnyJson, DataProviderArgs, Provider } from '~/types/interfaces'
-import BaseProvider from '~/services/dataProvider/provider/baseProvider'
-import { QUERY_TYPE } from '~/types/enums'
-
-class DefaultProvider extends BaseProvider implements Provider {
-  /**
-   * Exécute la requête et retourne la réponse désérialisée
-   * @param data
-   */
-  // eslint-disable-next-line require-await
-  async invoke (data: AnyJson): Promise<any> {
-    return data
-  }
-
-  /**
-   * Is the given argument a supported model
-   * @param args
-   */
-  static support (args:DataProviderArgs): boolean {
-    return args.type === QUERY_TYPE.DEFAULT
-  }
-}
-
-export default DefaultProvider

tests/unit/services/connection/connection.spec.ts

@@ -2,6 +2,7 @@ import { NuxtAxiosInstance } from '@nuxtjs/axios'
 import Connection from '~/services/connection/connection'
 import axios from '~/plugins/Data/axios'
 import { HTTP_METHOD, QUERY_TYPE } from '~/types/enums'
+import { DataPersisterArgs } from '~/types/interfaces'
 
 const axiosMock = axios as jest.Mocked<NuxtAxiosInstance>
 
@@ -44,13 +45,13 @@ describe('invoke()', () => {
 
     it('should return item data', async () => {
       Connection.connector.$request = jest.fn().mockReturnValue({ data: 'data user 1' })
-      const response = await Connection.invoke(HTTP_METHOD.PUT, 'users', { type: QUERY_TYPE.MODEL, id: 1, data: {} })
+      const response = await Connection.invoke(HTTP_METHOD.PUT, 'users', { type: QUERY_TYPE.MODEL, id: 1, data: {} } as DataPersisterArgs)
       expect(response).toStrictEqual({ data: 'data user 1' })
     })
 
     it('should call put and return item data', async () => {
       Connection.put = jest.fn().mockReturnValue({})
-      await Connection.invoke(HTTP_METHOD.PUT, 'users', { type: QUERY_TYPE.MODEL, id: 1, data: {} })
+      await Connection.invoke(HTTP_METHOD.PUT, 'users', { type: QUERY_TYPE.MODEL, id: 1, data: {} } as DataPersisterArgs)
       expect(Connection.put).toHaveBeenCalled()
     })
   })

tests/unit/services/connection/constructUrl.spec.ts

@@ -7,13 +7,13 @@ import { repositoryHelper } from '~/services/store/repository'
 describe('invoke()', () => {
   describe('getDefaultUrl()', () => {
     it('should throw an error if URL is missing', () => {
-      expect(() => UrlBuilder.invoke({
+      expect(() => UrlBuilder.build({
         type: QUERY_TYPE.DEFAULT
       })).toThrow()
     })
 
     it('should return the URL concat with Root URL', () => {
-      expect(UrlBuilder.invoke({
+      expect(UrlBuilder.build({
         type: QUERY_TYPE.DEFAULT,
         url: 'users'
       })).toEqual('/api/users')
@@ -22,13 +22,13 @@ describe('invoke()', () => {
 
   describe('getEnumUrl()', () => {
     it('should throw an error if enumType is missing', () => {
-      expect(() => UrlBuilder.invoke({
+      expect(() => UrlBuilder.build({
         type: QUERY_TYPE.ENUM
       })).toThrow()
     })
 
     it('should return the Enum URL concat with Root URL', () => {
-      expect(UrlBuilder.invoke({
+      expect(UrlBuilder.build({
         type: QUERY_TYPE.ENUM,
         enumType: 'billing_type'
       })).toEqual('/api/enum/billing_type')
@@ -37,7 +37,7 @@ describe('invoke()', () => {
 
   describe('getModelUrl()', () => {
     it('should throw an error if model is missing', () => {
-      expect(() => UrlBuilder.invoke({
+      expect(() => UrlBuilder.build({
         type: QUERY_TYPE.MODEL
       })).toThrow()
     })
@@ -46,7 +46,7 @@ describe('invoke()', () => {
       const repositoryHelperMock = repositoryHelper as jest.Mocked<typeof repositoryHelper>
       repositoryHelperMock.getEntity = jest.fn().mockReturnValue('users')
 
-      expect(UrlBuilder.invoke({
+      expect(UrlBuilder.build({
         type: QUERY_TYPE.MODEL,
         model: User
       })).toEqual('/api/users')
@@ -56,7 +56,7 @@ describe('invoke()', () => {
       const repositoryHelperMock = repositoryHelper as jest.Mocked<typeof repositoryHelper>
       repositoryHelperMock.getEntity = jest.fn().mockReturnValue('users')
 
-      expect(() => UrlBuilder.invoke({
+      expect(() => UrlBuilder.build({
         type: QUERY_TYPE.MODEL,
         model: User,
         rootModel: Organization
@@ -69,7 +69,7 @@ describe('invoke()', () => {
         .mockReturnValueOnce('users')
         .mockReturnValueOnce('organizations')
 
-      expect(UrlBuilder.invoke({
+      expect(UrlBuilder.build({
         type: QUERY_TYPE.MODEL,
         model: User,
         rootModel: Organization,

types/interfaces.d.ts

@@ -133,51 +133,48 @@ interface EnumChoice {
 }
 interface EnumChoices extends Array<EnumChoice> {}
 
+interface DataManager {
+  initCtx(ctx: Context): void,
+  invoke(args: UrlArgs): Promise<any>,
+}
+
 interface UrlArgs {
   readonly type: QUERY_TYPE,
-  readonly url?:string,
-  readonly enumType?:string,
+  readonly url?: string,
+  readonly enumType?: string,
   readonly model?: typeof Model,
   readonly rootModel?: typeof Model,
-  readonly id?:any,
-  readonly rootId?:number
-  readonly showProgress?:boolean
+  readonly id?: any,
+  readonly rootId?: number
+  readonly showProgress?: boolean
 
   readonly hook?: string
 }
 
+interface DataProviderArgs extends UrlArgs {}
 interface DataPersisterArgs extends UrlArgs {
   data?: AnyJson
 }
+interface DataDeleterArgs extends UrlArgs {}
 
+interface HookProvider {
+  invoke(args: DataProviderArgs): Promise<any>,
+}
 interface HookPersister {
   invoke(args: DataPersisterArgs): Promise<any>,
 }
-
-interface DataDeleterArgs extends UrlArgs {
-}
-
 interface HookDeleter {
   invoke(args: DataDeleterArgs): Promise<any>,
 }
 
-interface DataProviderArgs extends UrlArgs {
+interface Processor {
+  process(data: AnyJson): Promise<any>
 }
 
-interface HookProvider {
-  invoke(args: DataProviderArgs): Promise<any>,
-}
-interface Provider {
-  invoke(data: AnyJson): Promise<any>,
+interface Normalizer {
+  normalize(args: DataPersisterArgs): any,
 }
 interface Denormalizer {
   denormalize(data: any): any,
 }
-interface Normalizer {
-  normalize(args: DataPersisterArgs): any,
-}
 
-interface DataProviders {
-  initCtx(ctx: Context): void,
-  invoke(args: DataProviderArgs): Promise<any>,
-}

use/form/useChecker.ts

@@ -1,7 +1,7 @@
 import { ref, Ref } from '@nuxtjs/composition-api'
 import VueI18n from 'vue-i18n'
 import { QUERY_TYPE } from '~/types/enums'
-import { DataProviders } from '~/types/interfaces'
+import { DataManager } from '~/types/interfaces'
 
 /**
  * @category Use/form
@@ -12,12 +12,12 @@ class UseChecker {
   /**
    * Use méthode fournissant une fonction pour tester la validité d'un Siret ainsi que la gestion du message d'erreur
    */
-  public static useHandleSiret (i18n: VueI18n, $dataProvider: DataProviders) {
+  public static useHandleSiret (i18n: VueI18n, $dataManager: DataManager) {
     const siretError: Ref<boolean> = ref(false)
     const siretErrorMessage: Ref<string> = ref('')
 
     const checkSiret = async (siret: string) => {
-      const response = await $dataProvider.invoke({
+      const response = await $dataManager.invoke({
         type: QUERY_TYPE.DEFAULT,
         url: 'siret-checking',
         id: siret