emissions-api-sdk 1.0.0

package/test/apiTest.test.ts

@@ -0,0 +1,168 @@
+import * as requestModule from "../src/request";
+import * as locationApi from "../src/api/Location";
+import * as fugitiveApi from "../src/api/Fugitive";
+import * as mobileApi from "../src/api/Mobile";
+import * as stationaryApi from "../src/api/Stationary";
+import * as GenericCalculation from "../src/api/Calculation";
+import * as TransportationDistributionApi from "../src/api/TransportationAndDistribution";
+import * as Factors from "../src/api/Factor";
+import * as FactorSets from "../src/api/FactorSets";
+
+import {
+  LOCATION_API_PATH,
+  FUGITIVE_API_PATH,
+  STATIONARY_API_PATH,
+  MOBILE_API_PATH,
+  GENERIC_CALCULATION_API_PATH,
+  TRANSPORTATION_AND_DISTRIBUTION_API_PATH,
+  FACTOR_API_PATH,
+  FACTOR_SET_API_PATH,
+  SEARCH_API_PATH,
+} from "../src/Constants";
+import locationPayload from "./mocks/LocationRequest";
+import commonpayload from "./mocks/CommonRequest";
+import { Client } from "../src/Client";
+import GenericCalculationPayload from "./mocks/GenericCalculationRequest";
+import FactorPayload from "./mocks/FactorRequest";
+import SearchPayload from "./mocks/SearchRequest";
+
+type ApiTestCase = {
+  name: string;
+  func: (payload?: any) => Promise<string>;
+  path: string;
+  payload?: any;
+  pathParams?: string | string[];
+  method: "GET" | "POST";
+};
+
+const mockResp = "mock-success-response";
+
+const testCases: ApiTestCase[] = [
+  {
+    name: "Location API",
+    func: locationApi.calculate,
+    path: LOCATION_API_PATH,
+    payload: locationPayload,
+    method: "POST",
+  },
+  {
+    name: "Fugitive API",
+    func: fugitiveApi.calculate,
+    path: FUGITIVE_API_PATH,
+    payload: commonpayload,
+    method: "POST",
+  },
+  {
+    name: "Mobile API",
+    func: mobileApi.calculate,
+    path: MOBILE_API_PATH,
+    payload: commonpayload,
+    method: "POST",
+  },
+  {
+    name: "Stationary API",
+    func: stationaryApi.calculate,
+    path: STATIONARY_API_PATH,
+    payload: commonpayload,
+    method: "POST",
+  },
+  {
+    name: "GenericCalculation API",
+    func: GenericCalculation.calculate,
+    path: GENERIC_CALCULATION_API_PATH,
+    payload: GenericCalculationPayload,
+    method: "POST",
+  },
+  {
+    name: "Factor API",
+    func: Factors.retrieveFactor,
+    path: FACTOR_API_PATH,
+    payload: FactorPayload,
+    method: "POST",
+  },
+  {
+    name: "Transportation and Distribution API",
+    func: TransportationDistributionApi.calculate,
+    path: TRANSPORTATION_AND_DISTRIBUTION_API_PATH,
+    payload: GenericCalculationPayload,
+    method: "POST",
+  },
+  {
+    name: "FactorSet API",
+    func: FactorSets.get,
+    path: FACTOR_SET_API_PATH,
+    method: "GET",
+  },
+  {
+    name: "Search API",
+    func: Factors.search,
+    path: SEARCH_API_PATH,
+    payload: SearchPayload,
+    method: "POST",
+  },
+];
+
+describe("API Test calculate functions", () => {
+  let spy: jest.SpyInstance;
+  let tokenSpy: jest.SpyInstance;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    tokenSpy = jest
+      .spyOn(Client as any, "requestToken")
+      .mockResolvedValue(
+        "eyJpzGciOiJIUzI1NlIsInR5cCI6IkplVCJ9." +
+          Buffer.from(
+            JSON.stringify({ exp: Math.floor(Date.now() / 1000) + 3600 })
+          ).toString("base64") +
+          ".signature"
+      );
+
+    Client.getClient({
+      apiKey: "mock-api-key",
+      clientId: "mock-client-id",
+      orgId: "mock-org-id",
+    });
+    spy = jest
+      .spyOn(requestModule, "makeApiRequest")
+      .mockResolvedValue(mockResp);
+  });
+  afterEach(() => {
+    tokenSpy.mockRestore();
+    spy.mockRestore();
+  });
+  describe.each(testCases)(
+    "$name",
+    ({ func, path, payload, pathParams, method }) => {
+      it("Should call makeApiRequest with API url", async () => {
+        let result;
+        if (method === "POST") {
+          result = await func(payload);
+        } else {
+          result =
+            pathParams !== undefined
+              ? await func(pathParams)
+              : await func();
+        }
+        const clientDomain = Client.getInstance().getDomain();
+
+        let UrlWithParams = `${clientDomain}${path}`;
+        if (method === "GET" && pathParams) {
+          UrlWithParams = `${clientDomain}${path}/${
+            Array.isArray(pathParams) ? pathParams.join("/") : pathParams
+          }`;
+        }
+
+        const expectedUrl =
+          method === "GET" ? UrlWithParams : `${clientDomain}${path}`;
+
+        const expectedRequest: any = {
+          method,
+          url: expectedUrl,
+        };
+        if (method === "POST") expectedRequest.data = payload;
+        expect(spy).toHaveBeenCalledWith(expectedRequest);
+        expect(result).toBe(mockResp);
+      });
+    }
+  );
+});

