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

package/dist/cli.js

@@ -12,7 +12,7 @@ function createTokenStore(initialToken) {
     };
 }
 
-const version = "10.0.0-beta.1";
+const version = "10.0.0-beta.3";
 
 const environment = typeof process !== 'undefined' && process.env ? process.env : {};
 
@@ -1102,8 +1102,8 @@ function makeApiRequest(oauthTokenStore, oauthTokenRequester, options, httpMetho
                         'X-Allthings-Caller': `${options.serviceName
                             ? options.serviceName
                             :
-                                environment.SEVICE_NAME
-                                    ? environment.SEVICE_NAME
+                                environment.SERVICE_NAME
+                                    ? environment.SERVICE_NAME
                                     : 'unknown service name'} --- clientID ${options.clientId?.split('_')[0] ??
                             options.clientId ??
                             'no client id present'}`,

package/dist/lib.cjs.js

@@ -11,7 +11,7 @@ function createTokenStore(initialToken) {
     };
 }
 
-const version = "10.0.0-beta.1";
+const version = "10.0.0-beta.3";
 
 const environment = typeof process !== 'undefined' && process.env ? process.env : {};
 
@@ -1101,8 +1101,8 @@ function makeApiRequest(oauthTokenStore, oauthTokenRequester, options, httpMetho
                         'X-Allthings-Caller': `${options.serviceName
                             ? options.serviceName
                             :
-                                environment.SEVICE_NAME
-                                    ? environment.SEVICE_NAME
+                                environment.SERVICE_NAME
+                                    ? environment.SERVICE_NAME
                                     : 'unknown service name'} --- clientID ${options.clientId?.split('_')[0] ??
                             options.clientId ??
                             'no client id present'}`,

package/dist/package.json

@@ -0,0 +1,172 @@
+{
+  "name": "@allthings/sdk",
+  "version": "10.0.0-beta.3",
+  "description": "",
+  "author": "Allthings GmbH",
+  "keywords": [
+    "allthings",
+    "sdk"
+  ],
+  "license": "MIT",
+  "repository": "git@github.com:allthings/node-sdk.git",
+  "bugs": {
+    "url": "https://github.com/allthings/node-sdk/issues"
+  },
+  "homepage": "https://github.com/allthings/node-sdk",
+  "engines": {
+    "node": "^22 || >=24"
+  },
+  "packageManager": "yarn@4.15.0",
+  "release": {
+    "repositoryUrl": "https://github.com/allthings/node-sdk.git"
+  },
+  "main": "dist/lib.cjs.js",
+  "module": "dist/src/index.js",
+  "browser": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "require": "./dist/lib.cjs.js",
+      "browser": "./dist/src/index.js",
+      "import": "./dist/src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": [
+    "./dist/cli.js"
+  ],
+  "files": [
+    "dist/cli.js",
+    "dist/lib.cjs.js",
+    "dist/package.json",
+    "dist/src/**/*.js",
+    "dist/src/**/*.d.ts"
+  ],
+  "bin": {
+    "allthings": "dist/cli.js"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "test": "npm run clean && jest",
+    "test:ci": "jest --runInBand",
+    "watch:build": "tsc -d -w -p tsconfig.build.json & rollup -c --watch",
+    "watch:test": "jest --watch",
+    "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",
+    "dev": "tsc -w",
+    "prepare": "husky",
+    "prepublishOnly": "npm run build",
+    "prettier": "prettier --write",
+    "security-check": "yarn npm audit --severity high --environment production --recursive",
+    "upgrade-dependencies": "yarn upgrade-interactive",
+    "semantic-release": "semantic-release",
+    "serve": "npx serve -l 3333",
+    "test:implicit-flow": "open http://localhost:3333/test/fixtures/implicit-flow?clientId=$ALLTHINGS_OAUTH_CLIENT_ID",
+    "test:authorization-code": "open http://localhost:3333/test/fixtures/authorization-code?clientId=$ALLTHINGS_OAUTH_CLIENT_ID&clientSecret=$ALLTHINGS_OAUTH_CLIENT_SECRET"
+  },
+  "dependenciesMeta": {
+    "unrs-resolver": {
+      "built": true
+    }
+  },
+  "dependencies": {
+    "bottleneck": "2.19.5"
+  },
+  "devDependencies": {
+    "@allthings/eslint-config": "3.1.0",
+    "@commitlint/cli": "21.0.1",
+    "@commitlint/config-conventional": "21.0.1",
+    "@rollup/plugin-commonjs": "29.0.2",
+    "@rollup/plugin-json": "6.1.0",
+    "@rollup/plugin-node-resolve": "16.0.3",
+    "@types/jest": "30.0.0",
+    "@types/node": "24.12.4",
+    "aws-sdk-client-mock": "4.1.0",
+    "coveralls": "3.1.1",
+    "eslint": "9.39.4",
+    "husky": "9.1.7",
+    "jest": "30.4.2",
+    "jest-environment-jsdom": "30.4.1",
+    "lint-staged": "17.0.5",
+    "prettier": "3.8.3",
+    "rimraf": "6.1.3",
+    "rollup": "4.60.4",
+    "rollup-plugin-hashbang": "3.0.0",
+    "semantic-release": "25.0.3",
+    "ts-jest": "29.4.9",
+    "typescript": "6.0.3"
+  },
+  "prettier": {
+    "printWidth": 80,
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "all",
+    "useTabs": false
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "yarn prettier",
+      "yarn lint"
+    ],
+    "*.{json}": [
+      "yarn prettier"
+    ]
+  },
+  "jest": {
+    "bail": false,
+    "collectCoverage": true,
+    "collectCoverageFrom": [
+      "src/**/*.{ts,tsx}",
+      "!src/cli.ts",
+      "!src/global.d.ts",
+      "!src/index.ts",
+      "!src/aws/index.ts",
+      "!src/oauth/types.ts"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 89,
+        "functions": 96,
+        "lines": 97,
+        "statements": 96
+      }
+    },
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/test/"
+    ],
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "json"
+    ],
+    "preset": "ts-jest",
+    "roots": [
+      "src/"
+    ],
+    "setupFilesAfterEnv": [
+      "./test/setup.ts"
+    ],
+    "testEnvironment": "node",
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx)$",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "ts-jest",
+        {
+          "diagnostics": {
+            "warnOnly": true
+          }
+        }
+      ]
+    }
+  }
+}

