@qikdev/sdk 0.2.3 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qikdev/sdk",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "type": "module",
   "description": "Promise based Javascript SDK",
   "main": "./dist/main.js",

package/src/api/qik.access.js

@@ -492,8 +492,28 @@ var QikAccess = function (QikCore) {
 
     //////////////////////////////////
 
+    //The user should be able to list any scopes that they have
+    //permission to do things in.
+    if (ANY_ACTION == "listany" || OWN_ACTION == "listown") {
+      if (type === "scope") {
+        var itemID = QikCore.utils.id(item);
+        return !!user.permissions[itemID];
+      }
+    }
+
+    //////////////////////////////////
+
     var itemScopes = QikCore.utils.ids(item.meta.scopes || []);
 
+    //Scopes don't have meta.scopes, instead use the scope's
+    //path (ancestors) plus the scope's own ID
+    if (type === "scope") {
+      itemScopes = [
+        ...QikCore.utils.ids(item.path || []),
+        QikCore.utils.id(item),
+      ];
+    }
+
     //////////////////////////////////
 
     var actionAnyScopesHash;

package/src/api/qik.api.js

@@ -2,22 +2,7 @@ import axios from "axios";
 import qs from "qs";
 import { version } from "../version.js";
 
-import {
-  cacheAdapterEnhancer,
-  throttleAdapterEnhancer,
-  Cache,
-} from "axios-extensions";
-
-function isString(value) {
-  const type = typeof value;
-  return (
-    type === "string" ||
-    (type === "object" &&
-      value != null &&
-      !Array.isArray(value) &&
-      getTag(value) == "[object String]")
-  );
-}
+
 
 /**
  * Creates a new instance of Axios, with automatic authentication and token refreshing functionality.
@@ -192,71 +177,6 @@ var QikAPI = function (qik) {
 
   //////////////////////////////////////////////////////////////////////////////
 
-  /**
-   *
-   * Make a GET request to the API
-   * @alias api.get
-   * @param  {Object} endpoint The endpoint to request
-   * @param  {Object} options The options to pass to axios for making the request
-   * @example
-   *
-   * const result = await sdk.api.get('/user');
-   */
-  var f = function () {};
-
-  /**
-   *
-   *
-   * @alias api.post
-   * @description Make a POST request to the API
-   * @param  {Object} endpoint The endpoint to request
-   * @param  {Object} body The post body to send with the request
-   * @param  {Object} options The options to pass to axios for making the request
-   * @example
-   *
-   * const result = await sdk.api.post('/login', {username:'', password:''});
-   */
-  var f = function () {};
-
-  /**
-   *
-   * Make a PUT request to the API
-   * @alias api.put
-   * @param  {Object} endpoint The endpoint to request
-   * @param  {Object} body The post body to send with the request
-   * @param  {Object} options The options to pass to axios for making the request
-   * @example
-   *
-   * const result = await sdk.api.put('/content/61eca4746971e75c1fc670cf', {title:'A new title'});
-   */
-  var f = function () {};
-
-  /**
-   *
-   * Make a PATCH request to the API
-   * @alias api.patch
-   * @param  {Object} endpoint The endpoint to request
-   * @param  {Object} body The post body to send with the request
-   * @param  {Object} options The options to pass to axios for making the request
-   * @example
-   *
-   * const result = await sdk.api.patch('/content/61eca4746971e75c1fc670cf', {title:'A new title'});
-   */
-  var f = function () {};
-
-  /**
-   *
-   * Make a DELETE request to the API
-   * @alias api.delete
-   * @param  {Object} endpoint The endpoint to request
-   * @param  {Object} body The post body to send with the request
-   * @param  {Object} options The options to pass to axios for making the request
-   * @example
-   *
-   * const result = await sdk.api.delete('/content/61eca4746971e75c1fc670cf');
-   */
-  var f = function () {};
-
   function createNewAxios(adapter) {
     var instance = axios.create({
       paramsSerializer: (params) =>
@@ -370,8 +290,6 @@ var QikAPI = function (qik) {
             //Not found
             break;
           default:
-            //Some other error, likely a problem connecting to the server
-            // console.log('qik.api > connection error', status, err);
             break;
         }
 
@@ -387,20 +305,9 @@ var QikAPI = function (qik) {
   /////////////////////////////////////////////////////
 
   function retrieveIDs(data) {
-    var dataString;
-
-    if (_isString(data)) {
-      dataString = data;
-    } else {
-      dataString = JSON.stringify(data);
-    }
-
-    //Find all mongo ids included in the object
-    var myregexp = /[0-9a-fA-F]{24}/g;
-    var matches = dataString.match(myregexp);
-
-    //Make sure the matches are unique
-    return [...new Set(matches)];
+    const text = typeof data === "string" ? data : JSON.stringify(data);
+    const matches = text.match(/\b[0-9a-f]{24}\b/gi);
+    return matches ? [...new Set(matches)] : [];
   }
 
   ///////////////////////////////////////

package/src/api/qik.auth.js

@@ -276,19 +276,19 @@ var QikAuth = function(qik) {
 
             if (!credentials) {
                 return reject({
-                    message: 'Missing credentials!',
+                    message: 'Login requires an email and password',
                 })
             }
 
             if (!credentials.email || !credentials.email.length) {
                 return reject({
-                    message: 'Username was not provided',
+                    message: 'An email address is required to log in',
                 })
             }
 
             if (!credentials.password || !credentials.password.length) {
                 return reject({
-                    message: 'Password was not provided',
+                    message: 'A password is required to log in',
                 })
             }
 
@@ -362,44 +362,44 @@ var QikAuth = function(qik) {
 
             if (!credentials) {
                 return reject({
-                    message: 'No details provided',
+                    message: 'Signup details are required',
                 })
             }
 
             if (!credentials.firstName || !credentials.firstName.length) {
                 return reject({
-                    message: 'First Name was not provided',
+                    message: 'Please provide a first name',
                 })
             }
 
             if (!credentials.lastName || !credentials.lastName.length) {
                 return reject({
-                    message: 'Last Name was not provided',
+                    message: 'Please provide a last name',
                 })
             }
 
             if (!credentials.email || !credentials.email.length) {
                 return reject({
-                    message: 'Email/Username was not provided',
+                    message: 'An email address is required to sign up',
                 })
             }
 
 
             if (!credentials.password || !credentials.password.length) {
                 return reject({
-                    message: 'Password was not provided',
+                    message: 'A password is required to sign up',
                 })
             }
 
             if (!credentials.confirmPassword || !credentials.confirmPassword.length) {
                 return reject({
-                    message: 'Confirm Password was not provided',
+                    message: 'Please confirm your password',
                 })
             }
 
             if (credentials.confirmPassword != credentials.password) {
                 return reject({
-                    message: 'Your passwords do not match',
+                    message: 'Password and confirmation do not match',
                 })
             }
 
@@ -568,13 +568,13 @@ var QikAuth = function(qik) {
 
         if (!details) {
             return Promise.reject({
-                message: 'No details were provided for password reset request',
+                message: 'Please provide your account details to reset your password',
             })
         }
 
         if (!details.email || !details.email.length) {
             return Promise.reject({
-                message: 'Email is required but was not provided',
+                message: 'An email address is required for password reset',
             })
         }
 
@@ -738,8 +738,6 @@ var QikAuth = function(qik) {
 
     ///////////////////////////////////////////////////
 
-    var retryCount = 0;
-
     /**
      * @alias auth.sync
      * @description A useful function to sync the current user session with the server.
@@ -756,7 +754,6 @@ var QikAuth = function(qik) {
                 if (res.data) {
                     const currentUser = storageAdapter.getUser();
                     if (currentUser) {
-                        // Update the session data within the current user object
                         const updatedUser = { ...currentUser };
                         if (updatedUser.session) {
                             Object.assign(updatedUser.session, res.data);
@@ -765,28 +762,17 @@ var QikAuth = function(qik) {
                         }
                         service.set(updatedUser);
                     } else {
-                        // No current user, set the response data as new user
                         service.set(res.data);
                     }
                 } else {
                     service.set(null);
                 }
 
-                retryCount = 0;
                 dispatch();
             })
             .catch(function(err) {
-
-                // if (retryCount > 2) {
                 service.set(null);
-                retryCount = 0;
                 dispatch();
-                // } else {
-
-                // retryCount++;
-                // service.sync();
-                // }
-
             });
     }
 

package/src/api/qik.cache.js

@@ -23,13 +23,11 @@ var QikCache = {
      */
     reset() {
         Object.entries(caches).forEach(([key, cache]) => {
-            // console.log(`Reset ${key} cache`, cache);
             if(cache.clear) {
                 cache.clear()
             } else if(cache.reset) {
                 cache.reset()
             }
-
         })
     },
 
@@ -48,10 +46,7 @@ var QikCache = {
             return caches[key];
         }
         caches[key] = new Cache(options)
-
-        // console.log('Created new cache', key);
         return caches[key];
-
     }
 }
 

package/src/api/qik.core.js

@@ -1,5 +1,3 @@
-// if (process.browser) {
-
 import QikAPI from './qik.api.js';
 import QikAuth from './qik.auth.js';
 import QikUtils from './qik.utils.js';
@@ -87,8 +85,6 @@ export default function(options) {
     ///////////////////////////////////////
 
     const core = Object.assign(options, {
-        //Other options
-        // domain:'',
         version,
         global:{},
     })

package/src/api/qik.utils.js

@@ -1012,79 +1012,37 @@ service.getTypeFromID = function (id) {
  * sdk.utils.currencySymbol('usd');
  *
  */
-service.currencySymbol = function (currency) {
-  //Ensure lowercase currency
-  currency = String(currency).toLowerCase();
+const CURRENCY_SYMBOLS = { gbp: "\u00A3", eur: "\u20AC" };
 
-  switch (String(currency).toLowerCase()) {
-    case "gbp":
-      return "£";
-      break;
-    case "eur":
-      return "€";
-      break;
-    default:
-      return "$";
-      break;
-  }
+service.currencySymbol = function (currency) {
+  return CURRENCY_SYMBOLS[String(currency).toLowerCase()] || "$";
 };
 
-service.getAvailableCurrencies = function (DefaultCountryID) {
-  var array = [];
-
-  array.push({
-    name: `USD (${service.currencySymbol("usd")})`,
-    value: "usd",
-    countryCode: { US: true },
-  });
-
-  array.push({
-    name: `GBP (${service.currencySymbol("gbp")})`,
-    value: "gbp",
-    countryCode: { GB: true, UK: true },
-  });
-
-  array.push({
-    name: `CAD (${service.currencySymbol("cad")})`,
-    value: "cad",
-    countryCode: { CA: true },
-  });
-
-  array.push({
-    name: `AUD (${service.currencySymbol("aud")})`,
-    value: "aud",
-    countryCode: { AU: true },
-  });
-
-  array.push({
-    name: `NZD (${service.currencySymbol("nzd")})`,
-    value: "nzd",
-    countryCode: { NZ: true },
-  });
-
-  array.push({
-    name: `SGD (${service.currencySymbol("sgd")})`,
-    value: "sgd",
-    countryCode: { SG: true },
-  });
-
-  if (DefaultCountryID) {
-    var findMatch = array.findIndex(function (currency) {
-      return currency.countryCode[DefaultCountryID];
-    });
-
-    const moveArrayItem = (array, fromIndex, toIndex) => {
-      const arr = [...array];
-      arr.splice(toIndex, 0, ...arr.splice(fromIndex, 1));
-      return arr;
-    };
-
-    if (findMatch != -1) {
-      array = moveArrayItem(array, findMatch, 0);
+const SUPPORTED_CURRENCIES = [
+  { code: "usd", countries: ["US"] },
+  { code: "gbp", countries: ["GB", "UK"] },
+  { code: "cad", countries: ["CA"] },
+  { code: "aud", countries: ["AU"] },
+  { code: "nzd", countries: ["NZ"] },
+  { code: "sgd", countries: ["SG"] },
+];
+
+service.getAvailableCurrencies = function (defaultCountryID) {
+  let currencies = SUPPORTED_CURRENCIES.map(({ code, countries }) => ({
+    name: `${code.toUpperCase()} (${service.currencySymbol(code)})`,
+    value: code,
+    countryCode: Object.fromEntries(countries.map((c) => [c, true])),
+  }));
+
+  if (defaultCountryID) {
+    const idx = currencies.findIndex((c) => c.countryCode[defaultCountryID]);
+    if (idx > 0) {
+      const [match] = currencies.splice(idx, 1);
+      currencies.unshift(match);
     }
   }
 
-  return array;
+  return currencies;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1392,34 +1350,18 @@ service.errorMessage = function (err) {
     err = err[0];
   }
 
-  ////////////////////////////////////
-
-  var candidates = ["response.data.message", "response.data", "message"];
-
-  var message;
-
-  candidates.forEach(function (path) {
-    if (message) {
-      return;
-    }
-
-    var m = _get(err, path);
-    if (m) {
-      message = m;
-    }
-  });
+  // Walk through the error object to find the most useful message
+  let message =
+    err?.response?.data?.message ||
+    (typeof err?.response?.data === "string" ? err.response.data : null) ||
+    err?.message ||
+    null;
 
   if (Array.isArray(message)) {
     message = message[0];
   }
 
-  ////////////////////////////////////
-
-  message = message || JSON.stringify(err);
-
-  ////////////////////////////////////
-
-  return message;
+  return message || JSON.stringify(err);
 };
 
 ////////////////////////////////////
@@ -1433,19 +1375,14 @@ service.errorMessage = function (err) {
  * sdk.utils.guid()
  */
 service.guid = function () {
-  var u =
-    new Date().getTime().toString(16) +
-    Math.random().toString(16).substring(2) +
-    "0".repeat(16);
-  return (
-    u.substr(0, 8) +
-    "-" +
-    u.substr(8, 4) +
-    "-4000-8" +
-    u.substr(12, 3) +
-    "-" +
-    u.substr(15, 12)
-  );
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  // Fallback for environments without crypto.randomUUID
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+    const r = (Math.random() * 16) | 0;
+    return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
+  });
 };
 
 ////////////////////////////////////
@@ -1479,87 +1416,59 @@ export default service;
 
 /////////////////////////////////////////////
 
-//Export the event dispatcher
+/**
+ * A lightweight event emitter that can be attached to any service object
+ * to provide pub/sub event capabilities. Can be called with or without `new`.
+ */
 export function EventDispatcher() {
-  var listeners = {};
-
-  /////////////////////////////////////////////
-
-  var dispatcher = {};
-
-  /////////////////////////////////////////////
-
-  //Remove all listeners
-  dispatcher.removeAllListeners = function () {
-    listeners = {};
-  };
-
-  /////////////////////////////////////////////
-
-  dispatcher.dispatch = function (event, details) {
-    if (listeners[event]) {
-      //For each listener
-      listeners[event].forEach(function (callback) {
-        return callback(details);
-      });
-    }
-  };
-
-  /////////////////////////////////////////////
-
-  dispatcher.addEventListener = function (event, callback) {
-    if (!listeners[event]) {
-      listeners[event] = [];
-    }
-
-    const type = typeof callback;
-    if (type !== "function") {
-      throw new Error(
-        `addEventListener() requires a function but ${type} was added`,
-      );
-    } else {
-      if (listeners[event].indexOf(callback) == -1) {
-        //Add to the listeners
-        listeners[event].push(callback);
-      } else {
-        //A
-        //lready listening
+  const handlers = new Map();
+
+  const emitter = {
+    dispatch(event, details) {
+      const fns = handlers.get(event);
+      if (fns) {
+        for (const fn of fns) {
+          fn(details);
+        }
       }
-    }
-  };
-
-  /////////////////////////////////////////////
-
-  dispatcher.removeEventListener = function (event, callback) {
-    if (!listeners[event]) {
-      listeners[event] = [];
-    }
-
-    //Get the index of the listener
-    var index = listeners[event].indexOf(callback);
+    },
 
-    if (index != -1) {
-      //Remove from the listeners
-      listeners[event].splice(index, 1);
-    }
-  };
+    addEventListener(event, callback) {
+      if (typeof callback !== "function") {
+        throw new TypeError(
+          `Expected a function for addEventListener, received ${typeof callback}`,
+        );
+      }
 
-  /////////////////////////////////////////////
+      if (!handlers.has(event)) {
+        handlers.set(event, new Set());
+      }
 
-  //Wrap the event listener functionality
-  dispatcher.bootstrap = function (service) {
-    if (!service) {
-      // console.log('No service to bootstrap to')
-      return;
-    }
+      handlers.get(event).add(callback);
+    },
 
-    service.dispatch = dispatcher.dispatch;
-    service.addEventListener = dispatcher.addEventListener;
-    service.removeEventListener = dispatcher.removeEventListener;
-    service.removeAllListeners = dispatcher.removeAllListeners;
+    removeEventListener(event, callback) {
+      const fns = handlers.get(event);
+      if (fns) {
+        fns.delete(callback);
+        if (fns.size === 0) {
+          handlers.delete(event);
+        }
+      }
+    },
+
+    removeAllListeners() {
+      handlers.clear();
+    },
+
+    bootstrap(target) {
+      if (!target) return;
+      target.dispatch = emitter.dispatch;
+      target.addEventListener = emitter.addEventListener;
+      target.removeEventListener = emitter.removeEventListener;
+      target.removeAllListeners = emitter.removeAllListeners;
+    },
   };
 
-  /////////////////////////////////////////////
-
-  return dispatcher;
+  return emitter;
 }

package/src/version.js

@@ -1 +1 @@
-export const version = "0.2.3";
+export const version = "0.4.0";