emissions-api-sdk 1.0.8 → 1.0.10

package/src/interfaces/response/EmissionResponseWithDetails.ts

@@ -1,51 +1,11 @@
 import { EmissionResponse } from './EmissionResponse';
 
 /**
- * Interface for unit information in emission details
+ * Interface for factor set details
  */
-export interface UnitInfo {
-  /** Unit name */
-  name: string;
-  
-  /** Unit description (optional) */
-  description?: string;
-}
-
-/**
- * Interface for area information
- */
-export interface AreaInfo {
-  /** Internal name of the area */
-  internalName: string;
-  
-  /** Standard name of the area */
-  standardName: string;
-
-  alpha3?: string;
-}
-
-/**
- * Interface for area type information
- */
-export interface AreaType {
-  /** Type name (e.g., "Planet", "State") */
-  name: string;
-}
-
-/**
- * Interface for factor data type categories
- */
-export interface FactorDataTypeCategory {
-  /** Category name */
-  name: string;
-}
-
-/**
- * Interface for factor set information
- */
-export interface FactorSetInfo {
-  /** Factor set type */
-  type: string;
+export interface FactorSetDetails {
+  /** Name of the factor set */
+  name?: string;
   
   /** Description of the factor set */
   description?: string;
@@ -55,135 +15,108 @@ export interface FactorSetInfo {
   
   /** Source URL for the factor set */
   sourceUrl?: string;
-
-  factorSource?: string;
-}
-export interface FactorSelectionDefault {
-    actorDataType?: string;
-    areaName?: string;
-    factorSetName?: string;
+  
+  /** Citation information for the factor set */
+  citation?: string;
 }
+
 /**
- * Interface for factor data type code
+ * Interface for factor details
  */
-export interface FactorDataTypeCode {
-  /** Unit of measure */
-  unitOfMeasure: string;
+export interface FactorDetails {
+  /** Name of the factor */
+  name?: string;
   
-  /** Activity type */
-  type: string;
+  /** Description of the factor */
+  description?: string;
   
-  /** Activity subtype */
-  subtype: string;
+  /** Total CO2 equivalent emissions */
+  totalCO2e?: number;
   
-  /** Unique factor identifier */
-  factorId: number;
+  /** CO2 emissions value */
+  CO2?: number;
   
-  /** activity based or spend based */
-  methodology: string;
-
-  /** scopes data belongs to */
-	scope : string[];
-}
-
-/**
- * Interface for factor set version information
- */
-export interface FactorSetVersion {
-  /** Publication start date */
-  publishedFrom?: string;
+  /** CH4 (Methane) emissions value */
+  CH4?: number;
   
-  /** Publication end date (optional) */
-  publishedTo?: string;
+  /** N2O (Nitrous Oxide) emissions value */
+  N2O?: number;
   
-  /** Source of the factor */
-  factorSource: string;
-}
-
-/**
- * Interface for factor value
- */
-export interface FactorValue {
-  /** Unit information */
-  unit: {
-    /** Unit name */
-    name: string;
-  };
-  
-  /** Factor value */
-  value: number;
-}
-
-/**
- * Interface for factor metadata
- */
-export interface FactorMetaData {
-  /** Metadata key */
-  key: string;
+  /** Biogenic CO2 emissions value */
+  bioCO2?: number;
   
-  /** Metadata value */
-  value: string;
-}
-
-/**
- * Interface for unit conversion information
- */
-export interface UnitConversion {
-  /** Input unit */
-  inputUnit: string;
+  /** Indirect CO2 equivalent emissions value */
+  indirectCO2e?: number;
+  
+  /** Hydrofluorocarbon emissions value */
+  HFC?: number;
+  
+  /** Perfluorocarbon emissions value */
+  PFC?: number;
+  
+  /** Sulfur hexafluoride emissions value */
+  SF6?: number;
+  
+  /** Nitrogen trifluoride emissions value */
+  NF3?: number;
   
-  /** Unit from database */
-  unitFromDb: string;
+  /** Energy consumption in megawatt-hours */
+  'energy(MWh)'?: number;
+  
+  /** Input unit of measurement */
+  inputUnit?: string;
+  
+  /** Unit of measurement for emissions */
+  unit?: string;
   
   /** Conversion ratio */
-  conversionRatio: string;
-}
-
-/**
- * Interface for detailed emission data
- */
-export interface EmissionData {
-  /** Array of unit information */
-  unit: UnitInfo[];
+  conversionRatio?: string;
   
-  /** Array of area information */
-  area: AreaInfo[];
+  /** Type of activity */
+  activityType?: string;
   
-  /** Array of area types */
-  areaType: AreaType[];
+  /** Activity subtype */
+  activitySubtype?: string;
   
-  /** Array of factor data type categories */
-  factorDataTypeCategories: FactorDataTypeCategory[];
-
-  factorSelectionDefault? :FactorSelectionDefault[];
+  /** Unique factor identifier */
+  factorId?: number;
   
-  /** Array of factor set information */
-  factorSet: FactorSetInfo[];
+  /** Methodology (activity based or spend based) */
+  methodology?: string;
   
-  /** Array of factor data type codes */
-  factorDataTypeCode: FactorDataTypeCode[];
+  /** Scopes data belongs to */
+  scopes?: string[];
   
-  /** Array of factor set versions */
-  factorSetVersion: FactorSetVersion[];
+  /** Area name */
+  areaName?: string;
   
-  /** Array of factor values */
-  factorValue: FactorValue[];
+  /** Area type */
+  areaType?: string;
   
-  /** Array of factor metadata */
-  factorMetaData: FactorMetaData[];
+  /** Publication start date */
+  publishedFrom?: string;
+  
+  /** Publication end date */
+  publishedTo?: string;
   
-  /** Array of unit conversions */
-  unitConversion: UnitConversion[];
+  /** Source of the factor */
+  source?: string;
 }
 
 /**
- * Interface representing the emission calculation response with detailed information
+ * Interface for include details
  */
-export interface EmissionResponseWithDetails {
-  /** Emission calculation result */
-  result: EmissionResponse;
+export interface IncludeDetails {
+  /** Factor set details */
+  factorSet?: FactorSetDetails;
   
+  /** Factor details */
+  factor?: FactorDetails;
+}
+
+
+export interface EmissionResponseWithDetails extends EmissionResponse {
   /** Detailed emission data */
-  data: EmissionData;
+  details?: IncludeDetails;
 }
 

package/test/client.test.ts

@@ -1,7 +1,7 @@
 import { Client } from "../src/Client";
 import axios from "axios";
 import MockAdapter from "axios-mock-adapter";
-import { TOKEN_GENERATION_API } from "../src/Constants";
+import { TOKEN_GENERATION_API, PAT_TOKEN_EXCHANGE_API } from "../src/Constants";
 import { ClientConfig } from "../src/interfaces/Config";
 
 const mock = new MockAdapter(axios);
@@ -57,6 +57,27 @@ describe("Client initialization and Header Authorization", () => {
       'If apiKey is provided , "clientId" and "OrgId" must also be provided.'
     );
   });
+
+  it("Should throw validation error for missing clientId with patToken", async () => {
+    await expect(
+      Client.getClient({ patToken: "pat-token" } as unknown as ClientConfig)
+    ).rejects.toThrow(
+      'If patToken is provided, "clientId" must also be provided.'
+    );
+  });
+
+  it("Should throw validation error when orgId is provided with patToken", async () => {
+    await expect(
+      Client.getClient({
+        patToken: "pat-token",
+        clientId: "client123",
+        orgId: "org456"
+      } as ClientConfig)
+    ).rejects.toThrow(
+      'orgId should not be provided when using patToken.'
+    );
+  });
+
   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" })
@@ -79,4 +100,75 @@ describe("Client initialization and Header Authorization", () => {
     });
     expect(spy).not.toHaveBeenCalled();
   });
+
+  it("should initialize client with PAT token and return auth header", 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`;
+
+    mock.onPost(PAT_TOKEN_EXCHANGE_API).reply(200, mockToken);
+
+    await Client.getClient({
+      patToken: "test-pat-token",
+      clientId: "test-client-id",
+    });
+
+    const instance = Client.getInstance();
+    expect(instance.getAuthHeader()).toEqual({
+      Authorization: `Bearer ${mockToken}`,
+    });
+  });
+
+  it("should initialize client with PAT token and custom authUrl", 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 customAuthUrl = "https://custom-auth.example.com/exchange";
+    mock.onPost(customAuthUrl).reply(200, mockToken);
+
+    await Client.getClient({
+      patToken: "test-pat-token",
+      clientId: "test-client-id",
+      authUrl: customAuthUrl,
+    });
+
+    const instance = Client.getInstance();
+    expect(instance.getAuthHeader()).toEqual({
+      Authorization: `Bearer ${mockToken}`,
+    });
+  });
+
+  it("should call requestTokenFromPAT with correct headers", 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`;
+
+    mock.onPost(PAT_TOKEN_EXCHANGE_API).reply((config) => {
+      expect(config.headers?.["X-IBM-Client-Id"]).toBe("saascore-test-client-id");
+      expect(config.headers?.["X-IBM-Envizi-Pat"]).toBe("test-pat-token");
+      expect(config.headers?.["Accept"]).toBe("application/json");
+      return [200, mockToken];
+    });
+
+    await Client.getClient({
+      patToken: "test-pat-token",
+      clientId: "test-client-id",
+    });
+
+    const instance = Client.getInstance();
+    expect(instance).toBeDefined();
+  });
 });