package/dist/src/cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { restClient } from './index';
+export async function main() {
+    const [, , action, ...arguments_] = process.argv;
+    const client = restClient();
+    console.log('\n\n', arguments_);
+    if (action === 'list-active-users') {
+        console.log(await client.getCurrentUser());
+    }
+    else {
+        console.log('Please provide an action to perform.');
+    }
+    console.log('\n\n');
+}
+main().catch(console.error);

package/dist/src/constants.js

@@ -0,0 +1,25 @@
+import { version } from '../package.json';
+import { environment } from './utils/environment';
+const REST_API_URL = 'https://api.allthings.me';
+const OAUTH_URL = 'https://accounts.allthings.me';
+export const QUEUE_CONCURRENCY = undefined;
+export const QUEUE_DELAY = 0;
+export const QUEUE_RESERVOIR = 30;
+export const QUEUE_RESERVOIR_REFILL_INTERVAL = 166;
+export const REQUEST_BACK_OFF_INTERVAL = 200;
+export const REQUEST_MAX_RETRIES = 50;
+export const DEFAULT_API_WRAPPER_OPTIONS = {
+    apiUrl: environment.ALLTHINGS_REST_API_URL || REST_API_URL,
+    clientId: environment.ALLTHINGS_OAUTH_CLIENT_ID,
+    clientSecret: environment.ALLTHINGS_OAUTH_CLIENT_SECRET,
+    oauthUrl: environment.ALLTHINGS_OAUTH_URL || OAUTH_URL,
+    password: environment.ALLTHINGS_OAUTH_PASSWORD,
+    requestBackOffInterval: REQUEST_BACK_OFF_INTERVAL,
+    requestMaxRetries: REQUEST_MAX_RETRIES,
+    scope: 'user:profile',
+    username: environment.ALLTHINGS_OAUTH_USERNAME,
+};
+export const USER_AGENT = `Allthings Node SDK REST Client/${version}`;
+export const DEFAULT_AWS_CONFIGURATION = {
+    region: 'eu-central-2',
+};

