bcchapi 1.0.9 → 2.0.1

package/test/client.test.ts

@@ -1,226 +0,0 @@
-import { expect, describe, it, vi, afterEach, beforeEach } from 'vitest';
-import {
-  Client,
-  Frequency,
-  InvalidCredentialsError,
-  InvalidSeriesError,
-  InvalidFrequencyError,
-} from '../src';
-import { reverseDate } from '../src/utils';
-import fetchMock from './mocks/fetch.mock';
-import fixtures from './fixtures';
-
-const fetchSpy = vi.spyOn(global, 'fetch').mockImplementation(fetchMock);
-
-describe('Client', () => {
-  const client = new Client({
-    user: 'test',
-    pass: 'test',
-  });
-
-  const invalidClient = new Client({
-    user: '',
-    pass: '',
-  });
-
-  it('should create a Client instance', () => {
-    expect(client).toBeInstanceOf(Client);
-  });
-
-  describe('getSeries', () => {
-    beforeEach(() => {
-      fetchSpy.mockImplementation(fetchMock);
-    });
-    afterEach(() => {
-      fetchSpy.mockReset();
-    });
-
-    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');
-
-      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');
-
-      expect(fetchSpy).not.toHaveBeenCalled();
-    });
-
-    it('should throw error if credentials are invalid', async () => {
-      await expect(invalidClient.getSeries({ series: 'TEST' })).rejects.toThrow(
-        InvalidCredentialsError,
-      );
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('should throw error if series does not exist', async () => {
-      await expect(client.getSeries({ series: 'invalid' })).rejects.toThrow(InvalidSeriesError);
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('should return the series history information', async () => {
-      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(series.data[i].date).toBe(
-          reverseDate(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');
-        }
-      }
-    });
-
-    it('should filter the series history by date range', async () => {
-      const series = await client.getSeries({
-        series: 'TEST',
-        until: '2020-12-05',
-      });
-
-      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(5);
-
-      for (let i = 0; i < series.data.length; i += 1) {
-        expect(series.data[i].date).toBe(
-          reverseDate(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');
-        }
-      }
-    });
-
-    it('should return empty results if series has no data', async () => {
-      const series = await client.getSeries({
-        series: 'TEST',
-        since: '2020-12-16',
-      });
-
-      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', () => {
-    beforeEach(() => {
-      fetchSpy.mockImplementation(fetchMock);
-    });
-    afterEach(() => {
-      fetchSpy.mockReset();
-    });
-
-    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');
-
-      expect(fetchSpy).not.toHaveBeenCalled();
-    });
-
-    it('should throw error if credentials are invalid', async () => {
-      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);
-
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('should return the series metadata information', async () => {
-      const series = await client.searchSeries({
-        frequency: Frequency.Daily,
-      });
-
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      expect(series).toBeInstanceOf(Array);
-      expect(series).toHaveLength(1);
-    });
-  });
-});

package/test/fixtures/index.ts

@@ -1,15 +0,0 @@
-import getSeriesSuccess from './responses/getseries.success.json';
-import getSeriesInvalid from './responses/getseries.invalid.json';
-import searchSeriesSuccess from './responses/searchseries.success.json';
-import searchSeriesInvalid from './responses/searchseries.invalid.json';
-import credentialsInvalid from './responses/credentials.invalid.json';
-
-export default {
-  response: {
-    credentialsInvalid,
-    getSeriesInvalid,
-    getSeriesSuccess,
-    searchSeriesInvalid,
-    searchSeriesSuccess,
-  },
-};

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

@@ -1,11 +0,0 @@
-{
-  "Codigo": -5,
-  "Descripcion": "Invalid username or password",
-  "Series": {
-    "descripEsp": null,
-    "descripIng": null,
-    "seriesId": null,
-    "Obs": null
-  },
-  "SeriesInfos": []
-}

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

@@ -1,11 +0,0 @@
-{
-  "Codigo": -50,
-  "Descripcion": "An internal error has occurred, information is not available.",
-  "Series": {
-    "descripEsp": null,
-    "descripIng": null,
-    "seriesId": null,
-    "Obs": null
-  },
-  "SeriesInfos": []
-}

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

@@ -1,87 +0,0 @@
-{
-  "Codigo": 0,
-  "Descripcion": "Success",
-  "Series": {
-    "seriesId": "TEST",
-    "descripEsp": "Test",
-    "descripIng": "Test",
-    "Obs": [
-      {
-        "indexDateString": "01-12-2020",
-        "value": "12.01",
-        "statusCode": "OK"
-      },
-      {
-        "indexDateString": "02-12-2020",
-        "value": "12.02",
-        "statusCode": "OK"
-      },
-      {
-        "indexDateString": "03-12-2020",
-        "value": "12.03",
-        "statusCode": "OK"
-      },
-      {
-        "indexDateString": "04-12-2020",
-        "value": "12.04",
-        "statusCode": "OK"
-      },
-      {
-        "indexDateString": "05-12-2020",
-        "value": "NaN",
-        "statusCode": "ND"
-      },
-      {
-        "indexDateString": "06-12-2020",
-        "value": "NaN",
-        "statusCode": "ND"
-      },
-      {
-        "indexDateString": "07-12-2020",
-        "value": "12.07",
-        "statusCode": "OK"
-      },
-      {
-        "indexDateString": "08-12-2020",
-        "value": "NaN",
-        "statusCode": "ND"
-      },
-      {
-        "indexDateString": "09-12-2020",
-        "value": "12.09",
-        "statusCode": "OK"
-      },
-      {
-        "indexDateString": "10-12-2020",
-        "value": "12.10",
-        "statusCode": "OK"
-      },
-      {
-        "indexDateString": "11-12-2020",
-        "value": "12.11",
-        "statusCode": "OK"
-      },
-      {
-        "indexDateString": "12-12-2020",
-        "value": "NaN",
-        "statusCode": "ND"
-      },
-      {
-        "indexDateString": "13-12-2020",
-        "value": "NaN",
-        "statusCode": "ND"
-      },
-      {
-        "indexDateString": "14-12-2020",
-        "value": "12.14",
-        "statusCode": "OK"
-      },
-      {
-        "indexDateString": "15-12-2020",
-        "value": "12.15",
-        "statusCode": "OK"
-      }
-    ]
-  },
-  "SeriesInfo": []
-}

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

@@ -1,11 +0,0 @@
-{
-  "Codigo": -1,
-  "Descripcion": "FrequencyCode must have a valid code (ie. DAILY, MONTHLY, QUARTERLY or ANNUAL)",
-  "Series": {
-    "descripEsp": null,
-    "descripIng": null,
-    "seriesId": null,
-    "Obs": null
-  },
-  "SeriesInfos": []
-}

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

@@ -1,22 +0,0 @@
-{
-  "Codigo": 0,
-  "Descripcion": "Success",
-  "Series": {
-    "descripEsp": null,
-    "descripIng": null,
-    "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"
-    }
-  ]
-}

package/test/handlers/handle-get-series.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as Errors from '../../src/errors';
-import { handleGetSeriesResponse } from '../../src/handlers';
-import { ApiResponse } from '../../src/types';
-import fixtures from '../fixtures';
-
-describe('handleGetSeriesResponse', () => {
-  it('should parse correctly a valid response', () => {
-    const parsed = handleGetSeriesResponse(
-      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(() =>
-      handleGetSeriesResponse(fixtures.response.credentialsInvalid as unknown as ApiResponse),
-    ).toThrow(Errors.InvalidCredentialsError);
-  });
-
-  it('should throw an InvalidSeriesError if the response code is -50', () => {
-    expect(() =>
-      handleGetSeriesResponse(fixtures.response.getSeriesInvalid as unknown as ApiResponse),
-    ).toThrow(Errors.InvalidSeriesError);
-  });
-
-  it('should throw a ResponseError if the response code is unknown', () => {
-    expect(() => handleGetSeriesResponse({} as ApiResponse)).toThrow(Errors.WebServiceError);
-  });
-});

package/test/handlers/handle-search-series.test.ts

@@ -1,48 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as Errors from '../../src/errors';
-import { ApiResponse } from '../../src/types';
-import { handleSearchSeriesResponse } from '../../src/handlers';
-import fixtures from '../fixtures';
-
-describe('handleSearchSeriesResponse', () => {
-  it('should parse correctly a valid response', () => {
-    const parsed = handleSearchSeriesResponse(
-      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(() =>
-      handleSearchSeriesResponse(fixtures.response.credentialsInvalid as unknown as ApiResponse),
-    ).toThrow(Errors.InvalidCredentialsError);
-  });
-
-  it('should throw an InvalidFrequencyError if the response code is -1', () => {
-    expect(() =>
-      handleSearchSeriesResponse(fixtures.response.searchSeriesInvalid as unknown as ApiResponse),
-    ).toThrow(Errors.InvalidFrequencyError);
-  });
-
-  it('should throw a ResponseError if the response code is unknown', () => {
-    expect(() => handleSearchSeriesResponse({} as ApiResponse)).toThrow(Errors.WebServiceError);
-  });
-});

package/test/mocks/fetch.mock.ts

@@ -1,76 +0,0 @@
-import { Frequency } from '../../src/client';
-import { reverseDate } from '../../src/utils';
-import fixtures from '../fixtures';
-
-export default (input: string | URL | Request) => {
-  const params = new URL(input.toString()).searchParams;
-  const func = params.get('function') || 'GetSeries';
-
-  if (params.get('user') !== 'test' || params.get('pass') !== 'test') {
-    return Promise.resolve({
-      json: () => Promise.resolve(fixtures.response.credentialsInvalid),
-    } as Response);
-  }
-
-  if (func === 'GetSeries') {
-    if (fixtures.response.getSeriesSuccess.Series.seriesId !== params.get('timeseries')) {
-      return Promise.resolve({
-        json: () => Promise.resolve(fixtures.response.getSeriesInvalid),
-      } as Response);
-    }
-
-    const firstDate = params.get('firstdate');
-    const lastDate = params.get('lastdate');
-    const obs = fixtures.response.getSeriesSuccess.Series.Obs.filter((o) => {
-      if (firstDate && lastDate) {
-        return (
-          reverseDate(o.indexDateString) >= firstDate && reverseDate(o.indexDateString) <= lastDate
-        );
-      }
-      if (firstDate) {
-        return reverseDate(o.indexDateString) >= firstDate;
-      }
-      if (lastDate) {
-        return reverseDate(o.indexDateString) <= lastDate;
-      }
-      return true;
-    });
-    const series = {
-      ...fixtures.response.getSeriesSuccess.Series,
-      Obs: obs,
-    };
-
-    return Promise.resolve({
-      json: () =>
-        Promise.resolve({
-          ...fixtures.response.getSeriesSuccess,
-          Series: series,
-        }),
-    } as Response);
-  }
-
-  if (func === 'SearchSeries') {
-    const frequency = params.get('frequency');
-
-    if (!Object.values(Frequency).includes(frequency as Frequency)) {
-      return Promise.resolve({
-        json: () => Promise.resolve(fixtures.response.searchSeriesInvalid),
-      } as Response);
-    }
-
-    const response = {
-      ...fixtures.response.searchSeriesSuccess,
-      SeriesInfo: fixtures.response.searchSeriesSuccess.SeriesInfos.filter(
-        (series) => series.frequencyCode === frequency,
-      ),
-    };
-
-    return Promise.resolve({
-      json: () => Promise.resolve(response),
-    } as Response);
-  }
-
-  return Promise.resolve({
-    json: () => Promise.resolve({}),
-  } as Response);
-};

package/test/utils/is-valid-date.test.ts

@@ -1,17 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { isValidDate } from '../../src/utils';
-
-describe('isValidDate', () => {
-  it('should return true if the date is valid', () => {
-    expect(isValidDate('2020-01-01')).toBe(true);
-    expect(isValidDate(new Date())).toBe(true);
-  });
-
-  it('should return false if the date is invalid', () => {
-    expect(isValidDate('invalid')).toBe(false);
-    expect(isValidDate({})).toBe(false);
-    expect(isValidDate(undefined)).toBe(false);
-    expect(isValidDate(null)).toBe(false);
-    expect(isValidDate(new Date('invalid'))).toBe(false);
-  });
-});

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

@@ -1,11 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { reverseDate } from '../../src/utils';
-
-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');
-  });
-});

package/tsconfig.eslint.json

@@ -1,5 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {},
-  "include": ["./src", "./test"]
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "@tsconfig/node20/tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "resolveJsonModule": true,
-    "declaration": true
-  },
-  "include": ["src/**/*"]
-}

package/vitest.config.mts

@@ -1,9 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    dir: 'test',
-  },
-});