@davra/ui-core 1.0.0-alpha.2 → 1.0.0-alpha.3

package/src/services/metricsCountersService.ts

@@ -1,24 +0,0 @@
-import {DavraApiClient} from './davraApi'
-import type { MetricCounter } from '~/types'
-
-const getMetricsCounters = async (): Promise< MetricCounter[] > => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      '/api/v1/iotdata/metrics/counters',
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Metric Counter API Error')
-  }
-}
-
-export default {
-  getMetricsCounters,
-}

package/src/services/metricsService.test.ts

@@ -1,97 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import MetricsService from '~/services/metricsService'
-
-const mockGet = vi.fn()
-const mockPost = vi.fn()
-vi.mock('./davraApi', () => {
-  return {
-    default: vi.fn(() => ({
-      get: mockGet,
-      post: mockPost,
-    })),
-  }
-})
-
-describe('Metrics Service', () => {
-  beforeEach(() => {
-
-  })
-
-  afterEach(() => {
-
-  })
-
-  it('getMetrics success', async () => {
-    const mockMetrics = ['metric1']
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: { fields: mockMetrics }, status: 200 })
-
-    const result = await MetricsService.getMetrics()
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/iotdata/meta-data/metrics', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(mockMetrics)
-  })
-
-  it('getMetrics api unkown error', async () => {
-    mockGet.mockRejectedValueOnce({ response: { status: 500 } })
-
-    await expect(MetricsService.getMetrics()).rejects.toThrow(new Error('API Error 500 '))
-  })
-
-  it('postMetrics success', async () => {
-    const mockMetric = {
-      name: 'm1',
-      label: 'M1',
-      units: '%',
-      description: 'long description here',
-      semantics: 'metric',
-      labels: {},
-    }
-    const axiosPost = mockPost.mockResolvedValueOnce({ status: 200 })
-
-    await MetricsService.postMetric(mockMetric)
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v1/iotdata/meta-data',
-      mockMetric, {
-        headers: {
-          Accept: 'application/json',
-        },
-      })
-  })
-  it('postMetrcis success with no smantics', async () => {
-    const mockMetric = {
-      name: 'm1',
-      label: 'M1',
-      units: '%',
-      description: 'long description here',
-      labels: {},
-    }
-    const axiosPost = mockPost.mockResolvedValueOnce({ status: 200 })
-
-    await MetricsService.postMetric(mockMetric)
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v1/iotdata/meta-data',
-      { ...mockMetric, semantics: 'metric' }, {
-        headers: {
-          Accept: 'application/json',
-        },
-      })
-  })
-
-  it('postMetrcis api unkown error', async () => {
-    mockPost.mockRejectedValueOnce({ response: { status: 500 } })
-    const mockMetric = {
-      name: 'm1',
-      label: 'M1',
-      units: '%',
-      description: 'long description here',
-      labels: {},
-    }
-
-    await expect(MetricsService.postMetric(mockMetric)).rejects.toThrow(new Error('API Error 500 '))
-  })
-})

package/src/services/metricsService.ts

