@arrowsphere/api-client 3.8.0 → 3.9.0-rc.2

package/CHANGELOG.md

@@ -3,6 +3,15 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.9.0] - 2022-07-05
+
+### Changed
+
+- Adding 3 new EndPoints of consumption:
+  - Get Monthly Consumption
+  - Get Daily Consumption
+  - Get BI Consumption
+
 ## [3.8.0] - 2022-07-04
 
 ### Changed

package/build/consumption/consumptionClient.d.ts

@@ -0,0 +1,13 @@
+import { AbstractClient, Parameters } from '../abstractClient';
+import { ConsumptionBI } from './entities/bi/consumptionBI';
+import { GetResult } from '../getResult';
+import { Consumption } from './entities/consumption/consumption';
+export declare class ConsumptionClient extends AbstractClient {
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    getMonthlyConsumption(licenseReference: string, parameters: Parameters): Promise<GetResult<Consumption>>;
+    getDailyConsumption(licenseReference: string, parameters: Parameters): Promise<GetResult<Consumption>>;
+    getBIConsumption(parameters: Parameters): Promise<GetResult<ConsumptionBI>>;
+}

package/build/consumption/consumptionClient.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsumptionClient = void 0;
+const abstractClient_1 = require("../abstractClient");
+const consumptionBI_1 = require("./entities/bi/consumptionBI");
+const getResult_1 = require("../getResult");
+const consumption_1 = require("./entities/consumption/consumption");
+class ConsumptionClient extends abstractClient_1.AbstractClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the API
+         */
+        this.basePath = '/consumption';
+    }
+    async getMonthlyConsumption(licenseReference, parameters) {
+        this.path = `/monthly/license/${licenseReference}`;
+        return new getResult_1.GetResult(consumption_1.Consumption, await this.get(parameters));
+    }
+    async getDailyConsumption(licenseReference, parameters) {
+        this.path = `/daily/license/${licenseReference}`;
+        return new getResult_1.GetResult(consumption_1.Consumption, await this.get(parameters));
+    }
+    async getBIConsumption(parameters) {
+        this.path = '/bi/top/monthly';
+        return new getResult_1.GetResult(consumptionBI_1.ConsumptionBI, await this.get(parameters));
+    }
+}
+exports.ConsumptionClient = ConsumptionClient;
+//# sourceMappingURL=consumptionClient.js.map

package/build/consumption/entities/bi/consumptionBI.d.ts

@@ -0,0 +1,27 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { Period, PeriodType } from './period/period';
+import { Top, TopType } from './top/top';
+export declare enum ConsumptionBIFields {
+    COLUMN_CURRENCY = "currency",
+    COLUMN_PERIOD = "period",
+    COLUMN_AGGREGATE = "aggregate",
+    COLUMN_METRIC = "metric",
+    COLUMN_TOP = "top"
+}
+export declare type ConsumptionBIType = {
+    [ConsumptionBIFields.COLUMN_CURRENCY]?: string;
+    [ConsumptionBIFields.COLUMN_PERIOD]?: PeriodType;
+    [ConsumptionBIFields.COLUMN_AGGREGATE]?: string;
+    [ConsumptionBIFields.COLUMN_METRIC]?: string;
+    [ConsumptionBIFields.COLUMN_TOP]?: Array<TopType>;
+};
+export declare class ConsumptionBI extends AbstractEntity<ConsumptionBIType> {
+    #private;
+    constructor(consumptionResponse: ConsumptionBIType);
+    get currency(): string | undefined;
+    get period(): Period | undefined;
+    get aggregate(): string | undefined;
+    get metric(): string | undefined;
+    get top(): Array<Top> | undefined;
+    toJSON(): ConsumptionBIType;
+}

package/build/consumption/entities/bi/consumptionBI.js

