bcchapi 1.0.0 → 1.0.1

package/src/errors.ts

@@ -1,4 +1,4 @@
-import { ErrorResponse } from './response';
+import { ErrorResponse } from './types';
 
 export enum ErrorCodes {
   InvalidCredentials = -5,
@@ -33,4 +33,4 @@ export class InvalidSeriesError extends WebServiceError {
   constructor(response?: ErrorResponse) {
     super(response, 'Invalid series id');
   }
-}
+}

package/src/helpers/is-valid-date.ts

@@ -0,0 +1,9 @@
+export default function isValidDate(date: unknown): boolean {
+  if (typeof date === 'string') {
+    return !Number.isNaN(Date.parse(date));
+  }
+  if (date instanceof Date) {
+    return !Number.isNaN(date.getTime());
+  }
+  return false;
+}

package/src/helpers/parsers.ts

@@ -0,0 +1,56 @@
+import reverseDate from './reverse-date';
+import {
+  ErrorCodes,
+  InvalidFrequencyError,
+  InvalidCredentialsError,
+  InvalidSeriesError,
+  WebServiceError,
+} from '../errors';
+import { ApiResponse, ErrorResponse, GetSeriesResponse, SearchSeriesResponse } from '../types';
+
+export function parseGetSeriesResponse<T extends ApiResponse>(response: T): GetSeriesResponse {
+  if (response.Codigo !== 0) {
+    switch (response.Codigo) {
+      case ErrorCodes.InvalidCredentials:
+        throw new InvalidCredentialsError();
+      case ErrorCodes.InvalidSeries:
+        throw new InvalidSeriesError();
+      default:
+        throw new WebServiceError(response as ApiResponse as ErrorResponse);
+    }
+  }
+
+  return {
+    seriesId: response.Series.seriesId || '',
+    description: response.Series.descripIng || '',
+    data: (response.Series.Obs || []).map((obs) => ({
+      date: reverseDate(obs.indexDateString),
+      value: parseFloat(obs.value),
+    })),
+  };
+}
+
+export function parseSearchSeriesResponse<T extends ApiResponse>(
+  response: T,
+): SearchSeriesResponse {
+  if (response.Codigo !== 0) {
+    switch (response.Codigo) {
+      case ErrorCodes.InvalidCredentials:
+        throw new InvalidCredentialsError();
+      case ErrorCodes.InvalidFrequency:
+        throw new InvalidFrequencyError();
+      default:
+        throw new WebServiceError(response as ApiResponse as ErrorResponse);
+    }
+  }
+
+  return response.SeriesInfos.map((series) => ({
+    seriesId: series.seriesId,
+    frequency: series.frequencyCode,
+    title: series.englishTitle,
+    firstObservedAt: reverseDate(series.firstObservation),
+    lastObservedAt: reverseDate(series.lastObservation),
+    updatedAt: reverseDate(series.updatedAt),
+    createdAt: reverseDate(series.createdAt),
+  }));
+}

package/src/helpers/reverse-date.ts

@@ -0,0 +1,3 @@
+export default function reverseDate(date: string): string {
+  return date.split('-').reverse().join('-');
+}

package/src/index.ts

@@ -1,3 +1,8 @@
-export { Client, ClientConfig, GetSeriesInput, SearchSeriesInput } from './client';
-export { ApiResponse, ErrorResponse, Frequency, GetSeriesResponse, SearchSeriesResponse } from './response';
-export { WebServiceError, InvalidCredentialsError, InvalidFrequencyError, InvalidSeriesError} from './errors';
+export { Client, ClientConfig, Frequency } from './client';
+export { ApiResponse, ErrorResponse, GetSeriesResponse, SearchSeriesResponse } from './types';
+export {
+  WebServiceError,
+  InvalidCredentialsError,
+  InvalidFrequencyError,
+  InvalidSeriesError,
+} from './errors';

package/src/types.ts