package/test/client.test.ts

@@ -0,0 +1,82 @@
+import { Client } from "../src/Client";
+import axios from "axios";
+import MockAdapter from "axios-mock-adapter";
+import { TOKEN_GENERATION_API } from "../src/Constants";
+import { ClientConfig } from "../src/interfaces/Config";
+
+const mock = new MockAdapter(axios);
+
+describe("Client initialization and Header Authorization", () => {
+  const base64Header = Buffer.from(
+    JSON.stringify({ alg: "HS256", typ: "JWT" })
+  ).toString("base64url");
+  const base64Payload = Buffer.from(
+    JSON.stringify({ exp: Math.floor(Date.now() / 1000) + 600 })
+  ).toString("base64url");
+  const mockToken = `${base64Header}.${base64Payload}.Signature`;
+
+  const config = {
+    apiKey: " somerandomkey",
+    clientId: "emptyclient",
+    orgId: "OrgId",
+  };
+  beforeEach(() => {
+    mock.reset();
+    mock.onGet(TOKEN_GENERATION_API).reply(200, mockToken);
+  });
+
+  it("should initialize client and return auth header", async () => {
+    await Client.getClient(config);
+    const instance = Client.getInstance();
+    expect(instance.getAuthHeader()).toEqual({
+      Authorization: `Bearer ${mockToken}`,
+    });
+  });
+
+  it("Should throw if getInstance called before initiating client", () => {
+    Client["instance"] = null;
+    expect(() => Client.getInstance()).toThrow(
+      "Client is not initialized. Call Client.getClient() first."
+    );
+  });
+
+  it("Should throw validation error for missing dependent config", async () => {
+    await expect(
+      Client.getClient({ host: "custom-host", clientId: "clientId" })
+    ).rejects.toThrow(
+      'If custom "host" is provided, "authUrl" must also be provided.'
+    );
+    await expect(
+      Client.getClient({ token: "custom token" } as unknown as ClientConfig)
+    ).rejects.toThrow(
+      'If token is provided directly, "clientId" must also be provided.'
+    );
+    await expect(
+      Client.getClient({ apiKey: "abc" } as unknown as ClientConfig)
+    ).rejects.toThrow(
+      'If apiKey is provided , "clientId" and "OrgId" must also be provided.'
+    );
+  });
+  it("should not call refresh token if userProvidedToken is set and set token to userProvided", async () => {
+    const base64Header = Buffer.from(
+      JSON.stringify({ alg: "HS256", typ: "JWT" })
+    ).toString("base64url");
+    const base64Payload = Buffer.from(
+      JSON.stringify({ exp: Math.floor(Date.now() / 1000) + 600 })
+    ).toString("base64url");
+    const mockToken = `${base64Header}.${base64Payload}.Signature`;
+
+    const userToken = mockToken;
+    const spy = jest.spyOn(Client as any, "requestToken");
+    await Client.getClient({
+      token: userToken,
+      clientId: "sample id",
+    } as any);
+    const instance = Client.getInstance();
+    await instance.refreshToken();
+    expect(instance.getAuthHeader()).toEqual({
+      Authorization: `Bearer ${userToken}`,
+    });
+    expect(spy).not.toHaveBeenCalled();
+  });
+});