package/dist/src/index.js

@@ -0,0 +1,4 @@
+export { default as createTokenStore } from './oauth/createTokenStore';
+export { EnumCommunicationPreferenceChannel, EnumUnitObjectType, EnumUnitType, EnumUserPermissionObjectType, EnumUserPermissionRole, EnumUserRelationType, EnumUtilisationPeriodType, default as restClient, } from './rest';
+export { EnumCommunicationMethodType, EnumCountryCode, EnumInputChannel, EnumLocale, EnumLookupUserType, EnumResource, EnumServiceProviderType, EnumTimezone, } from './rest/types';
+export { buildQueryString, parseQueryString } from './utils/queryString';

package/dist/src/oauth/authorizationCodeGrant.js

@@ -0,0 +1,56 @@
+import { buildQueryString } from '../utils/queryString';
+export const RESPONSE_TYPE = 'code';
+export const GRANT_TYPE = 'authorization_code';
+const castToAuthorizationRequestParameters = (parameters) => {
+    const { redirectUri, clientId, scope, state } = parameters;
+    if (!clientId) {
+        throw new Error('Missing required "clientId" parameter to perform authorization code grant redirect');
+    }
+    if (!redirectUri) {
+        throw new Error('Missing required "redirectUri" parameter to perform authorization code grant redirect');
+    }
+    return {
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        response_type: RESPONSE_TYPE,
+        ...(scope ? { scope } : {}),
+        ...(state ? { state } : {}),
+    };
+};
+export const isEligibleForClientRedirect = (parameters) => {
+    try {
+        return !!castToAuthorizationRequestParameters(parameters);
+    }
+    catch {
+        return false;
+    }
+};
+export const getRedirectUrl = (parameters) => `${parameters.oauthUrl}/oauth/authorize?${buildQueryString(castToAuthorizationRequestParameters(parameters))}`;
+const castToTokenRequestParameters = (parameters) => {
+    const { authorizationCode, redirectUri, clientId, clientSecret } = parameters;
+    if (!clientId) {
+        throw new Error('Missing required "clientId" parameter to perform authorization code grant');
+    }
+    if (!redirectUri) {
+        throw new Error('Missing required "redirectUri" parameter to perform authorization code grant');
+    }
+    if (!authorizationCode) {
+        throw new Error('Missing required "authorizationCode" parameter to perform authorization code grant');
+    }
+    return {
+        client_id: clientId,
+        code: authorizationCode,
+        grant_type: GRANT_TYPE,
+        redirect_uri: redirectUri,
+        ...(clientSecret ? { client_secret: clientSecret } : {}),
+    };
+};
+export const isEligible = (parameters) => {
+    try {
+        return !!castToTokenRequestParameters(parameters);
+    }
+    catch {
+        return false;
+    }
+};
+export const requestToken = (tokenRequester, parameters) => tokenRequester(castToTokenRequestParameters(parameters));

package/dist/src/oauth/clientCredentialsGrant.js

@@ -0,0 +1,25 @@
+export const GRANT_TYPE = 'client_credentials';
+const castClientOptionsToRequestParameters = (clientOptions) => {
+    const { scope, clientId, clientSecret } = clientOptions;
+    if (!clientId) {
+        throw new Error('Missing required "clientId" parameter to perform client credentials grant');
+    }
+    if (!clientSecret) {
+        throw new Error('Missing required "clientSecret" parameter to perform client credentials grant');
+    }
+    return {
+        client_id: clientId,
+        client_secret: clientSecret,
+        grant_type: GRANT_TYPE,
+        ...(scope ? { scope } : {}),
+    };
+};
+export const isEligible = (clientOptions) => {
+    try {
+        return !!castClientOptionsToRequestParameters(clientOptions);
+    }
+    catch {
+        return false;
+    }
+};
+export const requestToken = (oauthTokenRequest, clientOptions) => oauthTokenRequest(castClientOptionsToRequestParameters(clientOptions));