@@ -0,0 +1,113 @@
+interface SeriesValue {
+  /**
+   * Series observed date in DD-MM-YYYY format.
+   */
+  indexDateString: string;
+  /**
+   * Series observed value.
+   */
+  value: string;
+  /**
+   * Series observed value status code (ND = no data recorded).
+   */
+  statusCode: 'OK' | 'ND';
+}
+
+interface SeriesHistory {
+  /**
+   * Series identifier.
+   */
+  seriesId: string;
+  /**
+   * Series name in Spanish.
+   */
+  descripEsp: string;
+  /**
+   * Series name in English.
+   */
+  descripIng: string;
+  /**
+   * List of series observed values.
+   */
+  Obs: SeriesValue[];
+}
+
+type NullSeries = {
+  [key in keyof SeriesHistory]: null;
+};
+
+interface SeriesMetadata {
+  /**
+   * Series identifier.
+   */
+  seriesId: string;
+  /**
+   * Series frequency.
+   */
+  frequencyCode: string;
+  /**
+   * Series name in Spanish.
+   */
+  spanishTitle: string;
+  /**
+   * Series name in English.
+   */
+  englishTitle: string;
+  /**
+   * Date of first observation in DD-MM-YYYY format.
+   */
+  firstObservation: string;
+  /**
+   * Date of last observation in DD-MM-YYYY format.
+   */
+  lastObservation: string;
+  /**
+   * Date of last update in DD-MM-YYYY format.
+   */
+  updatedAt: string;
+  /**
+   * Date of creation in DD-MM-YYYY format.
+   */
+  createdAt: string;
+}
+
+export interface ApiResponse {
+  /**
+   * Response status code.
+   */
+  Codigo: number;
+  /**
+   * Response status message.
+   */
+  Descripcion: string;
+
+  /**
+   * Series historic information.
+   */
+  Series: SeriesHistory | NullSeries;
+  /**
+   * Series metadata information.
+   */
+  SeriesInfos: SeriesMetadata[];
+}
+
+export interface ErrorResponse extends ApiResponse {
+  Series: NullSeries;
+  SeriesInfos: never[];
+}
+
+export interface GetSeriesResponse {
+  seriesId: string;
+  description: string;
+  data: ReadonlyArray<{ date: string; value: number }>;
+}
+
+export type SearchSeriesResponse = ReadonlyArray<{
+  seriesId: string;
+  frequency: string;
+  title: string;
+  firstObservedAt: string;
+  lastObservedAt: string;
+  updatedAt: string;
+  createdAt: string;
+}>;

package/test/client.test.ts