package/test/mocks/CommonRequest.ts

@@ -0,0 +1,19 @@
+import { CommonRequest } from '../../src/interfaces/Api';
+
+const commonPayload: CommonRequest = {
+  location: {
+    country: 'usa',
+    stateProvince: 'new york',
+  },
+  time: {
+    date: '2025-06-10',
+  },
+  activity: {
+    value: 10,
+    unit: 'unit',
+    type: 'type',
+  },
+  includeDetails: false,
+};
+
+export default commonPayload;

package/test/mocks/FactorRequest.ts

@@ -0,0 +1,16 @@
+import { FactorRequest } from "../../src/interfaces/Api";
+
+const FactorPayload: FactorRequest = {
+  location: {
+   "country": "GBR"
+  },
+  time: {
+    date: "2025-06-10",
+  },
+  activity: {
+    "type":"electricity",
+    "unit": "kwh"
+  },
+};
+
+export default FactorPayload;

package/test/mocks/GenericCalculationRequest.ts

@@ -0,0 +1,19 @@
+import { CalculationRequest } from "../../src/interfaces/Api";
+
+const GenericCalculationPayload: CalculationRequest = {
+  location: {
+    country: "usa",
+  },
+  time: {
+    date: "2025-06-10",
+  },
+  activity: {
+    type: "electricity:default factor",
+    value: 0.1,
+    unit: "kwh",
+    
+  },
+  includeDetails: true,
+};
+
+export default GenericCalculationPayload;

package/test/mocks/LocationRequest.ts

@@ -0,0 +1,19 @@
+import { LocationRequest } from '../../src/interfaces/Api';
+
+const locationPayload: LocationRequest = {
+  location: {
+    country: 'usa',
+    stateProvince: 'new york',
+  },
+  time: {
+    date: '2025-06-10',
+  },
+  activity: {
+    value: 100,       // Required
+    type: 'electricity', // Optional
+    unit: 'kWh',         // Optional
+  },
+  includeDetails: true,
+};
+
+export default locationPayload;

package/test/mocks/SearchRequest.ts

@@ -0,0 +1,19 @@
+import { SearchRequest } from "../../src/interfaces/Api";
+
+const SearchPayload: SearchRequest = {
+  location: {
+   "country": "usa"
+  },
+  time: {
+    date: "2025-06-10",
+  },
+  activity: {
+    "search": "electricity"
+  },
+  pagination:{
+    "page": 10,
+    "size": 1
+  }
+};
+
+export default SearchPayload;

package/test/request.test.ts