@@ -0,0 +1,75 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _currency, _period, _aggregate, _metric, _top;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsumptionBI = exports.ConsumptionBIFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const period_1 = require("./period/period");
+const top_1 = require("./top/top");
+var ConsumptionBIFields;
+(function (ConsumptionBIFields) {
+    ConsumptionBIFields["COLUMN_CURRENCY"] = "currency";
+    ConsumptionBIFields["COLUMN_PERIOD"] = "period";
+    ConsumptionBIFields["COLUMN_AGGREGATE"] = "aggregate";
+    ConsumptionBIFields["COLUMN_METRIC"] = "metric";
+    ConsumptionBIFields["COLUMN_TOP"] = "top";
+})(ConsumptionBIFields = exports.ConsumptionBIFields || (exports.ConsumptionBIFields = {}));
+class ConsumptionBI extends abstractEntity_1.AbstractEntity {
+    constructor(consumptionResponse) {
+        super(consumptionResponse);
+        _currency.set(this, void 0);
+        _period.set(this, void 0);
+        _aggregate.set(this, void 0);
+        _metric.set(this, void 0);
+        _top.set(this, void 0);
+        __classPrivateFieldSet(this, _currency, consumptionResponse[ConsumptionBIFields.COLUMN_CURRENCY]);
+        __classPrivateFieldSet(this, _period, consumptionResponse[ConsumptionBIFields.COLUMN_PERIOD]
+            ? new period_1.Period(consumptionResponse[ConsumptionBIFields.COLUMN_PERIOD])
+            : undefined);
+        __classPrivateFieldSet(this, _aggregate, consumptionResponse[ConsumptionBIFields.COLUMN_AGGREGATE]);
+        __classPrivateFieldSet(this, _metric, consumptionResponse[ConsumptionBIFields.COLUMN_METRIC]);
+        __classPrivateFieldSet(this, _top, consumptionResponse[ConsumptionBIFields.COLUMN_TOP]
+            ? consumptionResponse[ConsumptionBIFields.COLUMN_TOP].map((top) => new top_1.Top(top))
+            : undefined);
+    }
+    get currency() {
+        return __classPrivateFieldGet(this, _currency);
+    }
+    get period() {
+        return __classPrivateFieldGet(this, _period);
+    }
+    get aggregate() {
+        return __classPrivateFieldGet(this, _aggregate);
+    }
+    get metric() {
+        return __classPrivateFieldGet(this, _metric);
+    }
+    get top() {
+        return __classPrivateFieldGet(this, _top);
+    }
+    toJSON() {
+        var _a, _b;
+        return {
+            [ConsumptionBIFields.COLUMN_CURRENCY]: this.currency,
+            [ConsumptionBIFields.COLUMN_PERIOD]: (_a = this.period) === null || _a === void 0 ? void 0 : _a.toJSON(),
+            [ConsumptionBIFields.COLUMN_AGGREGATE]: this.aggregate,
+            [ConsumptionBIFields.COLUMN_METRIC]: this.metric,
+            [ConsumptionBIFields.COLUMN_TOP]: (_b = this.top) === null || _b === void 0 ? void 0 : _b.map((top) => top.toJSON()),
+        };
+    }
+}
+exports.ConsumptionBI = ConsumptionBI;
+_currency = new WeakMap(), _period = new WeakMap(), _aggregate = new WeakMap(), _metric = new WeakMap(), _top = new WeakMap();
+//# sourceMappingURL=consumptionBI.js.map

package/build/consumption/entities/bi/period/period.d.ts

@@ -0,0 +1,16 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum PeriodFields {
+    COLUMN_FROM = "from",
+    COLUMN_TO = "to"
+}
+export declare type PeriodType = {
+    [PeriodFields.COLUMN_FROM]: string;
+    [PeriodFields.COLUMN_TO]: string;
+};
+export declare class Period extends AbstractEntity<PeriodType> {
+    #private;
+    constructor(periodResponse: PeriodType);
+    get from(): string;
+    get to(): string;
+    toJSON(): PeriodType;
+}

package/build/consumption/entities/bi/period/period.js

