emissions-api-sdk 1.0.0 → 1.0.2

package/src/interfaces/response/FactorResponse.ts

@@ -0,0 +1,78 @@
+/**
+ * Interface representing the response from the retrieve factor API
+ */
+export interface FactorResponse {
+  /** Unique transaction identifier */
+  transactionId: string;
+  
+  /** Total CO2 equivalent emissions (optional - not present in all responses)*/
+  totalCO2e?: number;
+  
+  /** CO2 emissions value (optional - not present in all responses) */
+  CO2?: number;
+  
+  /** CH4 (Methane) emissions value (optional - not present in all responses) */
+  CH4?: number;
+  
+  /** N2O (Nitrous Oxide) emissions value (optional - not present in all responses) */
+  N2O?: number;
+
+ /** Biogenic CO2 emissions value (optional - not present in all responses) */
+ bioCO2?: number;
+
+ /** Indirect CO2 equivalent emissions value (optional - not present in all responses) */
+ indirectCO2e?: number;
+
+ /** Hydrofluorocarbon emissions value (optional - not present in all responses) */
+ HFC?: number;
+
+ /** Perfluorocarbon emissions value (optional - not present in all responses) */
+ PFC?: number;
+
+ /** Sulfur hexafluoride emissions value (optional - not present in all responses) */
+ SF6?: number;
+
+ /** Nitrogen trifluoride emissions value (optional - not present in all responses) */
+ NF3?: number;
+
+  
+  /** Unit of measurement for emissions */
+  unit?: string;
+  
+  /** Description of the emission factors (optional)*/
+  description?: string;
+  
+  /** Factor set identifier (e.g., "IPCC", "IGES") */
+  factorSet: string;
+  
+  /** Source reference for the emission factors (optional)*/
+  source?: string;
+  
+  /** Type of activity (e.g., "Gas/Diesel Oil", "Electricity") */
+  activityType: string;
+  
+  /** Array of supported activity units */
+  activityUnit: string[];
+  
+  /** Name of the emission factor */
+  name?: string;
+  
+  /** Publication start date in ISO format (optional)*/
+  publishedFrom?: string;
+  
+  /** Publication end date in ISO format (optional) */
+  publishedTo?: string;
+
+  /** Effective start date in ISO format (optional) */
+  effectiveFrom?: string;
+
+  /** Effective end date in ISO format (optional) */
+  effectiveTo?: string;
+
+  
+  /** Geographic region (e.g., "Earth", "India") */
+  region: string;
+  
+  /** Unique factor identifier */
+  factorId: number;
+}

package/src/interfaces/response/FactorSetResponse.ts

@@ -0,0 +1,52 @@
+/**
+ * Interface for individual factor set within the response
+ */
+export interface FactorSet {
+  /** Unique identifier for the factor set (required) */
+  id: number;
+  
+  /** Name of the factor set (required) */
+  name: string;
+  
+  /** License type for the factor set (required, e.g., "Public") */
+  license: string;
+  
+  /** Number of factors in this set (required) */
+  factorCount: number;
+  
+  /** Source URL for the factor set data */
+  sourceUrl?: string;
+  
+  /** Detailed description of the factor set */
+  description?: string;
+  
+  /** Short description of the factor set */
+  descriptionShort?: string;
+  
+  /** Array of emission factor types included in this set */
+  types?: string[];
+  
+  /** Array of regions/countries covered by this factor set */
+  regions?: string[];
+  
+  /** Array of version years available for this factor set */
+  versions?: string[];
+  
+  /** Provider/publisher of the factor set */
+  provider?: string;
+  
+  /** Optional citation information for the factor set */
+  citation?: string;
+}
+
+/**
+ * Interface for Factor Set API response
+ */
+export interface FactorSetResponse {
+  /** Transaction ID for the API request */
+  transactionId: string;
+  
+  /** Array of factor sets returned in the response */
+  factorSets: FactorSet[];
+}
+

package/src/interfaces/response/SearchResponse.ts

