oneentry 1.0.65 → 1.0.67

package/dist/_cjs/admins/adminsApi.d.ts

@@ -1,4 +1,4 @@
-import OneEntry from "../base/oneEntry";
+import OneEntry from "../base/modules";
 import { IAdminEntity, IAdmins } from "./adminsInterfaces";
 /**
  * Controllers for working with users - admins

package/dist/admins/adminsApi.d.ts

@@ -1,11 +1,13 @@
-import OneEntry from "../base/oneEntry";
+import AsyncModules from "../base/asyncModules";
 import { IAdminEntity, IAdmins } from "./adminsInterfaces";
-import { IConfig } from "../base/utils";
+import StateModule from "../base/stateModule";
 /**
  * Controllers for working with users - admins
  */
-export default class AdminsApi extends OneEntry implements IAdmins {
-    constructor(url: string, config: IConfig);
+export default class AdminsApi extends AsyncModules implements IAdmins {
+    protected state: StateModule;
+    protected _url: string;
+    constructor(state: StateModule);
     /**
      * Get all user objects - admins.
      *

package/dist/admins/adminsApi.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const oneEntry_1 = require("../base/oneEntry");
+const asyncModules_1 = require("../base/asyncModules");
 /**
  * Controllers for working with users - admins
  */
-class AdminsApi extends oneEntry_1.default {
-    constructor(url, config) {
-        super(url, config);
-        this._url += '/api/content/admins';
+class AdminsApi extends asyncModules_1.default {
+    constructor(state) {
+        super(state);
+        this._url = state.url + '/api/content/admins';
     }
     /**
      * Get all user objects - admins.
@@ -18,7 +18,7 @@ class AdminsApi extends oneEntry_1.default {
      *
      * @returns Returns all AdminEntity user objects
      */
-    async getAdminsInfo(langCode = this._defaultLangCode, offset = 0, limit = 30) {
+    async getAdminsInfo(langCode = this.state.lang, offset = 0, limit = 30) {
         const response = await this._fetchGet(`?langCode=${langCode}&offset=${offset}&limit=${limit}`);
         return this._normalizeData(response, langCode);
     }

package/dist/attribute-sets/attributeSetsApi.d.ts

@@ -1,11 +1,13 @@
-import OneEntry from "../base/oneEntry";
+import AsyncModules from "../base/asyncModules";
 import { IAttributesSets, IAttributesSetsEntity } from "./attributeSetsInterfaces";
-import { IConfig } from "../base/utils";
+import StateModule from "../base/stateModule";
 /**
  * Controllers for working with attributes.
  */
-export default class AttributesSetsApi extends OneEntry implements IAttributesSets {
-    constructor(url: string, config: IConfig);
+export default class AttributesSetsApi extends AsyncModules implements IAttributesSets {
+    protected state: StateModule;
+    protected _url: string;
+    constructor(state: StateModule);
     /**
      * Get all attributes with data from the attribute sets.
      *

package/dist/attribute-sets/attributeSetsApi.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const oneEntry_1 = require("../base/oneEntry");
+const asyncModules_1 = require("../base/asyncModules");
 /**
  * Controllers for working with attributes.
  */
-class AttributesSetsApi extends oneEntry_1.default {
-    constructor(url, config) {
-        super(url, config);
-        this._url += '/api/content/attributes-sets';
+class AttributesSetsApi extends asyncModules_1.default {
+    constructor(state) {
+        super(state);
+        this._url = state.url + '/api/content/attributes-sets';
     }
     /**
      * Get all attributes with data from the attribute sets.
@@ -17,7 +17,7 @@ class AttributesSetsApi extends oneEntry_1.default {
      *
      * @returns Returns an array of AttributeInSet objects.
      */
-    async getAttributesByMarker(marker, langCode = this._defaultLangCode) {
+    async getAttributesByMarker(marker, langCode = this.state.lang) {
         const result = await this._fetchGet(`/${marker}/attributes?langCode=${langCode}`);
         return this._dataPostProcess(result, langCode);
     }
@@ -30,7 +30,7 @@ class AttributesSetsApi extends oneEntry_1.default {
      *
      * @returns Returns a AttributeInSet object.
      */
-    async getSingleAttributeByMarkerSet(attributeMarker, setMarker, langCode = this._defaultLangCode) {
+    async getSingleAttributeByMarkerSet(attributeMarker, setMarker, langCode = this.state.lang) {
         const result = await this._fetchGet(`/${setMarker}/attributes/${attributeMarker}?langCode=${langCode}`);
         return result;
     }

package/dist/auth-provider/authProviderApi.d.ts

@@ -1,11 +1,13 @@
-import OneEntry from "../base/oneEntry";
-import { IConfig } from "../base/utils";
+import AsyncModules from "../base/asyncModules";
 import { IAuthProvider, ISignUpData, ISignUpEntity, ICodeEntity, IAuthEntity, IAuthProvidersEntity, IAuthPostBody } from "./authProvidersInterfaces";
+import StateModule from "../base/stateModule";
 /**
  * Controllers for working with auth services.
  */
-export default class AuthProviderApi extends OneEntry implements IAuthProvider {
-    constructor(url: string, config: IConfig);
+export default class AuthProviderApi extends AsyncModules implements IAuthProvider {
+    protected state: StateModule;
+    protected _url: string;
+    constructor(state: StateModule);
     /**
      * User registration
      * @param {string} marker - The text identifier of the authorization provider. Example - email

package/dist/auth-provider/authProviderApi.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const oneEntry_1 = require("../base/oneEntry");
+const asyncModules_1 = require("../base/asyncModules");
 /**
  * Controllers for working with auth services.
  */
-class AuthProviderApi extends oneEntry_1.default {
-    constructor(url, config) {
-        super(url, config);
-        this._url += '/api/content/users-auth-providers';
+class AuthProviderApi extends asyncModules_1.default {
+    constructor(state) {
+        super(state);
+        this._url = state.url + '/api/content/users-auth-providers';
     }
     /**
      * User registration
@@ -42,7 +42,7 @@ class AuthProviderApi extends oneEntry_1.default {
      *   }
      * }
      */
-    async signUp(marker, data, langCode = this._defaultLangCode) {
+    async signUp(marker, data, langCode = this.state.lang) {
         const body = this._normalizePostBody(data, langCode);
         const result = await this._fetchPost(`/marker/${marker}/users/sign-up`, body);
         return this._normalizeData(result);
@@ -95,7 +95,8 @@ class AuthProviderApi extends oneEntry_1.default {
      */
     async auth(marker, data) {
         const result = await this._fetchPost(`/marker/${marker}/users/auth`, data);
-        this._userToken = result.accessToken;
+        this.state.userToken = result.accessToken;
+        this.state.refreshToken = result.refreshToken;
         return result;
     }
     /**
@@ -107,6 +108,8 @@ class AuthProviderApi extends oneEntry_1.default {
     async refresh(marker, token) {
         const data = { refreshToken: token };
         const result = await this._fetchPost(`/marker/${marker}/users/refresh`, data);
+        this.state.userToken = result.accessToken;
+        this.state.refreshToken = result.refreshToken;
         return result;
     }
     /**
@@ -120,7 +123,8 @@ class AuthProviderApi extends oneEntry_1.default {
         };
         const result = await this._fetchPost(`/marker/${marker}/users/logout`, data);
         if (result) {
-            this._userToken = null;
+            this.state.userToken = undefined;
+            this.state.refreshToken = undefined;
         }
         return result;
     }
@@ -148,7 +152,7 @@ class AuthProviderApi extends oneEntry_1.default {
      * @param {number} [offset] - Parameter for pagination. Default 0
      * @param {number} [limit] - Parameter for pagination. Default 30
      */
-    async getAuthProviders(langCode = this._defaultLangCode, offset = 0, limit = 30) {
+    async getAuthProviders(langCode = this.state.lang, offset = 0, limit = 30) {
         const result = await this._fetchGet(`?langCode=${langCode}&offset=${offset}&limit=${limit}`);
         return this._normalizeData(result);
     }
@@ -157,7 +161,7 @@ class AuthProviderApi extends oneEntry_1.default {
      * @param {string} marker - The text identifier of the authorization provider. Example - email
      * @param {string} [langCode] - Optional parameter language code. Default "en_US"
      */
-    async getMarker(marker, langCode = this._defaultLangCode) {
+    async getMarker(marker, langCode = this.state.lang) {
         const result = await this._fetchGet(`/marker/${marker}?langCode=${langCode}`);
         return this._normalizeData(result);
     }

package/dist/auth-provider/authProvidersInterfaces.d.ts

@@ -31,7 +31,7 @@ interface IAuthFormData {
 interface ISignUpData {
     formIdentifier: string;
     authData: Array<{
-        marker: 'login' | 'password';
+        marker: string;
         value: string;
     }>;
     formData: IAuthFormData | Array<IAuthFormData>;
@@ -49,7 +49,7 @@ interface ISignUpEntity {
     isActive: boolean;
     authProviderId: number;
     formData: Array<{
-        marker: 'login' | 'password';
+        marker: string;
         value: string;
     }>;
     notificationData: IAuthFormData | Array<IAuthFormData>;

package/dist/base/asyncModules.d.ts

@@ -0,0 +1,16 @@
+import SyncModules from "./syncModules";
+import StateModule from "./stateModule";
+export default abstract class AsyncModules extends SyncModules {
+    protected state: StateModule;
+    protected _NO_FETCH: boolean;
+    protected _https: any;
+    protected _url: string;
+    protected constructor(state: StateModule);
+    protected _fetchGet(path: string): Promise<any>;
+    protected _fetchPost(path: string, data: any): Promise<any>;
+    protected _fetchPut(path: string, data: any): Promise<any>;
+    protected _fetchDelete(path: string, data?: any): Promise<any>;
+    protected refreshToken(): Promise<boolean>;
+    private makeOptions;
+    private browserResponse;
+}

package/dist/base/asyncModules.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const syncModules_1 = require("./syncModules");
+class AsyncModules extends syncModules_1.default {
+    constructor(state) {
+        super(state);
+        this._url = this.state.url;
+        this.state = state;
+        this._NO_FETCH = !!(typeof process === 'object' && process.versions);
+        try {
+            this._https = this._NO_FETCH ? require('https') : null;
+        }
+        catch (e) {
+            this._https = null;
+        }
+    }
+    async _fetchGet(path) {
+        const options = this.makeOptions('GET');
+        if (!this._NO_FETCH) {
+            return await this.browserResponse(path, options);
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const req = this._https.get(this._getFullPath(path), options, (res) => {
+                    let data = '';
+                    res.on('data', (chunk) => {
+                        data += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(JSON.parse(data));
+                    });
+                });
+                req.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        }
+    }
+    async _fetchPost(path, data) {
+        const options = this.makeOptions('POST', data);
+        if (!this._NO_FETCH) {
+            return await this.browserResponse(path, options);
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const req = this._https.request(this._getFullPath(path), options, (res) => {
+                    let responseData = '';
+                    res.on('data', (chunk) => {
+                        responseData += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(JSON.parse(responseData));
+                    });
+                });
+                req.on('error', (error) => {
+                    reject(error);
+                });
+                req.write(JSON.stringify(data));
+                req.end();
+            });
+        }
+    }
+    async _fetchPut(path, data) {
+        const options = this.makeOptions('PUT', data);
+        if (!this._NO_FETCH) {
+            return await this.browserResponse(path, options);
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const req = this._https.request(this._getFullPath(path), options, (res) => {
+                    let responseData = '';
+                    res.on('data', (chunk) => {
+                        responseData += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(JSON.parse(responseData));
+                    });
+                });
+                req.on('error', (error) => {
+                    reject(error);
+                });
+                req.write(JSON.stringify(data));
+                req.end();
+            });
+        }
+    }
+    async _fetchDelete(path, data) {
+        const options = this.makeOptions('DELETE');
+        if (!this._NO_FETCH) {
+            return await this.browserResponse(path, options);
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const req = this._https.delete(this._getFullPath(path), options, (res) => {
+                    let data = '';
+                    res.on('data', (chunk) => {
+                        data += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(JSON.parse(data));
+                    });
+                });
+                req.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        }
+    }
+    async refreshToken() {
+        console.log('ref token', this.state.refreshToken);
+        const response = await fetch(this.state.url + `/api/content/users-auth-providers/marker/email/users/refresh`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-app-token': this.state.token
+            },
+            body: JSON.stringify({ refreshToken: this.state.refreshToken })
+        });
+        if (response.ok) {
+            const result = await response.json();
+            this.state.refreshToken = result.refreshToken;
+            this.state.userToken = result.accessToken;
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    makeOptions(method, data) {
+        const options = {
+            method: method,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-app-token': this.state.token,
+            }
+        };
+        if (data instanceof FormData || data instanceof Blob) {
+            delete options.headers['Content-Type'];
+        }
+        if (data) {
+            options['body'] = JSON.stringify(data);
+        }
+        if (this.state.userToken) {
+            options.headers['Authorization'] = 'Bearer ' + this.state.userToken;
+        }
+        return options;
+    }
+    async browserResponse(path, options) {
+        const response = await fetch(this._getFullPath(path), options);
+        if (response.status == 401) {
+            const refresh = await this.refreshToken();
+            if (refresh) {
+                const secondResponse = await fetch(this._getFullPath(path), options);
+                return await secondResponse.json();
+            }
+        }
+        if (!response.ok) {
+            const error = await response.json();
+            throw error;
+        }
+        return await response.json();
+    }
+}
+exports.default = AsyncModules;

package/dist/base/modules.d.ts

@@ -0,0 +1,14 @@
+import { IConfig } from "./utils";
+import SyncModules from "./syncModules";
+export default abstract class Modules extends SyncModules {
+    protected _token: string | undefined;
+    protected _userToken: string | undefined;
+    protected _multipleResponse: boolean;
+    protected _NO_FETCH: boolean;
+    protected _https: any;
+    constructor(url: string, config?: IConfig);
+    protected _fetchGet(path: string): Promise<any>;
+    protected _fetchPost(path: string, data: any): Promise<any>;
+    protected _fetchPut(path: string, data: any): Promise<any>;
+    protected _fetchDelete(path: string, data?: any): Promise<any>;
+}

package/dist/base/modules.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const syncModules_1 = require("./syncModules");
+class Modules extends syncModules_1.default {
+    constructor(url, config = {}) {
+        var _a;
+        super(url, config);
+        this._token = config.token;
+        this._userToken = config.userToken;
+        this._multipleResponse = (_a = config.multipleRequests) !== null && _a !== void 0 ? _a : true;
+        this._NO_FETCH = !!(typeof process === 'object' && process.versions);
+        try {
+            this._https = this._NO_FETCH ? require('https') : null;
+        }
+        catch (e) {
+            this._https = null;
+        }
+    }
+    async _fetchGet(path) {
+        const options = {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-app-token': this._token,
+                'Authorization': this._userToken
+            }
+        };
+        if (!this._NO_FETCH) {
+            const response = await fetch(this._getFullPath(path), options);
+            if (!response.ok) {
+                const error = await response.json();
+                throw error;
+            }
+            return await response.json();
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const req = this._https.get(this._getFullPath(path), options, (res) => {
+                    let data = '';
+                    res.on('data', (chunk) => {
+                        data += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(JSON.parse(data));
+                    });
+                });
+                req.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        }
+    }
+    async _fetchPost(path, data) {
+        const options = {
+            method: 'POST',
+            headers: {
+                'x-app-token': this._token,
+                'Content-Type': 'application/json',
+                'Authorization': this._userToken ? 'Bearer ' + this._userToken : null
+            }
+        };
+        if (data instanceof FormData || data instanceof Blob) {
+            delete options.headers['Content-Type'];
+        }
+        if (!this._NO_FETCH) {
+            const response = await fetch(this._getFullPath(path), {
+                ...options,
+                body: JSON.stringify(data)
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw error;
+            }
+            return await response.json();
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const req = this._https.request(this._getFullPath(path), options, (res) => {
+                    let responseData = '';
+                    res.on('data', (chunk) => {
+                        responseData += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(JSON.parse(responseData));
+                    });
+                });
+                req.on('error', (error) => {
+                    reject(error);
+                });
+                req.write(JSON.stringify(data));
+                req.end();
+            });
+        }
+    }
+    async _fetchPut(path, data) {
+        const options = {
+            method: 'PUT',
+            headers: {
+                'x-app-token': this._token,
+                'Content-Type': 'application/json',
+                'Authorization': this._userToken ? 'Bearer ' + this._userToken : null
+            },
+        };
+        if (data instanceof FormData || data instanceof Blob) {
+            delete options.headers['Content-Type'];
+        }
+        if (!this._NO_FETCH) {
+            const response = await fetch(this._getFullPath(path), {
+                ...options,
+                body: JSON.stringify(data),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw error;
+            }
+            return await response.json();
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const req = this._https.request(this._getFullPath(path), options, (res) => {
+                    let responseData = '';
+                    res.on('data', (chunk) => {
+                        responseData += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(JSON.parse(responseData));
+                    });
+                });
+                req.on('error', (error) => {
+                    reject(error);
+                });
+                req.write(JSON.stringify(data));
+                req.end();
+            });
+        }
+    }
+    async _fetchDelete(path, data) {
+        const options = {
+            method: 'DELETE',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-app-token': this._token,
+                'Authorization': this._userToken ? 'Bearer ' + this._userToken : null
+            },
+            body: data
+        };
+        if (!this._NO_FETCH) {
+            const response = await fetch(this._getFullPath(path), options);
+            if (!response.ok) {
+                const error = await response.json();
+                throw error;
+            }
+            return await response.json();
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const req = this._https.delete(this._getFullPath(path), options, (res) => {
+                    let data = '';
+                    res.on('data', (chunk) => {
+                        data += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(JSON.parse(data));
+                    });
+                });
+                req.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        }
+    }
+}
+exports.default = Modules;

package/dist/base/oneEntry.d.ts

@@ -1,23 +0,0 @@
-import { IProductsQuery } from '../products/productsInterfaces';
-import { IConfig } from "./utils";
-import { IUploadingQuery } from "../file-uploding/fileUploadingInterfaces";
-export default abstract class OneEntry {
-    protected _url: string;
-    protected _token: string | undefined;
-    protected _userToken: string | undefined;
-    protected _defaultLangCode: string;
-    protected _multipleResponse: boolean;
-    protected _NO_FETCH: boolean;
-    protected _https: any;
-    constructor(url: string, config?: IConfig);
-    protected _getFullPath(path: string): string;
-    protected _fetchGet(path: string): Promise<any>;
-    protected _fetchPost(path: string, data: any): Promise<any>;
-    protected _fetchPut(path: string, data: any): Promise<any>;
-    protected _fetchDelete(path: string, data?: any): Promise<any>;
-    protected _queryParamsToString(query: IProductsQuery | IUploadingQuery): string;
-    protected _normalizeData(data: any, langCode?: string): any;
-    protected _normalizePostBody(body: any, langCode?: string): any;
-    protected _clearArray(data: Record<string, any>): any;
-    protected _dataPostProcess(data: any, langCode?: string): any;
-}