@@ -1,6 +1,6 @@
-import { expect, describe, it, vi, afterEach, afterAll, beforeEach } from 'vitest';
-import { Client } from '../src';
+import { expect, describe, it, vi, afterEach, beforeEach } from 'vitest';
 import {
+  Client,
   Frequency,
   InvalidCredentialsError,
   InvalidSeriesError,
@@ -8,9 +8,8 @@ import {
 } from '../src';
 import fetchMock from './mocks/fetch.mock';
 import fixtures from './fixtures';
-import { reverseDate } from '../src/helpers';
+import reverseDate from '../src/helpers/reverse-date';
 
-// global.fetch = vi.fn().mockImplementation(fetchMock);
 const fetchSpy = vi.spyOn(global, 'fetch').mockImplementation(fetchMock);
 
 describe('Client', () => {
@@ -23,7 +22,7 @@ describe('Client', () => {
     user: '',
     pass: '',
   });
-  
+
   it('should create a Client instance', () => {
     expect(client).toBeInstanceOf(Client);
   });
@@ -37,46 +36,62 @@ describe('Client', () => {
     });
 
     it('should throw an error if series is not a non-empty string', async () => {
-      await expect(client.getSeries({
-        series: undefined as unknown as string,
-      })).rejects.toThrow('series must be a non-empty string');
-      await expect(client.getSeries({
-        series: '',
-      })).rejects.toThrow('series must be a non-empty string');
+      await expect(
+        client.getSeries({
+          series: undefined as unknown as string,
+        }),
+      ).rejects.toThrow('series must be a non-empty string');
+      await expect(
+        client.getSeries({
+          series: '',
+        }),
+      ).rejects.toThrow('series must be a non-empty string');
 
       expect(fetchSpy).not.toHaveBeenCalled();
     });
 
     it('should throw an error if date range is invalid', async () => {
-      await expect(client.getSeries({
-        series: 'TEST',
-        since: 'invalid',
-      })).rejects.toThrow('"since" is not a valid date string or Date object');
-      await expect(client.getSeries({
-        series: 'TEST',
-        since: new Date('invalid'),
-      })).rejects.toThrow('"since" is not a valid date string or Date object');
-
-      await expect(client.getSeries({
-        series: 'TEST',
-        until: 'invalid',
-      })).rejects.toThrow('"until" is not a valid date string or Date object');
-      await expect(client.getSeries({
-        series: 'TEST',
-        until: new Date('invalid'),
-      })).rejects.toThrow('"until" is not a valid date string or Date object');
-
-      await expect(client.getSeries({
-        series: 'TEST',
-        since: new Date(2020, 0, 1),
-        until: new Date(2000, 0, 1),
-      })).rejects.toThrow('invalid date range');
+      await expect(
+        client.getSeries({
+          series: 'TEST',
+          since: 'invalid',
+        }),
+      ).rejects.toThrow('"since" is not a valid date string or Date object');
+      await expect(
+        client.getSeries({
+          series: 'TEST',
+          since: new Date('invalid'),
+        }),
+      ).rejects.toThrow('"since" is not a valid date string or Date object');
+
+      await expect(
+        client.getSeries({
+          series: 'TEST',
+          until: 'invalid',
+        }),
+      ).rejects.toThrow('"until" is not a valid date string or Date object');
+      await expect(
+        client.getSeries({
+          series: 'TEST',
+          until: new Date('invalid'),
+        }),
+      ).rejects.toThrow('"until" is not a valid date string or Date object');
+
+      await expect(
+        client.getSeries({
+          series: 'TEST',
+          since: new Date(2020, 0, 1),
+          until: new Date(2000, 0, 1),
+        }),
+      ).rejects.toThrow('invalid date range');
 
       expect(fetchSpy).not.toHaveBeenCalled();
     });
 
     it('should throw error if credentials are invalid', async () => {
-      await expect(invalidClient.getSeries({ series: 'TEST' })).rejects.toThrow(InvalidCredentialsError);
+      await expect(invalidClient.getSeries({ series: 'TEST' })).rejects.toThrow(
+        InvalidCredentialsError,
+      );
       expect(fetchSpy).toHaveBeenCalledTimes(1);
     });
 
@@ -89,16 +104,20 @@ describe('Client', () => {
       const series = await client.getSeries({ series: 'TEST' });
 
       expect(fetchSpy).toHaveBeenCalledTimes(1);
-      
+
       expect(series).toBeDefined();
       expect(series.seriesId).toBe('TEST');
       expect(series.description).toBe('Test');
       expect(series.data).toBeInstanceOf(Array);
       expect(series.data).toHaveLength(15);
-      
+
       for (let i = 0; i < series.data.length; i += 1) {
-        expect(reverseDate(series.data[i].date)).toBe(fixtures.response.getSeriesSuccess.Series.Obs[i].indexDateString);
-        expect(series.data[i].value.toFixed(2)).toBe(fixtures.response.getSeriesSuccess.Series.Obs[i].value);
+        expect(reverseDate(series.data[i].date)).toBe(
+          fixtures.response.getSeriesSuccess.Series.Obs[i].indexDateString,
+        );
+        expect(series.data[i].value.toFixed(2)).toBe(
+          fixtures.response.getSeriesSuccess.Series.Obs[i].value,
+        );
 
         if (Number.isNaN(series.data[i].value)) {
           expect(fixtures.response.getSeriesSuccess.Series.Obs[i].statusCode).toBe('ND');
@@ -111,7 +130,7 @@ describe('Client', () => {
         series: 'TEST',
         until: '2020-12-05',
       });
-      
+
       expect(fetchSpy).toHaveBeenCalledTimes(1);
 
       expect(series).toBeDefined();
@@ -119,10 +138,14 @@ describe('Client', () => {
       expect(series.description).toBe('Test');
       expect(series.data).toBeInstanceOf(Array);
       expect(series.data).toHaveLength(5);
-      
+
       for (let i = 0; i < series.data.length; i += 1) {
-        expect(reverseDate(series.data[i].date)).toBe(fixtures.response.getSeriesSuccess.Series.Obs[i].indexDateString);
-        expect(series.data[i].value.toFixed(2)).toBe(fixtures.response.getSeriesSuccess.Series.Obs[i].value);
+        expect(reverseDate(series.data[i].date)).toBe(
+          fixtures.response.getSeriesSuccess.Series.Obs[i].indexDateString,
+        );
+        expect(series.data[i].value.toFixed(2)).toBe(
+          fixtures.response.getSeriesSuccess.Series.Obs[i].value,
+        );
 
         if (Number.isNaN(series.data[i].value)) {
           expect(fixtures.response.getSeriesSuccess.Series.Obs[i].statusCode).toBe('ND');
@@ -137,14 +160,13 @@ describe('Client', () => {
       });
 
       expect(fetchSpy).toHaveBeenCalledTimes(1);
-      
+
       expect(series).toBeDefined();
       expect(series.seriesId).toBe('TEST');
       expect(series.description).toBe('Test');
       expect(series.data).toBeInstanceOf(Array);
       expect(series.data).toHaveLength(0);
     });
-
   });
 
   describe('searchSeries', () => {
@@ -156,28 +178,36 @@ describe('Client', () => {
     });
 
     it('should throw an error if frequency is not a non-empty string', async () => {
-      await expect(client.searchSeries({
-        frequency: undefined as unknown as Frequency,
-      })).rejects.toThrow('frequency must be a non-empty string');
-      await expect(client.searchSeries({
-        frequency: '' as Frequency,
-      })).rejects.toThrow('frequency must be a non-empty string');
+      await expect(
+        client.searchSeries({
+          frequency: undefined as unknown as Frequency,
+        }),
+      ).rejects.toThrow('frequency must be a non-empty string');
+      await expect(
+        client.searchSeries({
+          frequency: '' as Frequency,
+        }),
+      ).rejects.toThrow('frequency must be a non-empty string');
 
       expect(fetchSpy).not.toHaveBeenCalled();
     });
 
     it('should throw error if credentials are invalid', async () => {
-      await expect(invalidClient.searchSeries({
-        frequency: Frequency.Daily,
-      })).rejects.toThrow(InvalidCredentialsError);
+      await expect(
+        invalidClient.searchSeries({
+          frequency: Frequency.Daily,
+        }),
+      ).rejects.toThrow(InvalidCredentialsError);
 
       expect(fetchSpy).toHaveBeenCalledTimes(1);
     });
 
     it('should throw error if frequency is invalid', async () => {
-      await expect(client.searchSeries({
-        frequency: 'invalid' as Frequency,
-      })).rejects.toThrow(InvalidFrequencyError);
+      await expect(
+        client.searchSeries({
+          frequency: 'invalid' as Frequency,
+        }),
+      ).rejects.toThrow(InvalidFrequencyError);
 
       expect(fetchSpy).toHaveBeenCalledTimes(1);
     });
@@ -188,9 +218,9 @@ describe('Client', () => {
       });
 
       expect(fetchSpy).toHaveBeenCalledTimes(1);
-      
+
       expect(series).toBeInstanceOf(Array);
       expect(series).toHaveLength(1);
     });
   });
-});
+});

package/test/fixtures/index.ts

@@ -12,4 +12,4 @@ export default {
     searchSeriesInvalid,
     searchSeriesSuccess,
   },
-};
+};

