@arrowsphere/api-client 3.27.0 → 3.28.0-rc.fdi.1

package/CHANGELOG.md

@@ -3,8 +3,16 @@
 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.28.0] - 2023-05-10
+
+### Changed
+
+- add notification endpoint
+
 ## [3.27.0] - 2023-05-10
 
+### Changed
+
 - update create order client to add attributes for injection scenario
 
 ## [3.26.0] - 2023-04-20

package/build/abstractClient.d.ts

@@ -57,6 +57,10 @@ export declare abstract class AbstractClient {
      * ArrowSphere API key
      */
     protected apiKey: string;
+    /**
+     * ArrowSphere token
+     */
+    protected token: string;
     /**
      * Current pagination page number
      */
@@ -84,6 +88,7 @@ export declare abstract class AbstractClient {
      * @returns this
      */
     setApiKey(key: string): this;
+    setToken(apiKey: string): this;
     /**
      * Sets the client ArrowSphere API url
      * @param url - API url

package/build/abstractClient.js

@@ -50,6 +50,10 @@ class AbstractClient {
          * ArrowSphere API key
          */
         this.apiKey = '';
+        /**
+         * ArrowSphere token
+         */
+        this.token = '';
         /**
          * Current pagination page number
          */
@@ -80,6 +84,10 @@ class AbstractClient {
         this.apiKey = key;
         return this;
     }
+    setToken(apiKey) {
+        this.token = apiKey;
+        return this;
+    }
     /**
      * Sets the client ArrowSphere API url
      * @param url - API url

package/build/campaign/index.d.ts

@@ -14,6 +14,7 @@ export * from './entities/v2/campaign/landingPage/landingPageFooter/landingPageF
 export * from './entities/v2/campaign/landingPage/landingPage';
 export * from './entities/v2/campaign/landingPage/landingPageHeader';
 export * from './entities/v2/campaign/campaign';
+export * from './entities/v2/campaignList';
 export { AssetsCampaignAssets };
 export * from './entities/campaignAssets/campaignAssets';
 export * from './campaignClient';

package/build/campaign/index.js

@@ -40,6 +40,7 @@ __exportStar(require("./entities/v2/campaign/landingPage/landingPageFooter/landi
 __exportStar(require("./entities/v2/campaign/landingPage/landingPage"), exports);
 __exportStar(require("./entities/v2/campaign/landingPage/landingPageHeader"), exports);
 __exportStar(require("./entities/v2/campaign/campaign"), exports);
+__exportStar(require("./entities/v2/campaignList"), exports);
 __exportStar(require("./entities/campaignAssets/campaignAssets"), exports);
 __exportStar(require("./campaignClient"), exports);
 //# sourceMappingURL=index.js.map

package/build/index.d.ts

@@ -12,6 +12,7 @@ export * from './general/';
 export * from './getResult';
 export * from './pagination';
 export * from './licenses/';
+export * from './notifications/';
 export * from './orders/';
 export * from './publicApiClient';
 export * from './publicGraphQLClient';

package/build/index.js

@@ -37,6 +37,7 @@ __exportStar(require("./general/"), exports);
 __exportStar(require("./getResult"), exports);
 __exportStar(require("./pagination"), exports);
 __exportStar(require("./licenses/"), exports);
+__exportStar(require("./notifications/"), exports);
 __exportStar(require("./orders/"), exports);
 __exportStar(require("./publicApiClient"), exports);
 __exportStar(require("./publicGraphQLClient"), exports);

package/build/notifications/entities/details/notificationDetails.d.ts

@@ -0,0 +1,31 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum NotificationDetailsFields {
+    COLUMN_ID = "id",
+    COLUMN_USERNAME = "userName",
+    COLUMN_CREATED = "created",
+    COLUMN_EXPIRES = "expires",
+    COLUMN_SUBJECT = "subject",
+    COLUMN_CONTENT = "content",
+    COLUMN_HAS_BEEN_READ = "hasBeenRead"
+}
+export declare type NotificationDetailsType = {
+    [NotificationDetailsFields.COLUMN_ID]: string;
+    [NotificationDetailsFields.COLUMN_USERNAME]: string;
+    [NotificationDetailsFields.COLUMN_CREATED]: number;
+    [NotificationDetailsFields.COLUMN_EXPIRES]: number;
+    [NotificationDetailsFields.COLUMN_SUBJECT]: string;
+    [NotificationDetailsFields.COLUMN_CONTENT]: string;
+    [NotificationDetailsFields.COLUMN_HAS_BEEN_READ]: number;
+};
+export declare class NotificationDetails extends AbstractEntity<NotificationDetailsType> {
+    #private;
+    constructor(notification: NotificationDetailsType);
+    get id(): string;
+    get userName(): string;
+    get created(): number;
+    get expires(): number;
+    get subject(): string;
+    get content(): string;
+    get hasBeenRead(): number;
+    toJSON(): NotificationDetailsType;
+}

package/build/notifications/entities/details/notificationDetails.js

@@ -0,0 +1,82 @@
+"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 _id, _userName, _created, _expires, _subject, _content, _hasBeenRead;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationDetails = exports.NotificationDetailsFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var NotificationDetailsFields;
+(function (NotificationDetailsFields) {
+    NotificationDetailsFields["COLUMN_ID"] = "id";
+    NotificationDetailsFields["COLUMN_USERNAME"] = "userName";
+    NotificationDetailsFields["COLUMN_CREATED"] = "created";
+    NotificationDetailsFields["COLUMN_EXPIRES"] = "expires";
+    NotificationDetailsFields["COLUMN_SUBJECT"] = "subject";
+    NotificationDetailsFields["COLUMN_CONTENT"] = "content";
+    NotificationDetailsFields["COLUMN_HAS_BEEN_READ"] = "hasBeenRead";
+})(NotificationDetailsFields = exports.NotificationDetailsFields || (exports.NotificationDetailsFields = {}));
+class NotificationDetails extends abstractEntity_1.AbstractEntity {
+    constructor(notification) {
+        super(notification);
+        _id.set(this, void 0);
+        _userName.set(this, void 0);
+        _created.set(this, void 0);
+        _expires.set(this, void 0);
+        _subject.set(this, void 0);
+        _content.set(this, void 0);
+        _hasBeenRead.set(this, void 0);
+        __classPrivateFieldSet(this, _id, notification[NotificationDetailsFields.COLUMN_ID]);
+        __classPrivateFieldSet(this, _userName, notification[NotificationDetailsFields.COLUMN_USERNAME]);
+        __classPrivateFieldSet(this, _created, notification[NotificationDetailsFields.COLUMN_CREATED]);
+        __classPrivateFieldSet(this, _expires, notification[NotificationDetailsFields.COLUMN_EXPIRES]);
+        __classPrivateFieldSet(this, _subject, notification[NotificationDetailsFields.COLUMN_SUBJECT]);
+        __classPrivateFieldSet(this, _content, notification[NotificationDetailsFields.COLUMN_CONTENT]);
+        __classPrivateFieldSet(this, _hasBeenRead, notification[NotificationDetailsFields.COLUMN_HAS_BEEN_READ]);
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _id);
+    }
+    get userName() {
+        return __classPrivateFieldGet(this, _userName);
+    }
+    get created() {
+        return __classPrivateFieldGet(this, _created);
+    }
+    get expires() {
+        return __classPrivateFieldGet(this, _expires);
+    }
+    get subject() {
+        return __classPrivateFieldGet(this, _subject);
+    }
+    get content() {
+        return __classPrivateFieldGet(this, _content);
+    }
+    get hasBeenRead() {
+        return __classPrivateFieldGet(this, _hasBeenRead);
+    }
+    toJSON() {
+        return {
+            [NotificationDetailsFields.COLUMN_ID]: this.id,
+            [NotificationDetailsFields.COLUMN_USERNAME]: this.userName,
+            [NotificationDetailsFields.COLUMN_CREATED]: this.created,
+            [NotificationDetailsFields.COLUMN_EXPIRES]: this.expires,
+            [NotificationDetailsFields.COLUMN_SUBJECT]: this.subject,
+            [NotificationDetailsFields.COLUMN_CONTENT]: this.content,
+            [NotificationDetailsFields.COLUMN_HAS_BEEN_READ]: this.hasBeenRead,
+        };
+    }
+}
+exports.NotificationDetails = NotificationDetails;
+_id = new WeakMap(), _userName = new WeakMap(), _created = new WeakMap(), _expires = new WeakMap(), _subject = new WeakMap(), _content = new WeakMap(), _hasBeenRead = new WeakMap();
+//# sourceMappingURL=notificationDetails.js.map

package/build/notifications/entities/notification.d.ts

@@ -0,0 +1,14 @@
+import { NotificationDetails, NotificationDetailsType } from './details/notificationDetails';
+import { AbstractEntity } from '../../abstractEntity';
+export declare enum NotificationFields {
+    COLUMN_NOTIFICATION = "notification"
+}
+export declare type NotificationType = {
+    [NotificationFields.COLUMN_NOTIFICATION]: NotificationDetailsType;
+};
+export declare class Notification extends AbstractEntity<NotificationType> {
+    #private;
+    constructor(notification: NotificationType);
+    get notification(): NotificationDetails;
+    toJSON(): NotificationType;
+}

package/build/notifications/entities/notification.js

@@ -0,0 +1,41 @@
+"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 _notification;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notification = exports.NotificationFields = void 0;
+const notificationDetails_1 = require("./details/notificationDetails");
+const abstractEntity_1 = require("../../abstractEntity");
+var NotificationFields;
+(function (NotificationFields) {
+    NotificationFields["COLUMN_NOTIFICATION"] = "notification";
+})(NotificationFields = exports.NotificationFields || (exports.NotificationFields = {}));
+class Notification extends abstractEntity_1.AbstractEntity {
+    constructor(notification) {
+        super(notification);
+        _notification.set(this, void 0);
+        __classPrivateFieldSet(this, _notification, new notificationDetails_1.NotificationDetails(notification[NotificationFields.COLUMN_NOTIFICATION]));
+    }
+    get notification() {
+        return __classPrivateFieldGet(this, _notification);
+    }
+    toJSON() {
+        return {
+            [NotificationFields.COLUMN_NOTIFICATION]: this.notification.toJSON(),
+        };
+    }
+}
+exports.Notification = Notification;
+_notification = new WeakMap();
+//# sourceMappingURL=notification.js.map

package/build/notifications/entities/notifications.d.ts

@@ -0,0 +1,14 @@
+import { NotificationDetails, NotificationDetailsType } from './details/notificationDetails';
+import { AbstractEntity } from '../../abstractEntity';
+export declare enum NotificationsFields {
+    COLUMN_NOTIFICATIONS = "notifications"
+}
+export declare type NotificationsType = {
+    [NotificationsFields.COLUMN_NOTIFICATIONS]: NotificationDetailsType[];
+};
+export declare class Notifications extends AbstractEntity<NotificationsType> {
+    #private;
+    constructor(notification: NotificationsType);
+    get notifications(): NotificationDetails[];
+    toJSON(): NotificationsType;
+}

package/build/notifications/entities/notifications.js

@@ -0,0 +1,41 @@
+"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 _notifications;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notifications = exports.NotificationsFields = void 0;
+const notificationDetails_1 = require("./details/notificationDetails");
+const abstractEntity_1 = require("../../abstractEntity");
+var NotificationsFields;
+(function (NotificationsFields) {
+    NotificationsFields["COLUMN_NOTIFICATIONS"] = "notifications";
+})(NotificationsFields = exports.NotificationsFields || (exports.NotificationsFields = {}));
+class Notifications extends abstractEntity_1.AbstractEntity {
+    constructor(notification) {
+        super(notification);
+        _notifications.set(this, void 0);
+        __classPrivateFieldSet(this, _notifications, notification[NotificationsFields.COLUMN_NOTIFICATIONS].map((notification) => new notificationDetails_1.NotificationDetails(notification)));
+    }
+    get notifications() {
+        return __classPrivateFieldGet(this, _notifications);
+    }
+    toJSON() {
+        return {
+            [NotificationsFields.COLUMN_NOTIFICATIONS]: this.notifications.map((notification) => notification.toJSON()),
+        };
+    }
+}
+exports.Notifications = Notifications;
+_notifications = new WeakMap();
+//# sourceMappingURL=notifications.js.map

package/build/notifications/entities/total.d.ts

@@ -0,0 +1,13 @@
+import { AbstractEntity } from '../../abstractEntity';
+export declare enum TotalFields {
+    COLUMN_TOTAL = "total"
+}
+export declare type TotalType = {
+    [TotalFields.COLUMN_TOTAL]: number;
+};
+export declare class Total extends AbstractEntity<TotalType> {
+    #private;
+    constructor(total: TotalType);
+    get total(): number;
+    toJSON(): TotalType;
+}

package/build/notifications/entities/total.js

@@ -0,0 +1,40 @@
+"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 _total;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Total = exports.TotalFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+var TotalFields;
+(function (TotalFields) {
+    TotalFields["COLUMN_TOTAL"] = "total";
+})(TotalFields = exports.TotalFields || (exports.TotalFields = {}));
+class Total extends abstractEntity_1.AbstractEntity {
+    constructor(total) {
+        super(total);
+        _total.set(this, void 0);
+        __classPrivateFieldSet(this, _total, total[TotalFields.COLUMN_TOTAL]);
+    }
+    get total() {
+        return __classPrivateFieldGet(this, _total);
+    }
+    toJSON() {
+        return {
+            [TotalFields.COLUMN_TOTAL]: this.total,
+        };
+    }
+}
+exports.Total = Total;
+_total = new WeakMap();
+//# sourceMappingURL=total.js.map

package/build/notifications/index.d.ts

@@ -0,0 +1,5 @@
+export * from './entities/details/notificationDetails';
+export * from './entities/notifications';
+export * from './entities/notification';
+export * from './entities/total';
+export * from './notificationsClient';

package/build/notifications/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/details/notificationDetails"), exports);
+__exportStar(require("./entities/notifications"), exports);
+__exportStar(require("./entities/notification"), exports);
+__exportStar(require("./entities/total"), exports);
+__exportStar(require("./notificationsClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/notifications/notificationsClient.d.ts

@@ -0,0 +1,39 @@
+import { AbstractClient, Parameters, ParametersWithPaginationType, Payload } from '../abstractClient';
+import { GetResult } from '../getResult';
+import { Notifications } from './entities/notifications';
+import { Notification } from './entities/notification';
+import { Total } from './entities/total';
+export declare enum ListParametersFields {
+    COLUMN_CREATED = "created",
+    COLUMN_HAS_BEEN_READ = "hasBeenRead",
+    COLUMN_SEARCH_AFTER = "searchAfter"
+}
+export declare type ListParametersType = ParametersWithPaginationType & {
+    [ListParametersFields.COLUMN_CREATED]?: string;
+    [ListParametersFields.COLUMN_HAS_BEEN_READ]?: string;
+    [ListParametersFields.COLUMN_SEARCH_AFTER]?: string;
+};
+export declare enum CreatePayloadFields {
+    COLUMN_USERNAME = "username",
+    COLUMN_SUBJECT = "subject",
+    COLUMN_CONTENT = "content"
+}
+export declare type CreatePayloadType = {
+    [CreatePayloadFields.COLUMN_USERNAME]: string;
+    [CreatePayloadFields.COLUMN_SUBJECT]: string;
+    [CreatePayloadFields.COLUMN_CONTENT]: string;
+};
+export declare class NotificationsClient extends AbstractClient {
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    list(parameters?: ListParametersType): Promise<GetResult<Notifications>>;
+    create(payload: CreatePayloadType, parameters?: Parameters): Promise<GetResult<Notification>>;
+    deleteAll(parameters?: Parameters): Promise<void>;
+    getNotification(notificationId: string, parameters?: Parameters): Promise<GetResult<Notification>>;
+    deleteNotification(notificationId: string, parameters?: Parameters): Promise<void>;
+    readAll(payload?: Payload, parameters?: Parameters): Promise<void>;
+    read(notificationId: string, payload?: Payload, parameters?: Parameters): Promise<void>;
+    count(parameters?: Parameters): Promise<GetResult<Total>>;
+}

package/build/notifications/notificationsClient.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsClient = exports.CreatePayloadFields = exports.ListParametersFields = void 0;
+const abstractClient_1 = require("../abstractClient");
+const getResult_1 = require("../getResult");
+const notifications_1 = require("./entities/notifications");
+const notification_1 = require("./entities/notification");
+const total_1 = require("./entities/total");
+var ListParametersFields;
+(function (ListParametersFields) {
+    ListParametersFields["COLUMN_CREATED"] = "created";
+    ListParametersFields["COLUMN_HAS_BEEN_READ"] = "hasBeenRead";
+    ListParametersFields["COLUMN_SEARCH_AFTER"] = "searchAfter";
+})(ListParametersFields = exports.ListParametersFields || (exports.ListParametersFields = {}));
+var CreatePayloadFields;
+(function (CreatePayloadFields) {
+    CreatePayloadFields["COLUMN_USERNAME"] = "username";
+    CreatePayloadFields["COLUMN_SUBJECT"] = "subject";
+    CreatePayloadFields["COLUMN_CONTENT"] = "content";
+})(CreatePayloadFields = exports.CreatePayloadFields || (exports.CreatePayloadFields = {}));
+class NotificationsClient extends abstractClient_1.AbstractClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the API
+         */
+        this.basePath = '/notification';
+    }
+    async list(parameters = {}) {
+        return new getResult_1.GetResult(notifications_1.Notifications, await this.get(parameters));
+    }
+    async create(payload, parameters = {}) {
+        return new getResult_1.GetResult(notification_1.Notification, await this.post(payload, parameters));
+    }
+    async deleteAll(parameters = {}) {
+        return await this.delete(parameters);
+    }
+    async getNotification(notificationId, parameters = {}) {
+        this.path = `${notificationId}`;
+        return new getResult_1.GetResult(notification_1.Notification, await this.get(parameters));
+    }
+    async deleteNotification(notificationId, parameters = {}) {
+        this.path = `${notificationId}`;
+        return await this.delete(parameters);
+    }
+    async readAll(payload = {}, parameters = {}) {
+        this.path = '/read';
+        return await this.patch(payload, parameters);
+    }
+    async read(notificationId, payload = {}, parameters = {}) {
+        this.path = `/${notificationId}/read`;
+        return await this.patch(payload, parameters);
+    }
+    async count(parameters = {}) {
+        this.path = '/count';
+        return new getResult_1.GetResult(total_1.Total, await this.get(parameters));
+    }
+}
+exports.NotificationsClient = NotificationsClient;
+//# sourceMappingURL=notificationsClient.js.map

