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

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.SERVICE_NAME
+                                    ? environment.SERVICE_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;
+}

package/dist/src/rest/types.js

@@ -0,0 +1,62 @@
+export var EnumResource;
+(function (EnumResource) {
+    EnumResource["group"] = "group";
+    EnumResource["property"] = "property";
+    EnumResource["serviceProvider"] = "propertyManager";
+    EnumResource["registrationCode"] = "registrationCode";
+    EnumResource["unit"] = "unit";
+    EnumResource["user"] = "user";
+    EnumResource["utilisationPeriod"] = "utilisationPeriod";
+})(EnumResource || (EnumResource = {}));
+export var EnumCountryCode;
+(function (EnumCountryCode) {
+    EnumCountryCode["CH"] = "CH";
+    EnumCountryCode["DE"] = "DE";
+    EnumCountryCode["FR"] = "FR";
+    EnumCountryCode["IT"] = "IT";
+    EnumCountryCode["NL"] = "NL";
+    EnumCountryCode["PT"] = "PT";
+    EnumCountryCode["US"] = "US";
+})(EnumCountryCode || (EnumCountryCode = {}));
+export var EnumLocale;
+(function (EnumLocale) {
+    EnumLocale["ch_de"] = "ch_DE";
+    EnumLocale["ch_fr"] = "ch_FR";
+    EnumLocale["ch_it"] = "ch_it";
+    EnumLocale["de_DE"] = "de_DE";
+    EnumLocale["it_IT"] = "it_IT";
+    EnumLocale["fr_FR"] = "fr_FR";
+    EnumLocale["pt_PT"] = "pt_PT";
+    EnumLocale["en_US"] = "en_US";
+})(EnumLocale || (EnumLocale = {}));
+export var EnumTimezone;
+(function (EnumTimezone) {
+    EnumTimezone["EuropeBerlin"] = "Europe/Berlin";
+    EnumTimezone["EuropeLondon"] = "Europe/London";
+    EnumTimezone["EuropeSofia"] = "Europe/Sofia";
+    EnumTimezone["EuropeZurich"] = "Europe/Zurich";
+    EnumTimezone["UTC"] = "UTC";
+})(EnumTimezone || (EnumTimezone = {}));
+export var EnumServiceProviderType;
+(function (EnumServiceProviderType) {
+    EnumServiceProviderType["propertyManager"] = "property-manager";
+    EnumServiceProviderType["craftspeople"] = "craftspeople";
+})(EnumServiceProviderType || (EnumServiceProviderType = {}));
+export var EnumCommunicationMethodType;
+(function (EnumCommunicationMethodType) {
+    EnumCommunicationMethodType["email"] = "email";
+})(EnumCommunicationMethodType || (EnumCommunicationMethodType = {}));
+export var EnumInputChannel;
+(function (EnumInputChannel) {
+    EnumInputChannel["APP"] = "app";
+    EnumInputChannel["COCKPIT"] = "cockpit";
+    EnumInputChannel["CRAFTSMEN"] = "craftsmen";
+    EnumInputChannel["EMAIL"] = "email";
+    EnumInputChannel["PHONE"] = "phone";
+    EnumInputChannel["WHATS_APP"] = "whats_app";
+})(EnumInputChannel || (EnumInputChannel = {}));
+export var EnumLookupUserType;
+(function (EnumLookupUserType) {
+    EnumLookupUserType["agent"] = "agent";
+    EnumLookupUserType["tenant"] = "tenant";
+})(EnumLookupUserType || (EnumLookupUserType = {}));

package/dist/src/utils/environment.js

@@ -0,0 +1 @@
+export const environment = typeof process !== 'undefined' && process.env ? process.env : {};

package/dist/src/utils/functional.js

@@ -0,0 +1,14 @@
+export const partial = (function_, ...partialArguments) => (...arguments_) => function_(...partialArguments, ...arguments_);
+export function times(function_, n) {
+    return [...new Array(n)].map(function_);
+}
+export async function until(predicate, transformer, initialValue, iterationCount = 0) {
+    const transformed = await transformer(initialValue, iterationCount);
+    return (await predicate(transformed, iterationCount))
+        ? transformed
+        : until(predicate, transformer, transformed, iterationCount + 1);
+}
+export function clearIntervalFunction(intervalId) {
+    clearInterval(intervalId);
+    return true;
+}

package/dist/src/utils/logger.js

@@ -0,0 +1,15 @@
+import { environment } from './environment';
+const SUBSCRIPTIONS = environment.DEBUG?.split(',').map((item) => item.trim()) || [];
+export default function makeLogger(name) {
+    return ['log', 'info', 'warn', 'error'].reduce((logger, type) => ({
+        ...logger,
+        [type]: function log(...logs) {
+            if (SUBSCRIPTIONS.includes('*') ||
+                SUBSCRIPTIONS.includes(name) ||
+                SUBSCRIPTIONS.includes(name.toLocaleLowerCase())) {
+                console[type](`${name}:`, ...logs);
+            }
+            return true;
+        },
+    }), {});
+}

