@arrowsphere/api-client 3.5.0 → 3.6.0

package/CHANGELOG.md

@@ -3,6 +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.6.0] - 2022-05-17
+
+### Changed
+
+- Adding 4 new EndPoints of Contact Information:
+  - Create Contact
+  - Get a Contact
+  - Get list of Contact
+  - Update a Contact
+
 ## [3.5.0] - 2022-05-02
 
 ### Changed

package/build/abstractClient.d.ts

@@ -112,6 +112,7 @@ export declare abstract class AbstractClient {
      */
     protected post(payload?: Payload, parameters?: Parameters, headers?: Headers, options?: Options): Promise<AxiosResponse['data']>;
     protected put(payload?: Payload, parameters?: Parameters, headers?: Headers, options?: Options): Promise<void>;
+    protected patch<T>(payload?: Payload, parameters?: Parameters, headers?: Headers, options?: Options): Promise<T>;
     /**
      * Generates the full url for request
      * @param parameters - Parameters to serialize

package/build/abstractClient.js

@@ -157,6 +157,12 @@ class AbstractClient {
         });
         return this.getResponse(response);
     }
+    async patch(payload = {}, parameters = {}, headers = {}, options = {}) {
+        const response = await this.client.patch(this.generateUrl(parameters, options), payload, {
+            headers: this.prepareHeaders(headers),
+        });
+        return this.getResponse(response);
+    }
     /**
      * Generates the full url for request
      * @param parameters - Parameters to serialize

package/build/contact/contactClient.d.ts

@@ -0,0 +1,37 @@
+import { AbstractClient, Parameters } from '../abstractClient';
+import { GetResult } from '../getResult';
+import { ContactCreate } from './entities/contactCreate';
+import { Contact } from './entities/contact';
+import { ContactList } from './entities/contactList';
+export declare enum ContactRequestFields {
+    COLUMN_FIRSTNAME = "firstname",
+    COLUMN_LASTNAME = "lastname",
+    COLUMN_EMAIL = "email",
+    COLUMN_PHONE = "phone",
+    COLUMN_ERP_ID = "erpId",
+    COLUMN_TYPE = "type",
+    COLUMN_ROLE = "role"
+}
+export declare type ContactRequestType = {
+    [ContactRequestFields.COLUMN_FIRSTNAME]: string;
+    [ContactRequestFields.COLUMN_LASTNAME]: string;
+    [ContactRequestFields.COLUMN_EMAIL]: string;
+    [ContactRequestFields.COLUMN_PHONE]: string;
+    [ContactRequestFields.COLUMN_ERP_ID]: string;
+    [ContactRequestFields.COLUMN_TYPE]: string;
+    [ContactRequestFields.COLUMN_ROLE]: string;
+};
+export declare class ContactClient extends AbstractClient {
+    /**
+     * The base path of the Customers API
+     */
+    private ROOT_PATH;
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    createContact(postData: ContactRequestType, parameters?: Parameters): Promise<GetResult<ContactCreate>>;
+    listContact(perPage?: number, page?: number, parameters?: Parameters): Promise<GetResult<ContactList>>;
+    getContact(contactReference: string, parameters?: Parameters): Promise<GetResult<Contact>>;
+    updateContact(contactReference: string, patchData: ContactRequestType, parameters?: Parameters): Promise<GetResult<Contact>>;
+}

package/build/contact/contactClient.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactClient = exports.ContactRequestFields = void 0;
+const abstractClient_1 = require("../abstractClient");
+const getResult_1 = require("../getResult");
+const contactCreate_1 = require("./entities/contactCreate");
+const contact_1 = require("./entities/contact");
+const contactList_1 = require("./entities/contactList");
+var ContactRequestFields;
+(function (ContactRequestFields) {
+    ContactRequestFields["COLUMN_FIRSTNAME"] = "firstname";
+    ContactRequestFields["COLUMN_LASTNAME"] = "lastname";
+    ContactRequestFields["COLUMN_EMAIL"] = "email";
+    ContactRequestFields["COLUMN_PHONE"] = "phone";
+    ContactRequestFields["COLUMN_ERP_ID"] = "erpId";
+    ContactRequestFields["COLUMN_TYPE"] = "type";
+    ContactRequestFields["COLUMN_ROLE"] = "role";
+})(ContactRequestFields = exports.ContactRequestFields || (exports.ContactRequestFields = {}));
+class ContactClient extends abstractClient_1.AbstractClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the Customers API
+         */
+        this.ROOT_PATH = '/contacts';
+        /**
+         * The base path of the API
+         */
+        this.basePath = this.ROOT_PATH;
+    }
+    async createContact(postData, parameters = {}) {
+        return new getResult_1.GetResult(contactCreate_1.ContactCreate, await this.post(postData, parameters));
+    }
+    async listContact(perPage = 25, page = 1, parameters = {}) {
+        this.setPerPage(perPage);
+        this.setPage(page);
+        return new getResult_1.GetResult(contactList_1.ContactList, await this.get(parameters));
+    }
+    async getContact(contactReference, parameters = {}) {
+        this.path = `/${contactReference}`;
+        return new getResult_1.GetResult(contact_1.Contact, await this.get(parameters));
+    }
+    async updateContact(contactReference, patchData, parameters = {}) {
+        this.path = `/${contactReference}`;
+        return new getResult_1.GetResult(contact_1.Contact, await this.patch(patchData, parameters));
+    }
+}
+exports.ContactClient = ContactClient;
+//# sourceMappingURL=contactClient.js.map