package/build/publicApiClient.d.ts

@@ -11,6 +11,7 @@ import { StandardsClient } from './security/standards/standardsClient';
 import { RegisterClient } from './security';
 import { CartClient } from './cart/cartClient';
 import { SupportCenterClient } from './supportCenter';
+import { NotificationsClient } from './notifications';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -61,5 +62,6 @@ export declare class PublicApiClient extends AbstractClient {
     getSecurityRegisterClient(): RegisterClient;
     getCartClient(): CartClient;
     getSupportCenterClient(): SupportCenterClient;
+    getNotificationsClient(): NotificationsClient;
 }
 export default PublicApiClient;

package/build/publicApiClient.js

@@ -14,6 +14,7 @@ const standardsClient_1 = require("./security/standards/standardsClient");
 const security_1 = require("./security");
 const cartClient_1 = require("./cart/cartClient");
 const supportCenter_1 = require("./supportCenter");
+const notifications_1 = require("./notifications");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -131,6 +132,12 @@ class PublicApiClient extends abstractClient_1.AbstractClient {
             .setApiKey(this.apiKey)
             .setHeaders(this.headers);
     }
+    getNotificationsClient() {
+        return new notifications_1.NotificationsClient()
+            .setUrl(this.url)
+            .setToken(this.token)
+            .setHeaders(this.headers);
+    }
 }
 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.27.0",
+  "version": "3.28.0-rc.fdi.1",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",