@karpeleslab/klbfw 0.1.13 → 0.2.1

package/internal.js

@@ -1,88 +1,166 @@
 'use strict';
-const fwWrapper = require('./fw-wrapper');
+/**
+ * @fileoverview Internal helpers for the KLB Frontend Framework
+ * 
+ * This module provides internal utility functions for REST API interactions,
+ * timezone handling, and response parsing.
+ */
 
-// vim: et:ts=4:sw=4
+const fwWrapper = require('./fw-wrapper');
 
-function get_tz_pad(number, length) {
-    var str = "" + number;
-    while (str.length < length)
+/**
+ * Pads a number with leading zeros
+ * @param {number} number - The number to pad
+ * @param {number} length - The desired length of the result
+ * @returns {string} The padded number
+ */
+const padNumber = (number, length) => {
+    let str = String(number);
+    while (str.length < length) {
         str = '0' + str;
+    }
     return str;
-}
-
-function get_timezone_data() {
-    // grab current offset value & built string
-    var offset = new Date().getTimezoneOffset();
-    offset = ((offset < 0 ? '+' : '-') + // Note the reversed sign!
-        get_tz_pad(parseInt(Math.abs(offset / 60)), 2) +
-        get_tz_pad(Math.abs(offset % 60), 2));
-
-    // check if we have intl info
-
-    if (typeof Intl != 'undefined' && (Intl.DateTimeFormat != undefined)) {
-        return Intl.DateTimeFormat().resolvedOptions().timeZone + ";" + offset;
+};
+
+/**
+ * Gets timezone data in a format suitable for API calls
+ * @returns {string} Formatted timezone string
+ */
+const getTimezoneData = () => {
+    // Grab current offset value & build string
+    const offset = new Date().getTimezoneOffset();
+    const sign = offset < 0 ? '+' : '-'; // Note the reversed sign!
+    const formattedOffset = sign + 
+        padNumber(parseInt(Math.abs(offset / 60)), 2) +
+        padNumber(Math.abs(offset % 60), 2);
+
+    // Check if we have Intl info
+    if (typeof Intl !== 'undefined' && Intl.DateTimeFormat !== undefined) {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone + ";" + formattedOffset;
     }
 
-    return offset;
-}
-
-function rest_url(path, with_token, context) {
-    if (!with_token) {
-        if (fwWrapper.getCallUrlPrefix()) return fwWrapper.getCallUrlPrefix() + "/_special/rest/" + path;
-        return "/_special/rest/" + path;
+    return formattedOffset;
+};
+
+/**
+ * Constructs a REST API URL
+ * @param {string} path - API endpoint path
+ * @param {boolean} withToken - Whether to include authentication token
+ * @param {Object} context - Context object with additional parameters
+ * @returns {string} Constructed URL
+ */
+const buildRestUrl = (path, withToken, context) => {
+    if (!withToken) {
+        if (fwWrapper.getCallUrlPrefix()) return fwWrapper.getCallUrlPrefix() + "/_rest/" + path;
+        return "/_rest/" + path;
     }
+    
     context = context || {};
-    var glue = '?';
-
+    let glue = '?';
+    
+    let callUrl;
     if (fwWrapper.getSiteStatic()) {
-        var call_url = "/_special/rest/" + path + "?static";
+        callUrl = "/_rest/" + path + "?static";
         glue = '&';
     } else {
-        var call_url = "/_special/rest/" + path;
+        callUrl = "/_rest/" + path;
+    }
+    
+    if (fwWrapper.getCallUrlPrefix()) {
+        callUrl = fwWrapper.getCallUrlPrefix() + callUrl;
     }
-    if (fwWrapper.getCallUrlPrefix()) call_url = fwWrapper.getCallUrlPrefix() + call_url;
 
-    // copy context, proceed with overload then add to url
-    var ctx_final = fwWrapper.getContext();
-    for (var i in context) ctx_final[i] = context[i];
-    for (var i in ctx_final) {
-        if (i == "_") continue;
-        call_url = call_url + glue + "_ctx[" + i + "]=" + encodeURIComponent(ctx_final[i]);
+    // Copy context, proceed with overload then add to url
+    const ctxFinal = fwWrapper.getContext();
+    for (const key in context) {
+        ctxFinal[key] = context[key];
+    }
+    
+    for (const key in ctxFinal) {
+        if (key === "_") continue;
+        callUrl = callUrl + glue + "_ctx[" + key + "]=" + encodeURIComponent(ctxFinal[key]);
         glue = '&';
     }
-    return call_url;
-}
+    
+    return callUrl;
+};
+
+/**
+ * Checks if the environment supports required features
+ * @returns {boolean} Whether the environment is supported
+ */
+const checkSupport = () => {
+    const missingFeatures = [];
+    
+    if (typeof fetch === "undefined") {
+        missingFeatures.push("fetch API");
+    }
 
-function internal_rest(name, verb, params, context) {
+    if (!fwWrapper.supported()) {
+        missingFeatures.push("Framework wrapper");
+    }
+    
+    if (missingFeatures.length > 0) {
+        console.error("Missing required features: " + missingFeatures.join(", "));
+        return false;
+    }
+    
+    return true;
+};
+
+/**
+ * Makes an internal REST API call
+ * @param {string} name - API endpoint name
+ * @param {string} verb - HTTP method (GET, POST, etc.)
+ * @param {Object|string} params - Request parameters
+ * @param {Object} context - Context object with additional parameters
+ * @returns {Promise} Fetch promise
+ */
+const internalRest = (name, verb, params, context) => {
     verb = verb || "GET";
     params = params || {};
     context = context || {};
 
     if (typeof window !== "undefined") {
-        context['t'] = get_timezone_data();
+        context['t'] = getTimezoneData();
     }
-    var call_url = rest_url(name, true, context);
-
-    var headers = {};
-    if (fwWrapper.getToken() != '') {
-        headers['Authorization'] = 'Session '+fwWrapper.getToken();
+    
+    const callUrl = buildRestUrl(name, true, context);
+    const headers = {};
+    
+    if (fwWrapper.getToken() !== '') {
+        headers['Authorization'] = 'Session ' + fwWrapper.getToken();
     }
 
-    if (verb == "GET") {
+    // Handle GET requests
+    if (verb === "GET") {
         if (params) {
-            // check if params is a json string, or if it needs encoding
+            // Check if params is a JSON string, or if it needs encoding
             if (typeof params === "string") {
-                call_url += "&_=" + encodeURIComponent(params);
+                return fetch(callUrl + "&_=" + encodeURIComponent(params), {
+                    method: verb, 
+                    credentials: 'include', 
+                    headers: headers
+                });
             } else {
-                call_url += "&_=" + encodeURIComponent(JSON.stringify(params));
+                return fetch(callUrl + "&_=" + encodeURIComponent(JSON.stringify(params)), {
+                    method: verb, 
+                    credentials: 'include', 
+                    headers: headers
+                });
             }
         }
-
-        return fetch(call_url, {method: verb, credentials: 'include', headers: headers});
+        
+        return fetch(callUrl, {
+            method: verb, 
+            credentials: 'include', 
+            headers: headers
+        });
     }
 
-    if ((FormData != undefined) && (params instanceof FormData)) {
-        return fetch(call_url, {
+    // Handle FormData
+    if (typeof FormData !== "undefined" && (params instanceof FormData)) {
+        return fetch(callUrl, {
             method: verb,
             credentials: 'include',
             body: params,
@@ -90,70 +168,76 @@ function internal_rest(name, verb, params, context) {
         });
     }
 
+    // Handle JSON requests
     headers['Content-Type'] = 'application/json; charset=utf-8';
-
-    return fetch(call_url, {
+    
+    return fetch(callUrl, {
         method: verb,
         credentials: 'include',
         body: JSON.stringify(params),
         headers: headers
     });
-}
-
-function checkSupport() {
-    var ok = true;
-    if (!fetch) {
-        console.error("Fetch unsupported");
-        ok = false;
-    }
-
-    if (!fwWrapper.supported()) {
-        console.error("FW not found");
-        ok = false;
+};
+
+/**
+ * Parses API response and resolves/rejects accordingly
+ * @param {Response} response - Fetch Response object
+ * @param {Function} resolve - Promise resolve function
+ * @param {Function} reject - Promise reject function
+ */
+const responseParse = (response, resolve, reject) => {
+    // Check if response is ok (status 200-299)
+    if (!response.ok) {
+        reject({
+            message: `HTTP Error: ${response.status} ${response.statusText}`,
+            status: response.status, 
+            headers: response.headers
+        });
+        return;
     }
-
-    return ok;
-}
-
-function responseParse(response, resolve, reject) {
-    var contentType = response.headers.get("content-type");
-    if (!contentType || contentType.indexOf("application/json") == -1) {
-        response.text().then(
-            function (text) {
-                reject({message: "Not JSON", body: text, headers: response.headers});
-            },
-            reject
-        ).catch(reject);
-
+    
+    const contentType = response.headers.get("content-type");
+    if (!contentType || contentType.indexOf("application/json") === -1) {
+        response.text()
+            .then(text => {
+                reject({
+                    message: "Not JSON", 
+                    body: text, 
+                    headers: response.headers
+                });
+            })
+            .catch(error => reject(error));
         return;
     }
 
-    response.json().then(
-        function (json) {
-            // check for gtag
-            if ((json.gtag) && (typeof window !== "undefined") && (window.gtag)) {
-                json.gtag.map(function (item) { window.gtag.apply(null, item); });
+    response.json()
+        .then(json => {
+            // Check for gtag
+            if (json.gtag && typeof window !== "undefined" && window.gtag) {
+                json.gtag.map(item => window.gtag.apply(null, item));
             }
-            // check for result
-            if (json.result != "success" && json.result != "redirect") {
+            
+            // Check for result
+            if (json.result !== "success" && json.result !== "redirect") {
                 json.headers = response.headers;
                 reject(json);
             } else {
                 resolve(json);
             }
-        },
-        reject
-    ).catch(reject)
-}
-
-module.exports.get_tz_pad = get_tz_pad;
-
-module.exports.get_timezone_data = get_timezone_data;
-
-module.exports.rest_url = rest_url;
-
-module.exports.internal_rest = internal_rest;
-
+        })
+        .catch(error => reject(error));
+};
+
+// Backward compatibility aliases
+module.exports.get_tz_pad = padNumber;
+module.exports.get_timezone_data = getTimezoneData;
+module.exports.rest_url = buildRestUrl;
+module.exports.internal_rest = internalRest;
 module.exports.checkSupport = checkSupport;
-
 module.exports.responseParse = responseParse;
+
+// New exports with camelCase naming
+module.exports.padNumber = padNumber;
+module.exports.getTimezoneData = getTimezoneData;
+module.exports.buildRestUrl = buildRestUrl;
+module.exports.internalRest = internalRest;

package/package.json

@@ -1,10 +1,20 @@
 {
   "name": "@karpeleslab/klbfw",
-  "version": "0.1.13",
+  "version": "0.2.1",
   "description": "Frontend Framework",
   "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "*.js",
+    "*.d.ts",
+    "LICENSE",
+    "README.md"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:integration": "RUN_INTEGRATION_TESTS=true jest test/integration.test.js --env=node",
+    "test:coverage": "jest --coverage"
   },
   "repository": {
     "type": "git",
@@ -17,6 +27,21 @@
   },
   "homepage": "https://github.com/KarpelesLab/klbfw#readme",
   "dependencies": {
-    "js-sha256": "^0.9.0"
+    "js-sha256": "^0.11.0"
+  },
+  "optionalDependencies": {
+    "node-fetch": "^2.7.0",
+    "xmldom": "^0.6.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "node-fetch": "^2.7.0",
+    "xmldom": "^0.6.0"
+  },
+  "jest": {
+    "testEnvironment": "jsdom",
+    "collectCoverage": true,
+    "coverageDirectory": "coverage"
   }
 }

package/rest.js

@@ -1,113 +1,161 @@
-'use strict'
-// vim: et:ts=4:sw=4
+'use strict';
+/**
+ * @fileoverview REST API client for KLB Frontend Framework
+ * 
+ * This module provides functions for making REST API calls to KLB backend services.
+ */
 
 const internal = require('./internal');
 const fwWrapper = require('./fw-wrapper');
 
-module.exports.rest = (name, verb, params, context) => {
+/**
+ * Handles platform-specific API calls
+ * @param {string} name - API endpoint name
+ * @param {string} verb - HTTP method (GET, POST, etc.)
+ * @param {Object} params - Request parameters
+ * @param {Object} context - Context object with additional parameters
+ * @returns {Promise} API response promise
+ */
+const handlePlatformCall = (name, verb, params, context) => {
+    // For platform-specific REST implementations
     if (typeof __platformAsyncRest !== "undefined") {
         context = context || {};
-        var ctx_final = fwWrapper.getContext();
-        for (var i in context) ctx_final[i] = context[i];
-        var p1 = new Promise(function(resolve, reject) {
-            __platformAsyncRest(name, verb, params, ctx_final).then(function(result) {
-                if (result.result != "success") {
-                    reject(result);
-                } else {
-                    resolve(result);
-                }
-            }, reject);
+        const ctxFinal = fwWrapper.getContext();
+        
+        // Merge context
+        for (const key in context) {
+            ctxFinal[key] = context[key];
+        }
+        
+        return new Promise((resolve, reject) => {
+            __platformAsyncRest(name, verb, params, ctxFinal)
+                .then(result => {
+                    if (result.result !== "success" && result.result !== "redirect") {
+                        reject(result);
+                    } else {
+                        resolve(result);
+                    }
+                })
+                .catch(error => {
+                    reject(error || new Error('Unknown platform async error'));
+                });
         });
-        return p1;
     }
+    
+    // For legacy platform REST implementation
     if (typeof __platformRest !== "undefined") {
-      // direct SSR-mode call to rest api
-      return new Promise(function(resolve, reject) {
-        __platformRest(name, verb, params, function(res, err) {
-            if (err) {
-                reject(err);
-            } else if (res.result != "success") {
-                reject(res);
-            } else {
-                resolve(res);
-            }
+        return new Promise((resolve, reject) => {
+            __platformRest(name, verb, params, (res, err) => {
+                if (err) {
+                    reject(err);
+                } else if (res.result !== "success") {
+                    reject(res);
+                } else {
+                    resolve(res);
+                }
+            });
         });
-      });
     }
+    
+    return null;
+};
 
-    if(!internal.checkSupport()) return;
+/**
+ * Makes a REST API call
+ * @param {string} name - API endpoint name
+ * @param {string} verb - HTTP method (GET, POST, etc.)
+ * @param {Object} params - Request parameters
+ * @param {Object} context - Context object with additional parameters
+ * @returns {Promise} API response promise
+ */
+const rest = (name, verb, params, context) => {
+    // Try platform-specific REST implementations first
+    const platformResult = handlePlatformCall(name, verb, params, context);
+    if (platformResult) {
+        return platformResult;
+    }
 
-    return new Promise(function(resolve, reject) {
-        var restResolved = function(data) {
-            internal.responseParse(data, resolve, reject);
-        }
+    // Fall back to standard fetch implementation
+    if (!internal.checkSupport()) {
+        return Promise.reject(new Error('Environment not supported'));
+    }
 
-        var restRejected = function(data) {
+    return new Promise((resolve, reject) => {
+        const handleSuccess = data => {
+            internal.responseParse(data, resolve, reject);
+        };
+        
+        const handleError = data => {
             reject(data);
-        }
-
-        var restCatch = function(data) {
-            console.error(data);
-            // TODO log errors
-        }
-
-
-        internal.internal_rest(name, verb, params, context)
-            .then(restResolved, restRejected)
-            .catch(restCatch)
+        };
+        
+        const handleException = error => {
+            console.error(error);
+            // TODO: Add proper error logging
+        };
+
+        internal.internalRest(name, verb, params, context)
+            .then(handleSuccess, handleError)
+            .catch(handleException);
     });
 };
 
-module.exports.rest_get = (name, params) => {
-    if (typeof __platformAsyncRest !== "undefined") {
-        return __platformAsyncRest(name, "GET", params);
-    }
-    if (typeof __platformRest !== "undefined") {
-      // direct SSR-mode call to rest api
-      return new Promise(function(resolve, reject) {
-        __platformRest(name, "GET", params, function(res, err) {
-            if (err) {
-                reject(err);
-            } else if (res.result != "success") {
-                reject(res);
-            } else {
-                resolve(res);
-            }
-        });
-      });
+/**
+ * Makes a GET request to the REST API
+ * @param {string} name - API endpoint name
+ * @param {Object} params - Request parameters
+ * @returns {Promise} API response promise
+ */
+const restGet = (name, params) => {
+    // Try platform-specific REST implementations first
+    const platformResult = handlePlatformCall(name, "GET", params);
+    if (platformResult) {
+        return platformResult;
     }
 
-    if(!internal.checkSupport()) return;
+    // Fall back to standard fetch implementation
+    if (!internal.checkSupport()) {
+        return Promise.reject(new Error('Environment not supported'));
+    }
 
     params = params || {};
-    var call_url = internal.rest_url(name, false);
+    let callUrl = internal.buildRestUrl(name, false);
 
     if (params) {
-        // check if params is a json string, or if it needs encoding
+        // Check if params is a JSON string, or if it needs encoding
         if (typeof params === "string") {
-            call_url += "?_=" + encodeURIComponent(params);
+            callUrl += "?_=" + encodeURIComponent(params);
         } else {
-            call_url += "?_=" + encodeURIComponent(JSON.stringify(params));
+            callUrl += "?_=" + encodeURIComponent(JSON.stringify(params));
         }
     }
 
-    var restResolved = function(data) {
-        internal.responseParse(data, resolve, reject);
-    }
-
-    var restRejected = function(data) {
-        reject(data);
-    }
-
-    var restCatch = function(data) {
-        console.error(data);
-        // TODO log errors
-    }
-
-    return new Promise(function(resolve, reject) {
-        fetch(call_url, {
+    return new Promise((resolve, reject) => {
+        const handleSuccess = data => {
+            internal.responseParse(data, resolve, reject);
+        };
+        
+        const handleError = data => {
+            reject(data);
+        };
+        
+        const handleException = error => {
+            console.error(error);
+            // TODO: Add proper error logging
+        };
+
+        fetch(callUrl, {
             method: 'GET',
             credentials: 'include'
-        }).then(restResolved, restRejected).catch(restCatch);
+        })
+        .then(handleSuccess, handleError)
+        .catch(handleException);
     });
-}
+};
+
+// Export new camelCase API
+module.exports.rest = rest;
+module.exports.restGet = restGet;
+
+// Backward compatibility
+module.exports.rest_get = restGet;