@@ -0,0 +1,47 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _from, _to;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Period = exports.PeriodFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var PeriodFields;
+(function (PeriodFields) {
+    PeriodFields["COLUMN_FROM"] = "from";
+    PeriodFields["COLUMN_TO"] = "to";
+})(PeriodFields = exports.PeriodFields || (exports.PeriodFields = {}));
+class Period extends abstractEntity_1.AbstractEntity {
+    constructor(periodResponse) {
+        super(periodResponse);
+        _from.set(this, void 0);
+        _to.set(this, void 0);
+        __classPrivateFieldSet(this, _from, periodResponse[PeriodFields.COLUMN_FROM]);
+        __classPrivateFieldSet(this, _to, periodResponse[PeriodFields.COLUMN_TO]);
+    }
+    get from() {
+        return __classPrivateFieldGet(this, _from);
+    }
+    get to() {
+        return __classPrivateFieldGet(this, _to);
+    }
+    toJSON() {
+        return {
+            [PeriodFields.COLUMN_FROM]: this.from,
+            [PeriodFields.COLUMN_TO]: this.to,
+        };
+    }
+}
+exports.Period = Period;
+_from = new WeakMap(), _to = new WeakMap();
+//# sourceMappingURL=period.js.map

package/build/consumption/entities/bi/top/top.d.ts

@@ -0,0 +1,22 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum TopFields {
+    COLUMN_RANK = "rank",
+    COLUMN_METRIC = "metric",
+    COLUMN_NAME = "name",
+    COLUMN_REF = "ref"
+}
+export declare type TopType = {
+    [TopFields.COLUMN_RANK]: string;
+    [TopFields.COLUMN_METRIC]: number;
+    [TopFields.COLUMN_NAME]: string;
+    [TopFields.COLUMN_REF]: string;
+};
+export declare class Top extends AbstractEntity<TopType> {
+    #private;
+    constructor(topResponse: TopType);
+    get rank(): string;
+    get metric(): number;
+    get name(): string;
+    get ref(): string;
+    toJSON(): TopType;
+}

package/build/consumption/entities/bi/top/top.js

@@ -0,0 +1,61 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _rank, _metric, _name, _ref;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Top = exports.TopFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var TopFields;
+(function (TopFields) {
+    TopFields["COLUMN_RANK"] = "rank";
+    TopFields["COLUMN_METRIC"] = "metric";
+    TopFields["COLUMN_NAME"] = "name";
+    TopFields["COLUMN_REF"] = "ref";
+})(TopFields = exports.TopFields || (exports.TopFields = {}));
+class Top extends abstractEntity_1.AbstractEntity {
+    constructor(topResponse) {
+        super(topResponse);
+        _rank.set(this, void 0);
+        _metric.set(this, void 0);
+        _name.set(this, void 0);
+        _ref.set(this, void 0);
+        __classPrivateFieldSet(this, _rank, topResponse[TopFields.COLUMN_RANK]);
+        __classPrivateFieldSet(this, _metric, topResponse[TopFields.COLUMN_METRIC]);
+        __classPrivateFieldSet(this, _name, topResponse[TopFields.COLUMN_NAME]);
+        __classPrivateFieldSet(this, _ref, topResponse[TopFields.COLUMN_REF]);
+    }
+    get rank() {
+        return __classPrivateFieldGet(this, _rank);
+    }
+    get metric() {
+        return __classPrivateFieldGet(this, _metric);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name);
+    }
+    get ref() {
+        return __classPrivateFieldGet(this, _ref);
+    }
+    toJSON() {
+        return {
+            [TopFields.COLUMN_RANK]: this.rank,
+            [TopFields.COLUMN_METRIC]: this.metric,
+            [TopFields.COLUMN_NAME]: this.name,
+            [TopFields.COLUMN_REF]: this.ref,
+        };
+    }
+}
+exports.Top = Top;
+_rank = new WeakMap(), _metric = new WeakMap(), _name = new WeakMap(), _ref = new WeakMap();
+//# sourceMappingURL=top.js.map

package/build/consumption/entities/consumption/consumption.d.ts

@@ -0,0 +1,16 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum ConsumptionFields {
+    COLUMN_HEADERS = "headers",
+    COLUMN_LINES = "lines"
+}
+export declare type ConsumptionType = {
+    [ConsumptionFields.COLUMN_HEADERS]: Array<string>;
+    [ConsumptionFields.COLUMN_LINES]: Array<string | number>;
+};
+export declare class Consumption extends AbstractEntity<ConsumptionType> {
+    #private;
+    constructor(consumptionResponse: ConsumptionType);
+    get headers(): Array<string>;
+    get lines(): Array<string | number>;
+    toJSON(): ConsumptionType;
+}

package/build/consumption/entities/consumption/consumption.js