@@ -0,0 +1,52 @@
+import { FactorResponse } from './FactorResponse';
+
+/**
+ * Pagination parameters for search requests
+ */
+export interface Pagination {
+  /** Page number */
+  page: number;
+  
+  /** Page size */
+  size: number;
+}
+
+/**
+ * Request body structure for pagination links
+ */
+export interface PaginationBody {
+  /** Pagination parameters */
+  pagination?: Pagination;
+}
+
+/**
+ * Link object for pagination in search results
+ */
+export interface SearchLink {
+  /** Relationship type (e.g., "next", "prev") */
+  rel: string;
+  
+  /** URL for the link */
+  href: string;
+  
+  /** Content type */
+  type: string;
+  
+  /** HTTP method */
+  method: string;
+  
+  /** Request body for pagination */
+  body?: PaginationBody;
+}
+
+/**
+ * Interface representing the response from the search factor API
+ */
+export interface SearchResponse {
+  /** Array of factor results */
+  factors: FactorResponse[];
+  
+  /** Pagination links (optional) */
+  links?: SearchLink[];
+}
+

package/src/interfaces/response/TypeResponse.ts

@@ -0,0 +1,7 @@
+/**
+ * Interface for type metadata API 
+ */
+export interface TypeResponse {
+  /** Array of string*/
+  types: string[];
+}

package/src/interfaces/response/UnitResponse.ts

@@ -0,0 +1,7 @@
+/**
+ * Interface for /units metadata API
+ */
+export interface UnitResponse {
+  /** Array of string*/
+  units: string[];
+}

package/test/apiTest.test.ts

@@ -18,6 +18,28 @@ import {
   FACTOR_API_PATH,
   FACTOR_SET_API_PATH,
   SEARCH_API_PATH,
+  LOCATION_TYPES,
+  FUGITIVE_API_TYPES,
+  MOBILE_API_TYPES,
+  STATIONARY_API_TYPES,
+  CALCULATION_TYPES,
+  FACTOR_API_TYPES,
+  TRANSPORTATION_AND_DISTRIBUTION_API_TYPES,
+  LOCATION_API_AREA,
+  FUGITIVE_API_AREA,
+  MOBILE_API_AREA,
+  STATIONARY_API_AREA,
+  GENERAL_API_AREA,
+  FACTOR_API_AREA,
+  TRANSPORTATION_AND_DISTRIBUTION_API_AREA,
+  LOCATION_API_UNITS,
+  SEARCH_API_AREA,
+  FUGITIVE_API_UNITS,
+  MOBILE_API_UNITS,
+  STATIONARY_API_UNITS,
+  GENERAL_API_UNITS,
+  FACTOR_API_UNITS,
+  TRANSPORTATION_AND_DISTRIBUTION_API_UNITS,
 } from "../src/Constants";
 import locationPayload from "./mocks/LocationRequest";
 import commonpayload from "./mocks/CommonRequest";
@@ -28,10 +50,11 @@ import SearchPayload from "./mocks/SearchRequest";
 
 type ApiTestCase = {
   name: string;
-  func: (payload?: any) => Promise<string>;
+  func: (payload?: any) => Promise<any>;
   path: string;
   payload?: any;
   pathParams?: string | string[];
+  queryParams?: Record<string, string>;
   method: "GET" | "POST";
 };
 
@@ -100,6 +123,145 @@ const testCases: ApiTestCase[] = [
     payload: SearchPayload,
     method: "POST",
   },