package/dist/src/utils/object.js

@@ -0,0 +1,6 @@
+export function remapKeys(input, mapFunction) {
+    return Object.entries(input).reduce((accumulator, entry) => ({
+        ...accumulator,
+        [mapFunction(entry[0])]: entry[1],
+    }), {});
+}

package/dist/src/utils/queryString.js

@@ -0,0 +1,13 @@
+export function buildQueryString(params) {
+    const usp = new URLSearchParams();
+    for (const [key, value] of Object.entries(params).sort(([a], [b]) => a.localeCompare(b))) {
+        if (value != null && value !== '') {
+            usp.append(key, String(value));
+        }
+    }
+    return usp.toString();
+}
+export function parseQueryString(query) {
+    const cleaned = query.startsWith('#') ? query.slice(1) : query;
+    return Object.fromEntries(new URLSearchParams(cleaned));
+}

package/dist/src/utils/random.js

@@ -0,0 +1,7 @@
+export function pseudoRandomString(length = 16) {
+    let token = '';
+    while (token.length < length) {
+        token += Math.random().toString(36).slice(2);
+    }
+    return token.slice(0, Math.max(0, length));
+}

package/dist/src/utils/sleep.js

@@ -0,0 +1,3 @@
+export default function sleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(() => resolve(true), milliseconds));
+}

package/dist/src/utils/string.js

@@ -0,0 +1,6 @@
+export function camelCaseToDash(input) {
+    return input.replace(/([A-Z])/g, (g) => `-${g[0].toLowerCase()}`);
+}
+export function dashCaseToCamel(input) {
+    return input.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}

package/dist/src/utils/stringToDate.js

@@ -0,0 +1,6 @@
+export function stringToDate(s) {
+    return new Date(Date.parse(s));
+}
+export function dateToString(d) {
+    return d.toISOString();
+}

package/dist/src/utils/upload.js

@@ -0,0 +1,24 @@
+export const createManyFiles = async (attachments, apiClient) => {
+    const responses = await Promise.all(attachments.map(async (attachment) => {
+        try {
+            const result = await apiClient.fileCreate({
+                file: attachment.content,
+                name: attachment.filename,
+            });
+            return result;
+        }
+        catch (error) {
+            return error instanceof Error ? error : new Error(String(error));
+        }
+    }));
+    return responses;
+};
+export async function createManyFilesSorted(files, client) {
+    const result = await createManyFiles(files, client);
+    return {
+        error: result.filter((item) => item instanceof Error),
+        success: result
+            .filter((item) => !(item instanceof Error))
+            .map((item) => item.id),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allthings/sdk",
-  "version": "10.0.0-beta.1",
+  "version": "10.0.0-beta.3",
   "description": "",
   "author": "Allthings GmbH",
   "keywords": [
@@ -21,15 +21,15 @@
     "repositoryUrl": "https://github.com/allthings/node-sdk.git"
   },
   "main": "dist/lib.cjs.js",
-  "module": "dist/lib.esm.js",
-  "browser": "dist/lib.esm.js",
+  "module": "dist/src/index.js",
+  "browser": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
-      "browser": "./dist/lib.esm.js",
-      "import": "./dist/lib.esm.js",
-      "require": "./dist/lib.cjs.js"
+      "require": "./dist/lib.cjs.js",
+      "browser": "./dist/src/index.js",
+      "import": "./dist/src/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -37,8 +37,11 @@
     "./dist/cli.js"
   ],
   "files": [
-    "dist/*.js",
-    "dist/**/*.d.ts"
+    "dist/cli.js",
+    "dist/lib.cjs.js",
+    "dist/package.json",
+    "dist/src/**/*.js",
+    "dist/src/**/*.d.ts"
   ],
   "bin": {
     "allthings": "dist/cli.js"
@@ -52,7 +55,7 @@
     "lint": "yarn lint:tsc && yarn lint:eslint",
     "lint:eslint": "eslint src",
     "lint:tsc": "tsc --noEmit --pretty",
-    "build": "npm run clean && tsc -d -p tsconfig.build.json && cp package.json dist/ && rollup -c --bundleConfigAsCjs && rm dist/package.json",
+    "build": "npm run clean && tsc -d -p tsconfig.build.json && cp package.json dist/ && rollup -c --bundleConfigAsCjs",
     "dev": "tsc -w",
     "prepare": "husky",
     "prepublishOnly": "npm run build",