package/build/contact/entities/contact.d.ts

@@ -0,0 +1,43 @@
+import { AbstractEntity } from '../../abstractEntity';
+export declare enum ContactFields {
+    COLUMN_ID = "id",
+    COLUMN_COMPANY_ID = "companyId",
+    COLUMN_RESELLER = "reseller",
+    COLUMN_FIRSTNAME = "firstname",
+    COLUMN_LASTNAME = "lastname",
+    COLUMN_EMAIL = "email",
+    COLUMN_PHONE = "phone",
+    COLUMN_ERP_ID = "erpId",
+    COLUMN_TYPE = "type",
+    COLUMN_ROLE = "role",
+    COLUMN_STATUS = "status"
+}
+export declare type ContactType = {
+    [ContactFields.COLUMN_ID]: number;
+    [ContactFields.COLUMN_COMPANY_ID]: number;
+    [ContactFields.COLUMN_RESELLER]: string;
+    [ContactFields.COLUMN_FIRSTNAME]: string;
+    [ContactFields.COLUMN_LASTNAME]: string;
+    [ContactFields.COLUMN_EMAIL]: string;
+    [ContactFields.COLUMN_PHONE]: string;
+    [ContactFields.COLUMN_ERP_ID]: string;
+    [ContactFields.COLUMN_TYPE]: string;
+    [ContactFields.COLUMN_ROLE]: string;
+    [ContactFields.COLUMN_STATUS]: string;
+};
+export declare class Contact extends AbstractEntity<ContactType> {
+    #private;
+    constructor(contactDataInput: ContactType);
+    get id(): number;
+    get companyId(): number;
+    get reseller(): string;
+    get firstname(): string;
+    get lastname(): string;
+    get email(): string;
+    get phone(): string;
+    get erpId(): string;
+    get type(): string;
+    get role(): string;
+    get status(): string;
+    toJSON(): ContactType;
+}

package/build/contact/entities/contact.js