+  {
+    name: "Location API - getTypes",
+    func: locationApi.getTypes,
+    path: LOCATION_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Fugitive API - getTypes",
+    func: fugitiveApi.getTypes,
+    path: FUGITIVE_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Mobile API - getTypes",
+    func: mobileApi.getTypes,
+    path: MOBILE_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Stationary API - getTypes",
+    func: stationaryApi.getTypes,
+    path: STATIONARY_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "GenericCalculation API - getTypes",
+    func: GenericCalculation.getTypes,
+    path: CALCULATION_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Factor API - getTypes",
+    func: Factors.getTypes,
+    path: FACTOR_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Transportation and Distribution API - getTypes",
+    func: TransportationDistributionApi.getTypes,
+    path: TRANSPORTATION_AND_DISTRIBUTION_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Location API - getArea",
+    func: locationApi.getArea,
+    path: LOCATION_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Fugitive API - getArea",
+    func: fugitiveApi.getArea,
+    path: FUGITIVE_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Mobile API - getArea",
+    func: mobileApi.getArea,
+    path: MOBILE_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Stationary API - getArea",
+    func: stationaryApi.getArea,
+    path: STATIONARY_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "GenericCalculation API - getArea",
+    func: GenericCalculation.getArea,
+    path: GENERAL_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Factor API - getArea",
+    func: Factors.getArea,
+    path: FACTOR_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Factor SEARCH API - getArea",
+    func: Factors.getSearchArea,
+    path: SEARCH_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Transportation and Distribution API - getArea",
+    func: TransportationDistributionApi.getArea,
+    path: TRANSPORTATION_AND_DISTRIBUTION_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Location API - getUnits",
+    func: locationApi.getUnits,
+    path: LOCATION_API_UNITS,
+    queryParams: { type: "electricity" },
+    method: "GET",
+  },
+  {
+    name: "Fugitive API - getUnits",
+    func: fugitiveApi.getUnits,
+    path: FUGITIVE_API_UNITS,
+    queryParams: { type: "Natural Gas - Scope 3:AAA" },
+    method: "GET",
+  },
+  {
+    name: "Mobile API - getUnits",
+    func: mobileApi.getUnits,
+    path: MOBILE_API_UNITS,
+    queryParams: { type: "Cars:B20:(NE)" },
+    method: "GET",
+  },
+  {
+    name: "Stationary API - getUnits",
+    func: stationaryApi.getUnits,
+    path: STATIONARY_API_UNITS,
+    queryParams: { type: "Jet Kerosene" },
+    method: "GET",
+  },
+  {
+    name: "GenericCalculation API - getUnits",
+    func: GenericCalculation.getUnits,
+    path: GENERAL_API_UNITS,
+    queryParams: { type: "Natural Gas - Scope 3:AAA" },
+    method: "GET",
+  },
+  {
+    name: "Factor API - getUnits",
+    func: Factors.getUnits,
+    path: FACTOR_API_UNITS,
+    queryParams: { type: "HFC-263fb" },
+    method: "GET",
+  },
+  {
+    name: "Transportation and Distribution API - getUnits",
+    func: TransportationDistributionApi.getUnits,
+    path: TRANSPORTATION_AND_DISTRIBUTION_API_UNITS,
+    queryParams: { type: "Business Travel - Cars:Diesel - Small" },
+    method: "GET",
+  },
 ];
 
 describe("API Test calculate functions", () => {
@@ -132,16 +294,20 @@ describe("API Test calculate functions", () => {
   });
   describe.each(testCases)(
     "$name",
-    ({ func, path, payload, pathParams, method }) => {
+    ({ func, path, payload, pathParams, queryParams, 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();
+          // For GET requests with queryParams, pass the type value
+          if (queryParams) {
+            result = await func(queryParams.type);
+          } else if (pathParams !== undefined) {
+            result = await func(pathParams);
+          } else {
+            result = await func();
+          }
         }
         const clientDomain = Client.getInstance().getDomain();
 
@@ -160,6 +326,7 @@ describe("API Test calculate functions", () => {
           url: expectedUrl,
         };
         if (method === "POST") expectedRequest.data = payload;
+        if (method === "GET" && queryParams) expectedRequest.params = queryParams;
         expect(spy).toHaveBeenCalledWith(expectedRequest);
         expect(result).toBe(mockResp);
       });

package/dist/api/Factors.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveFactor = retrieveFactor;
-exports.getFactorSets = getFactorSets;
-exports.Search = Search;
-const Client_1 = require("../Client");
-const Constants_1 = require("../Constants");
-const request_1 = require("../request");
-/**
- * Retrieves a factor details by making a POST request to the factor API endpoint.
- *
- * @export
- * @param {FactorRequest} payload - The factor request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the factor string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const factorRequest = {
-    
-    "activity": {
-         "factorId": 12345
-    }
-  };
-  
-  or
-
-  const factorRequest = {
-             "time" : {
-                "date": "2025-01-04"
-            },
-            "location": {
-                "country": "usa",
-                                "stateProvince": "new york"
-            },
-            "activity": {
-                            "type":"natural gas"
-            },
-            "includeDetails": true
-        };
- * const factor = await retrieveFactor(factorRequest);
- */
-async function retrieveFactor(payload) {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.FACTOR_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.POST,
-        url,
-        data: payload,
-    });
-}
-/**
- * Retrieves factor sets by making a GET request to the factor set API endpoint.
- *
- * @export
- * @return {Promise<string>} A promise that resolves to the factor sets string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const factorSets = await getFactorSets();
- */
-async function getFactorSets() {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.FACTOR_SET_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.GET,
-        url
-    });
-}
-/**
- * Performs a search operation by making a POST request to the search API endpoint.
- *
- * @export
- * @param {SearchRequest} payload - The search request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the search results string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const searchRequest = {
-    "time":{
-      "date": "2020-06-10"
-    },
-    "activity": {
-      "search" : "travel"},
-  "location": {
-      "country": "USA"
-    }
-  };
- * const results = await Search(searchRequest);
- */
-async function Search(payload) {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.SEARCH_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.POST,
-        url,
-        data: payload,
-    });
-}

