@qikdev/sdk 0.1.170 → 0.1.180

package/src/api/qik.content.js

@@ -1,5 +1,5 @@
-import axios from "axios";
-import _ from "lodash";
+import axios from 'axios';
+import _ from 'lodash';
 
 ///////////////////////////////////////////////////
 
@@ -11,126 +11,137 @@ import _ from "lodash";
  * @hideconstructor
  * @param {QikCore} qik A reference to the parent instance of the QikCore module. This module is usually created by a QikCore instance that passes itself in as the first argument.
  */
-export default function (qik) {
-  if (!qik.api) {
-    throw new Error(`Can't Instantiate QikContent before QikAPI exists`);
-  }
-
-  ///////////////////////////////////////////////////
-
-  var service = {
-    debug: false,
-    loadingGlossary: false,
-  };
-
-  ///////////////////////////////////////////////////////////////////////////////
-
-  const variables = {};
-  let inflightVariablesRequest;
-
-  /**
-   *
-   * Retrieves all global variables for the current user. This is often used when running custom code in an action.
-   * @alias content.variables
-   * @param  {Array} keys Provide specific keys of variables you want to retrieve
-   * @param  {Object} options Additional options when making the request
-   * @param  {Boolean} options.reload Force variables to reload and not be cached. If false will retrieve any variables that are already known from the in memory cache.
-   * @example
-   *
-   * const { OAUTH_CLIENT_ID, OAUTH_KEY } = await sdk.content.variables();
-   */
-
-  service.variables = async function (keys, options) {
-    options = options || {};
-    keys = keys || [];
-
-    var reload = options.refresh || options.reload || !variables.data;
-    if (reload) {
-      if (!inflightVariablesRequest) {
-        inflightVariablesRequest = qik.api.post(`/variables`, { keys });
-        inflightVariablesRequest.then(resolveRequest, resolveRequest);
-        function resolveRequest() {
-          inflightVariablesRequest = null;
-        }
-      }
+export default function(qik) {
 
-      const { data } = await inflightVariablesRequest;
-      variables.data = data;
-      qik.dispatch("variables", data);
+    if (!qik.api) {
+        throw new Error(`Can't Instantiate QikContent before QikAPI exists`);
     }
 
-    return variables.data;
-  };
+    ///////////////////////////////////////////////////
 
-  ///////////////////////////////////////////////////
+    var service = {
+        debug: false,
+        loadingGlossary:false,
+    }
 
-  const glossaryCache = qik.cache.get("user:glossary");
 
-  let inflightGlossaryRequest;
+    ///////////////////////////////////////////////////////////////////////////////
 
-  /**
-     *
-     * Retrieves the glossary of all content types visible to the requesting user.
+    const variables = {}
+    let inflightVariablesRequest;
+
+
+    /**
+     * 
+     * Retrieves all global variables for the current user. This is often used when running custom code in an action.
+     * @alias content.variables
+     * @param  {Array} keys Provide specific keys of variables you want to retrieve
+     * @param  {Object} options Additional options when making the request
+     * @param  {Boolean} options.reload Force variables to reload and not be cached. If false will retrieve any variables that are already known from the in memory cache.
+     * @example
+     * 
+     * const { OAUTH_CLIENT_ID, OAUTH_KEY } = await sdk.content.variables();
+     */
+
+    service.variables = async function(keys, options) {
+        options = options || {};
+        keys = keys || [];
+
+        var reload = options.refresh || options.reload || !variables.data;
+        if (reload) {
+            if(!inflightVariablesRequest) {
+                inflightVariablesRequest = qik.api.post(`/variables`, {keys});
+                inflightVariablesRequest.then(resolveRequest, resolveRequest);
+                function resolveRequest() {
+                    inflightVariablesRequest = null;
+                }
+            }
+            
+            const { data } = await inflightVariablesRequest
+            variables.data = data;
+            qik.dispatch('variables', data)
+        }
+
+        return variables.data;
+    }
+
+    ///////////////////////////////////////////////////
+
+    const glossaryCache = qik.cache.get('user:glossary');
+    
+    let inflightGlossaryRequest;
+
+     /**
+     * 
+     * Retrieves the glossary of all content types visible to the requesting user. 
      By default this will include all fields, validation, expressions and other configuration
      * @alias content.glossary
      * @param  {Object} options Additional options
-     * @param  {Boolean} options.hash Whether to return the data as a keyed object
+     * @param  {Boolean} options.hash Whether to return the data as a keyed object 
      allowing for fast selection of specific content types, by default will return as an array
      * @param  {Boolean} options.reload Force glossary to reload and not be cached.
       If false will retrieve content type data from the in memory cache
      * @example
-     *
+     * 
      * const { article, profile } = await sdk.content.glossary({hash:true});
      */
-  service.glossary = async function (options) {
-    options = options || {};
-
-    // Check if we already have the glossary cached
-    let cached = glossaryCache.get("glossary");
-    var reload = options.refresh || options.reload || !cached;
-
-    // If we are forcing a reload
-    if (reload) {
-      if (!inflightGlossaryRequest) {
-        service.loadingGlossary = true;
-
-        inflightGlossaryRequest = qik.api.get(`/glossary`, { cache: false });
-        inflightGlossaryRequest.then(resolveRequest, resolveRequest);
-        function resolveRequest() {
-          inflightGlossaryRequest = null;
-          service.loadingGlossary = false;
+    service.glossary = async function(options) {
+        options = options || {};
+
+        
+        // Check if we already have the glossary cached
+        let cached = glossaryCache.get('glossary');
+        var reload = options.refresh || options.reload || !cached;
+
+        // If we are forcing a reload
+        if (reload) {
+            if(!inflightGlossaryRequest) {
+
+                service.loadingGlossary = true;
+
+                inflightGlossaryRequest = qik.api.get(`/glossary`, {cache:false});
+                inflightGlossaryRequest.then(resolveRequest, resolveRequest);
+                function resolveRequest() {
+                    inflightGlossaryRequest = null;
+                    service.loadingGlossary = false;
+                }
+            }
+            
+            // Now we have the glossary
+            const { data } = await inflightGlossaryRequest
+            
+            // Cache it for later
+            glossaryCache.set('glossary', data);
+            cached = data;
+            qik.dispatch('glossary', data)
         }
-      }
 
-      // Now we have the glossary
-      const { data } = await inflightGlossaryRequest;
 
-      // Cache it for later
-      glossaryCache.set("glossary", data);
-      cached = data;
-      qik.dispatch("glossary", data);
-    }
+        if (options.hash) {
+            var result = qik.utils.hash(cached, 'key');
+            return result;
+        }
 
-    if (options.hash) {
-      var result = qik.utils.hash(cached, "key");
-      return result;
-    }
+        if (options.hex) {
+            var result = qik.utils.hash(cached, 'hex');
+            return result;
+        }
 
-    if (options.hex) {
-      var result = qik.utils.hash(cached, "hex");
-      return result;
+        return cached;
     }
 
-    return cached;
-  };
 
-  ///////////////////////////////////////////////////
 
-  const scopeGlossaryCache = qik.cache.get("user:scope:glossary");
-  let inflightScopeGlossaryRequest;
+    ///////////////////////////////////////////////////
 
-  /**
-     *
+    
+
+    const scopeGlossary = {}
+
+    let inflightScopeGlossaryRequest;
+
+     /**
+     * 
      * Retrieves the scope glossary of all scopes the user can know about. This helps to convert a scope id into a human readable title.
      * @alias content.scopeGlossary
      * @param  {Object} options Additional options
@@ -139,701 +150,709 @@ export default function (qik) {
      * @param  {Boolean} options.reload Force the glossary to reload and not be cached.
       If false will retrieve content type data from the in memory cache
      * @example
-     *
+     * 
      * const scopes = await sdk.content.scopeGlossary();
      */
 
-  service.scopeGlossary = async function (options) {
-    options = options || {};
-
-    // Check if we already have the scope glossary cached
-    let cached = scopeGlossaryCache.get("scopes");
-    var reload = options.refresh || options.reload || !cached;
-
-    if (reload) {
-      if (!inflightScopeGlossaryRequest) {
-        inflightScopeGlossaryRequest = qik.api.get(`/scope/glossary`, {
-          cache: false,
-        });
-        inflightScopeGlossaryRequest.then(resolveRequest, resolveRequest);
-        function resolveRequest() {
-          inflightScopeGlossaryRequest = null;
+    service.scopeGlossary = async function(options) {
+        options = options || {};
+
+        var reload = options.refresh || options.reload || !scopeGlossary.data;
+
+
+        if (reload) {
+
+            if(!inflightScopeGlossaryRequest) {
+                inflightScopeGlossaryRequest = qik.api.get(`/scope/glossary`, {cache:false});
+                inflightScopeGlossaryRequest.then(resolveRequest, resolveRequest);
+                function resolveRequest() {
+                    inflightScopeGlossaryRequest = null;
+                }
+            }
+            
+            const { data } = await inflightScopeGlossaryRequest
+            scopeGlossary.data = data;
         }
-      }
 
-      const { data } = await inflightScopeGlossaryRequest;
+        if (options.hash) {
+            var result = qik.utils.hash(scopeGlossary.data, '_id');
+            return result;
+        }
 
-      // Cache it for later
-      scopeGlossaryCache.set("scopes", data);
-      cached = data;
-      qik.dispatch("glossary:scope", data);
+        return scopeGlossary.data;
     }
 
-    if (options.hash) {
-      var result = qik.utils.hash(cached, "_id");
-      return result;
-    }
 
-    return cached;
-  };
 
-  ///////////////////////////////////////////////////
 
-  /**
-   *
-   * Retrieves all available filter comparators for each data type
-   * @alias content.comparators
-   * @param  {Object} options Additional options
-   * @param  {Boolean} options.reload Ignore any locally cached data
-   * @example
-   * const {hash, available, types} = await sdk.content.comparators();
-   * console.log(available) // {boolean:[{title:'Is equal to', operator:'equal'...}]}
-   * console.log(hash) // {equal:[{title:'Is equal to', operator:'equal'...}]}
-   */
+    ///////////////////////////////////////////////////
 
-  const comparators = {};
+    /**
+     * 
+     * Retrieves all available filter comparators for each data type
+     * @alias content.comparators
+     * @param  {Object} options Additional options
+     * @param  {Boolean} options.reload Ignore any locally cached data
+     * @example
+     * const {hash, available, types} = await sdk.content.comparators();
+     * console.log(available) // {boolean:[{title:'Is equal to', operator:'equal'...}]}
+     * console.log(hash) // {equal:[{title:'Is equal to', operator:'equal'...}]}
+     */
 
-  service.comparators = async function (options) {
-    options = options || {};
 
-    var reload = options.reload || options.refresh || !comparators.data;
+    const comparators = {}
 
-    if (reload) {
-      const { data } = await qik.api.get(`/system/comparators`);
+    service.comparators = async function(options) {
+        options = options || {};
 
-      /////////////////////////////
+        var reload = options.reload || options.refresh || !comparators.data;
 
-      data.available = {};
+        if (reload) {
+            const { data } = await qik.api.get(`/system/comparators`);
 
-      Object.entries(data.types).forEach(([key, value]) => {
-        data.available[key] = value.map(function (comparatorKey) {
-          return data.hash[comparatorKey];
-        });
-      });
 
-      /////////////////////////////
+            /////////////////////////////
 
-      comparators.data = data;
-    }
+            data.available = {};
 
-    // if (options.hash) {
-    //     var result = qik.utils.hash(comparators.data, 'key');
-    //     return result;
-    // }
+            Object.entries(data.types).forEach(([key, value]) => {
+                data.available[key] = value.map(function(comparatorKey) {
+                    return data.hash[comparatorKey];
+                })
+            });
 
-    return comparators.data;
-  };
 
-  ///////////////////////////////////////////////////
+            /////////////////////////////
 
-  function getLimits(fieldDefinition) {
-    var { minimum, maximum } = fieldDefinition;
-    minimum = qik.utils.parseInt(minimum);
-    minimum = Math.max(minimum, 0);
+            comparators.data = data;
+        }
 
-    maximum = qik.utils.parseInt(maximum);
-    maximum = Math.max(maximum, 0); // cant be less than 0
-    if (maximum == 0) {
-      //Unlimited maximum
-    } else {
-      maximum = Math.max(maximum, minimum); // cant be less than the minimum
-    }
-    return { minimum, maximum };
-  }
-
-  service.meetsValidationRequirements = function (
-    input,
-    fieldType,
-    validationCriteria,
-  ) {
-    if (validationCriteria.minLength) {
-      var stringLength = String(input).length;
-      if (stringLength < validationCriteria.minLength) {
-        return `Must be at least ${validationCriteria.minLength} characters`;
-      }
-    }
 
-    if (validationCriteria.maxLength) {
-      var stringLength = String(input).length;
-      if (stringLength > validationCriteria.maxLength) {
-        return `Can be no more than ${validationCriteria.maxLength} characters`;
-      }
+
+        // if (options.hash) {
+        //     var result = qik.utils.hash(comparators.data, 'key');
+        //     return result;
+        // }
+
+        return comparators.data;
     }
 
-    if (validationCriteria.minValue) {
-      if (input !== undefined) {
-        var number = Number(input);
-        if (number < validationCriteria.minValue) {
-          return `Must be at least ${validationCriteria.minValue}`;
+    ///////////////////////////////////////////////////
+
+
+    function getLimits(fieldDefinition) {
+
+        var { minimum, maximum } = fieldDefinition;
+        minimum = qik.utils.parseInt(minimum);
+        minimum = Math.max(minimum, 0);
+
+        maximum = qik.utils.parseInt(maximum);
+        maximum = Math.max(maximum, 0); // cant be less than 0
+        if (maximum == 0) {
+            //Unlimited maximum
+        } else {
+            maximum = Math.max(maximum, minimum); // cant be less than the minimum
         }
-      }
+        return { minimum, maximum };
     }
 
-    if (validationCriteria.maxValue) {
-      if (input !== undefined) {
-        var number = Number(input);
-        if (number > validationCriteria.maxValue) {
-          return `Can be no greater than ${validationCriteria.maxValue}`;
+
+    
+
+    service.meetsValidationRequirements = function(input, fieldType, validationCriteria) {
+
+        if (validationCriteria.minLength) {
+            var stringLength = String(input).length;
+            if (stringLength < validationCriteria.minLength) {
+                return `Must be at least ${validationCriteria.minLength} characters`;
+
+            }
         }
-      }
-    }
-  };
-
-  /**
-   * Checks if a certain input validates against a field definition
-   * @alias content.validateField
-   * @param  {Any} input The input to validate
-   * @param  {Object} fieldDefinition The field to validate against
-   * @param  {Object} options Additional options when calling the function
-   * @example
-   * const validationResult = await sdk.content.validateField('Johnny Bobbins', {title:'Name', key:'firstName', type:'string', minimum:1, maximum:1, ...});
-   * console.log(validationResult)
-   * // Results in { valid:true }
-   *
-   * const validationResult = await sdk.content.validateField('Johnny Bobbins', {title:'Number', key:'number', type:'integer', minimum:1, maximum:1, ...});
-   * console.log(validationResult)
-   * // Results in { valid:false, status:400, message:'Invalid number input for field' }
-   */
-
-  service.validateField = function (input, fieldDefinition, options) {
-    options = options || {};
-
-    var fieldType = fieldDefinition.type || "string";
-    var { minimum, maximum } = getLimits(fieldDefinition);
-
-    var isObject = fieldDefinition.type == "group" && fieldDefinition.asObject;
-    var singleValue = isObject
-      ? minimum === maximum && maximum === 1
-      : maximum === 1;
-    var multiValue = !singleValue;
-
-    //////////////////
-
-    var isNumeric;
-    switch (fieldType) {
-      case "integer":
-      case "decimal":
-      case "number":
-      case "float":
-        isNumeric = true;
-        break;
-    }
 
-    //////////////////
+        if (validationCriteria.maxLength) {
+            var stringLength = String(input).length;
+            if (stringLength > validationCriteria.maxLength) {
+                return `Can be no more than ${validationCriteria.maxLength} characters`;
 
-    var inputWasProvided = qik.utils.exists(input);
+            }
+        }
 
-    //If an answer is required
-    if (minimum) {
-      //but none was provided
-      if (!inputWasProvided) {
-        //Throw an error
-        return {
-          valid: false,
-          message: `${fieldDefinition.title} is a required field`,
-          status: 400,
-        };
-      }
-    } else {
-      //No answer is needed and none was provided
-      if (!inputWasProvided) {
-        return {
-          valid: true,
-        };
-      }
+        if (validationCriteria.minValue) {
+            if(input !== undefined) {
+
+            
+                var number = Number(input);
+                if (number < validationCriteria.minValue) {
+                    return `Must be at least ${validationCriteria.minValue}`;
+
+                }
+            }
+        }
+
+        if (validationCriteria.maxValue) {
+            if(input !== undefined) {
+
+                
+                var number = Number(input);
+                if (number > validationCriteria.maxValue) {
+                    return `Can be no greater than ${validationCriteria.maxValue}`;
+
+                }
+            }
+        }
     }
 
-    //////////////////
+    /**
+     * Checks if a certain input validates against a field definition
+     * @alias content.validateField
+     * @param  {Any} input The input to validate
+     * @param  {Object} fieldDefinition The field to validate against
+     * @param  {Object} options Additional options when calling the function
+     * @example
+     * const validationResult = await sdk.content.validateField('Johnny Bobbins', {title:'Name', key:'firstName', type:'string', minimum:1, maximum:1, ...});
+     * console.log(validationResult) 
+     * // Results in { valid:true }
+     *
+     * const validationResult = await sdk.content.validateField('Johnny Bobbins', {title:'Number', key:'number', type:'integer', minimum:1, maximum:1, ...});
+     * console.log(validationResult) 
+     * // Results in { valid:false, status:400, message:'Invalid number input for field' }
+     */
+
+    service.validateField = function(input, fieldDefinition, options) {
+        options = options || {}
+
+        var fieldType = fieldDefinition.type || 'string';
+        var { minimum, maximum } = getLimits(fieldDefinition);
+
+        var isObject = (fieldDefinition.type == 'group' && fieldDefinition.asObject);
+        var singleValue = isObject ? minimum === maximum && maximum === 1 : maximum === 1;
+        var multiValue = !singleValue;
+
+        //////////////////
+
+        var isNumeric;
+        switch (fieldType) {
+            case 'integer':
+            case 'decimal':
+            case 'number':
+            case 'float':
+                isNumeric = true;
+                break;
+        }
+
+        //////////////////
+
+        var inputWasProvided = qik.utils.exists(input);
 
-    //If we are requiring multiple values
-    if (multiValue) {
-      //But the input is not an array
-      if (!Array.isArray(input)) {
+        //If an answer is required 
         if (minimum) {
-          return {
-            valid: false,
-            message: `${fieldDefinition.title} requires at least ${minimum} values`,
-            status: 400,
-          };
+            //but none was provided
+            if (!inputWasProvided) {
+                //Throw an error
+                return {
+                    valid: false,
+                    message: `${fieldDefinition.title} is a required field`,
+                    status: 400,
+                }
+            }
         } else {
-          console.log("NOT PROVIDED AS ARRAY", fieldDefinition.title, input);
-          return {
-            valid: false,
-            message: `${fieldDefinition.title} must be provided as an array`,
-            status: 400,
-          };
+            //No answer is needed and none was provided
+            if (!inputWasProvided) {
+                return {
+                    valid: true,
+                }
+            }
         }
-      }
 
-      ////////////////////////////
+        //////////////////
 
-      var compacted = input;
 
-      compacted = compacted.filter(function (v) {
-        //Check if we care about this value
-        var empty = v === undefined || v === null || v === "";
-        return !empty;
-      });
+        //If we are requiring multiple values
+        if (multiValue) {
 
-      // console.log('COMPACTED', input.length, compacted.length);
+            //But the input is not an array
+            if (!Array.isArray(input)) {
 
-      ////////////////////////////
+                if (minimum) {
+                    return {
+                        valid: false,
+                        message: `${fieldDefinition.title} requires at least ${minimum} values`,
+                        status: 400,
+                    }
+                } else {
 
-      //We need an exact number of answers
-      if (minimum == maximum) {
-        //But we don't have the number of answers needed
-        if (minimum && compacted.length != minimum) {
-          return {
-            valid: false,
-            message: `${fieldDefinition.title} requires exactly ${maximum} values`,
-            status: 400,
-          };
-        }
-      }
+                    console.log('NOT PROVIDED AS ARRAY', fieldDefinition.title, input)
+                    return {
+                        valid: false,
+                        message: `${fieldDefinition.title} must be provided as an array`,
+                        status: 400,
+                    }
+                }
+            }
 
-      //We have too many answers
-      if (maximum && compacted.length > maximum) {
-        return {
-          valid: false,
-          message: `${fieldDefinition.title} requires less than ${maximum + 1} values`,
-          status: 400,
-        };
-      }
 
-      //We don't have enough answers
-      if (compacted.length < minimum) {
-        // console.log(fieldDefinition.title, 'INPUT', input.length, minimum, input, compacted)
 
-        return {
-          valid: false,
-          message: `${fieldDefinition.title} requires at least ${minimum} values`,
-          status: 400,
-        };
-      }
+            ////////////////////////////
 
-      ////////////////////////////
+            var compacted = input;
 
-      var foundBadEntry;
+            compacted = compacted.filter(function(v) {
+                //Check if we care about this value
+                var empty = v === undefined || v === null || v === '';
+                return !empty;
+            })
 
-      //Find any bad values
-      var badEntry = compacted.find(function (val) {
-        var valueFieldType = fieldType;
 
-        if (fieldDefinition.type === "group") {
-          valueFieldType = "object";
-        }
+            // console.log('COMPACTED', input.length, compacted.length);
 
-        if (
-          fieldDefinition.type === "reference" &&
-          fieldDefinition.widget === "form"
-        ) {
-          valueFieldType = "object";
-        }
+            ////////////////////////////
 
-        var isValid = qik.utils.isValidValue(
-          val,
-          valueFieldType,
-          options.strict,
-        );
+            //We need an exact number of answers
+            if (minimum == maximum) {
 
-        ////////////////////////////
+                //But we don't have the number of answers needed
+                if (minimum && (compacted.length != minimum)) {
+                    return {
+                        valid: false,
+                        message: `${fieldDefinition.title} requires exactly ${maximum} values`,
+                        status: 400,
+                    }
+                }
+            }
 
-        if (!isValid) {
-          foundBadEntry = true;
-          return true;
-        }
+            //We have too many answers
+            if (maximum && (compacted.length > maximum)) {
+
+                return {
+                    valid: false,
+                    message: `${fieldDefinition.title} requires less than ${maximum+1} values`,
+                    status: 400,
+                }
+            }
+
+            //We don't have enough answers
+            if (compacted.length < minimum) {
 
-        ////////////////////////////
-
-        //Is there additional validation requirements
-        if (fieldDefinition.validation) {
-          var additionalValidationErrors = service.meetsValidationRequirements(
-            val,
-            fieldType,
-            fieldDefinition.validation,
-          );
-          if (additionalValidationErrors) {
-            foundBadEntry = true;
-            return true;
-          }
+                // console.log(fieldDefinition.title, 'INPUT', input.length, minimum, input, compacted)
+
+                return {
+                    valid: false,
+                    message: `${fieldDefinition.title} requires at least ${minimum} values`,
+                    status: 400,
+                }
+            }
+
+            ////////////////////////////
+
+            var foundBadEntry;
+
+            //Find any bad values
+            var badEntry = compacted.find(function(val) {
+                var valueFieldType = fieldType;
+
+                if (fieldDefinition.type === 'group') {
+                    valueFieldType = 'object';
+                }
+
+                if (fieldDefinition.type === 'reference' && fieldDefinition.widget === 'form') {
+                    valueFieldType = 'object';
+                }
+
+                var isValid = qik.utils.isValidValue(val, valueFieldType, options.strict);
+
+                ////////////////////////////
+
+                if (!isValid) {
+                    foundBadEntry = true;
+                    return true;
+                }
+
+                ////////////////////////////
+
+                //Is there additional validation requirements
+                if (fieldDefinition.validation) {
+                    var additionalValidationErrors = service.meetsValidationRequirements(val, fieldType, fieldDefinition.validation)
+                    if (additionalValidationErrors) {
+                        foundBadEntry = true;
+                        return true;
+                    }
+                }
+            })
+
+            if (foundBadEntry) {
+                let badValueMessage = `Invalid input for ${fieldDefinition.title}`;
+                return {
+                    valid: false,
+                    message: badValueMessage,
+                    status: 400,
+                }
+            }
+
+        } else {
+
+            var dataType = fieldType;
+            var widgetType = fieldDefinition.widget;
+            if (dataType === 'group') {
+                dataType = 'object';
+            }
+
+            if (dataType === 'reference' && widgetType === 'form') {
+                dataType = 'object';
+            }
+
+
+            //////////////////
+
+            var cleanedValue = service.getCleanedValue(input, dataType, options);
+
+           
+            //////////////////
+
+            var isValidValue = qik.utils.isValidValue(cleanedValue, dataType, options.strict);
+
+            //////////////////
+
+            //Invalid input
+            if (!isValidValue) {
+                return {
+                    valid: false,
+                    message: `Single value '${input}' is not a valid ${dataType} for ${fieldDefinition.title}`,
+                    criteria: {
+                        isValidValue,
+                        cleanedValue,
+                        fieldType,
+                        options,
+                    },
+                    status: 400,
+                }
+            }
+
+            //Is there additional validation requirements
+            let hasAdditionalValidation = false;
+
+            const validation = {}
+            if(String(fieldDefinition.minValue)) { validation.minValue = parseInt(fieldDefinition.minValue); hasAdditionalValidation = true }
+            if(String(fieldDefinition.maxValue)) { validation.maxValue = parseInt(fieldDefinition.maxValue); hasAdditionalValidation = true }
+            if(String(fieldDefinition.minLength)) { validation.minLength = parseInt(fieldDefinition.minLength); hasAdditionalValidation = true }
+            if(String(fieldDefinition.maxLength)) { validation.maxLength = parseInt(fieldDefinition.maxLength); hasAdditionalValidation = true }
+
+
+            if (hasAdditionalValidation) {
+                const validationCriteria = Object.assign({}, validation, fieldDefinition.validation || {});
+                var additionalValidationError = service.meetsValidationRequirements(input, fieldType, validationCriteria)
+                if (additionalValidationError) {
+                    return {
+                        valid: false,
+                        message: additionalValidationError,
+                        status: 400,
+                    };
+                }
+            }
         }
-      });
 
-      if (foundBadEntry) {
-        let badValueMessage = `Invalid input for ${fieldDefinition.title}`;
-        return {
-          valid: false,
-          message: badValueMessage,
-          status: 400,
-        };
-      }
-    } else {
-      var dataType = fieldType;
-      var widgetType = fieldDefinition.widget;
-      if (dataType === "group") {
-        dataType = "object";
-      }
-
-      if (dataType === "reference" && widgetType === "form") {
-        dataType = "object";
-      }
-
-      //////////////////
-
-      var cleanedValue = service.getCleanedValue(input, dataType, options);
-
-      //////////////////
-
-      var isValidValue = qik.utils.isValidValue(
-        cleanedValue,
-        dataType,
-        options.strict,
-      );
-
-      //////////////////
-
-      //Invalid input
-      if (!isValidValue) {
+        //////////////////
+
         return {
-          valid: false,
-          message: `Single value '${input}' is not a valid ${dataType} for ${fieldDefinition.title}`,
-          criteria: {
-            isValidValue,
-            cleanedValue,
-            fieldType,
-            options,
-          },
-          status: 400,
-        };
-      }
-
-      //Is there additional validation requirements
-      let hasAdditionalValidation = false;
-
-      const validation = {};
-      if (String(fieldDefinition.minValue)) {
-        validation.minValue = parseInt(fieldDefinition.minValue);
-        hasAdditionalValidation = true;
-      }
-      if (String(fieldDefinition.maxValue)) {
-        validation.maxValue = parseInt(fieldDefinition.maxValue);
-        hasAdditionalValidation = true;
-      }
-      if (String(fieldDefinition.minLength)) {
-        validation.minLength = parseInt(fieldDefinition.minLength);
-        hasAdditionalValidation = true;
-      }
-      if (String(fieldDefinition.maxLength)) {
-        validation.maxLength = parseInt(fieldDefinition.maxLength);
-        hasAdditionalValidation = true;
-      }
-
-      if (hasAdditionalValidation) {
-        const validationCriteria = Object.assign(
-          {},
-          validation,
-          fieldDefinition.validation || {},
-        );
-        var additionalValidationError = service.meetsValidationRequirements(
-          input,
-          fieldType,
-          validationCriteria,
-        );
-        if (additionalValidationError) {
-          return {
-            valid: false,
-            message: additionalValidationError,
-            status: 400,
-          };
+            valid: true,
+        }
+
+    }
+
+    service.getCleanedValue = function(input, dataType, options) {
+        switch (dataType) {
+            case 'number':
+            case 'float':
+            case 'decimal':
+                if (!qik.utils.exists(input)) {
+                    return undefined;
+                } else {
+                    return Number(input);
+                }
+                break;
+            case 'integer':
+                if (!qik.utils.exists(input)) {
+                    return undefined;
+                } else {
+                    return parseInt(input);
+                }
+                break;
+            case 'boolean':
+                if (!qik.utils.exists(input)) {
+                    return undefined;
+                }
+                return qik.utils.parseBoolean(input);
+                break;
+            case 'email':
+                return options.strict ? input : String(input).toLowerCase();
+                break;
+            case 'reference':
+                return options.strict ? input : qik.utils.id(input);
+                break;
+            default:
+                return options.strict ? input : qik.utils.cleanValue(input, dataType, options);
+                break
         }
-      }
+
+        return input;
     }
 
-    //////////////////
+    ///////////////////////////////////////////////////
+
+    /**
+     * 
+     * Retrieves a list of records matching the provided criteria
+     * @alias content.list
+     * @param  {String} type The type or definition of records we want to retrieve
+     * @param  {Object} options The options for our query
+     * @param  {String} options.search Freeform text keywords
+     * @param  {Object} options.sort How to sort the results
+     * @param  {String} options.sort.key Which key to sort on
+     * @param  {String} options.sort.direction Which direction to sort on
+     * @param  {Object} options.sort.type What type of data is being sorted
+     * @param  {Object} options.page Page configuration
+     * @param  {Number} options.page.size Page size
+     * @param  {Number} options.page.index Page index
+     * @param  {Object} options.filter How to filter the results
+     * @example
+     * 
+     * 
+     * sdk.content.list('profile', {
+     *     search:'Jim',
+     *     page:{
+     *         size:50,
+     *         index:2,
+     *     },
+     *     sort:{
+     *         key:'age',
+     *         direction:'asc',
+     *         type:'integer',
+     *     },
+     *     filter:{
+     *         operator:'and',
+     *         filters:[{
+     *             key:'age',
+     *             comparator:'>',
+     *             value:5,
+     *         }],
+     *     },
+     * })
+     */
 
-    return {
-      valid: true,
-    };
-  };
+    service.list = async function(type, options, advanced) {
 
-  service.getCleanedValue = function (input, dataType, options) {
-    switch (dataType) {
-      case "number":
-      case "float":
-      case "decimal":
-        if (!qik.utils.exists(input)) {
-          return undefined;
-        } else {
-          return Number(input);
+        
+
+
+        if (!advanced) {
+            advanced = {};
         }
-        break;
-      case "integer":
-        if (!qik.utils.exists(input)) {
-          return undefined;
+
+        const remoteURL = advanced.remoteURL || `/content/${type}/list`;
+
+        if (advanced.cancellable) {
+
+            if (!advanced.config) {
+                advanced.config = {}
+            }
+
+            //Create a cancel token
+            const CancelToken = qik.api.CancelToken;
+            const source = CancelToken.source();
+            advanced.config.cancelToken = source.token;
+
+            
+            const promise = qik.api.post(remoteURL, options, advanced.config);
+            return {
+                promise,
+                cancel(message) {
+                    source.cancel(message || 'Operation canceled by the user.');
+                },
+            }
+
         } else {
-          return parseInt(input);
+            const { data } = await qik.api.post(remoteURL, options, advanced.config);
+            return data;
         }
-        break;
-      case "boolean":
-        if (!qik.utils.exists(input)) {
-          return undefined;
+
+
+
+
+
+    }
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * 
+     * Create an item
+     * @alias content.create
+     * @param  {String} type The type or definition of the record we want to create
+     * @param  {Object} input The data for our new record
+     * @example
+     * 
+     * 
+     * const result = await sdk.content.create('profile', {
+     *     firstName:'Mickey',
+     *     lastName:'Mouse',
+     *     gender:'male',
+     *     meta:{
+     *       scopes:['61eca4746971e75c1fc670cf'],
+     *     }
+     * })
+     */
+
+    service.create = async function(type, input) {
+
+        const dataModel = {...input};
+
+        // Sanitize down to just ids before we send
+        if(dataModel.meta?.scopes) {
+            dataModel.meta.scopes = qik.utils.ids(dataModel.meta.scopes);
         }
-        return qik.utils.parseBoolean(input);
-        break;
-      case "email":
-        return options.strict ? input : String(input).toLowerCase();
-        break;
-      case "reference":
-        return options.strict ? input : qik.utils.id(input);
-        break;
-      default:
-        return options.strict
-          ? input
-          : qik.utils.cleanValue(input, dataType, options);
-        break;
+
+
+        const { data } = await qik.api.post(`/content/${type}/create`, dataModel);
+        return data;
     }
 
-    return input;
-  };
-
-  ///////////////////////////////////////////////////
-
-  /**
-   *
-   * Retrieves a list of records matching the provided criteria
-   * @alias content.list
-   * @param  {String} type The type or definition of records we want to retrieve
-   * @param  {Object} options The options for our query
-   * @param  {String} options.search Freeform text keywords
-   * @param  {Object} options.sort How to sort the results
-   * @param  {String} options.sort.key Which key to sort on
-   * @param  {String} options.sort.direction Which direction to sort on
-   * @param  {Object} options.sort.type What type of data is being sorted
-   * @param  {Object} options.page Page configuration
-   * @param  {Number} options.page.size Page size
-   * @param  {Number} options.page.index Page index
-   * @param  {Object} options.filter How to filter the results. Additional documentation can be found here: https://rest.docs.qik.dev/#filter-syntax
-   * @example
-   *
-   *
-   * sdk.content.list('profile', {
-   *     search:'Jim',
-   *     page:{
-   *         size:50,
-   *         index:2,
-   *     },
-   *     sort:{
-   *         key:'age',
-   *         direction:'asc',
-   *         type:'integer',
-   *     },
-   *     filter:{
-   *         operator:'and',
-   *         filters:[{
-   *             key:'age',
-   *             comparator:'>',
-   *             value:5,
-   *         }],
-   *     },
-   * })
-   */
-
-  service.list = async function (type, options, advanced) {
-    if (!advanced) {
-      advanced = {};
+    /**
+     * 
+     * Update an item, Only fields the user has permission to view will be returned
+     * @alias content.update
+     * @param  {String} id The id of the record we want to update
+     * @param  {Object} input The data to update
+     * @example
+     * 
+     * const result = await sdk.content.update('61eca4746971e75c1fc670cd', {
+     *     firstName:'Minnie',
+     *     lastName:'Mouse',
+     *     gender:'female',
+     *     meta:{
+     *       scopes:['61eca4746971e75c1fc670cd'],
+     *     }
+     * })
+     */
+    service.update = async function(id, input) {
+        id = qik.utils.id(id);
+
+        const dataModel = {...input};
+        
+        // Sanitize down to just ids before we send
+        if(dataModel.meta?.scopes) {
+            dataModel.meta.scopes = qik.utils.ids(dataModel.meta.scopes);
+        }
+
+
+        const { data } = await qik.api.put(`/content/${id}`, dataModel);
+        return data;
     }
 
-    const remoteURL = advanced.remoteURL || `/content/${type}/list`;
-
-    if (advanced.cancellable) {
-      if (!advanced.config) {
-        advanced.config = {};
-      }
-
-      //Create a cancel token
-      const CancelToken = qik.api.CancelToken;
-      const source = CancelToken.source();
-      advanced.config.cancelToken = source.token;
-
-      const promise = qik.api.post(remoteURL, options, advanced.config);
-      return {
-        promise,
-        cancel(message) {
-          source.cancel(message || "Operation canceled by the user.");
-        },
-      };
-    } else {
-      const { data } = await qik.api.post(remoteURL, options, advanced.config);
-      return data;
+    /**
+     * 
+     * Partially update and patch an item, Only fields the user has permission to edit will be updated
+     * @alias content.patch
+     * @param  {String} id The id of the record we want to update
+     * @param  {Object} input The data to update, this will be merged with existing data
+     * @example
+     * 
+     * const result = await sdk.content.patch('61eca4746971e75c1fc670cd', {
+     *     firstName:'Mickey',
+     *     gender:'male',
+     * })
+     */
+    service.patch = async function(id, input) {
+        id = qik.utils.id(id);
+
+        const dataModel = {...input};
+        
+        // Sanitize down to just ids before we send
+        if(dataModel.meta?.scopes) {
+            dataModel.meta.scopes = qik.utils.ids(dataModel.meta.scopes);
+        }
+
+
+        const { data } = await qik.api.patch(`/content/${id}`, dataModel);
+        return data;
     }
-  };
-
-  ///////////////////////////////////////////////////
-
-  /**
-   *
-   * Create an item
-   * @alias content.create
-   * @param  {String} type The type or definition of the record we want to create
-   * @param  {Object} input The data for our new record
-   * @example
-   *
-   *
-   * const result = await sdk.content.create('profile', {
-   *     firstName:'Mickey',
-   *     lastName:'Mouse',
-   *     gender:'male',
-   *     meta:{
-   *       scopes:['61eca4746971e75c1fc670cf'],
-   *     }
-   * })
-   */
-
-  service.create = async function (type, input) {
-    const dataModel = { ...input };
-
-    // Sanitize down to just ids before we send
-    if (dataModel.meta?.scopes) {
-      dataModel.meta.scopes = qik.utils.ids(dataModel.meta.scopes);
+
+    /**
+     * 
+     * Get an item from the database, Only fields the user has permission to view will be returned
+     * @alias content.get
+     * @param  {String} id The id of the record we want to update
+     * @example
+     * 
+     * const result = await sdk.content.get('61eca4746971e75c1fc670cd')
+     */
+    service.get = async function(id, params) {
+        id = qik.utils.id(id);
+        params = params || {}
+
+        const { data } = await qik.api.get(`/content/${id}`, params);
+        return data;
     }
 
-    const { data } = await qik.api.post(`/content/${type}/create`, dataModel);
-    return data;
-  };
-
-  /**
-   *
-   * Update an item, Only fields the user has permission to view will be returned
-   * @alias content.update
-   * @param  {String} id The id of the record we want to update
-   * @param  {Object} input The data to update
-   * @example
-   *
-   * const result = await sdk.content.update('61eca4746971e75c1fc670cd', {
-   *     firstName:'Minnie',
-   *     lastName:'Mouse',
-   *     gender:'female',
-   *     meta:{
-   *       scopes:['61eca4746971e75c1fc670cd'],
-   *     }
-   * })
-   */
-  service.update = async function (id, input) {
-    id = qik.utils.id(id);
-
-    const dataModel = { ...input };
-
-    // Sanitize down to just ids before we send
-    if (dataModel.meta?.scopes) {
-      dataModel.meta.scopes = qik.utils.ids(dataModel.meta.scopes);
+    service.getFromID = async function(id) {
+        return service.get(id);
+    }
+
+    /**
+     * 
+     * Delete an item from the database
+     * @alias content.delete
+     * @param  {String} id The id of the record we want to delete
+     * @example
+     * const result = await sdk.content.delete('61eca4746971e75c1fc670cd')
+     */
+    service.delete = async function(id, input) {
+        id = qik.utils.id(id);
+        const { data } = await qik.api.delete(`/content/${id}`, input);
+        return data;
     }
 
-    const { data } = await qik.api.put(`/content/${id}`, dataModel);
-    return data;
-  };
-
-  /**
-   *
-   * Partially update and patch an item, Only fields the user has permission to edit will be updated
-   * @alias content.patch
-   * @param  {String} id The id of the record we want to update
-   * @param  {Object} input The data to update, this will be merged with existing data
-   * @example
-   *
-   * const result = await sdk.content.patch('61eca4746971e75c1fc670cd', {
-   *     firstName:'Mickey',
-   *     gender:'male',
-   * })
-   */
-  service.patch = async function (id, input) {
-    id = qik.utils.id(id);
-
-    const dataModel = { ...input };
-
-    // Sanitize down to just ids before we send
-    if (dataModel.meta?.scopes) {
-      dataModel.meta.scopes = qik.utils.ids(dataModel.meta.scopes);
+    /**
+     * 
+     * Restore a deleted item from the database
+     * @alias content.restore
+     * @param  {String} id The id of the record we want to restore
+     * @example
+     * const result = await sdk.content.restore('61eca4746971e75c1fc670cd')
+     */
+    service.restore = async function(id, input) {
+        id = qik.utils.id(id);
+        const { data } = await qik.api.get(`/content/${id}/restore`, input);
+        return data;
     }
 
-    const { data } = await qik.api.patch(`/content/${id}`, dataModel);
-    return data;
-  };
-
-  /**
-   *
-   * Get an item from the database, Only fields the user has permission to view will be returned
-   * @alias content.get
-   * @param  {String} id The id of the record we want to update
-   * @example
-   *
-   * const result = await sdk.content.get('61eca4746971e75c1fc670cd')
-   */
-  service.get = async function (id, params) {
-    id = qik.utils.id(id);
-    params = params || {};
-
-    const { data } = await qik.api.get(`/content/${id}`, params);
-    return data;
-  };
-
-  service.getFromID = async function (id) {
-    return service.get(id);
-  };
-
-  /**
-   *
-   * Delete an item from the database
-   * @alias content.delete
-   * @param  {String} id The id of the record we want to delete
-   * @example
-   * const result = await sdk.content.delete('61eca4746971e75c1fc670cd')
-   */
-  service.delete = async function (id, input) {
-    id = qik.utils.id(id);
-    const { data } = await qik.api.delete(`/content/${id}`, input);
-    return data;
-  };
-
-  /**
-   *
-   * Restore a deleted item from the database
-   * @alias content.restore
-   * @param  {String} id The id of the record we want to restore
-   * @example
-   * const result = await sdk.content.restore('61eca4746971e75c1fc670cd')
-   */
-  service.restore = async function (id, input) {
-    id = qik.utils.id(id);
-    const { data } = await qik.api.get(`/content/${id}/restore`, input);
-    return data;
-  };
-
-  /**
-   *
-   * Retrieve an item from the database by providing it's 'slug'
-   * @alias content.getFromSlug
-   * @param  {String} slug The slug id of the record we want to retrieve
-   * it must be provided as either `(type):(slug)`` or `(definition):(slug)`
-   * (if unsure use the `meta.abs` absolute slug property of the item you are wanting to retrieve).
-   * @example
-   * const result = await sdk.content.getFromSlug('article:how-to-get-started')
-   * const result = await sdk.content.getFromSlug('car:toyota-landcruiser')
-   * const result = await sdk.content.getFromSlug('article:toyota-landcruiser')
-   */
-  service.getFromSlug = async function (slug) {
-    const { data } = await qik.api.get(`/content/slug/${slug}`);
-    return data;
-  };
-
-  // service.getFromSlug = async function(type, slug) {
-  //     const { data } = await qik.api.get(`/content/${type}/slug/${slug}`);
-  //     return data;
-  // }
-
-  // service.getFromExternalID = async function(type, externalID) {
-  //     const { data } = await qik.api.get(`/content/${type}/external/${externalID}`);
-  //     return data;
-  // }
-
-  return service;
-}
+
+    /**
+     * 
+     * Retrieve an item from the database by providing it's 'slug'
+     * @alias content.getFromSlug
+     * @param  {String} slug The slug id of the record we want to retrieve
+     * it must be provided as either `(type):(slug)`` or `(definition):(slug)` 
+     * (if unsure use the `meta.abs` absolute slug property of the item you are wanting to retrieve).
+     * @example
+     * const result = await sdk.content.getFromSlug('article:how-to-get-started')
+     * const result = await sdk.content.getFromSlug('car:toyota-landcruiser')
+     * const result = await sdk.content.getFromSlug('article:toyota-landcruiser')
+     */
+    service.getFromSlug = async function(slug) {
+        const { data } = await qik.api.get(`/content/slug/${slug}`);
+        return data;
+    }
+
+    // service.getFromSlug = async function(type, slug) {
+    //     const { data } = await qik.api.get(`/content/${type}/slug/${slug}`);
+    //     return data;
+    // }
+
+    // service.getFromExternalID = async function(type, externalID) {
+    //     const { data } = await qik.api.get(`/content/${type}/external/${externalID}`);
+    //     return data;
+    // }
+
+
+    return service;
+
+}