@allthings/sdk 10.0.0-beta.1 → 10.0.0-beta.2

package/dist/src/rest/methods/notification.js

@@ -0,0 +1,57 @@
+import { dateToString, stringToDate } from '../../utils/stringToDate';
+export var EnumNotificationCategory;
+(function (EnumNotificationCategory) {
+    EnumNotificationCategory["events"] = "events";
+    EnumNotificationCategory["hintsAndTips"] = "hints-and-tips";
+    EnumNotificationCategory["lostAndFound"] = "lost-and-found";
+    EnumNotificationCategory["localDeals"] = "local-deals";
+    EnumNotificationCategory["localEvents"] = "local-events";
+    EnumNotificationCategory["miscellaneous"] = "miscellaneous";
+    EnumNotificationCategory["deals"] = "deals";
+    EnumNotificationCategory["messages"] = "messages";
+    EnumNotificationCategory["adminMessages"] = "admin-messages";
+    EnumNotificationCategory["newThingsToGive"] = "new-things-to-give";
+    EnumNotificationCategory["newThingsForSale"] = "new-things-for-sale";
+    EnumNotificationCategory["surveys"] = "surveys";
+    EnumNotificationCategory["supportOffer"] = "support-offer";
+    EnumNotificationCategory["supportRequest"] = "support-request";
+    EnumNotificationCategory["sustainability"] = "sustainability";
+    EnumNotificationCategory["localServices"] = "local-services";
+    EnumNotificationCategory["services"] = "services";
+    EnumNotificationCategory["ticketDigestEmail"] = "ticket-digest-email";
+    EnumNotificationCategory["appDigestEmail"] = "app-digest-email";
+    EnumNotificationCategory["newFile"] = "new-file";
+})(EnumNotificationCategory || (EnumNotificationCategory = {}));
+export var EnumNotificationType;
+(function (EnumNotificationType) {
+    EnumNotificationType["clipboardThing"] = "clipboard-thing";
+    EnumNotificationType["comment"] = "comment";
+    EnumNotificationType["communityArticle"] = "community-article";
+    EnumNotificationType["newFile"] = "new-file";
+    EnumNotificationType["ticketComment"] = "ticket-comment";
+    EnumNotificationType["welcomeNotification"] = "welcome-notification";
+})(EnumNotificationType || (EnumNotificationType = {}));
+function remapNotificationResult({ createdAt, objectID, referencedObjectID, ...restNotification }) {
+    return {
+        createdAt: stringToDate(createdAt),
+        objectId: objectID,
+        referencedObjectId: referencedObjectID,
+        ...restNotification,
+    };
+}
+export async function notificationsGetByUser(client, userId, page = 1, limit = -1) {
+    const { _embedded: { items: notifications }, total, metaData, } = await client.get(`/v1/users/${userId}/notifications?page=${page}&limit=${limit}`);
+    return {
+        _embedded: { items: notifications.map(remapNotificationResult) },
+        metaData,
+        total,
+    };
+}
+export async function notificationsUpdateReadByUser(client, userId, lastReadAt = new Date()) {
+    return client.patch(`/v1/users/${userId}/notifications`, {
+        lastReadAt: dateToString(lastReadAt),
+    });
+}
+export async function notificationUpdateRead(client, notificationId) {
+    return remapNotificationResult(await client.patch(`/v1/notifications/${notificationId}`, { read: true }));
+}

package/dist/src/rest/methods/notificationSettings.js

@@ -0,0 +1,19 @@
+import { remapKeys } from '../../utils/object';
+import { camelCaseToDash, dashCaseToCamel } from '../../utils/string';
+export var EnumNotificationSettingsValue;
+(function (EnumNotificationSettingsValue) {
+    EnumNotificationSettingsValue["never"] = "never";
+    EnumNotificationSettingsValue["immediately"] = "immediately";
+    EnumNotificationSettingsValue["daily"] = "daily";
+    EnumNotificationSettingsValue["weekly"] = "weekly";
+    EnumNotificationSettingsValue["biweekly"] = "biweekly";
+    EnumNotificationSettingsValue["monthly"] = "monthly";
+})(EnumNotificationSettingsValue || (EnumNotificationSettingsValue = {}));
+export async function notificationSettingsUpdateByUser(client, userId, data) {
+    const result = await client.patch(`/v1/users/${userId}/notification-settings`, { notificationSettings: remapKeys(data, camelCaseToDash) });
+    return remapKeys(result, dashCaseToCamel);
+}
+export async function notificationSettingsResetByUser(client, userId) {
+    const result = await client.delete(`/v1/users/${userId}/notification-settings`);
+    return remapKeys(result, dashCaseToCamel);
+}