package/dist/src/oauth/createTokenStore.js

@@ -0,0 +1,8 @@
+export default function createTokenStore(initialToken) {
+    const token = new Map(Object.entries(initialToken || {}));
+    return {
+        get: (key) => token.get(key),
+        reset: () => token.clear(),
+        set: (update) => Object.entries(update).forEach(([key, value]) => token.set(key, value)),
+    };
+}

package/dist/src/oauth/implicitGrant.js

@@ -0,0 +1,24 @@
+import { buildQueryString } from '../utils/queryString';
+export const RESPONSE_TYPE = 'token';
+const castToAuthorizationRequestParameters = (parameters) => {
+    const { clientId, scope, state, redirectUri } = parameters;
+    if (!clientId) {
+        throw new Error('Missing required "clientId" parameter to perform implicit grant');
+    }
+    return {
+        client_id: clientId,
+        redirect_uri: redirectUri || window.location.href,
+        response_type: RESPONSE_TYPE,
+        ...(scope ? { scope } : {}),
+        ...(state ? { state } : {}),
+    };
+};
+export const isEligibleForClientRedirect = (parameters) => {
+    try {
+        return !!castToAuthorizationRequestParameters(parameters);
+    }
+    catch {
+        return false;
+    }
+};
+export const getRedirectUrl = (parameters) => `${parameters.oauthUrl}/oauth/authorize?${buildQueryString(castToAuthorizationRequestParameters(parameters))}`;

package/dist/src/oauth/makeFetchTokenRequester.js

@@ -0,0 +1,38 @@
+import { USER_AGENT } from '../constants';
+import makeLogger from '../utils/logger';
+import { buildQueryString } from '../utils/queryString';
+const logger = makeLogger('OAuth Token Request');
+const makeFetchTokenRequester = (url) => async (parameters) => {
+    try {
+        const response = await fetch(url, {
+            body: buildQueryString(parameters),
+            cache: 'no-cache',
+            credentials: 'omit',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                accept: 'application/json',
+                'user-agent': USER_AGENT,
+            },
+            method: 'POST',
+            mode: 'cors',
+        });
+        if (response.status !== 200) {
+            throw response;
+        }
+        const { access_token: newAccessToken, refresh_token: newRefreshToken, expires_in: expiresIn, } = await response.json();
+        return {
+            accessToken: newAccessToken,
+            expiresIn,
+            refreshToken: newRefreshToken,
+        };
+    }
+    catch (error) {
+        if (!(error instanceof Response)) {
+            throw error;
+        }
+        const errorName = `HTTP ${error.status} — ${error.statusText}`;
+        logger.error(errorName, error);
+        throw new Error(`HTTP ${error.status} — ${error.statusText}. Could not get token.`);
+    }
+};
+export default makeFetchTokenRequester;

package/dist/src/oauth/maybeUpdateToken.js

