feat(update): 🚀 accepted mssage as string value

Author: TouchSek

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-api-queries",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "Elegant and simple way to build requests for REST API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/__tests__/base-proxy.test.ts

@@ -4,6 +4,8 @@ import MockAdapter from 'axios-mock-adapter'
 import PostProxy from '../core/PostPorxy'
 import type { ValidatorType } from '../core/Validator'
 import Validator from '../core/Validator'
+import BaseTransformer from '../core/BaseTransformer'
+import PaginationTransformer from '../core/PaginationTransformer'
 
 let proxy: PostProxy
 let mockAdapter
@@ -17,15 +19,47 @@ describe('BaseProxy', () => {
     proxy = new PostProxy()
     mockAdapter = new MockAdapter(axios)
   })
+
+  it('it should fetch items with pagination', async () => {
+    const items = {
+      data: [{ first_name: 'Chantouch', last_name: 'Sek' }],
+      pagination: { count: 1, page: 1, perPage: 20 },
+    }
+    mockAdapter.onGet('/posts').reply(200, items)
+    const { data, pagination = {} } = await proxy.removeParameters().all()
+    const all = {
+      items: BaseTransformer.fetchCollection(data),
+      pagination: PaginationTransformer.fetch(pagination),
+    }
+    expect(all).toHaveProperty('pagination')
+    expect(data).toEqual(all.items)
+    expect(all.pagination.page).toEqual(1)
+  })
+
+  it('it should fetch items with meta that has pagination', async () => {
+    const items = {
+      data: [{ first_name: 'Chantouch', last_name: 'Sek' }],
+      meta: {
+        pagination: { count: 1, current_page: 1, perPage: 20 },
+        include: [],
+      },
+    }
+    mockAdapter.onGet('/posts').reply(200, items)
+    const { data, meta = {} } = await proxy.removeParameters().all()
+    const all = {
+      items: BaseTransformer.fetchCollection(data),
+      pagination: PaginationTransformer.fetch(meta),
+    }
+    expect(meta).toHaveProperty('pagination')
+    expect(data.length).toEqual(1)
+    expect(all.pagination.page).toEqual(1)
+  })
+
   it('will fetch all records', async () => {
     const items = [{ first_name: 'Chantouch', last_name: 'Sek' }]
     mockAdapter.onGet('/posts').reply(200, { data: items })
-    try {
-      const { data } = await proxy.removeParameters().all()
-      expect(data).toEqual(items)
-    } catch (e) {
-      console.log('all:', e)
-    }
+    const { data } = await proxy.removeParameters().all()
+    expect(data).toEqual(items)
   })
 
   it('will fetch all records with query params', async () => {

src/__tests__/validator.test.ts

@@ -9,10 +9,18 @@ describe('Validator', () => {
   afterEach(() => {
     validator.flush()
   })
-  test('Add error', () => {
+  test('Add an error', () => {
     validator.add('name', 'The name field is required.')
     expect(validator.any()).toBeTruthy()
   })
+  test('Add an error message as string', () => {
+    const errors = {
+      name: 'The name field is required.',
+    }
+    validator.fill(errors)
+    expect(validator.any()).toBeTruthy()
+    expect(validator.first('name')).toEqual('The name field is required.')
+  })
   test('Check if error has "name" key.', () => {
     validator.add('name', 'The name field is required.')
     expect(validator.has('name')).toBeTruthy()

src/core/PaginationTransformer.ts

@@ -1,7 +1,32 @@
 import BaseTransformer from './BaseTransformer'
+import snakecaseKeys from 'snakecase-keys'
+
+export interface PaginationOptions {
+  per_page?: string | number
+  total_pages?: string | number
+  current_page?: string | number
+  total?: string | number
+  links?: string | number
+  count?: string | number
+  page?: string | number
+  items_per_page?: string | number
+  page_count?: string | number
+  items_length?: string | number
+  page_start?: string | number
+  page_stop?: string | number
+  include?: string | string[]
+}
+
+export interface MetaOptions {
+  pagination?: PaginationOptions
+  include?: string | string[]
+}
 
 class PaginationTransformer extends BaseTransformer {
-  static fetch(meta: MetaOptions) {
+  static fetch(meta: MetaOptions | any) {
+    if (!meta.hasOwnProperty('pagination')) {
+      return snakecaseKeys(meta, { deep: true })
+    }
     const { pagination = {}, include } = meta
     return {
       perPage: pagination.per_page,
@@ -22,24 +47,3 @@ class PaginationTransformer extends BaseTransformer {
 }
 
 export default PaginationTransformer
-
-export interface PaginationOptions {
-  per_page?: string | number
-  total_pages?: string | number
-  current_page?: string | number
-  total?: string | number
-  links?: string | number
-  count?: string | number
-  page?: string | number
-  items_per_page?: string | number
-  page_count?: string | number
-  items_length?: string | number
-  page_start?: string | number
-  page_stop?: string | number
-  include?: string | string[]
-}
-
-export interface MetaOptions {
-  pagination?: PaginationOptions
-  include?: string | string[]
-}

src/core/Validator.ts

@@ -1,8 +1,4 @@
-import { is, isArray } from '../util/objects'
-
-export interface ErrorOptions {
-  [key: string]: string | string[]
-}
+import { is } from '../util/objects'
 
 class Validator {
   public errors: any
@@ -25,7 +21,7 @@ class Validator {
   }
 
   has(field: any | any[]): boolean {
-    if (isArray(field)) {
+    if (field instanceof Array) {
       return is(Object.keys(this.errors), field)
     }
     let hasError = this.errors.hasOwnProperty(field)
@@ -39,7 +35,7 @@ class Validator {
   }
 
   first(field: any | any[]): string {
-    if (isArray(field)) {
+    if (field instanceof Array) {
       for (let i = 0; i < field.length; i++) {
         if (!this.errors.hasOwnProperty(field[i])) {
           continue
@@ -83,20 +79,28 @@ class Validator {
     return this.errors
   }
 
-  fill(errors: ErrorOptions): void {
+  fill(errors: any): void {
+    for (const error in errors) {
+      if (!errors.hasOwnProperty(error)) {
+        continue
+      }
+      if (!(errors[error] instanceof Array)) {
+        errors[error] = [errors[error]]
+      }
+    }
     this.errors = errors
   }
 
   flush(): void {
     this.errors = {}
   }
 
-  clear(attribute?: any | any[]): void {
+  clear(attribute?: string | string[]): void {
     if (!attribute) {
       return this.flush()
     }
     const errors = Object.assign({}, this.errors)
-    if (isArray(attribute)) {
+    if (attribute instanceof Array) {
       attribute.map((field: string) => {
         Object.keys(errors)
           .filter(