PredicateCore.js

  1. /**
  2.  * Rules
  3.  * @module core
  4.  * @namespace core
  5.  * @since 1.0.0
  6.  * @note rules are 100% tested from PredicateCore.test.js
  7.  */
  9. const {
  10.   merge,
  11.   find,
  12.   curry,
  13.   prop,
  14.   tap,
  15.   pipe,
  16.   filter,
  17.   map,
  18.   over,
  19.   lens,
  20.   lensPath,
  21.   takeLast,
  22.   set,
  23.   differenceWith,
  24.   lensProp,
  25.   insert,
  26. } = require('ramda');
  28. const option = require('option');
  30. function head(list) {
  31.   return option.fromNullable(list[0]).value();
  32. }
  34. module.exports = function({ dataclasses, invariants, errors, rules }) {
  35.   const {
  36.     CompoundPredicate,
  37.     ComparisonPredicate,
  38.     Predicate,
  39.     Target,
  40.     LogicalType,
  41.   } = dataclasses;
  43.   /**
  44.    * Get a type by its type_id
  45.    * @param  {array} types
  46.    * @param  {string} type_id   type id name
  47.    * @return {?Type}  a Type
  48.    * @private
  49.    * @since 1.0.0
  50.    */
  51.   const _getTypeById = (types, type_id) =>
  52.     option.fromNullable(find(type => type.type_id == type_id, types));
  54.   /**
  55.    * Get a target by its target_id
  56.    * @param  {array} targets
  57.    * @param  {string} target_id target id name
  58.    * @return {?dataclasses.Target}
  59.    * @private
  60.    * @since 1.0.0
  61.    */
  62.   const _getTargetById = (targets, target_id) =>
  63.     option.fromNullable(find(target => target.target_id == target_id, targets));
  65.   /**
  66.    * Get a logical type by its logicalType_id
  67.    * @param  {array} logicalTypes
  68.    * @param  {string} logicalType_id logicalType id name
  69.    * @return {?dataclasses.Target}
  70.    * @private
  71.    * @since 1.0.0
  72.    */
  73.   const _getLogicalTypeById = (logicalTypes, logicalType_id) =>
  74.     option.fromNullable(
  75.       find(
  76.         logicalType => logicalType.logicalType_id == logicalType_id,
  77.         logicalTypes
  78.       )
  79.     );
  81.   /**
  82.    * _getOperatorsByIds
  83.    * @param  {Object} columns
  84.    * @param  {string[]} operator_ids
  85.    * @return {Array<dataclasses.operator>}
  86.    * @private
  87.    * @since 1.0.0
  88.    */
  89.   const _getOperatorsByIds = curry((operators, operator_ids) =>
  90.     pipe(filter(({ operator_id }) => operator_ids.includes(operator_id)))(
  91.       operators
  92.     )
  93.   );
  95.   const _set$operatorsToType = curry((columns, type) => {
  96.     type.$operators = _getOperatorsByIds(columns.operators, type.operator_ids);
  97.     return type;
  98.   });
  100.   const _set$typeToTarget = curry((columns, target) => {
  101.     const typeOption = _getTypeById(columns.types, target.type_id);
  102.     return invariants
  103.       .TargetMustReferToADefinedType(typeOption, target)
  104.       .then(type => {
  105.         target.$type = type;
  106.         return target;
  107.       });
  108.   });
  110.   /**
  111.    * Tap for Promise
  112.    * @param  {Function} f
  113.    * @return {Function}
  114.    * @private
  115.    */
  116.   const _tapPromise = f => {
  117.     return function(promise) {
  118.       return promise.then(result => {
  119.         f();
  120.         return result;
  121.       });
  122.     };
  123.   };
  125.   /**
  126.    * Run `fAfter()` (without any arguments) after `fBefore`, it will yield the promise yield from fBefore
  127.    * @param  {Function} fBefore
  128.    * @param  {Function} fAfter
  129.    * @return {Promise} promise from fBefore
  130.    * @private
  131.    */
  132.   const _afterPromise = (fBefore, fAfter) => pipe(fBefore, _tapPromise(fAfter));
  134.   // columns => Promise[columns]
  135.   const initializeColumns = columns => {
  136.     // at first I used lenses, but the code was way harder to read so it's better that way :)
  138.     // wrap operators
  139.     columns.operators = map(dataclasses.Operator, columns.operators);
  141.     // wrap logicalTypes
  142.     columns.logicalTypes = map(dataclasses.LogicalType, columns.logicalTypes);
  144.     // wrap types and set `$operators` attribute on each type
  145.     const wrapType = pipe(dataclasses.Type, _set$operatorsToType(columns));
  146.     columns.types = map(wrapType, columns.types);
  148.     // wrap targets and set `$type` attribut on each target
  149.     const wrapTarget = pipe(dataclasses.Target, _set$typeToTarget(columns));
  150.     return Promise.all(map(wrapTarget, columns.targets)).then(targets => {
  151.       columns.targets = targets;
  152.       return columns;
  153.     });
  154.   };
  156.   /**
  157.    * Create a new PredicateCore
  158.    * @param       {?dataclasses.CompoundPredicate} [data=PredicateCore.defaults.options.getDefaultData]
  159.    * @param       {Object} [columns=PredicateCore.defaults.columns]
  160.    * @param       {Object} [options=PredicateCore.defaults.options]
  161.    * @return {Promise<core.PredicateCoreAPI>}
  162.    * @memberof core
  163.    */
  164.   function PredicateCore({ data, columns, options } = {}) {
  165.     return initializeColumns(columns || PredicateCore.defaults.columns).then(
  166.       _columns => {
  167.         let _root;
  168.         const _options = merge(PredicateCore.defaults.options, options);
  170.         /**
  171.          * Loop through the predicate tree and update flags (e.g. $canBeRemoved)
  172.          * @private
  173.          */
  174.         function _apply$flags() {
  175.           const canRemoveAnyPredicate = !rules.predicateToRemoveIsTheLastComparisonPredicate(
  176.             _root,
  177.             CompoundPredicate,
  178.             ComparisonPredicate
  179.           );
  181.           CompoundPredicate.forEach(_root, function(predicate) {
  182.             predicate.$canBeRemoved =
  183.               canRemoveAnyPredicate &&
  184.               !rules.predicateToRemoveIsRootPredicate(_root, predicate);
  185.           });
  186.         }
  188.         /**
  189.          * Set PredicateCore data
  190.          * @param {dataclasses.CompoundPredicate} root CompoundPredicate
  191.          * @return {Promise<undefined, errors.RootPredicateMustBeACompoundPredicate>} resolved promise yield nothing, rejected promise yield RootPredicateMustBeACompoundPredicate error
  192.          * @since 1.0.0
  193.          * @memberof core.api
  194.          */
  195.         function setData(root) {
  196.           return invariants
  197.             .RootPredicateMustBeACompoundPredicate(root, CompoundPredicate)
  198.             .then(() => {
  199.               _root = root;
  200.             });
  201.         }
  203.         /**
  204.          * Add a ComparisonPredicate or CompoundPredicate
  205.          * @param  {Object} option
  206.          * @param  {string} options.type what type of Predicate to add
  207.          * @param  {string} [options.how=after] should we insert it before, after or instead of? (currently only after is supported)
  208.          * @param  {dataclasses.Predicate} options.where current element
  209.          * @return {Promise<dataclasses.Predicate>} inserted predicate
  210.          * @since 1.0.0
  211.          * @memberof core.api
  212.          */
  213.         function add({ where, how = 'after', type }) {
  214.           // currently only after is supported
  215.           return (
  216.             Promise.resolve()
  217.               .then(() => invariants.AddOnlySupportsAfter(how))
  218.               .then(() =>
  219.                 invariants.PredicateTypeMustBeValid(type, Predicate.Types)
  220.               )
  221.               // generate the Predicates
  222.               .then(() => _options[`getDefault${type}`](_columns, _options))
  223.               // then add it
  224.               .then(predicate => {
  225.                 const isComparisonPredicate = ComparisonPredicate.is(where);
  227.                 if (isComparisonPredicate || CompoundPredicate.is(where)) {
  228.                   if (isComparisonPredicate) {
  229.                     // it's a comparisonpredicate
  230.                     // first find predicates array that contains the element
  231.                     const path = _find(where);
  232.                     // we are starting from a ComparisonPredicate that always live inside a CompoundPredicate.predicates array
  233.                     const [compoundpredicate, [_, index]] = takeLast(2, path);
  234.                     compoundpredicate.predicates = insert(
  235.                       index + 1,
  236.                       predicate,
  237.                       compoundpredicate.predicates
  238.                     );
  239.                   } else {
  240.                     // it's a compoundpredicate
  241.                     // we want to add a CompoundPredicate after a compound predicate
  242.                     // so we need to add it as its first .predicates entry
  243.                     where.predicates.unshift(predicate);
  244.                   }
  246.                   return predicate;
  247.                 }
  249.                 return Promise.reject(
  250.                   new errors.CannotAddSomethingElseThanACompoundPredicateOrAComparisonPredicate()
  251.                 );
  252.               })
  253.           );
  254.         }
  256.         /**
  257.          * Remove a ComparisonPredicate or CompoundPredicate
  258.          * @param  {(dataclasses.ComparisonPredicate|dataclasses.CompoundPredicate)} predicate
  259.          * @return {Promise<dataclasses.Predicate>} yield the removed predicate, will reject the promise if remove was called with the root CompoundPredicate or the last ComparisonPredicate of the root CompoundPredicate
  260.          * @since 1.0.0
  261.          * @memberof core.api
  262.          */
  263.         function remove(predicate) {
  264.           return Promise.resolve()
  265.             .then(() =>
  266.               invariants.RemovePredicateMustDifferFromRootPredicate(
  267.                 _root,
  268.                 predicate
  269.               )
  270.             )
  271.             .then(() =>
  272.               invariants.RemovePredicateCannotBeTheLastComparisonPredicate(
  273.                 _root,
  274.                 predicate,
  275.                 CompoundPredicate,
  276.                 ComparisonPredicate
  277.               )
  278.             )
  279.             .then(() => {
  280.               if (
  281.                 CompoundPredicate.is(predicate) ||
  282.                 ComparisonPredicate.is(predicate)
  283.               ) {
  284.                 const path = _find(predicate);
  285.                 // we are starting from a ComparisonPredicate that always live
  286.                 // inside a CompoundPredicate.predicates array
  287.                 const [parentCompoundpredicate, [_, index]] = takeLast(2, path);
  288.                 parentCompoundpredicate.predicates.splice(index, 1);
  290.                 if (parentCompoundpredicate.predicates.length === 0) {
  291.                   // if there are not any more predicates
  292.                   // inside the parentCompoundpredicate, we should also remove it
  293.                   return remove(parentCompoundpredicate);
  294.                 }
  296.                 return predicate;
  297.               }
  299.               return Promise.reject(
  300.                 new errors.CannotRemoveSomethingElseThanACompoundPredicateOrAComparisonPredicate()
  301.               );
  302.             });
  303.         }
  305.         /**
  306.          * Change a CompoundPredicate logical
  307.          * @param {dataclasses.CompoundPredicate} predicate
  308.          * @param {string} newLogicalType_id
  309.          * @return {Promise<undefined, errors.PredicateMustBeACompoundPredicate>} yield nothing if everything went right, otherwise yield a reject promise with the PredicateMustBeACompoundPredicate error
  310.          * @since 1.0.0
  311.          * @memberof core.api
  312.          */
  313.         function setPredicateLogicalType_id(predicate, newLogicalType_id) {
  314.           return invariants
  315.             .PredicateMustBeACompoundPredicate(predicate, CompoundPredicate)
  316.             .then(() => {
  317.               // first change the logical type
  318.               return _getLogicalTypeById(
  319.                 _columns.logicalTypes,
  320.                 newLogicalType_id
  321.               );
  322.             })
  323.             .then(logicalTypeOption =>
  324.               invariants.LogicalType_idMustReferToADefinedLogicalType(
  325.                 logicalTypeOption
  326.               )
  327.             )
  328.             .then(logicalTypeOption => {
  329.               predicate.logic = logicalTypeOption.value(); // safe
  330.             });
  331.         }
  333.         /**
  334.          * Change a predicate's target
  335.          * @param {dataclasses.ComparisonPredicate} predicate
  336.          * @param {string} newTarget_id
  337.          * @return {Promise} yield nothing if everything went right, otherwise yield a reject promise with the PredicateMustBeAComparisonPredicate error
  338.          * @since 1.0.0
  339.          * @memberof core.api
  340.          */
  341.         function setPredicateTarget_id(predicate, newTarget_id) {
  342.           return invariants
  343.             .PredicateMustBeAComparisonPredicate(predicate, ComparisonPredicate)
  344.             .then(() => {
  345.               // first change the target
  346.               return _getTargetById(_columns.targets, newTarget_id);
  347.             })
  348.             .then(targetOption =>
  349.               invariants.Target_idMustReferToADefinedTarget(targetOption)
  350.             )
  351.             .then(targetOption => {
  352.               predicate.target = targetOption.value(); // safe
  354.               // then change the operator to the first operator for this target
  355.               return setPredicateOperator_id(
  356.                 predicate,
  357.                 head(predicate.target.$type.$operators).operator_id
  358.               );
  359.             });
  360.         }
  362.         /**
  363.          * Change a predicate's operator
  364.          * @param {dataclasses.ComparisonPredicate} predicate
  365.          * @param {string} newTarget_id
  366.          * @return {Promise<undefined, errors.PredicateMustBeAComparisonPredicate>} yield nothing if everything went right, otherwise yield a reject promise with the PredicateMustBeAComparisonPredicate error
  367.          * @since 1.0.0
  368.          * @memberof core.api
  369.          */
  370.         function setPredicateOperator_id(predicate, newOperator_id) {
  371.           return (
  372.             Promise.resolve()
  373.               // find operator
  374.               .then(() =>
  375.                 option.fromNullable(
  376.                   predicate.target.$type.$operators.find(
  377.                     operator => operator.operator_id === newOperator_id
  378.                   )
  379.                 )
  380.               )
  382.               .then(operatorOption =>
  383.                 invariants.Operator_idMustReferToADefinedOperator(
  384.                   operatorOption
  385.                 )
  386.               )
  387.               // change the operator
  388.               .then(operatorOption => {
  389.                 predicate.operator = operatorOption.value(); // safe
  391.                 // then reset arguments to array
  392.                 predicate.arguments = [];
  393.               })
  394.           );
  395.         }
  397.         /**
  398.          * Compute the JSON pointer path the element
  399.          * @param  {Object} element (http://jsonpatch.com/)
  400.          * @return {?Array} null if not found
  401.          * @readonly
  402.          * @since 1.0.0
  403.          */
  404.         function _find(element) {
  405.           return CompoundPredicate.reduce(
  406.             _root,
  407.             (acc, predicate, parents) => {
  408.               return element === predicate ? parents : acc;
  409.             },
  410.             null
  411.           );
  412.         }
  414.         // get data for initialization
  415.         return (
  416.           (data
  417.             ? Promise.resolve(data)
  418.             : _options.getDefaultData(_columns, _options)
  419.           )
  420.             // setup PredicateCore data
  421.             .then(_afterPromise(setData, _apply$flags))
  422.             // expose public API
  423.             .then(() => {
  424.               /**
  425.                * ui-predicate core public API
  426.                * @typedef {object} PredicateCoreAPI
  427.                * @namespace core.api
  428.                */
  429.               return {
  430.                 setData: _afterPromise(setData, _apply$flags),
  431.                 add: _afterPromise(add, _apply$flags),
  432.                 remove: _afterPromise(remove, _apply$flags),
  433.                 setPredicateTarget_id: _afterPromise(
  434.                   setPredicateTarget_id,
  435.                   _apply$flags
  436.                 ),
  437.                 setPredicateOperator_id: _afterPromise(
  438.                   setPredicateOperator_id,
  439.                   _apply$flags
  440.                 ),
  441.                 setPredicateLogicalType_id: _afterPromise(
  442.                   setPredicateLogicalType_id,
  443.                   _apply$flags
  444.                 ),
  446.                 /**
  447.                  * Get root CompoundPredicate
  448.                  * @return {dataclasses.CompoundPredicate}
  449.                  * @memberof core.api
  450.                  */
  451.                 get root() {
  452.                   return _root;
  453.                 },
  455.                 toJSON() {
  456.                   return _root;
  457.                 },
  459.                 // used for testing
  460.                 get columns() {
  461.                   return _columns;
  462.                 },
  464.                 // used for testing
  465.                 get options() {
  466.                   return _options;
  467.                 },
  468.               };
  469.             })
  470.         );
  471.       }
  472.     );
  473.   }
  475.   /**
  476.    * Defaults configuration of PredicateCore
  477.    * @type {Object}
  478.    * @namespace core.defaults
  479.    */
  480.   PredicateCore.defaults = {
  481.     options: {
  482.       /**
  483.        * When data is not set at construction time PredicateCore default behavior will be to use the first target and its first operator with empty argument
  484.        * @param  {Object} dataclasses every necessary data class
  485.        * @param  {Object} columns every necessary data class
  486.        * @param  {Object} options PredicateCore available options
  487.        * @return {Promise<dataclasses.CompoundPredicate>}  root CompoundPredicate
  488.        * @since 1.0.0
  489.        * @memberof core.defaults
  490.        */
  491.       getDefaultData(columns, options) {
  492.         return options
  493.           .getDefaultComparisonPredicate(columns, options)
  494.           .then(comparisonPredicate => {
  495.             return options.getDefaultCompoundPredicate(columns, options, [
  496.               comparisonPredicate,
  497.             ]);
  498.           });
  499.       },
  501.       /**
  502.        * Default compount predicate to use
  503.        *
  504.        * This function is called whenever a new CompoundPredicate is added to the UIPredicate
  505.        * @param  {Array<dataclasses.Predicate>} predicates
  506.        * @param  {Object} columns specified columns
  507.        * @param  {Object} options PredicateCore available options
  508.        * @return {Promise<dataclasses.CompoundPredicate>} a CompoundPredicate
  509.        * @since 1.0.0
  510.        * @memberof core.defaults
  511.        */
  512.       getDefaultCompoundPredicate(columns, options, predicates) {
  513.         return (!Array.isArray(predicates) || predicates.length === 0
  514.           ? options
  515.               .getDefaultComparisonPredicate(columns, options)
  516.               .then(comparisonPredicate => [comparisonPredicate])
  517.           : Promise.resolve(predicates)
  518.         ).then(predicates =>
  519.           options
  520.             .getDefaultLogicalType(predicates, columns, options)
  521.             .then(logicalType => CompoundPredicate(logicalType, predicates))
  522.         );
  523.       },
  525.       /**
  526.        * Default comparison predicate to use
  527.        *
  528.        * This function is called whenever a new ComparisonPredicate is added to the UIPredicate
  529.        * @param  {Object} columns specified columns
  530.        * @param  {Object} [options=PredicateCore.defaults.options] PredicateCore available options
  531.        * @return {Promise<dataclasses.ComparisonPredicate>} a Comparison
  532.        * @since 1.0.0
  533.        * @memberof core.defaults
  534.        */
  535.       getDefaultComparisonPredicate(columns, options) {
  536.         const firstTarget = head(columns.targets);
  537.         return ComparisonPredicate(
  538.           firstTarget,
  539.           head(firstTarget.$type.$operators),
  540.           []
  541.         );
  542.       },
  544.       /**
  545.        * Default logical type to use when a new comparison predicate is created
  546.        *
  547.        * This function is called whenever a new ComparisonPredicate is added to the UIPredicate
  548.        * @param  {Array<dataclasses.Predicate>} predicates specified columns
  549.        * @param  {Object} columns specified columns
  550.        * @param  {Object} [options=PredicateCore.defaults.options] PredicateCore available options
  551.        * @return {Promise<dataclasses.LogicalType>} a logical type
  552.        * @since 1.0.0
  553.        * @memberof core.defaults
  554.        */
  555.       getDefaultLogicalType(predicates, columns, options) {
  556.         return Promise.resolve(head(columns.logicalTypes));
  557.       },
  558.     },
  559.     columns: {
  560.       // besides array list names, everything else follows convention https://github.com/FGRibreau/sql-convention
  561.       operators: [
  562.         {
  563.           operator_id: 'is',
  564.           label: 'Est',
  565.         },
  566.         {
  567.           operator_id: 'contains',
  568.           label: 'Contient',
  569.         },
  570.         {
  571.           operator_id: 'isLowerThan',
  572.           label: '<',
  573.         },
  574.         {
  575.           operator_id: 'isEqualTo',
  576.           label: '=',
  577.         },
  578.         {
  579.           operator_id: 'isHigherThan',
  580.           label: '>',
  581.         },
  582.         {
  583.           operator_id: 'isBetween',
  584.           label: 'est compris entre',
  585.         },
  586.       ],
  587.       types: [
  588.         {
  589.           type_id: 'int',
  590.           operator_ids: ['isLowerThan', 'isEqualTo', 'isHigherThan'],
  591.         },
  592.         {
  593.           type_id: 'string',
  594.           operator_ids: ['is', 'contains'],
  595.         },
  596.         {
  597.           type_id: 'datetime',
  598.           operator_ids: ['is', 'isBetween'],
  599.         },
  600.       ],
  601.       targets: [
  602.         {
  603.           target_id: 'article.title',
  604.           label: 'Titre article',
  605.           type_id: 'string',
  606.         },
  607.         {
  608.           target_id: 'videoCount',
  609.           label: 'Nombre de vidéo',
  610.           type_id: 'int',
  611.         },
  612.         {
  613.           target_id: 'publishingAt',
  614.           label: 'Date de publication',
  615.           type_id: 'datetime',
  616.         },
  617.       ],
  618.       logicalTypes: [
  619.         {
  620.           logicalType_id: 'any',
  621.           label: 'Any',
  622.         },
  623.         {
  624.           logicalType_id: 'all',
  625.           label: 'All',
  626.         },
  627.         {
  628.           logicalType_id: 'none',
  629.           label: 'None',
  630.         },
  631.       ],
  632.     },
  633.   };
  635.   return PredicateCore;
  636. };