package/test/tokenRefresh.test.ts

@@ -3,7 +3,7 @@ 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";
+import { TOKEN_GENERATION_API, PAT_TOKEN_EXCHANGE_API } from "../src/Constants";
 
 const mock = new MockAdapter(mockAxios);
 describe("Token refreshing", () => {
@@ -49,4 +49,94 @@ describe("Token refreshing", () => {
     await instance.refreshToken();
     expect(spy).not.toHaveBeenCalledTimes(1);
   });
+
+  it("should refresh PAT token when it is about to expire", async () => {
+    const shortLiveToken = generateMockjwt(1);
+    const refreshedToken = generateMockjwt(600);
+    
+    mock
+      .onPost(PAT_TOKEN_EXCHANGE_API)
+      .replyOnce(200, shortLiveToken)
+      .onPost(PAT_TOKEN_EXCHANGE_API)
+      .replyOnce(200, refreshedToken);
+
+    jest
+      .spyOn(utils, "findExpiryTime")
+      .mockReturnValueOnce(Math.floor(Date.now() / 1000) + 1)
+      .mockReturnValueOnce(Math.floor(Date.now() / 1000) + 600);
+
+    await Client.getClient({
+      patToken: "test-pat-token",
+      clientId: "test-client-id",
+    });
+    const instance = Client.getInstance();
+
+    const spy = jest.spyOn(Client as any, "requestTokenFromPAT");
+
+    await instance.refreshToken();
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith({
+      patToken: "test-pat-token",
+      clientId: "test-client-id",
+      authUrl: PAT_TOKEN_EXCHANGE_API,
+    });
+  });
+
+  it("should not refresh PAT token if it is still valid", async () => {
+    const freshToken = generateMockjwt(600);
+    mock.onPost(PAT_TOKEN_EXCHANGE_API).reply(200, freshToken);
+
+    const spy = jest.spyOn(Client as any, "requestTokenFromPAT");
+
+    jest
+      .spyOn(utils, "findExpiryTime")
+      .mockReturnValue(Math.floor(Date.now() / 1000) + 600);
+
+    await Client.getClient({
+      patToken: "test-pat-token",
+      clientId: "test-client-id",
+    });
+    const instance = Client.getInstance();
+
+    spy.mockClear(); // Clear the initial call from getClient
+
+    await instance.refreshToken();
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it("should refresh PAT token with custom authUrl", async () => {
+    const shortLiveToken = generateMockjwt(1);
+    const refreshedToken = generateMockjwt(600);
+    const customAuthUrl = "https://custom-auth.example.com/exchange";
+    
+    mock
+      .onPost(customAuthUrl)
+      .replyOnce(200, shortLiveToken)
+      .onPost(customAuthUrl)
+      .replyOnce(200, refreshedToken);
+
+    const spy = jest.spyOn(Client as any, "requestTokenFromPAT");
+
+    jest
+      .spyOn(utils, "findExpiryTime")
+      .mockReturnValueOnce(Math.floor(Date.now() / 1000) + 1)
+      .mockReturnValueOnce(Math.floor(Date.now() / 1000) + 600);
+
+    await Client.getClient({
+      patToken: "test-pat-token",
+      clientId: "test-client-id",
+      authUrl: customAuthUrl,
+    });
+    const instance = Client.getInstance();
+
+    spy.mockClear(); // Clear the initial call from getClient
+
+    await instance.refreshToken();
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith({
+      patToken: "test-pat-token",
+      clientId: "test-client-id",
+      authUrl: customAuthUrl,
+    });
+  });
 });