bcchapi 1.0.8 → 2.0.0

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',
-  },
-});