@qikdev/sdk 0.1.16 → 0.1.20

package/src/api/qik.content.js

@@ -23,6 +23,484 @@ export default function(qik) {
         debug: false,
     }
 
+    ///////////////////////////////////////////////////
+
+    /**
+     * 
+     * Retrieves the glossary of content types available to the user
+     * @alias content.list
+     * @param  {String} type The type or definition of records we want to retrieve
+     * @example
+     * 
+     * QikContent.glossary()
+     */
+
+    const glossary = {}
+
+    service.glossary = async function(options) {
+        options = options || {};
+
+        var reload = options.refresh || options.reload || !glossary.data;
+
+        if (reload) {
+            console.log('reloading the glossary')
+            const { data } = await qik.api.get(`/glossary`);
+            glossary.data = data;
+        }
+
+        if (options.hash) {
+            var result = qik.utils.hash(glossary.data, 'key');
+            return result;
+        }
+
+        return glossary.data;
+    }
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * 
+     * Retrieves all available filter comparators for the various field types
+     * @alias content.comparators
+     * @example
+     * 
+     * QikContent.comparators()
+     */
+
+    const comparators = {}
+
+    service.comparators = async function(options) {
+        options = options || {};
+
+        var reload = options.refresh || !comparators.data;
+
+        if (reload) {
+            const { data } = await qik.api.get(`/system/comparators`);
+
+
+            /////////////////////////////
+
+            data.available = {};
+
+            Object.entries(data.types).forEach(([key, value]) => {
+                data.available[key] = value.map(function(comparatorKey) {
+                    return data.hash[comparatorKey];
+                })
+            });
+
+
+            /////////////////////////////
+
+            comparators.data = data;
+        }
+
+
+
+        // if (options.hash) {
+        //     var result = qik.utils.hash(comparators.data, 'key');
+        //     return result;
+        // }
+
+        return comparators.data;
+    }
+
+    ///////////////////////////////////////////////////
+
+
+    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 };
+    }
+
+
+    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 `must be less than ${validationCriteria.maxLength} characters`;
+
+            }
+        }
+
+        if (validationCriteria.minValue) {
+            var number = Number(input);
+            if (number < validationCriteria.minValue) {
+                return `must be greater than ${validationCriteria.minValue}`;
+
+            }
+        }
+
+        if (validationCriteria.maxValue) {
+            var number = Number(input);
+            if (number > validationCriteria.maxValue) {
+                return `must be less than ${validationCriteria.maxValue}`;
+
+            }
+        }
+    }
+
+    service.validateField = function(input, fieldDefinition, options) {
+
+        if (!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 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 we are requiring multiple values
+        if (multiValue) {
+
+            //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 {
+                    return {
+                        valid: false,
+                        message: `${fieldDefinition.title} must be provided as an array`,
+                        status: 400,
+                    }
+                }
+            }
+
+
+
+            ////////////////////////////
+
+            var compacted = input;
+
+            compacted = compacted.filter(function(v) {
+                //Check if we care about this value
+                var empty = v === undefined || v === null || v === '';
+                return !empty;
+            })
+
+
+            // console.log('COMPACTED', input.length, compacted.length);
+
+            ////////////////////////////
+
+            //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,
+                    }
+                }
+            }
+
+            //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 foundBadEntry;
+
+            //Find any bad values
+            var badEntry = compacted.find(function(val) {
+
+                var strict = options.strict;
+
+                var valueFieldType = fieldType;
+
+                if (fieldDefinition.type == 'group') {
+                    valueFieldType = 'object';
+                }
+
+                var isValid = qik.utils.isValidValue(val, valueFieldType, 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) {
+
+                // var badValueMessage =  `${badEntry || "''"} is not a valid ${fieldType} value for ${fieldDefinition.title}`;
+                // switch(fieldType) {
+                //     case 'string':
+                //         badValueMessage = `Empty or invalid value for ${fieldDefinition.title}`;
+                //     break;
+                // }
+
+                console.log('BAD ENTRY', badEntry, fieldDefinition)
+                let badValueMessage = `Invalid input for ${fieldDefinition.title}`;
+                return {
+                    valid: false,
+                    message: badValueMessage,
+                    status: 400,
+                }
+            }
+
+        } else {
+
+            //////////////////
+
+            var cleanedValue = getCleanedValue();
+
+
+            //////////////////
+
+            function getCleanedValue() {
+                switch (fieldType) {
+                    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, fieldType, options);
+                        break
+                }
+
+                return input;
+            }
+
+            //////////////////
+
+            var dataType = fieldType;
+            if (dataType == 'group') {
+                dataType = 'object';
+            }
+
+            //////////////////
+
+            var isValidValue = qik.utils.isValidValue(cleanedValue, dataType, options.strict);
+
+            //////////////////
+
+            //Invalid input
+            if (!isValidValue) {
+
+                console.log('FAILED', input, fieldType, cleanedValue, dataType, isValidValue)
+                return {
+                    valid: false,
+                    message: `Single value '${input}' is not a valid ${fieldType} for ${fieldDefinition.title}`,
+                    criteria: {
+                        isValidValue,
+                        cleanedValue,
+                        fieldType,
+                        options,
+                    },
+                    status: 400,
+                }
+            }
+
+            //Is there additional validation requirements
+            if (fieldDefinition.validation) {
+                var additionalValidationError = service.meetsValidationRequirements(input, fieldType, fieldDefinition.validation)
+                if (additionalValidationError) {
+                    return {
+                        valid: false,
+                        message: additionalValidationError,
+                        status: 400,
+                    };
+                }
+            }
+        }
+
+        //////////////////
+
+        return {
+            valid: true,
+        }
+
+    }
+
+
+
+
+    // service.validateFieldValue = function(value, field, errorLog, options) {
+    //     options = options || {};
+    //     errorLog = errorLog || [];
+
+
+    //     ///////////////////////////////////////////
+
+    //     let { key, type } = field;
+    //     let { minimum, maximum } = = getLimits(field);
+    //     let existingValue = value;
+
+    //     let isLayout = field.type == 'group' && !field.asObject;
+
+    //     if (isLayout) {
+    //         var subFields = service.mapFields(field.fields, { depth: 1 });
+    //         subFields.forEach(function(subField) {
+    //             service.validateFieldValue(input, subField, errorLog, options);
+    //         })
+    //     } else {
+    //         //If it's a group of fields
+    //         if (isGroup && asObject) {
+    //             //Get all the fields
+    //             var subFields = service.mapFields(field.fields, { depth: 1 });
+
+    //             //If the group is a single object
+    //             if (maximum === 1) {
+    //                 var groupObjectInput = existingValue;
+
+    //                 //Loop through each field
+    //                 subFields.forEach(function(subField) {
+    //                     //Update the entry data
+    //                     service.validateFieldValue(groupObjectInput, subField, errorLog, options);
+    //                 })
+    //             } else {
+
+    //                 //Generate a new array
+    //                 (existingValue || []).forEach(function(entry) {
+    //                     //Loop through each field
+    //                     subFields.forEach(function(subField) {
+    //                         //Update the entry data
+    //                         service.validateFieldValue(entry, subField, errorLog, options);
+    //                     })
+    //                 });
+    //             }
+    //         } else {
+    //             //We're a standard field so just wash and set and move on
+    //             var { valid, message } = service.validate(existingValue, field, options)
+
+    //             if (!valid) {
+    //                 errorLog.push({
+    //                     field,
+    //                     message,
+    //                 })
+    //             }
+    //         }
+    //     }
+    // }
+
+
+
+
+
     ///////////////////////////////////////////////////
 
     /**
@@ -31,14 +509,24 @@ export default function(qik) {
      * @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  {Object} options.search Freeform text keywords
+     * @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
      * 
      * 
      * QikContent.list('profile', {
      *     search:'Jim',
+     *     page:{
+     *         size:50,
+     *         index:2,
+     *     },
      *     sort:{
      *         key:'age',
      *         direction:'asc',
@@ -55,11 +543,41 @@ export default function(qik) {
      * })
      */
 