@@ -1,54 +0,0 @@
-import {DavraApiClient} from './davraApi'
-
-import type { Metric } from '~/types'
-
-const getMetrics = async (): Promise<any[]> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      '/api/v1/iotdata/meta-data/metrics',
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data.fields
-  }
-  catch (error: any) {
-    const errorMessage: string = typeof error?.response?.data?.message === 'string' ? error?.response?.data?.message : typeof error?.response?.data === 'string' ? error?.response?.data : ''
-    throw new Error(`API Error ${error?.response?.status} ${errorMessage}`)
-  }
-}
-const postMetric = async (metric: Metric): Promise<any> => {
-  try {
-    const { data } = await DavraApiClient().post<any>(
-      '/api/v1/iotdata/meta-data',
-      {
-        name: metric.name,
-        label: metric.label,
-        units: metric.units,
-        description: metric.description,
-        semantics: metric.semantics || 'metric',
-        labels: metric.labels,
-      },
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return data
-  }
-  catch (error: any) {
-    const errorMessage: string = typeof error?.response?.data?.message === 'string' ? error?.response?.data?.message : typeof error?.response?.data === 'string' ? error?.response?.data : ''
-    throw new Error(`API Error ${error?.response?.status} ${errorMessage}`)
-  }
-}
-
-export default {
-  getMetrics,
-  postMetric,
-}
-

package/src/services/timeseriesService.test.ts

@@ -1,86 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import TimeseriesService from '~/services/timeseriesService'
-
-const mockGet = vi.fn()
-const mockPost = vi.fn()
-vi.mock('./davraApi', () => {
-  return {
-    default: vi.fn(() => ({
-      get: mockGet,
-      post: mockPost,
-    })),
-  }
-})
-
-describe('Timeseries Service', () => {
-  beforeEach(() => {
-
-  })
-
-  afterEach(() => {
-
-  })
-
-  it('queryTimeseries success', async () => {
-    const mockQuery = {
-      metrics: [
-        {
-          name: 'davra.auditLog',
-          limit: 100000,
-        },
-      ],
-      start_absolute: 1593513044000,
-      end_absolute: 1593599444000,
-    }
-    const mockResponse = {
-      queries: [
-        {
-          sample_size: 0,
-          results: [
-            {
-              name: 'davra.auditLog',
-              tags: {},
-              values: [],
-            },
-          ],
-        },
-      ],
-    }
-    const axiosPost = mockPost.mockResolvedValueOnce({
-      data: mockResponse,
-      status: 200,
-    })
-
-    const result = await TimeseriesService.queryTimeseries(mockQuery)
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v2/timeseriesdata', mockQuery, {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(mockResponse)
-  })
-
-  it('queryTimeseries api unkown error', async () => {
-    const mockQuery = {
-      metrics: [
-        {
-          name: 'davra.auditLog',
-          limit: 100000,
-        },
-      ],
-      start_absolute: 1593513044000,
-      end_absolute: 1593599444000,
-    }
-    const axiosPost = mockPost.mockRejectedValueOnce('')
-
-    await expect(TimeseriesService.queryTimeseries(mockQuery)).rejects.toThrowError()
-
-    expect(axiosPost).toHaveBeenCalledWith('/api/v2/timeseriesdata', mockQuery, {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-  })
-})

package/src/services/timeseriesService.ts

@@ -1,24 +0,0 @@
-import {DavraApiClient} from './davraApi'
-import type { TimeseriesDataResponse } from '~/types'
-
-const queryTimeseries = async (query: any): Promise<TimeseriesDataResponse<any> | null > => {
-  try {
-    const { data } = await DavraApiClient().post<any>(
-      '/api/v2/timeseriesdata',
-      query,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Timeseries Error')
-  }
-}
-
-export default {
-  queryTimeseries,
-}

package/src/services/twinTypesService.test.ts

@@ -1,74 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import TwinTypesService from '~/services/twinTypesService'
-
-const mockGet = vi.fn()
-const mockPost = vi.fn()
-vi.mock('./davraApi', () => {
-  return {
-    default: vi.fn(() => ({
-      get: mockGet,
-      post: mockPost,
-    })),
-  }
-})
-
-describe('TwinTypes Service', () => {
-  beforeEach(() => {
-
-  })
-
-  afterEach(() => {
-
-  })
-
-  it('getTwinTypes success', async () => {
-    const mockTwinTypes = [{
-      _id: '5fb7fdd919ed592dd321d767',
-      tenantId: 'ruban',
-      UUID: 'e8cc8e7d-900b-49da-b3df-43dceb101690',
-      created: 1605893593664,
-      owner: '451e5a4868b3fd5bda206fc82e436ac3',
-      name: 'stateful_incident',
-      description: 'Default type for stateful incidents. Do not delete.',
-      customAttributes: {},
-    },
-    {
-      _id: '5fbd141f5d07a570541dec20',
-      name: 'testTypes',
-      description: 'sample description',
-      labels: {},
-      customAttributes: {
-        testAttribute: 'x',
-      },
-      tenantId: 'ruban',
-      UUID: 'de68d333-7cd6-45ff-bfb4-d7d55b99eec5',
-      created: 1606226975987,
-      owner: '451e5a4868b3fd5bda206fc82e436ac3',
-    }]
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: mockTwinTypes, status: 200 })
-
-    const result = await TwinTypesService.getTwinTypes()
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/twintypes', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual(mockTwinTypes)
-  })
-
-  it('getTwinTypes api unkown error', async () => {
-    const axiosGet = mockGet.mockRejectedValueOnce('')
-
-    const result = await TwinTypesService.getTwinTypes()
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/twintypes', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual([])
-  })
-})

package/src/services/twinTypesService.ts

@@ -1,24 +0,0 @@
-import { DavraApiClient } from './davraApi'
-import type { TwinType } from '~/types'
-
-const getTwinTypes = async (): Promise<TwinType[]> => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      '/api/v1/twintypes',
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-
-    )
-    return Object.values(data) || []
-  }
-  catch (error) {
-    return []
-  }
-}
-
-export default {
-  getTwinTypes,
-}

