@gandalan/weblibs 1.1.52 → 1.1.54

package/api/authUtils.js

@@ -2,9 +2,36 @@
 import { jwtDecode } from "jwt-decode";
 import validator from "validator";
 
+/**
+ * @typedef {Object} Settings
+ * @property {string} appToken - The application token.
+ * @property {string} mandantGuid - The mandant GUID.
+ * @property {string} apiBaseurl - The base URL for the API.
+ * @property {string} authUrl - The authentication URL.
+ */
+
+/**
+ * the current JWT token (encoded)
+ *
+ * @type {string}
+ */
 export let currentToken = undefined;
+
+/**
+ * the current refresh token (UUID v4)
+ *
+ * @type {string}
+ */
 export let currentRefreshToken = undefined;
 
+/**
+ * initializes the API client with the given appToken
+ *
+ * @export
+ * @async
+ * @param {string} appToken, UUID v4 format
+ * @returns {Settings} settings object
+ */
 export async function initIDAS(appToken)
 {
     if (!validator.isUUID(appToken))
@@ -59,6 +86,13 @@ export async function initIDAS(appToken)
     return settings;
 }
 
+/**
+ * sets up authentication 
+ *
+ * @export
+ * @async
+ * @param {Settings} settings
+ */
 export async function setup(settings)
 {
     console.log("Setup IDAS");
@@ -97,6 +131,12 @@ export async function setup(settings)
     console.log("Setup finished", settings);
 }
 
+/**
+ * starts a timer to refresh the JWT token before it expires
+ *
+ * @private
+ * @type {*}
+ */
 let timerRef = undefined;
 function startRefreshTimer(settings)
 {
@@ -119,6 +159,13 @@ function startRefreshTimer(settings)
     }, 5000);
 }
 
+/**
+ * checks if the current JWT token is invalid
+ *
+ * @export
+ * @param {Settings} settings
+ * @returns {boolean}
+ */
 export function isInvalid(settings)
 {
     if (!currentToken)
@@ -136,6 +183,13 @@ export function isInvalid(settings)
     return true;
 }
 
+/**
+ * tries to renew the JWT token
+ *
+ * @export
+ * @async
+ * @param {Settings} settings
+ */
 export async function tryRenew(settings)
 {
     console.log("Try to refresh");
@@ -173,6 +227,12 @@ export async function tryRenew(settings)
     }
 }
 