-    service.list = async function(type, options) {
+    service.list = async function(type, options, advanced) {
+
+
+        if (!advanced) {
+            advanced = {};
+        }
+
+        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(`/content/${type}/list`, options, advanced.config);
+            return {
+                promise,
+                cancel(message) {
+                    source.cancel(message || 'Operation canceled by the user.');
+                },
+            }
+
+        } else {
+            const { data } = await qik.api.post(`/content/${type}/list`, options, advanced.config);
+            return data;
+        }
+
+
+
+
 
-        console.log('Get the things', type, options);
-        return qik.api.post(`/content/${type}/list`, options);
-        
     }
 
     ///////////////////////////////////////////////////
@@ -83,9 +601,21 @@ export default function(qik) {
      * })
      */
 
-    service.create = async function(type, data) {
-        return qik.api.post(`/content/${type}/create`, data);
-        
+    service.create = async function(type, input) {
+        const { data } = await qik.api.post(`/content/${type}/create`, input);
+        return data;
+    }
+
+    service.update = async function(type, id, input) {
+        id = qik.utils.id(id);
+        const { data } = await qik.api.put(`/content/${type}/${id}`, input);
+        return data;
+    }
+
+    service.patch = async function(type, id, input) {
+        id = qik.utils.id(id);
+        const { data } = await qik.api.patch(`/content/${type}/${id}`, input);
+        return data;
     }
 
 

package/src/api/qik.core.js

@@ -3,9 +3,12 @@
 import QikAPI from './qik.api.js';
 import QikAuth from './qik.auth.js';
 import QikUtils from './qik.utils.js';
+import QikFilter from './qik.filter.js';
+import QikFiles from './qik.files.js';
 import QikCache from './qik.cache.js';
 import QikAccess from './qik.access.js';
 import QikContent from './qik.content.js';
+import QikSystem from './qik.system.js';
 import { EventDispatcher } from './qik.utils.js';
 
 ///////////////////////////////////////
@@ -39,8 +42,6 @@ import { EventDispatcher } from './qik.utils.js';
 
 import { version } from '../version.js';
 
-console.log('BEFORE class')
-
 export default function(options) {
     if (!options) {
         options = {
@@ -66,7 +67,7 @@ export default function(options) {
             options.apiURL = 'https://api.staging.qik.dev';
             break;
         case 'local':
-            options.apiURL = 'http://localhost:4001';
+            options.apiURL = 'http://api.qik.localhost:4001';
             break;
     }
 
@@ -76,6 +77,7 @@ export default function(options) {
         //Other options
         // domain:'',
         version,
+        global:{},
     })
 
     console.log('Instantiate class', core)
@@ -94,6 +96,7 @@ export default function(options) {
         value: cache,
         writable: false,
     });
+    
     ///////////////////////////////////////
 
     /**
@@ -109,6 +112,34 @@ export default function(options) {
 
     ///////////////////////////////////////
 
+    /**
+     * Provides helper functions for working
+     * with Qik filters
+     * @type {QikFilter}
+     */
+    const filter = QikFilter;
+    Object.defineProperty(core, 'filter', {
+        value: filter,
+        writable: false,
+    });
+
+
+
+    ///////////////////////////////////////
+
+    /**
+     * Provides helper functions for working
+     * with Qik files
+     * @type {QikFiles}
+     */
+    const files = new QikFiles(core);
+    Object.defineProperty(core, 'files', {
+        value: files,
+        writable: false,
+    });
+
+    ///////////////////////////////////////
+
     //Create a new global dispatcher so we can trigger events
     const dispatcher = new EventDispatcher();
     dispatcher.bootstrap(core);
@@ -162,6 +193,18 @@ export default function(options) {
         writable: false,
     });
 
+    ///////////////////////////////////////
+
+    /**
+     * A helper service for content create, update, read and delete operations.
+     * @type {QikContent}
+     */
+    const system = new QikSystem(core);
+    Object.defineProperty(core, 'system', {
+        value: system,
+        writable: false,
+    });
+
 
     ///////////////////////////////////////