package/dist/src/rest/methods/property.js

@@ -0,0 +1,17 @@
+export async function propertyCreate(client, appId, data) {
+    return client.post(`/v1/apps/${appId}/properties`, data);
+}
+export async function propertyGetById(client, propertyId) {
+    return client.get(`/v1/properties/${propertyId}`);
+}
+export async function propertyUpdateById(client, propertyId, data) {
+    return client.patch(`/v1/properties/${propertyId}`, data);
+}
+export async function getProperties(client, page = 1, limit = -1, filter = {}) {
+    const { _embedded: { items: properties }, total, } = await client.get('/v1/properties', {
+        filter: JSON.stringify(filter),
+        limit,
+        page,
+    });
+    return { _embedded: { items: properties }, total };
+}

package/dist/src/rest/methods/registrationCode.js

@@ -0,0 +1,24 @@
+export const remapRegistationCodeResult = (registrationCode) => {
+    const { tenantID: externalId, ...result } = registrationCode;
+    return { ...result, externalId };
+};
+export async function registrationCodeCreate(client, code, utilisationPeriods, options = { permanent: false }) {
+    const { externalId, ...moreOptions } = options;
+    return remapRegistationCodeResult(await client.post('/v1/registration-codes', {
+        code,
+        utilisationPeriods: typeof utilisationPeriods === 'string'
+            ? [utilisationPeriods]
+            : utilisationPeriods,
+        ...(externalId ? { externalId, tenantID: externalId } : {}),
+        ...moreOptions,
+    }));
+}
+export async function registrationCodeUpdateById(client, registrationCodeId, data) {
+    return remapRegistationCodeResult(await client.patch(`/v1/registration-codes/${registrationCodeId}`, data));
+}
+export async function registrationCodeGetById(client, registrationCodeId) {
+    return remapRegistationCodeResult(await client.get(`/v1/invitations/${registrationCodeId}`));
+}
+export async function registrationCodeDelete(client, registrationCodeId) {
+    return (await client.delete(`/v1/invitations/${registrationCodeId}`)) === '';
+}

package/dist/src/rest/methods/serviceProvider.js

@@ -0,0 +1,9 @@
+export async function serviceProviderCreate(client, data) {
+    return client.post('/v1/service-providers', data);
+}
+export async function serviceProviderGetById(client, serviceProviderId) {
+    return client.get(`/v1/service-providers/${serviceProviderId}`);
+}
+export async function serviceProviderUpdateById(client, serviceProviderId, data) {
+    return client.patch(`/v1/service-providers/${serviceProviderId}`, data);
+}

package/dist/src/rest/methods/ticket.js

@@ -0,0 +1,34 @@
+import { createManyFilesSorted } from '../../utils/upload';
+export var ETicketStatus;
+(function (ETicketStatus) {
+    ETicketStatus["CLOSED"] = "closed";
+    ETicketStatus["WAITING_FOR_AGENT"] = "waiting-for-agent";
+    ETicketStatus["WAITING_FOR_CUSTOMER"] = "waiting-for-customer";
+    ETicketStatus["WAITING_FOR_EXTERNAL"] = "waiting-for-external";
+})(ETicketStatus || (ETicketStatus = {}));
+export var ETrafficLightColor;
+(function (ETrafficLightColor) {
+    ETrafficLightColor["GREEN"] = "green";
+    ETrafficLightColor["RED"] = "red";
+    ETrafficLightColor["YELLOW"] = "yellow";
+})(ETrafficLightColor || (ETrafficLightColor = {}));
+export async function ticketGetById(client, ticketId) {
+    return client.get(`/v1/tickets/${ticketId}`);
+}
+export async function ticketCreateOnUser(client, userId, utilisationPeriodId, payload) {
+    return client.post(`/v1/users/${userId}/tickets`, {
+        ...payload,
+        files: payload.files
+            ? (await createManyFilesSorted(payload.files, client)).success
+            : [],
+        utilisationPeriod: utilisationPeriodId,
+    });
+}
+export async function ticketCreateOnServiceProvider(client, serviceProviderId, payload) {
+    return client.post(`/v1/property-managers/${serviceProviderId}/tickets`, {
+        ...payload,
+        files: payload.files
+            ? (await createManyFilesSorted(payload.files, client)).success
+            : [],
+    });
+}