package/src/services/twinsCountersService.test.ts

@@ -1,72 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import TwinsCountersService from '~/services/twinsCountersService'
-
-const mockGet = vi.fn()
-const mockPost = vi.fn()
-vi.mock('./davraApi', () => {
-  return {
-    default: vi.fn(() => ({
-      get: mockGet,
-      post: mockPost,
-    })),
-  }
-})
-
-describe('Twins Counters Service', () => {
-  beforeEach(() => {
-
-  })
-
-  afterEach(() => {
-
-  })
-
-  it('getTwinsCountersByUUID success', async () => {
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: '', status: 200, headers: { 'com-davra-total-results': '1' } })
-
-    const result = await TwinsCountersService.getTwinsCountersByUUID('uuid111')
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/iotdata/twins/counters/uuid111', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual('')
-  })
-
-  it('getTwinsCountersByUUID api unkown error', async () => {
-    const axiosGet = mockGet.mockRejectedValueOnce('')
-
-    await expect(TwinsCountersService.getTwinsCountersByUUID('uuid111')).rejects.toThrow(new Error('Twins Counters API Error'))
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/iotdata/twins/counters/uuid111', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-  })
-  it('getTwinsCountersLatestByUUID success', async () => {
-    const axiosGet = mockGet.mockResolvedValueOnce({ data: '', status: 200 })
-
-    const result = await TwinsCountersService.getTwinsCountersLatestByUUID('uuid111')
-
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/iotdata/twins/counters/latest/uuid111', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-
-    expect(result).toEqual('')
-  })
-
-  it('getTwinsCountersLatestByUUID api unkown error', async () => {
-    const axiosGet = mockGet.mockRejectedValueOnce('')
-
-    await expect(TwinsCountersService.getTwinsCountersLatestByUUID('uuid111')).rejects.toThrow(new Error('Twins Counters API Error'))
-    expect(axiosGet).toHaveBeenCalledWith('/api/v1/iotdata/twins/counters/latest/uuid111', {
-      headers: {
-        Accept: 'application/json',
-      },
-    })
-  })
-})

package/src/services/twinsCountersService.ts

@@ -1,40 +0,0 @@
-import {DavraApiClient} from './davraApi'
-import type { TwinCounter } from '~/types'
-
-const getTwinsCountersByUUID = async (uuid: string): Promise< TwinCounter > => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/iotdata/twins/counters/${uuid}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Twins Counters API Error')
-  }
-}
-const getTwinsCountersLatestByUUID = async (uuid: string): Promise< TwinCounter > => {
-  try {
-    const { data } = await DavraApiClient().get<any>(
-      `/api/v1/iotdata/twins/counters/latest/${uuid}`,
-      {
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-    )
-    return data
-  }
-  catch (error) {
-    throw new Error('Twins Counters API Error')
-  }
-}
-
-export default {
-  getTwinsCountersLatestByUUID,
-  getTwinsCountersByUUID,
-}