@@ -0,0 +1,110 @@
+"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, _companyId, _reseller, _firstname, _lastname, _email, _phone, _erpId, _type, _role, _status;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contact = exports.ContactFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+var ContactFields;
+(function (ContactFields) {
+    ContactFields["COLUMN_ID"] = "id";
+    ContactFields["COLUMN_COMPANY_ID"] = "companyId";
+    ContactFields["COLUMN_RESELLER"] = "reseller";
+    ContactFields["COLUMN_FIRSTNAME"] = "firstname";
+    ContactFields["COLUMN_LASTNAME"] = "lastname";
+    ContactFields["COLUMN_EMAIL"] = "email";
+    ContactFields["COLUMN_PHONE"] = "phone";
+    ContactFields["COLUMN_ERP_ID"] = "erpId";
+    ContactFields["COLUMN_TYPE"] = "type";
+    ContactFields["COLUMN_ROLE"] = "role";
+    ContactFields["COLUMN_STATUS"] = "status";
+})(ContactFields = exports.ContactFields || (exports.ContactFields = {}));
+class Contact extends abstractEntity_1.AbstractEntity {
+    constructor(contactDataInput) {
+        super(contactDataInput);
+        _id.set(this, void 0);
+        _companyId.set(this, void 0);
+        _reseller.set(this, void 0);
+        _firstname.set(this, void 0);
+        _lastname.set(this, void 0);
+        _email.set(this, void 0);
+        _phone.set(this, void 0);
+        _erpId.set(this, void 0);
+        _type.set(this, void 0);
+        _role.set(this, void 0);
+        _status.set(this, void 0);
+        __classPrivateFieldSet(this, _id, contactDataInput[ContactFields.COLUMN_ID]);
+        __classPrivateFieldSet(this, _companyId, contactDataInput[ContactFields.COLUMN_COMPANY_ID]);
+        __classPrivateFieldSet(this, _reseller, contactDataInput[ContactFields.COLUMN_RESELLER]);
+        __classPrivateFieldSet(this, _firstname, contactDataInput[ContactFields.COLUMN_FIRSTNAME]);
+        __classPrivateFieldSet(this, _lastname, contactDataInput[ContactFields.COLUMN_LASTNAME]);
+        __classPrivateFieldSet(this, _email, contactDataInput[ContactFields.COLUMN_EMAIL]);
+        __classPrivateFieldSet(this, _phone, contactDataInput[ContactFields.COLUMN_PHONE]);
+        __classPrivateFieldSet(this, _erpId, contactDataInput[ContactFields.COLUMN_ERP_ID]);
+        __classPrivateFieldSet(this, _type, contactDataInput[ContactFields.COLUMN_TYPE]);
+        __classPrivateFieldSet(this, _role, contactDataInput[ContactFields.COLUMN_ROLE]);
+        __classPrivateFieldSet(this, _status, contactDataInput[ContactFields.COLUMN_STATUS]);
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _id);
+    }
+    get companyId() {
+        return __classPrivateFieldGet(this, _companyId);
+    }
+    get reseller() {
+        return __classPrivateFieldGet(this, _reseller);
+    }
+    get firstname() {
+        return __classPrivateFieldGet(this, _firstname);
+    }
+    get lastname() {
+        return __classPrivateFieldGet(this, _lastname);
+    }
+    get email() {
+        return __classPrivateFieldGet(this, _email);
+    }
+    get phone() {
+        return __classPrivateFieldGet(this, _phone);
+    }
+    get erpId() {
+        return __classPrivateFieldGet(this, _erpId);
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _type);
+    }
+    get role() {
+        return __classPrivateFieldGet(this, _role);
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _status);
+    }
+    toJSON() {
+        return {
+            [ContactFields.COLUMN_ID]: this.id,
+            [ContactFields.COLUMN_COMPANY_ID]: this.companyId,
+            [ContactFields.COLUMN_RESELLER]: this.reseller,
+            [ContactFields.COLUMN_FIRSTNAME]: this.firstname,
+            [ContactFields.COLUMN_LASTNAME]: this.lastname,
+            [ContactFields.COLUMN_EMAIL]: this.email,
+            [ContactFields.COLUMN_PHONE]: this.phone,
+            [ContactFields.COLUMN_ERP_ID]: this.erpId,
+            [ContactFields.COLUMN_TYPE]: this.type,
+            [ContactFields.COLUMN_ROLE]: this.role,
+            [ContactFields.COLUMN_STATUS]: this.status,
+        };
+    }
+}
+exports.Contact = Contact;
+_id = new WeakMap(), _companyId = new WeakMap(), _reseller = new WeakMap(), _firstname = new WeakMap(), _lastname = new WeakMap(), _email = new WeakMap(), _phone = new WeakMap(), _erpId = new WeakMap(), _type = new WeakMap(), _role = new WeakMap(), _status = new WeakMap();
+//# sourceMappingURL=contact.js.map

package/build/contact/entities/contactCreate.d.ts

@@ -0,0 +1,13 @@
+import { AbstractEntity } from '../../abstractEntity';
+export declare enum ContactCreateFields {
+    COLUMN_ID = "id"
+}
+export declare type ContactCreateType = {
+    [ContactCreateFields.COLUMN_ID]: number;
+};
+export declare class ContactCreate extends AbstractEntity<ContactCreateType> {
+    #private;
+    constructor(createContactResponse: ContactCreateType);
+    get id(): number;
+    toJSON(): ContactCreateType;
+}