package/dist/src/rest/methods/unit.js

@@ -0,0 +1,95 @@
+export var EnumUnitObjectType;
+(function (EnumUnitObjectType) {
+    EnumUnitObjectType["adjoiningRoom"] = "adjoining-room";
+    EnumUnitObjectType["advertisingSpace"] = "advertising-space";
+    EnumUnitObjectType["aerial"] = "aerial";
+    EnumUnitObjectType["apartmentBuilding"] = "apartment-building";
+    EnumUnitObjectType["atm"] = "atm";
+    EnumUnitObjectType["atmRoom"] = "atm-room";
+    EnumUnitObjectType["attic"] = "attic";
+    EnumUnitObjectType["atticFlat"] = "attic-flat";
+    EnumUnitObjectType["bank"] = "bank";
+    EnumUnitObjectType["basment"] = "basment";
+    EnumUnitObjectType["bikeShed"] = "bike-shed";
+    EnumUnitObjectType["buildingLaw"] = "building-law";
+    EnumUnitObjectType["cafeteria"] = "cafeteria";
+    EnumUnitObjectType["caretakerRoom"] = "caretaker-room";
+    EnumUnitObjectType["carport"] = "carport";
+    EnumUnitObjectType["cellar"] = "cellar";
+    EnumUnitObjectType["commercialProperty"] = "commercial-property";
+    EnumUnitObjectType["commonRoom"] = "common-room";
+    EnumUnitObjectType["deliveryZone"] = "delivery-zone";
+    EnumUnitObjectType["diverse"] = "diverse";
+    EnumUnitObjectType["doubleParkingSpace"] = "double-parking-space";
+    EnumUnitObjectType["engineeringRoom"] = "engineering-room";
+    EnumUnitObjectType["entertainment"] = "entertainment";
+    EnumUnitObjectType["environment"] = "environment";
+    EnumUnitObjectType["estate"] = "estate";
+    EnumUnitObjectType["fillingStation"] = "filling-station";
+    EnumUnitObjectType["fitnessCenter"] = "fitness-center";
+    EnumUnitObjectType["flat"] = "flat";
+    EnumUnitObjectType["freeZone"] = "free-zone";
+    EnumUnitObjectType["garage"] = "garage";
+    EnumUnitObjectType["garden"] = "garden";
+    EnumUnitObjectType["gardenFlat"] = "garden-flat";
+    EnumUnitObjectType["heatingFacilities"] = "heating-facilities";
+    EnumUnitObjectType["hotel"] = "hotel";
+    EnumUnitObjectType["incidentalRentalExpenses"] = "incidental-rental-expenses";
+    EnumUnitObjectType["industry"] = "industry";
+    EnumUnitObjectType["kiosk"] = "kiosk";
+    EnumUnitObjectType["kitchen"] = "kitchen";
+    EnumUnitObjectType["loft"] = "loft";
+    EnumUnitObjectType["machine"] = "machine";
+    EnumUnitObjectType["maisonette"] = "maisonette";
+    EnumUnitObjectType["medicalPractice"] = "medical-practice";
+    EnumUnitObjectType["mopedShed"] = "moped-shed";
+    EnumUnitObjectType["motorcycleParkingSpace"] = "motorcycle-parking-space";
+    EnumUnitObjectType["office"] = "office";
+    EnumUnitObjectType["oneFamilyHouse"] = "one-family-house";
+    EnumUnitObjectType["parkingBox"] = "parking-box";
+    EnumUnitObjectType["parkingGarage"] = "parking-garage";
+    EnumUnitObjectType["parkingSpace"] = "parking-space";
+    EnumUnitObjectType["parkingSpaces"] = "parking-spaces";
+    EnumUnitObjectType["penthouse"] = "penthouse";
+    EnumUnitObjectType["productionPlant"] = "production-plant";
+    EnumUnitObjectType["pub"] = "pub";
+    EnumUnitObjectType["publicArea"] = "public-area";
+    EnumUnitObjectType["restaurant"] = "restaurant";
+    EnumUnitObjectType["retirementHome"] = "retirement-home";
+    EnumUnitObjectType["salesFloor"] = "sales-floor";
+    EnumUnitObjectType["school"] = "school";
+    EnumUnitObjectType["shelter"] = "shelter";
+    EnumUnitObjectType["storage"] = "storage";
+    EnumUnitObjectType["store"] = "store";
+    EnumUnitObjectType["storeroom"] = "storeroom";
+    EnumUnitObjectType["studio"] = "studio";
+    EnumUnitObjectType["terrace"] = "terrace";
+    EnumUnitObjectType["toilets"] = "toilets";
+    EnumUnitObjectType["utilityRoom"] = "utility-room";
+    EnumUnitObjectType["variableParkingSpace"] = "variable-parking-space";
+    EnumUnitObjectType["variableRoom"] = "variable-room";
+    EnumUnitObjectType["visitorParkingSpace"] = "visitor-parking-space";
+    EnumUnitObjectType["workshop"] = "workshop";
+})(EnumUnitObjectType || (EnumUnitObjectType = {}));
+export var EnumUnitType;
+(function (EnumUnitType) {
+    EnumUnitType["rented"] = "rented";
+    EnumUnitType["owned"] = "owned";
+})(EnumUnitType || (EnumUnitType = {}));
+export async function unitCreate(client, groupId, data) {
+    return client.post(`/v1/groups/${groupId}/units`, data);
+}
+export async function unitGetById(client, unitId) {
+    return client.get(`/v1/units/${unitId}`);
+}
+export async function unitUpdateById(client, unitId, data) {
+    return client.patch(`/v1/units/${unitId}`, data);
+}
+export async function getUnits(client, page = 1, limit = -1, filter = {}) {
+    const { _embedded: { items: units }, total, } = await client.get('/v1/units', {
+        filter: JSON.stringify(filter),
+        limit,
+        page,
+    });
+    return { _embedded: { items: units }, total };
+}