@@ -0,0 +1,47 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _headers, _lines;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumption = exports.ConsumptionFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var ConsumptionFields;
+(function (ConsumptionFields) {
+    ConsumptionFields["COLUMN_HEADERS"] = "headers";
+    ConsumptionFields["COLUMN_LINES"] = "lines";
+})(ConsumptionFields = exports.ConsumptionFields || (exports.ConsumptionFields = {}));
+class Consumption extends abstractEntity_1.AbstractEntity {
+    constructor(consumptionResponse) {
+        super(consumptionResponse);
+        _headers.set(this, void 0);
+        _lines.set(this, void 0);
+        __classPrivateFieldSet(this, _headers, consumptionResponse[ConsumptionFields.COLUMN_HEADERS]);
+        __classPrivateFieldSet(this, _lines, consumptionResponse[ConsumptionFields.COLUMN_LINES]);
+    }
+    get headers() {
+        return __classPrivateFieldGet(this, _headers);
+    }
+    get lines() {
+        return __classPrivateFieldGet(this, _lines);
+    }
+    toJSON() {
+        return {
+            [ConsumptionFields.COLUMN_HEADERS]: this.headers,
+            [ConsumptionFields.COLUMN_LINES]: this.lines,
+        };
+    }
+}
+exports.Consumption = Consumption;
+_headers = new WeakMap(), _lines = new WeakMap();
+//# sourceMappingURL=consumption.js.map

package/build/consumption/index.d.ts

@@ -0,0 +1,5 @@
+export * from './entities/consumption/consumption';
+export * from './entities/bi/period/period';
+export * from './entities/bi/top/top';
+export * from './entities/bi/consumptionBI';
+export * from './consumptionClient';

package/build/consumption/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entities/consumption/consumption"), exports);
+__exportStar(require("./entities/bi/period/period"), exports);
+__exportStar(require("./entities/bi/top/top"), exports);
+__exportStar(require("./entities/bi/consumptionBI"), exports);
+__exportStar(require("./consumptionClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/index.d.ts

@@ -6,6 +6,7 @@ export * from './abstractClient';
 export * from './abstractGraphQLClient';
 export * from './campaign/';
 export * from './catalog/';
+export * from './consumption';
 export { ContactInformation };
 export * from './customers/';
 export * from './general/';

package/build/index.js

@@ -32,6 +32,7 @@ __exportStar(require("./abstractClient"), exports);
 __exportStar(require("./abstractGraphQLClient"), exports);
 __exportStar(require("./campaign/"), exports);
 __exportStar(require("./catalog/"), exports);
+__exportStar(require("./consumption"), exports);
 __exportStar(require("./customers/"), exports);
 __exportStar(require("./general/"), exports);
 __exportStar(require("./licenses/"), exports);

package/build/publicApiClient.d.ts

@@ -6,6 +6,7 @@ import { CustomersClient } from './customers/customersClient';
 import { OrdersClient } from './orders';
 import { ContactClient } from './contact/contactClient';
 import { CampaignClient } from './campaign';
+import { ConsumptionClient } from './consumption/consumptionClient';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -51,5 +52,6 @@ export declare class PublicApiClient extends AbstractClient {
      * @returns {@link ContactClient}
      */
     getCampaignClient(): CampaignClient;
+    getConsumptionClient(): ConsumptionClient;
 }
 export default PublicApiClient;

package/build/publicApiClient.js

@@ -9,6 +9,7 @@ const customersClient_1 = require("./customers/customersClient");
 const orders_1 = require("./orders");
 const contactClient_1 = require("./contact/contactClient");
 const campaign_1 = require("./campaign");
+const consumptionClient_1 = require("./consumption/consumptionClient");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -88,6 +89,11 @@ class PublicApiClient extends abstractClient_1.AbstractClient {
             .setUrl(this.url)
             .setApiKey(this.apiKey);
     }
+    getConsumptionClient() {
+        return new consumptionClient_1.ConsumptionClient(this.client)
+            .setUrl(this.url)
+            .setApiKey(this.apiKey);
+    }
 }
 exports.PublicApiClient = PublicApiClient;
 exports.default = PublicApiClient;

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/ArrowSphere/nodejs-api-client.git"
   },
-  "version": "3.8.0",
+  "version": "3.9.0-rc.2",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",