package/dist/api/FugitiveEmission.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculate = calculate;
-const Client_1 = require("../Client");
-const Constants_1 = require("../Constants");
-const request_1 = require("../request");
-/**
- * Performs scope 1 fugitve emission calculations by making a POST request to the fugitive API endpoint.
- *
- * @export
- * @param {CommonRequest} payload - The request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the calculation result string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const request = {
-      "time": {
-        "date": "2025-01-04"
-      },
-      "location": {
-        "country": "usa"
-      },
-      "activity": {
-        "type": "R134A",
-        "value": 150,
-        "unit": "kg"
-      },
-      "includeDetails": false
-  };
- * const result = await calculate(request);
- */
-async function calculate(payload) {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.FUGITIVE_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.POST,
-        url,
-        data: payload,
-    });
-}

package/dist/api/GenericCalculation.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculate = calculate;
-const Client_1 = require("../Client");
-const Constants_1 = require("../Constants");
-const request_1 = require("../request");
-/**
- * Performs emission calculations by making a POST request to the generic calculation API endpoint.
- *
- * @export
- * @param {GenericCalculationRequest} payload - The calculation request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the calculation result string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const calculationRequest = {
-             "time" : {
-                "date": "2025-01-04"
-            },
-            "location": {
-                "country": "usa",
-                                "stateProvince": "new york"
-            },
-            "activity": {
-                            "type":"Waste Combusted - Steel Cans:Default factor",
-                            "unit": "kg",
-                            "value": 1223123.121
-            },
-            "includeDetails": true
-        };
- * const result = await calculate(calculationRequest);
- */
-async function calculate(payload) {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.GENERIC_CALCULATION_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.POST,
-        url,
-        data: payload,
-    });
-}

package/dist/api/LocationEmission.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculate = calculate;
-const Client_1 = require("../Client");
-const Constants_1 = require("../Constants");
-const request_1 = require("../request");
-/**
- * Performs scope 2 purchased energy Emission calculations by making a POST request to the location API endpoint.
- *
- * @export
- * @param {LocationRequest} payload - The location request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the purchased energy emission result string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const calculationRequest = {
-             "time" : {
-                "date": "2025-01-04"
-            },
-            "location": {
-                "country": "usa",
-                                "stateProvince": "new york"
-            },
-            "activity": {
-                            "type":"electricity",
-                            "unit": "kwh",
-                            "value": 14123143
-            },
-            "includeDetails": true
-        };
- * const result = await calculate(calculationRequest);
- */
-async function calculate(payload) {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.LOCATION_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.POST,
-        url,
-        data: payload,
-    });
-}

package/dist/api/MobileEmission.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculate = calculate;
-const request_1 = require("../request");
-const Constants_1 = require("../Constants");
-const Client_1 = require("../Client");
-/**
- * Performs Scope 1 mobile emissions related calculations by making a POST request to the mobile API endpoint.
- *
- * @export
- * @param {CommonRequest} payload - The request data to be sent to the mobile API
- * @return {Promise<string>} A promise that resolves to the calculation result string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const request = {
-    "time": {
-      "date": "2022-01-01"
-    },
-    "location": {
-      "country": "USA",
-      "stateProvince": "new york"
-    },
-    "activity": {
-      "type": "Diesel Fuel",
-      "value": 1500000,
-      "unit": "l"
-    },
-    "includeDetails": false
-  };
- * const result = await calculate(request);
- */
-async function calculate(payload) {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.MOBILE_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.POST,
-        url,
-        data: payload,
-    });
-}