package/dist/src/rest/methods/user.js

@@ -0,0 +1,134 @@
+export var EnumGender;
+(function (EnumGender) {
+    EnumGender["female"] = "female";
+    EnumGender["male"] = "male";
+})(EnumGender || (EnumGender = {}));
+export var EnumUserType;
+(function (EnumUserType) {
+    EnumUserType["allthingsUser"] = "allthings_user";
+    EnumUserType["allthingsContent"] = "allthings_content";
+    EnumUserType["customer"] = "customer";
+    EnumUserType["demoContent"] = "demo_content";
+    EnumUserType["demoPublic"] = "demo_public";
+    EnumUserType["partner"] = "partner";
+})(EnumUserType || (EnumUserType = {}));
+export var EnumCommunicationPreferenceChannel;
+(function (EnumCommunicationPreferenceChannel) {
+    EnumCommunicationPreferenceChannel["push"] = "push";
+    EnumCommunicationPreferenceChannel["email"] = "email";
+})(EnumCommunicationPreferenceChannel || (EnumCommunicationPreferenceChannel = {}));
+export var EnumUserPermissionRole;
+(function (EnumUserPermissionRole) {
+    EnumUserPermissionRole["appAdmin"] = "app-admin";
+    EnumUserPermissionRole["appOwner"] = "app-owner";
+    EnumUserPermissionRole["articlesAgent"] = "articles-agent";
+    EnumUserPermissionRole["articlesViewOnly"] = "articles-view-only";
+    EnumUserPermissionRole["bookableAssetAgent"] = "bookable-asset-agent";
+    EnumUserPermissionRole["bookingAgent"] = "booking-agent";
+    EnumUserPermissionRole["cockpitManager"] = "cockpit-manager";
+    EnumUserPermissionRole["dataConnectorAdmin"] = "data-connector-admin";
+    EnumUserPermissionRole["documentAdmin"] = "doc-admin";
+    EnumUserPermissionRole["externalAgent"] = "external-agent";
+    EnumUserPermissionRole["globalOrgAdmin"] = "global-org-admin";
+    EnumUserPermissionRole["globalUserAdmin"] = "global-user-admin";
+    EnumUserPermissionRole["orgAdmin"] = "org-admin";
+    EnumUserPermissionRole["orgTeamManager"] = "org-team-manager";
+    EnumUserPermissionRole["pinboardAgent"] = "pinboard-agent";
+    EnumUserPermissionRole["platformOwner"] = "platform-owner";
+    EnumUserPermissionRole["qa"] = "qa";
+    EnumUserPermissionRole["serviceCenterAgent"] = "service-center-agent";
+    EnumUserPermissionRole["serviceCenterManager"] = "service-center-manager";
+    EnumUserPermissionRole["setup"] = "setup";
+    EnumUserPermissionRole["tenantManager"] = "tenant-manager";
+})(EnumUserPermissionRole || (EnumUserPermissionRole = {}));
+export var EnumUserPermissionObjectType;
+(function (EnumUserPermissionObjectType) {
+    EnumUserPermissionObjectType["app"] = "App";
+    EnumUserPermissionObjectType["group"] = "Group";
+    EnumUserPermissionObjectType["property"] = "Property";
+    EnumUserPermissionObjectType["unit"] = "Unit";
+})(EnumUserPermissionObjectType || (EnumUserPermissionObjectType = {}));
+const remapUserResult = (user) => {
+    const { tenantIDs: tenantIds, ...result } = user;
+    return { ...result, tenantIds };
+};
+export const remapEmbeddedUser = (embedded) => embedded.users ? embedded.users.map(remapUserResult) : [];
+export async function userCreate(client, appId, username, data) {
+    return client.post('/v1/users', {
+        ...data,
+        creationContext: appId,
+        username,
+    });
+}
+export async function getUsers(client, page = 1, limit = -1, filter = {}) {
+    const { _embedded: { items: users }, total, } = await client.get('/v1/users', {
+        filter: JSON.stringify(filter),
+        limit,
+        page,
+    });
+    return { _embedded: { items: users.map(remapUserResult) }, total };
+}
+export async function getCurrentUser(client) {
+    return remapUserResult(await client.get('/v1/me'));
+}
+export async function userGetById(client, userId) {
+    return remapUserResult(await client.get(`/v1/users/${userId}`));
+}
+export async function userUpdateById(client, userId, data) {
+    const { tenantIds: tenantIDs, ...rest } = data;
+    return remapUserResult(await client.patch(`/v1/users/${userId}`, { ...rest, tenantIDs }));
+}
+export async function userCreatePermission(client, userId, data) {
+    const { objectId: objectID, ...rest } = data;
+    const { objectID: resultObjectId, ...result } = await client.post(`/v1/users/${userId}/permissions`, {
+        ...rest,
+        objectID,
+    });
+    return {
+        ...result,
+        objectId: resultObjectId,
+    };
+}
+export async function userCreatePermissionBatch(client, userId, permissions) {
+    const { objectId, objectType, roles, startDate, endDate } = permissions;
+    const batch = {
+        batch: roles.map((role) => ({
+            endDate: endDate?.toISOString(),
+            objectID: objectId,
+            objectType,
+            restrictions: [],
+            role,
+            startDate: startDate?.toISOString(),
+        })),
+    };
+    return !(await client.post(`/v1/users/${userId}/permissions`, batch));
+}
+export async function userGetPermissions(client, userId) {
+    const { _embedded: { items: permissions }, } = await client.get(`/v1/users/${userId}/roles?limit=-1`);
+    return permissions.map(({ objectID: objectId, ...result }) => ({
+        ...result,
+        objectId,
+    }));
+}
+export async function userDeletePermission(client, permissionId) {
+    return !(await client.delete(`/v1/permissions/${permissionId}`));
+}
+export async function userGetUtilisationPeriods(client, userId) {
+    const { _embedded: { items: utilisationPeriods }, } = await client.get(`/v1/users/${userId}/utilisation-periods`);
+    return utilisationPeriods;
+}
+export async function userCheckInToUtilisationPeriod(client, userId, utilisationPeriodId) {
+    const { email: userEmail } = await client.userGetById(userId);
+    return client.utilisationPeriodCheckInUser(utilisationPeriodId, {
+        email: userEmail,
+    });
+}
+export async function userGetByEmail(client, email, page = 1, limit = 1000) {
+    return client.getUsers(page, limit, { email });
+}
+export async function userChangePassword(client, userId, currentPassword, newPassword) {
+    return !(await client.put(`/v1/users/${userId}/password`, {
+        currentPassword,
+        plainPassword: newPassword,
+    }));
+}