package/build/contact/entities/contactCreate.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 _id;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactCreate = exports.ContactCreateFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+var ContactCreateFields;
+(function (ContactCreateFields) {
+    ContactCreateFields["COLUMN_ID"] = "id";
+})(ContactCreateFields = exports.ContactCreateFields || (exports.ContactCreateFields = {}));
+class ContactCreate extends abstractEntity_1.AbstractEntity {
+    constructor(createContactResponse) {
+        super(createContactResponse);
+        _id.set(this, void 0);
+        __classPrivateFieldSet(this, _id, createContactResponse[ContactCreateFields.COLUMN_ID]);
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _id);
+    }
+    toJSON() {
+        return {
+            [ContactCreateFields.COLUMN_ID]: this.id,
+        };
+    }
+}
+exports.ContactCreate = ContactCreate;
+_id = new WeakMap();
+//# sourceMappingURL=contactCreate.js.map

package/build/contact/entities/contactList.d.ts

@@ -0,0 +1,9 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { Contact, ContactType } from './contact';
+export declare type ContactListType = Array<ContactType>;
+export declare class ContactList extends AbstractEntity<ContactListType> {
+    #private;
+    constructor(contactListDataInput: Array<ContactType>);
+    get contactList(): Array<Contact>;
+    toJSON(): ContactListType;
+}

package/build/contact/entities/contactList.js

@@ -0,0 +1,35 @@
+"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 _contactList;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactList = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const contact_1 = require("./contact");
+class ContactList extends abstractEntity_1.AbstractEntity {
+    constructor(contactListDataInput) {
+        super(contactListDataInput);
+        _contactList.set(this, void 0);
+        __classPrivateFieldSet(this, _contactList, contactListDataInput.map((contact) => new contact_1.Contact(contact)));
+    }
+    get contactList() {
+        return __classPrivateFieldGet(this, _contactList);
+    }
+    toJSON() {
+        return this.contactList.map((contact) => contact.toJSON());
+    }
+}
+exports.ContactList = ContactList;
+_contactList = new WeakMap();
+//# sourceMappingURL=contactList.js.map

package/build/contact/index.d.ts

@@ -0,0 +1,4 @@
+export * from './entities/contactCreate';
+export * from './entities/contactList';
+export * from './entities/contact';
+export * from './contactClient';

package/build/contact/index.js

@@ -0,0 +1,17 @@
+"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/contactCreate"), exports);
+__exportStar(require("./entities/contactList"), exports);
+__exportStar(require("./entities/contact"), exports);
+__exportStar(require("./contactClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/index.d.ts

@@ -1,9 +1,11 @@
+import * as ContactInformation from './contact';
 export * from './publicApiClient';
 export * from './publicGraphQLClient';
 export * from './abstractEntity';
 export * from './abstractClient';
 export * from './abstractGraphQLClient';
 export * from './catalog/';
+export { ContactInformation };
 export * from './customers/';
 export * from './general/';
 export * from './licenses/';

package/build/index.js

@@ -6,10 +6,25 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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 });
+exports.ContactInformation = void 0;
+const ContactInformation = __importStar(require("./contact"));
+exports.ContactInformation = ContactInformation;
 __exportStar(require("./publicApiClient"), exports);
 __exportStar(require("./publicGraphQLClient"), exports);
 __exportStar(require("./abstractEntity"), exports);

package/build/publicApiClient.d.ts

@@ -4,6 +4,7 @@ import { LicensesClient } from './licenses/licensesClient';
 import { SubscriptionsClient } from './subscriptions/subscriptionsClient';
 import { CustomersClient } from './customers/customersClient';
 import { OrdersClient } from './orders';
+import { ContactClient } from './contact/contactClient';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -39,5 +40,10 @@ export declare class PublicApiClient extends AbstractClient {
      * @returns {@link OrdersClient}
      */
     getOrdersClient(): OrdersClient;
+    /**
+     * Creates a new {@link ContactClient} instance and returns it
+     * @returns {@link ContactClient}
+     */
+    getContactClient(): ContactClient;
 }
 export default PublicApiClient;

package/build/publicApiClient.js

@@ -7,6 +7,7 @@ const licensesClient_1 = require("./licenses/licensesClient");
 const subscriptionsClient_1 = require("./subscriptions/subscriptionsClient");
 const customersClient_1 = require("./customers/customersClient");
 const orders_1 = require("./orders");
+const contactClient_1 = require("./contact/contactClient");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -68,6 +69,15 @@ class PublicApiClient extends abstractClient_1.AbstractClient {
             .setUrl(this.url)
             .setApiKey(this.apiKey);
     }
+    /**
+     * Creates a new {@link ContactClient} instance and returns it
+     * @returns {@link ContactClient}
+     */
+    getContactClient() {
+        return new contactClient_1.ContactClient(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.5.0",
+  "version": "3.6.0",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",