package/test/fixtures/responses/credentials.invalid.json

@@ -8,4 +8,4 @@
     "Obs": null
   },
   "SeriesInfos": []
-}
+}

package/test/fixtures/responses/getseries.invalid.json

@@ -8,4 +8,4 @@
     "Obs": null
   },
   "SeriesInfos": []
-}
+}

package/test/fixtures/responses/getseries.success.json

@@ -84,4 +84,4 @@
     ]
   },
   "SeriesInfo": []
-}
+}

package/test/fixtures/responses/searchseries.invalid.json

@@ -8,4 +8,4 @@
     "Obs": null
   },
   "SeriesInfos": []
-}
+}

package/test/fixtures/responses/searchseries.success.json

@@ -7,14 +7,16 @@
     "seriesId": null,
     "Obs": null
   },
-  "SeriesInfos": [{
-    "seriesId": "TEST",
-    "frequencyCode": "DAILY",
-    "spanishTitle": "Test",
-    "englishTitle": "Test",
-    "firstObservation": "01-12-2020",
-    "lastObservation": "15-12-2020",
-    "updatedAt": "19-01-2024",
-    "createdAt": "19-01-2024"
-  }]
-}
+  "SeriesInfos": [
+    {
+      "seriesId": "TEST",
+      "frequencyCode": "DAILY",
+      "spanishTitle": "Test",
+      "englishTitle": "Test",
+      "firstObservation": "01-12-2020",
+      "lastObservation": "15-12-2020",
+      "updatedAt": "19-01-2024",
+      "createdAt": "19-01-2024"
+    }
+  ]
+}