package/dist/src/rest/methods/userRelation.js

@@ -0,0 +1,22 @@
+export var EnumUserRelationType;
+(function (EnumUserRelationType) {
+    EnumUserRelationType["isResponsible"] = "is-responsible";
+})(EnumUserRelationType || (EnumUserRelationType = {}));
+export async function userRelationCreate(client, userId, data) {
+    return client.post(`/v1/users/${userId}/user-relations/${data.type}`, {
+        ids: data.ids,
+        level: data.level,
+        readOnly: data.readOnly,
+        role: data.role,
+    });
+}
+export async function userRelationDelete(client, userId, data) {
+    return client.delete(`/v1/users/${userId}/user-relations/${data.type}`, {
+        ids: data.ids,
+        level: data.level,
+        role: data.role,
+    });
+}
+export async function userRelationsGetByUser(client, userId) {
+    return client.get(`/v1/users/${userId}/user-relations`);
+}

package/dist/src/rest/methods/utilisationPeriod.js

@@ -0,0 +1,49 @@
+import { remapRegistationCodeResult, } from './registrationCode';
+import { remapEmbeddedUser } from './user';
+export var EnumUtilisationPeriodType;
+(function (EnumUtilisationPeriodType) {
+    EnumUtilisationPeriodType["tenant"] = "tenant";
+    EnumUtilisationPeriodType["ownership"] = "ownership";
+    EnumUtilisationPeriodType["vacant"] = "vacant";
+})(EnumUtilisationPeriodType || (EnumUtilisationPeriodType = {}));
+export async function utilisationPeriodCreate(client, unitId, data) {
+    const { tenantIDs: tenantIds, _embedded, ...result } = await client.post(`/v1/units/${unitId}/utilisation-periods`, data);
+    return {
+        ...result,
+        invitations: _embedded.invitations.map(remapRegistationCodeResult),
+        tenantIds,
+        users: remapEmbeddedUser(_embedded),
+    };
+}
+export async function utilisationPeriodGetById(client, utilisationPeriodId) {
+    const { tenantIDs: tenantIds, _embedded, ...result } = await client.get(`/v1/utilisation-periods/${utilisationPeriodId}`);
+    return {
+        ...result,
+        invitations: _embedded.invitations.map(remapRegistationCodeResult),
+        tenantIds,
+        users: remapEmbeddedUser(_embedded),
+    };
+}
+export async function utilisationPeriodUpdateById(client, utilisationPeriodId, data) {
+    const { tenantIDs: tenantIds, _embedded, ...result } = await client.patch(`/v1/utilisation-periods/${utilisationPeriodId}`, data);
+    return {
+        ...result,
+        invitations: _embedded.invitations.map(remapRegistationCodeResult),
+        tenantIds,
+        users: remapEmbeddedUser(_embedded),
+    };
+}
+export async function utilisationPeriodDelete(client, utilisationPeriodId) {
+    return !(await client.delete(`/v1/utilisation-periods/${utilisationPeriodId}/soft`));
+}
+export async function utilisationPeriodCheckInUser(client, utilisationPeriodId, data) {
+    return ((await client.post(`/v1/utilisation-periods/${utilisationPeriodId}/users`, {
+        email: data.email,
+    })) && client.utilisationPeriodGetById(utilisationPeriodId));
+}
+export async function utilisationPeriodCheckOutUser(client, utilisationPeriodId, userId) {
+    return ((await client.delete(`/v1/utilisation-periods/${utilisationPeriodId}/users/${userId}`)) === '');
+}
+export async function utilisationPeriodAddRegistrationCode(client, utilisationPeriodId, code, tenant, permanent = false) {
+    return client.post(`/v1/utilisation-periods/${utilisationPeriodId}/registration-codes`, { code, permanent, tenant });
+}