@@ -0,0 +1,44 @@
+import { parseQueryString } from '../utils/queryString';
+import * as authorizationCodeGrant from './authorizationCodeGrant';
+import * as clientCredentialsGrant from './clientCredentialsGrant';
+import * as implicitGrant from './implicitGrant';
+import * as passwordGrant from './passwordGrant';
+import * as refreshTokenGrant from './refreshTokenGrant';
+export default async function maybeUpdateToken(oauthTokenStore, tokenFetcher, options, mustRefresh = false) {
+    if (!mustRefresh && oauthTokenStore.get('accessToken')) {
+        return;
+    }
+    const refreshOptions = {
+        ...options,
+        refreshToken: oauthTokenStore.get('refreshToken'),
+    };
+    if (refreshTokenGrant.isEligible(refreshOptions)) {
+        return oauthTokenStore.set(await refreshTokenGrant.requestToken(tokenFetcher, refreshOptions));
+    }
+    if (passwordGrant.isEligible(options)) {
+        return oauthTokenStore.set(await passwordGrant.requestToken(tokenFetcher, options));
+    }
+    if (typeof window !== 'undefined' && options.implicit) {
+        const parsedLocationHash = parseQueryString(window.location.hash);
+        const accessToken = parsedLocationHash.access_token;
+        if (accessToken) {
+            window.history.replaceState({}, '', window.location.href.split('#')[0]);
+            return oauthTokenStore.set({ accessToken });
+        }
+        if (implicitGrant.isEligibleForClientRedirect(options)) {
+            window.location.href = implicitGrant.getRedirectUrl(options);
+            return;
+        }
+    }
+    if (!mustRefresh && authorizationCodeGrant.isEligible(options)) {
+        return oauthTokenStore.set(await authorizationCodeGrant.requestToken(tokenFetcher, options));
+    }
+    if (options.authorizationRedirect &&
+        authorizationCodeGrant.isEligibleForClientRedirect(options)) {
+        return options.authorizationRedirect(authorizationCodeGrant.getRedirectUrl(options));
+    }
+    if (clientCredentialsGrant.isEligible(options)) {
+        return oauthTokenStore.set(await clientCredentialsGrant.requestToken(tokenFetcher, options));
+    }
+    return;
+}

package/dist/src/oauth/passwordGrant.js

@@ -0,0 +1,30 @@
+export const GRANT_TYPE = 'password';
+const castToTokenRequestParameters = (parameters) => {
+    const { username, password, scope, clientId, clientSecret } = parameters;
+    if (!clientId) {
+        throw new Error('Missing required "clientId" parameter to perform password grant');
+    }
+    if (!username) {
+        throw new Error('Missing required "username" parameter to perform password grant');
+    }
+    if (!password) {
+        throw new Error('Missing required "password" parameter to perform password grant');
+    }
+    return {
+        client_id: clientId,
+        grant_type: GRANT_TYPE,
+        password,
+        username,
+        ...(scope ? { scope } : {}),
+        ...(clientSecret ? { client_secret: clientSecret } : {}),
+    };
+};
+export const isEligible = (parameters) => {
+    try {
+        return !!castToTokenRequestParameters(parameters);
+    }
+    catch {
+        return false;
+    }
+};
+export const requestToken = (tokenRequester, parameters) => tokenRequester(castToTokenRequestParameters(parameters));

package/dist/src/oauth/refreshTokenGrant.js

@@ -0,0 +1,26 @@
+export const GRANT_TYPE = 'refresh_token';
+const castToTokenRequestParameters = (parameters) => {
+    const { clientId, clientSecret, refreshToken, scope } = parameters;
+    if (!clientId) {
+        throw new Error('Missing required "clientId" parameter to perform refresh token grant');
+    }
+    if (!refreshToken) {
+        throw new Error('Missing required "refreshToken" parameter to perform refresh token grant');
+    }
+    return {
+        client_id: clientId,
+        grant_type: GRANT_TYPE,
+        refresh_token: refreshToken,
+        ...(clientSecret ? { client_secret: clientSecret } : {}),
+        ...(scope ? { scope } : {}),
+    };
+};
+export const isEligible = (parameters) => {
+    try {
+        return !!castToTokenRequestParameters(parameters);
+    }
+    catch {
+        return false;
+    }
+};
+export const requestToken = (tokenRequester, parameters) => tokenRequester(castToTokenRequestParameters(parameters));

package/dist/src/oauth/requestAndSaveToStore.js

@@ -0,0 +1,5 @@
+export default async function requestAndSaveToStore(requester, tokenStore) {
+    const response = await requester();
+    tokenStore.set(response);
+    return response;
+}

package/dist/src/oauth/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/rest/delete.js

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

package/dist/src/rest/get.js

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