package/test/{helpers.test.ts → helpers/is-valid-date.test.ts}

@@ -1,16 +1,7 @@
 import { describe, it, expect } from 'vitest';
-import { reverseDate, isValidDate } from '../src/helpers';
+import isValidDate from '../../src/helpers/is-valid-date';
 
-describe('helpers: reverseDate', () => {
-  it('should reverse correctly a date in DD-MM-YYYY format', () => {
-    const date = '01-02-2020';
-    const reversed = reverseDate(date);
-
-    expect(reversed).toBe('2020-02-01');
-  });
-});
-
-describe('helpers: isValidDate', () => {
+describe('isValidDate', () => {
   it('should return true if the date is valid', () => {
     expect(isValidDate('2020-01-01')).toBe(true);
     expect(isValidDate(new Date())).toBe(true);
@@ -23,4 +14,4 @@ describe('helpers: isValidDate', () => {
     expect(isValidDate(null)).toBe(false);
     expect(isValidDate(new Date('invalid'))).toBe(false);
   });
-});
+});

package/test/helpers/parse-get-series.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import * as Errors from '../../src/errors';
+import { parseGetSeriesResponse } from '../../src/helpers/parsers';
+import { ApiResponse } from '../../src/types';
+import fixtures from '../fixtures';
+
+describe('parseGetSeriesResponse', () => {
+  it('should parse correctly a valid response', () => {
+    const parsed = parseGetSeriesResponse(
+      fixtures.response.getSeriesSuccess as unknown as ApiResponse,
+    );
+
+    expect(parsed).toBeDefined();
+    expect(parsed.seriesId).toBe(fixtures.response.getSeriesSuccess.Series.seriesId);
+    expect(parsed.description).toBe(fixtures.response.getSeriesSuccess.Series.descripIng);
+    expect(parsed.data).toHaveLength(fixtures.response.getSeriesSuccess.Series.Obs.length);
+
+    for (let i = 0; i < parsed.data.length; i += 1) {
+      expect(parsed.data[i].date).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+      expect(parsed.data[i].value.toFixed(2)).toBe(
+        fixtures.response.getSeriesSuccess.Series.Obs[i].value,
+      );
+
+      if (Number.isNaN(parsed.data[i].value)) {
+        expect(fixtures.response.getSeriesSuccess.Series.Obs[i].statusCode).toBe('ND');
+      }
+    }
+  });
+
+  it('should throw an InvalidCredentialsError if the response code is -5', () => {
+    expect(() =>
+      parseGetSeriesResponse(fixtures.response.credentialsInvalid as unknown as ApiResponse),
+    ).toThrow(Errors.InvalidCredentialsError);
+  });
+
+  it('should throw an InvalidSeriesError if the response code is -50', () => {
+    expect(() =>
+      parseGetSeriesResponse(fixtures.response.getSeriesInvalid as unknown as ApiResponse),
+    ).toThrow(Errors.InvalidSeriesError);
+  });
+
+  it('should throw a ResponseError if the response code is unknown', () => {
+    expect(() => parseGetSeriesResponse({} as ApiResponse)).toThrow(Errors.WebServiceError);
+  });
+});

package/test/helpers/parse-search-series.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import * as Errors from '../../src/errors';
+import { ApiResponse } from '../../src/types';
+import { parseSearchSeriesResponse } from '../../src/helpers/parsers';
+import fixtures from '../fixtures';
+
+describe('parseSearchSeriesResponse', () => {
+  it('should parse correctly a valid response', () => {
+    const parsed = parseSearchSeriesResponse(
+      fixtures.response.searchSeriesSuccess as unknown as ApiResponse,
+    );
+
+    expect(parsed).toBeInstanceOf(Array);
+    expect(parsed).toHaveLength(fixtures.response.searchSeriesSuccess.SeriesInfos.length);
+
+    for (let i = 0; i < parsed.length; i += 1) {
+      expect(parsed[i].seriesId).toBe(
+        fixtures.response.searchSeriesSuccess.SeriesInfos[i].seriesId,
+      );
+      expect(parsed[i].frequency).toBe(
+        fixtures.response.searchSeriesSuccess.SeriesInfos[i].frequencyCode,
+      );
+      expect(parsed[i].title).toBe(
+        fixtures.response.searchSeriesSuccess.SeriesInfos[i].englishTitle,
+      );
+      expect(parsed[i].firstObservedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+      expect(parsed[i].lastObservedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+      expect(parsed[i].updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+      expect(parsed[i].createdAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    }
+  });
+
+  it('should throw an InvalidCredentialsError if the response code is -5', () => {
+    expect(() =>
+      parseSearchSeriesResponse(fixtures.response.credentialsInvalid as unknown as ApiResponse),
+    ).toThrow(Errors.InvalidCredentialsError);
+  });
+
+  it('should throw an InvalidFrequencyError if the response code is -1', () => {
+    expect(() =>
+      parseSearchSeriesResponse(fixtures.response.searchSeriesInvalid as unknown as ApiResponse),
+    ).toThrow(Errors.InvalidFrequencyError);
+  });
+
+  it('should throw a ResponseError if the response code is unknown', () => {
+    expect(() => parseSearchSeriesResponse({} as ApiResponse)).toThrow(Errors.WebServiceError);
+  });
+});

package/test/helpers/reverse-date.test.ts

@@ -0,0 +1,11 @@
+import { describe, it, expect } from 'vitest';
+import reverseDate from '../../src/helpers/reverse-date';
+
+describe('reverseDate', () => {
+  it('should reverse correctly a date in DD-MM-YYYY format', () => {
+    const date = '01-02-2020';
+    const reversed = reverseDate(date);
+
+    expect(reversed).toBe('2020-02-01');
+  });
+});