@@ -0,0 +1,111 @@
+import axios, { Method } from "axios";
+import { makeApiRequest } from "../src/request";
+import { Client } from "../src/Client";
+import { RequestConfig } from "../src/interfaces/Config";
+import { get } from "http";
+import { CLIENT_SOURCE_HEADER } from "../src/Constants";
+
+jest.mock("axios");
+
+describe("makeApiRequest", () => {
+  const mockRefreshToken = jest.fn();
+  const mockGetAuthHeader = jest.fn();
+  const mockGetClientId = jest.fn();
+  const mockGetClientSource = jest.fn();
+  const mockAxiosRequest = axios.request as jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    const mockClient = {
+      refreshToken: mockRefreshToken,
+      getAuthHeader: mockGetAuthHeader,
+      getClientId: mockGetClientId,
+      getClientSource : mockGetClientSource
+    };
+
+    mockGetAuthHeader.mockReturnValue({ Authorization: "Bearer mock-token" });
+    mockGetClientId.mockReturnValue("mock-client-id");
+    mockGetClientSource.mockReturnValue("excel");
+
+    jest.spyOn(Client, "getInstance").mockReturnValue(mockClient as any);
+  });
+
+  it("should make a successful API call with full config", async () => {
+    const expectedResponse = { data: { success: true } };
+    mockAxiosRequest.mockResolvedValue(expectedResponse);
+
+    const config: RequestConfig = {
+      method: "POST" as Method,
+      url: "/test-route",
+      data: { key: "value" },
+      params: { id: 1 },
+      headers: { custom: "header" },
+    };
+
+    const result = await makeApiRequest<typeof expectedResponse.data>(config);
+
+    expect(mockRefreshToken).toHaveBeenCalled();
+    expect(mockGetAuthHeader).toHaveBeenCalled();
+    expect(mockGetClientId).toHaveBeenCalled();
+    expect(mockGetClientSource).toHaveBeenCalled(); 
+
+    expect(mockAxiosRequest).toHaveBeenCalledWith({
+      method: "POST",
+      url: "/test-route",
+      data: { key: "value" },
+      params: { id: 1 },
+      headers: {
+        Authorization: "Bearer mock-token",
+        custom: "header",
+        "Content-Type": "application/json",
+        "X-IBM-Client-Id": "ghgemissions-mock-client-id",
+        [CLIENT_SOURCE_HEADER]: "excel"
+      },
+    });
+
+    expect(result).toEqual(expectedResponse.data);
+  });
+
+  it("should make a request with minimal config", async () => {
+    const expectedResponse = { data: { message: "ok" } };
+    mockAxiosRequest.mockResolvedValue(expectedResponse);
+
+    const config: RequestConfig = {
+      method: "GET" as Method,
+      url: "/test-route",
+    };
+
+    const result = await makeApiRequest<typeof expectedResponse.data>(config);
+
+    expect(mockAxiosRequest).toHaveBeenCalledWith({
+      method: "GET",
+      url: "/test-route",
+      data: undefined,
+      params: undefined,
+      headers: {
+        Authorization: "Bearer mock-token",
+        "Content-Type": "application/json",
+        "X-IBM-Client-Id": "ghgemissions-mock-client-id",
+        [CLIENT_SOURCE_HEADER]: "excel"
+      },
+    });
+
+    expect(result).toEqual(expectedResponse.data);
+  });
+
+  it("should throw an error if axios request fails", async () => {
+    const error = new Error("Network failure");
+    mockAxiosRequest.mockRejectedValue(error);
+
+    const config: RequestConfig = {
+      method: "GET" as Method,
+      url: "/fail",
+    };
+
+    await expect(makeApiRequest(config)).rejects.toThrow("Network failure");
+
+    expect(mockRefreshToken).toHaveBeenCalled();
+    expect(mockAxiosRequest).toHaveBeenCalled();
+  });
+});

package/test/testUtils.ts

@@ -0,0 +1,5 @@
+export function generateMockjwt(expiryInSecsFromNow : number): string {
+    const header = Buffer.from(JSON.stringify({alg: 'HS256', typ: 'JWT'})).toString('base64url');
+    const payload = Buffer.from(JSON.stringify({exp: Math.floor(Date.now()/1000) + expiryInSecsFromNow})).toString('base64url');
+    return `${header}.${payload}.signature`;
+}

package/test/tokenRefresh.test.ts

@@ -0,0 +1,52 @@
+import { Client } from "../src/Client";
+import * as utils from "../src/utils";
+import mockAxios from "axios";
+import MockAdapter from "axios-mock-adapter";
+import { generateMockjwt } from "./testUtils";
+import { TOKEN_GENERATION_API } from "../src/Constants";
+
+const mock = new MockAdapter(mockAxios);
+describe("Token refreshing", () => {
+  const config = { apiKey: "abc", clientId: "234", orgId:"123" };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mock.reset();
+  });
+
+  it("should not refresh if token is still valid", async () => {
+    const freshToken = generateMockjwt(600);
+    mock.onGet(TOKEN_GENERATION_API).reply(200, { freshToken });
+
+    jest
+      .spyOn(utils, "findExpiryTime")
+      .mockReturnValue(Math.floor(Date.now() / 1000) + 600);
+
+    await Client.getClient(config);
+    const instance = Client.getInstance();
+
+    const spy = jest.spyOn(Client as any, "requestToken");
+
+    await instance.refreshToken();
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it("should not refresh if token is still valid", async () => {
+    const shortLiveToken = generateMockjwt(1);
+    const refreshToken = generateMockjwt(600);
+    mock
+      .onGet(TOKEN_GENERATION_API)
+      .reply(200, { refreshToken });
+
+    jest
+      .spyOn(utils, "findExpiryTime")
+      .mockReturnValue(Math.floor(Date.now() / 1000) + 1);
+
+    await Client.getClient(config);
+    const instance = Client.getInstance();
+
+    const spy = jest.spyOn(Client as any, "requestToken");
+
+    await instance.refreshToken();
+    expect(spy).not.toHaveBeenCalledTimes(1);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "CommonJS",
+    "declaration": true,
+    "declarationDir": "./dist/types",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"],
+    "exclude": ["test", "**/*.test.ts"]
+
+}