+/**
+ * redirects to the login page
+ *
+ * @export
+ * @param {Settings} settings
+ */
 export function redirectToLogin(settings, authPath)
 {
     const authEndpoint = (new URL(window.location.href).origin) + authPath;

package/api/fluentApi.js

@@ -1,9 +1,42 @@
 import { jwtDecode } from "jwt-decode";
-
+import { restClient } from "./fluentRestClient";
+import { authBuilder } from "./fluentAuthBuilder";
+
+/**
+ * @typedef {Object} EnvironmentConfig
+ * @property {string} name - The environment name.
+ * @property {string} version - The version number.
+ * @property {string} cms - The CMS URL.
+ * @property {string} idas - The IDAS API URL.
+ * @property {string} store - The store API URL.
+ * @property {string} docs - The documentation URL.
+ * @property {string} notify - The notification service URL.
+ * @property {string} feedback - The feedback service URL.
+ * @property {string} helpcenter - The help center URL.
+ * @property {string} reports - The reports service URL.
+ * @property {string} webhookService - The webhook service URL.
+ */
+
+/**
+ * buffer for environment data
+ * @private
+ * @type {Object.<string, EnvironmentConfig>}
+ */
 const envs = {};
 
+/**
+ * configure the time before token expiry to renew
+ * @type {number}
+ */
 const JWT_SAFE_RENEWAL = 30; // seconds before token expiry to renew
 
+/**
+ * fetches the environment data from the hub
+ * @export
+ * @async
+ * @param {string} [env="", env="dev", env="staging", env="produktiv"]
+ * @returns {Promise<EnvironmentConfig>}
+ */
 export async function fetchEnv(env = "") {
     if (!(env in envs)) {
         const hubUrl = `https://connect.idas-cloudservices.net/api/Endpoints?env=${env}`;
@@ -15,17 +48,37 @@ export async function fetchEnv(env = "") {
     return envs[env];
 }
 
+/** 
+ * @typedef {Object} JwtTokenExt
+ * @property {string} id
+ * @property {string} refreshToken
+*/
+
+/**
+ * decode the JWT token and return the refresh token
+ * @export
+ * @param {string} token
+ * @returns {string}
+ */
 export function getRefreshToken(token) {
-    const decoded = jwtDecode(token);
+    const decoded = /** @type {JwtTokenExt} */(jwtDecode(token));
     return decoded.refreshToken;
 }
 
+/**
+ * check if the token is still valid
+ * - checks the expiry date and the JWT_SAFE_RENEWAL buffer
+ * 
+ *  @export
+ * @param {string} token
+ * @returns {boolean}
+ */
 export function isTokenValid(token) 
 {
     try
     {
         const decoded = jwtDecode(token);
-        if (!decoded) 
+        if (!decoded || !decoded.exp) 
             throw new Error("Invalid token");
         return (decoded.exp - JWT_SAFE_RENEWAL > Date.now() / 1000);
     }
@@ -34,133 +87,37 @@ export function isTokenValid(token)
     }
 }
 
-export function authBuilder() {
-    return {
-        authUrl: "",
-        appToken: "",
-        token: "",
-        refreshToken: "",
-
-        useAppToken(appToken = "") {
-            this.appToken = appToken; return this;
-        },
-
-        useBaseUrl(authUrl = "") {
-            this.authUrl = authUrl; return this;
-        },
-
-        useToken(jwtToken = "") {
-            this.token = jwtToken; return this;
-        },
-
-        useRefreshToken(storedRefreshToken = "") {
-            this.refreshToken = storedRefreshToken; return this;
-        },
-
-        async authenticate(username = "", password = "") 
-        {
-            console.log("authenticating:", this.token ? `token set, exp: ${jwtDecode(this.token).exp - (Date.now() / 1000)}` : "no token,", this.refreshToken);
-
-            if (this.token && isTokenValid(this.token)) 
-                return this.token;
-
-            if (this.token && !this.refreshToken)
-                this.refreshToken = getRefreshToken(this.token);
-
-            if (this.refreshToken) {
-                try {
-                    const temptoken = await this.tryRefreshToken(this.refreshToken);
-                    if (temptoken) {
-                        this.token = temptoken;
-                        this.refreshToken = getRefreshToken(temptoken);
-                    }
-                } catch {
-                    // if refresh failed, we'll return the current token
-                    // - should still be valid for a while
-                }
-                return this.token;
-            }
-
-            if (username && password) {
-                const payload = { "Email": username, "Password": password, "AppToken": this.appToken };
-                const res = await fetch(`${this.authUrl}/LoginJwt`,
-                    { method: "POST", body: JSON.stringify(payload), headers: { "Content-Type": "application/json" } });
-                const temptoken = await res.json();
-                if (temptoken) {
-                    this.token = temptoken;
-                    return this.token;
-                }
-            }
-
-            throw new Error("not authenticated");
-        },
-
-        async tryRefreshToken(refreshToken = "") {
-            const payload = { "Token": refreshToken };            
-            const res = await fetch(`${this.authUrl}/LoginJwt/Refresh`,
-                {
-                    method: "PUT",
-                    body: JSON.stringify(payload),
-                    headers: { "Content-Type": "application/json" },
-                });
-            return res.ok ? await res.json() : null;
-        },
-    }
-}
-
-export function restClient()
-{
-    return {
-        baseUrl: "",
-        token: "",
-
-        useBaseUrl(url = "") {
-            this.baseUrl = url; return this;
-        },
-
-        useToken(jwtToken = "") {
-            this.token = jwtToken; return this;
-        },
-
-        async get(url = "", auth = true) {
-            const finalUrl = `${this.baseUrl}/${url}`;
-            const headers = this.token ? { "Authorization": `Bearer ${this.token}` } : {};
-            const res = await fetch(finalUrl, { method: "GET", headers });
-            if (res.ok)
-                return await res.json();
-            throw new Error(`GET ${finalUrl} failed: ${res.status} ${res.statusText}`);
-        },
-
-        async put(url = "", payload = {}) {
-            const finalUrl = `${this.baseUrl}/${url}`;
-            const headers = this.token ? { "Authorization": `Bearer ${this.token}`, "Content-Type": "application/json" } : {};
-            const res = await fetch(finalUrl, { method: "PUT", body: JSON.stringify(payload), headers });
-            if (res.ok)
-                return await res.json();
-            throw new Error(`PUT ${finalUrl} failed: ${res.status} ${res.statusText}`);
-        },
-
-        async post(url = "", payload = {}) {
-            const finalUrl = `${this.baseUrl}/${url}`;
-            const headers = this.token ? { "Authorization": `Bearer ${this.token}`, "Content-Type": "application/json" } : {};
-            const res = await fetch(finalUrl, { method: "POST", body: JSON.stringify(payload), headers });
-            if (res.ok)
-                return await res.json();
-            throw new Error(`POST ${finalUrl} failed: ${res.status} ${res.statusText}`);
-        },
-
-        async delete(url = "") {
-            const finalUrl = `${this.baseUrl}/${url}`;
-            const headers = this.token ? { "Authorization": `Bearer ${this.token}` } : {};
-            const res = await fetch(finalUrl, { method: "DELETE", headers });
-            if (res.ok)
-                return await res.json();
-            throw new Error(`DELETE ${finalUrl} failed: ${res.status} ${res.statusText}`);
-        }
-    }
-}
-
-export function api() {
+/**
+ * @typedef {Object} FluentApi
+ * @property {string} baseUrl - The base URL for API requests.
+ * @property {string} authUrl - The authentication URL.
+ * @property {string} env - The environment setting.
+ * @property {string} appToken - The application token.
+ * @property {string} storageEntry - The storage entry.
+ * @property {string} token - The JWT token for authorization.
+ * @property {string} refreshToken - The refresh token.
+ * @property {function(string) : FluentApi} useEnvironment - Sets the environment and returns the FluentApi object.
+ * @property {function(string) : FluentApi} useAppToken - Sets the application token and returns the FluentApi object.
+ * @property {function(string) : FluentApi} useBaseUrl - Sets the base URL for API requests and returns the FluentApi object.
+ * @property {function(string) : FluentApi} useAuthUrl - Sets the authentication URL and returns the FluentApi object.
+ * @property {function(string) : FluentApi} useToken - Sets the JWT token for authorization and returns the FluentApi object.
+ * @property {function(string) : FluentApi} useRefreshToken - Sets the refresh token and returns the FluentApi object.
+ * @property {function() : FluentApi} useGlobalAuth - Uses global authentication tokens and returns the FluentApi object.
+ * @property {function(string) : object|Array<any>} get - Async function to perform GET requests.
+ * @property {function(string, object) : object|Array<any>} put - Async function to perform PUT requests with a payload.
+ * @property {function(string, object) : object|Array<any>} post - Async function to perform POST requests with a payload.
+ * @property {function(string) : object|Array<any>} delete - Async function to perform DELETE requests.
+ * @property {Function} ensureAuthenticated - Ensures the user is authenticated before making a request.
+ * @property {Function} ensureBaseUrlIsSet - Ensures the base URL is set before making a request.
+ * @property {Function} redirectToLogin - Redirects to the login page.
+ */
+
+/**
+ * Builds a client to communicate with the IDAS api in a fluent syntax
+ * 
+ * @return {FluentApi}
+ */
+export function createApi() {
     return {
         baseUrl: "",
         authUrl: "",
@@ -170,59 +127,143 @@ export function api() {
         token: "",
         refreshToken: "",
 
+        /**
+         * set the environment to use
+         * 
+         * @param {string} env 
+         * @return {FluentApi}
+         */
         useEnvironment(env = "") {
             this.env = env; return this;
         },
 
+        /**
+         * set the app token to use
+         *
+         * @param {string} [newApptoken=""]
+         * @return {FluentApi}
+         */
         useAppToken(newApptoken = "") {
             this.appToken = newApptoken; return this;
         },
 
+        /**
+         * set the base URL for API requests
+         *
+         * @param {string} [url=""]
+         * @return {FluentApi}
+         */
         useBaseUrl(url = "") {
             this.baseUrl = url; return this;
         },
 
+        /**
+         * set the authentication URL
+         *
+         * @param {string} [url=""]
+         * @return {FluentApi}
+         */
         useAuthUrl(url = "") {
             this.authUrl = url; return this;
         },
 
+        /**
+         * set the JWT token for authorization
+         *
+         * @param {string} [jwtToken=""]
+         * @return {FluentApi}
+         */
         useToken(jwtToken = "") {
             this.token = jwtToken; return this;
         },
 
+        /**
+         * set the refresh token
+         *
+         * @param {string} [storedRefreshToken=""]
+         * @return {FluentApi}
+         */
         useRefreshToken(storedRefreshToken = "") {
             this.refreshToken = storedRefreshToken; return this;
         },
-
+        
+        /**
+         * tell the client to use the global authentication tokens
+         *
+         * @return {FluentApi}
+         */
         useGlobalAuth() {
+            // eslint-disable-next-line no-undef 
+            this.token = globalThis.idasTokens.token; 
             // eslint-disable-next-line no-undef
-            this.token = globalThis.idasTokens.token; this.refreshToken = globalThis.idasTokens.refreshToken; return this;
+            this.refreshToken = globalThis.idasTokens.refreshToken; 
+            return this;
         },
-
+        
+        /**
+         * GET request, ensure authenticated if needed
+         *
+         * @async
+         * @param {string} [url=""]
+         * @param {boolean} [auth=true]
+         * @returns {Promise<Object>}
+         */
         async get(url = "", auth = true) {
             if (auth) 
                 await this.ensureAuthenticated();
             return restClient().useBaseUrl(this.baseUrl).useToken(this.token).get(url);
         },
 
+        /**
+         * PUT request, ensure authenticated if needed
+         *
+         * @async
+         * @param {string} [url=""]
+         * @param {Object} [payload={}]
+         * @param {boolean} [auth=true]
+         * @returns {Promise<Object>}
+         */
         async put(url = "", payload = {}, auth = true) {
             if (auth) 
                 await this.ensureAuthenticated();
             return restClient().useBaseUrl(this.baseUrl).useToken(this.token).put(url, payload);
         },
 
+        /**
+         * POST request, ensure authenticated if needed
+         *
+         * @async
+         * @param {string} [url=""]
+         * @param {Object} [payload={}]
+         * @param {boolean} [auth=true]
+         * @returns {Promise<Object>}
+         */
         async post(url = "", payload = {}, auth = true) {
             if (auth) 
                 await this.ensureAuthenticated();
             return restClient().useBaseUrl(this.baseUrl).useToken(this.token).post(url, payload);
         },
-
+        
+        /**
+         * DELETE request, ensure authenticated if needed
+         *
+         * @async
+         * @param {string} [url=""]
+         * @param {boolean} [auth=true]
+         * @returns {Promise<Object>}
+         */
         async delete(url = "", auth = true) {
             if (auth) 
                 await this.ensureAuthenticated();
             return restClient().useBaseUrl(this.baseUrl).useToken(this.token).delete(url);
         },
 
+        /**
+         * Ensure the user is authenticated before making a request
+         *
+         * @async
+         * @private
+         */
         async ensureAuthenticated() {
             if (this.token && isTokenValid(this.token))
                 return;
@@ -252,7 +293,14 @@ export function api() {
                 this.redirectToLogin();
             }
         },
-
+        
+        /**
+         * Ensure the base URL is set before making a request. If not set, 
+         * retrieve the environment data and set the base URL.
+         *
+         * @async
+         * @private
+         */
         async ensureBaseUrlIsSet() {
             if (this.env && (!this.baseUrl || !this.authUrl)) {
                 const envInfo = await fetchEnv(this.env);
@@ -270,6 +318,12 @@ export function api() {
             }
         },
 
+        /**
+         * Redirect to the login page
+         *
+         * @param {string} [authPath=""]
+         * @private
+         */
         redirectToLogin(authPath = "") {
             if (!window) {
                 return;
@@ -284,14 +338,34 @@ export function api() {
             url.search = `?a=${this.appToken}&r=${encodeURIComponent(authUrlCallback)}`;
             let loginUrl = url.toString();
 
-            window.location = loginUrl;
+            window.location.href = loginUrl;
         },
     };
 }
 
+/**
+ * Default setup for IDAS
+ *
+ * @export
+ * @param {string} [appToken=""]
+ * @return {FluentApi}
+ */
 export function idasApi(appToken = "") {
-    return api()
+    return createApi()
         .useGlobalAuth()
         .useAppToken(appToken)
         .useEnvironment("dev");
 }
+
+/**
+ * Default setup for local API
+ *
+ * @export
+ * @return {FluentApi}
+ */
+export function localApi() {
+    return createApi()
+        .useGlobalAuth()
+        .useBaseUrl("/api")
+        .useEnvironment("dev");
+}

package/api/fluentAuthBuilder.js

@@ -0,0 +1,133 @@
+import { jwtDecode } from "jwt-decode";
+import { isTokenValid, getRefreshToken } from "./fluentApi";
+
+/**
+ * @typedef {Object} FluentAuth
+ * @property {string} authUrl - The authentication URL.
+ * @property {string} appToken - The application token.
+ * @property {string} token - The JWT token.
+ * @property {string} refreshToken - The refresh token.
+ * @property {function(string) : FluentApi} useAppToken - Sets the application token and returns the FluentApi object.
+ * @property {function(string) : FluentApi} useBaseUrl - Sets the base URL for authentication and returns the FluentApi object.
+ * @property {function(string) : FluentApi} useToken - Sets the JWT token and returns the FluentApi object.
+ * @property {function(string) : FluentApi} useRefreshToken - Sets the refresh token and returns the FluentApi object.
+ * @property {Function} authenticate - Authenticates the user with username and password, or refreshes the token.
+ * @property {Function} tryRefreshToken - Attempts to refresh the authentication token using the refresh token.
+ */
+
+/**
+ * Builds an authentication object
+ *
+ * @export
+ * @returns {FluentAuth}
+ */
+export function authBuilder() {
+    return {
+        authUrl: "",
+        appToken: "",
+        token: "",
+        refreshToken: "",
+
+        /**
+         * app token to use for authentication
+         *
+         * @param {string} [appToken=""]
+         * @returns {FluentAuth}
+         */
+        useAppToken(appToken = "") {
+            this.appToken = appToken; return this;
+        },
+
+        /**
+         * base URL for authentication
+         *
+         * @param {string} [authUrl=""]
+         * @returns {FluentAuth}
+         */
+        useBaseUrl(authUrl = "") {
+            this.authUrl = authUrl; return this;
+        },
+
+        /**
+         * token to use for authentication
+         *
+         * @param {string} [jwtToken=""]
+         * @returns {FluentAuth}
+         */
+        useToken(jwtToken = "") {
+            this.token = jwtToken; return this;
+        },
+
+        /**
+         * sets the refresh token to use
+         * @param {string} a refresh token (UUID v4 format)
+         * @returns {FluentAuth}
+         */
+        useRefreshToken(storedRefreshToken = "") {
+            this.refreshToken = storedRefreshToken; return this;
+        },
+
+        /**
+         * Authenticates the user with username and password, or refreshes the token.
+         *
+         * @param {string} username
+         * @param {string} password
+         * @returns
+         */
+        async authenticate(username = "", password = "") {
+            console.log("authenticating:", this.token ? `token set, exp: ${jwtDecode(this.token).exp - (Date.now() / 1000)}` : "no token,", this.refreshToken);
+
+            if (this.token && isTokenValid(this.token))
+                return this.token;
+
+            if (this.token && !this.refreshToken)
+                this.refreshToken = getRefreshToken(this.token);
+
+            if (this.refreshToken) {
+                try {
+                    const temptoken = await this.tryRefreshToken(this.refreshToken);
+                    if (temptoken) {
+                        this.token = temptoken;
+                        this.refreshToken = getRefreshToken(temptoken);
+                    }
+                } catch {
+                    // if refresh failed, we'll return the current token
+                    // - should still be valid for a while
+                }
+                return this.token;
+            }
+
+            if (username && password) {
+                const payload = { "Email": username, "Password": password, "AppToken": this.appToken };
+                const res = await fetch(`${this.authUrl}/LoginJwt`,
+                    { method: "POST", body: JSON.stringify(payload), headers: { "Content-Type": "application/json" } });
+                const temptoken = await res.json();
+                if (temptoken) {
+                    this.token = temptoken;
+                    return this.token;
+                }
+            }
+
+            throw new Error("not authenticated");
+        },
+
+        /**
+         * try to refresh the token using the refresh token
+         *
+         * @async
+         * @private
+         * @param {string} [refreshToken=""]
+         * @returns {unknown}
+         */
+        async tryRefreshToken(refreshToken = "") {
+            const payload = { "Token": refreshToken };
+            const res = await fetch(`${this.authUrl}/LoginJwt/Refresh`,
+                {
+                    method: "PUT",
+                    body: JSON.stringify(payload),
+                    headers: { "Content-Type": "application/json" },
+                });
+            return res.ok ? await res.json() : null;
+        },
+    };
+}

package/api/fluentRestClient.js

@@ -0,0 +1,109 @@
+/**
+ * @typedef {Object} FluentRESTClient
+ * @property {string} baseUrl - The base URL for API requests.
+ * @property {string} token - The JWT token for authorization.
+ * @property {function(string) : FluentRESTClient} useBaseUrl - Function to set the base URL and return the FluentApi object.
+ * @property {function(string) : FluentRESTClient} useToken - Function to set the JWT token and return the FluentApi object.
+ * @property {function(string) : object|Array<any>} get - Async function to perform GET requests.
+ * @property {function(string, object) : object|Array<any>} put - Async function to perform PUT requests with a payload.
+ * @property {function(string, object) : object|Array<any>} post - Async function to perform POST requests with a payload.
+ * @property {function(string) : object|Array<any>} delete - Async function to perform DELETE requests.
+ */
+
+/**
+ * Creates a REST client object with fluent API for making HTTP requests.
+ * @returns {FluentRESTClient} The REST client object.
+ */
+export function restClient() {
+    return {
+        baseUrl: "",
+        token: "",
+
+        /**
+         * set the base URL for all requests
+         * 
+         * @param {string} url to use as base URL
+         * @returns {FluentRESTClient}
+         */
+        useBaseUrl(url = "") {
+            this.baseUrl = url; return this;
+        },
+
+        /**
+         * set the JWT token for authorization
+         *
+         * @param {string} [jwtToken=""]
+         * @returns {FluentRESTClient}
+         */
+        useToken(jwtToken = "") {
+            this.token = jwtToken; return this;
+        },
+
+        /**
+         * GET request to the specified URL
+         *
+         * @async
+         * @param {string} [url=""]
+         * @param {boolean} [auth=true]
+         * @returns {Promise<any>}
+         */
+        async get(url = "", auth = true) {
+            const finalUrl = `${this.baseUrl}/${url}`;
+            const headers = this.token ? { "Authorization": `Bearer ${this.token}` } : {};
+            const res = await fetch(finalUrl, { method: "GET", headers });
+            if (res.ok)
+                return await res.json();
+            throw new Error(`GET ${finalUrl} failed: ${res.status} ${res.statusText}`);
+        },
+
+        /**
+         * PUT request to the specified URL
+         *
+         * @async
+         * @param {string} [url=""]
+         * @param {Object} [payload={}]
+         * @returns {Promise<any>}
+         */
+        async put(url = "", payload = {}) {
+            const finalUrl = `${this.baseUrl}/${url}`;
+            const headers = this.token ? { "Authorization": `Bearer ${this.token}`, "Content-Type": "application/json" } : {};
+            const res = await fetch(finalUrl, { method: "PUT", body: JSON.stringify(payload), headers });
+            if (res.ok)
+                return await res.json();
+            throw new Error(`PUT ${finalUrl} failed: ${res.status} ${res.statusText}`);
+        },
+
+        /**
+         * POST request to the specified URL
+         *
+         * @async
+         * @param {string} [url=""]
+         * @param {Object} [payload={}]
+         * @returns {Promise<any>}
+         */
+        async post(url = "", payload = {}) {
+            const finalUrl = `${this.baseUrl}/${url}`;
+            const headers = this.token ? { "Authorization": `Bearer ${this.token}`, "Content-Type": "application/json" } : {};
+            const res = await fetch(finalUrl, { method: "POST", body: JSON.stringify(payload), headers });
+            if (res.ok)
+                return await res.json();
+            throw new Error(`POST ${finalUrl} failed: ${res.status} ${res.statusText}`);
+        },
+
+        /**
+         * DELETE request to the specified URL
+         *
+         * @async
+         * @param {string} [url=""]
+         * @returns {Promise<any>}
+         */
+        async delete(url = "") {
+            const finalUrl = `${this.baseUrl}/${url}`;
+            const headers = this.token ? { "Authorization": `Bearer ${this.token}` } : {};
+            const res = await fetch(finalUrl, { method: "DELETE", headers });
+            if (res.ok)
+                return await res.json();
+            throw new Error(`DELETE ${finalUrl} failed: ${res.status} ${res.statusText}`);
+        }
+    };
+}

package/index.js

@@ -15,4 +15,7 @@ export {
 export { IDASFactory } from "./api/IDAS";
 export { RESTClient } from "./api/RESTClient";
 export { initIDAS } from "./api/authUtils";
-export { api, authBuilder, fetchEnv, getRefreshToken, idasApi } from "./api/fluentApi";
+
+export { createApi as api, idasApi, fetchEnv, getRefreshToken } from "./api/fluentApi";
+export { authBuilder } from "./api/fluentAuthBuilder";
+export { restClient } from "./api/fluentRestClient";

package/jsconfig.json

@@ -10,6 +10,7 @@
         "forceConsistentCasingInFileNames": true,
         "resolveJsonModule": true,
         "skipLibCheck": true,
+        "lib": [ "ES6" ],
         /**
          * To have warnings / errors of the Svelte compiler at the
          * correct position, enable source maps by default.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gandalan/weblibs",
-  "version": "1.1.52",
+  "version": "1.1.54",
   "description": "WebLibs for Gandalan JS/TS/Svelte projects",
   "keywords": [
     "gandalan"