package/dist/src/rest/patch.js

@@ -0,0 +1,3 @@
+export default async function patch(request, method, body, returnRawResultObject, headers) {
+    return request('patch', method, { body, headers }, returnRawResultObject);
+}

package/dist/src/rest/post.js

@@ -0,0 +1,3 @@
+export default async function post(request, method, body, returnRawResultObject, headers) {
+    return request('post', method, { body, headers }, returnRawResultObject);
+}

package/dist/src/rest/put.js

@@ -0,0 +1,3 @@
+export default async function put(request, method, body, returnRawResultObject, headers) {
+    return request('put', method, { body, headers }, returnRawResultObject);
+}

package/dist/src/rest/request.js

@@ -0,0 +1,159 @@
+import Bottleneck from 'bottleneck';
+import { QUEUE_CONCURRENCY, QUEUE_DELAY, QUEUE_RESERVOIR, QUEUE_RESERVOIR_REFILL_INTERVAL, USER_AGENT, } from '../constants';
+import maybeUpdateToken from '../oauth/maybeUpdateToken';
+import { environment } from '../utils/environment';
+import { clearIntervalFunction, until } from '../utils/functional';
+import makeLogger from '../utils/logger';
+import { buildQueryString } from '../utils/queryString';
+import sleep from '../utils/sleep';
+const requestLogger = makeLogger('REST API Request');
+const responseLogger = makeLogger('REST API Response');
+const RETRYABLE_STATUS_CODES = [401, 408, 429, 502, 503, 504];
+const TOKEN_REFRESH_STATUS_CODES = [401];
+const queue = new Bottleneck({
+    maxConcurrent: QUEUE_CONCURRENCY,
+    minTime: QUEUE_DELAY,
+    reservoir: QUEUE_RESERVOIR,
+});
+const refillIntervalSet = new Set();
+function isFormData(body) {
+    return typeof body !== 'undefined' && body.formData !== undefined;
+}
+function refillReservoir() {
+    if (refillIntervalSet.size === 0) {
+        const interval = setInterval(async () => {
+            const reservoir = (await queue.currentReservoir());
+            if (queue.empty() && (await queue.running()) === 0 && reservoir > 10) {
+                return ((await queue.incrementReservoir(1)) &&
+                    clearIntervalFunction(interval) &&
+                    refillIntervalSet.delete(interval));
+            }
+            return reservoir < QUEUE_RESERVOIR
+                ? queue.incrementReservoir(1)
+                : clearIntervalFunction(interval) && refillIntervalSet.delete(interval);
+        }, QUEUE_RESERVOIR_REFILL_INTERVAL);
+        return refillIntervalSet.add(interval);
+    }
+    return refillIntervalSet;
+}
+async function makeResultFromResponse(response) {
+    if (RETRYABLE_STATUS_CODES.includes(response.status)) {
+        return response.clone();
+    }
+    if (!response.ok) {
+        return new Error(`${response.status} ${response.statusText}\n\n${await response.text()}`);
+    }
+    if (response.headers.get('content-type') !== 'application/json' &&
+        response.status !== 204) {
+        return new Error(`Response content type was "${response.headers.get('content-type')}" but expected JSON`);
+    }
+    return {
+        body: response.status === 204 ? '' : await response.json(),
+        status: response.status,
+    };
+}
+export function responseWasSuccessful(response) {
+    return !RETRYABLE_STATUS_CODES.includes(response.status);
+}
+export function makeApiRequest(oauthTokenStore, oauthTokenRequester, options, httpMethod, apiMethod, payload, returnRawResultObject) {
+    return async (previousResult, retryCount) => {
+        if (retryCount > 0) {
+            if (retryCount > options.requestMaxRetries) {
+                const error = `Maximum number of retries reached while retrying ${previousResult.method} request ${previousResult.path}.`;
+                requestLogger.error(error);
+                throw new Error(error);
+            }
+            requestLogger.warn(`Warning: encountered ${previousResult.status}. Retrying ${previousResult.method} request ${previousResult.path} (retry #${retryCount}).`);
+            await sleep(Math.ceil(Math.random() *
+                options.requestBackOffInterval *
+                2 ** retryCount));
+        }
+        await maybeUpdateToken(oauthTokenStore, oauthTokenRequester, options, retryCount > 0 &&
+            TOKEN_REFRESH_STATUS_CODES.includes(previousResult.status));
+        const payloadQuery = payload?.query
+            ? (apiMethod.includes('?') ? '&' : '?') + buildQueryString(payload.query)
+            : '';
+        const url = `${options.apiUrl}/api${apiMethod}${payloadQuery}`;
+        if (!oauthTokenStore.get('accessToken')) {
+            throw new Error(`Unable to get OAuth2 access token. Error trying to call endpoint: ${url}`);
+        }
+        try {
+            return (refillReservoir() &&
+                (await queue.schedule(async () => {
+                    const method = httpMethod.toUpperCase();
+                    const body = payload?.body;
+                    const hasForm = isFormData(body);
+                    const form = isFormData(body) ? body.formData : {};
+                    const formData = Object.entries(form).reduce((previous, [name, value]) => {
+                        if (Array.isArray(value)) {
+                            const [content, filename] = value;
+                            const blobContent = content instanceof Blob ? content : new Blob([content]);
+                            previous.append(name, blobContent, filename);
+                        }
+                        else {
+                            previous.append(name, value);
+                        }
+                        return previous;
+                    }, new FormData());
+                    const headers = {
+                        accept: 'application/json',
+                        authorization: `Bearer ${oauthTokenStore.get('accessToken')}`,
+                        'X-Allthings-Caller': `${options.serviceName
+                            ? options.serviceName
+                            :
+                                environment.SEVICE_NAME
+                                    ? environment.SEVICE_NAME
+                                    : 'unknown service name'} --- clientID ${options.clientId?.split('_')[0] ??
+                            options.clientId ??
+                            'no client id present'}`,
+                        ...(hasForm ? {} : { 'content-type': 'application/json' }),
+                        ...(typeof window === 'undefined' &&
+                            typeof document === 'undefined' && { 'user-agent': USER_AGENT }),
+                        ...payload?.headers,
+                    };
+                    if (environment.LOG_REQUEST) {
+                        console.log({ sdkLogs: { method, url } });
+                    }
+                    requestLogger.log(method, url, {
+                        body,
+                        headers,
+                    });
+                    const requestBody = {
+                        body: hasForm ? formData : JSON.stringify(body),
+                    };
+                    const response = await fetch(url, {
+                        cache: 'no-cache',
+                        credentials: 'omit',
+                        headers,
+                        method,
+                        mode: 'cors',
+                        ...(hasForm || body ? requestBody : {}),
+                    });
+                    const result = await makeResultFromResponse(response);
+                    responseLogger.log(method, url, result instanceof Error
+                        ? { error: result }
+                        : {
+                            body: result.body,
+                            status: response.status,
+                        });
+                    return result instanceof Error && returnRawResultObject
+                        ? {
+                            body: result.message,
+                            status: response.status,
+                        }
+                        : result;
+                })));
+        }
+        catch (error) {
+            return error;
+        }
+    };
+}
+export default async function request(oauthTokenStore, oauthTokenRequester, options, httpMethod, apiMethod, payload, returnRawResultObject) {
+    const result = await until(responseWasSuccessful, makeApiRequest(oauthTokenStore, oauthTokenRequester, options, httpMethod, apiMethod, payload, returnRawResultObject));
+    if (result instanceof Error) {
+        requestLogger.log('Request Error', result, payload);
+        throw result;
+    }
+    return returnRawResultObject ? result : result.body;
+}