invariants.js

  1. /**
  2.  * Invariants
  3.  * @namespace invariants
  4.  * @since 1.0.0
  5.  * @note invariants are 100% tested from PredicateCore.test.js
  6.  */
  8. module.exports = ({ errors, rules }) => ({
  9.   /**
  10.    * [CompoundPredicateMustHaveAtLeastOneSubPredicate description]
  11.    * @param {?Array<Predicate>} predicates list of predicates to add to a CompoundPredicate at creation time
  12.    * @return {Promise<undefined, errors.CompoundPredicateMustHaveAtLeastOneSubPredicate>} resolve the promise if the invariant pass or yield a `CompoundPredicateMustHaveAtLeastOneSubPredicate` error otherwise
  13.    * @memberof invariants
  14.    * @since 1.0.0
  15.    */
  16.   CompoundPredicateMustHaveAtLeastOneSubPredicate: predicates =>
  17.     !Array.isArray(predicates) || predicates.length === 0
  18.       ? Promise.reject(
  19.           new errors.CompoundPredicateMustHaveAtLeastOneSubPredicate()
  20.         )
  21.       : Promise.resolve(),
  23.   /**
  24.    * @param {String} type Predicate type
  25.    * @param {Object} acceptedTypes list of accepted types
  26.    * @return {Promise<undefined, errors.InvalidPredicateType>} resolve the promise if the invariant pass or yield a `InvalidPredicateType` error otherwise
  27.    * @memberof invariants
  28.    * @since 1.0.0
  29.    */
  30.   PredicateTypeMustBeValid: (type, acceptedTypes) =>
  31.     !Object.keys(acceptedTypes).includes(type)
  32.       ? Promise.reject(new errors.InvalidPredicateType())
  33.       : Promise.resolve(),
  35.   /**
  36.    * @param {dataclasses.CompoundPredicate} root root
  37.    * @param {dataclasses.CompoundPredicate} CompoundPredicate CompoundPredicate
  38.    * @return {Promise<dataclasses.CompoundPredicate, errors.RootPredicateMustBeACompoundPredicate>} resolve the promise if the invariant pass or yield a `RootPredicateMustBeACompoundPredicate` error otherwise
  39.    * @memberof invariants
  40.    * @since 1.0.0
  41.    */
  42.   RootPredicateMustBeACompoundPredicate: (root, CompoundPredicate) =>
  43.     !CompoundPredicate.is(root)
  44.       ? Promise.reject(new errors.RootPredicateMustBeACompoundPredicate())
  45.       : Promise.resolve(root),
  47.   /**
  48.    * @param {dataclasses.Predicate} predicate predicate
  49.    * @param {dataclasses.ComparisonPredicate} ComparisonPredicate ComparisonPredicate constructor
  50.    * @return {Promise<undefined, errors.PredicateMustBeAComparisonPredicate>} resolve the promise if the invariant pass or yield a `PredicateMustBeAComparisonPredicate` error otherwise
  51.    * @memberof invariants
  52.    * @since 1.0.0
  53.    */
  55.   PredicateMustBeAComparisonPredicate: (predicate, ComparisonPredicate) =>
  56.     !ComparisonPredicate.is(predicate)
  57.       ? Promise.reject(new errors.PredicateMustBeAComparisonPredicate())
  58.       : Promise.resolve(),
  60.   /**
  61.    * @param {dataclasses.Predicate} predicate predicate
  62.    * @param {dataclasses.CompoundPredicate} CompoundPredicate CompoundPredicate constructor
  63.    * @return {Promise<undefined, errors.PredicateMustBeACompoundPredicate>} resolve the promise if the invariant pass or yield a `PredicateMustBeACompoundPredicate` error otherwise
  64.    * @memberof invariants
  65.    * @since 1.0.0
  66.    */
  67.   PredicateMustBeACompoundPredicate: (predicate, CompoundPredicate) =>
  68.     !CompoundPredicate.is(predicate)
  69.       ? Promise.reject(new errors.PredicateMustBeACompoundPredicate())
  70.       : Promise.resolve(),
  72.   /**
  73.    * @param {string} how how
  74.    * @return {Promise<undefined, errors.AddCurrentlyOnlySupportAfterInsertion>} resolve the promise if the invariant pass or yield a `AddOnlySupportsAfter` error otherwise
  75.    * @memberof invariants
  76.    * @since 1.0.0
  77.    */
  78.   AddOnlySupportsAfter: how =>
  79.     how !== 'after'
  80.       ? Promise.reject(new errors.AddCurrentlyOnlySupportAfterInsertion())
  81.       : Promise.resolve(),
  83.   /**
  84.    * @param {option<dataclasses.Type>} type type
  85.    * @param {dataclasses.Target} target target
  86.    * @return {Promise<dataclasses.Type, errors.TargetMustReferToADefinedType>} resolve the promise if the invariant pass or yield a `TargetMustReferToADefinedType` error otherwise
  87.    * @memberof invariants
  88.    * @since 1.0.0
  89.    */
  90.   TargetMustReferToADefinedType: (type, target) => {
  91.     if (type.isNone()) {
  92.       return Promise.reject(
  93.         new errors.TargetMustReferToADefinedType(
  94.           `target ${JSON.stringify(
  95.             target.target_id
  96.           )} does not refer to a defined type, target.type_id=${JSON.stringify(
  97.             target.type_id
  98.           )}`
  99.         )
  100.       );
  101.     }
  102.     return Promise.resolve(type.value());
  103.   },
  105.   /**
  106.    * @param {Option<dataclasses.LogicalType>} logicalType logicalType
  107.    * @return {Promise<dataclasses.LogicalType, errors.LogicalType_idMustReferToADefinedLogicalType>} resolve the promise if the invariant pass or yield a `LogicalType_idMustReferToADefinedLogicalType` error otherwise
  108.    * @memberof invariants
  109.    * @since 1.0.0
  110.    */
  111.   LogicalType_idMustReferToADefinedLogicalType: logicalType =>
  112.     !logicalType
  113.       ? Promise.reject(
  114.           new errors.LogicalType_idMustReferToADefinedLogicalType()
  115.         )
  116.       : Promise.resolve(logicalType),
  118.   /**
  119.    * @param {Option<dataclasses.Target>} target target
  120.    * @return {Promise<dataclasses.Target, errors.Target_idMustReferToADefinedTarget>} resolve the promise if the invariant pass or yield a `Target_idMustReferToADefinedTarget` error otherwise
  121.    * @memberof invariants
  122.    * @since 1.0.0
  123.    */
  124.   Target_idMustReferToADefinedTarget: target =>
  125.     !target
  126.       ? Promise.reject(new errors.Target_idMustReferToADefinedTarget())
  127.       : Promise.resolve(target),
  129.   /**
  130.    * @param {Option<dataclasses.Operator>} operator operator
  131.    * @return {Promise<dataclasses.Operator, errors.Operator_idMustReferToADefinedOperator>} resolve the promise if the invariant pass or yield a `Operator_idMustReferToADefinedOperator` error otherwise
  132.    * @memberof invariants
  133.    * @since 1.0.0
  134.    */
  135.   Operator_idMustReferToADefinedOperator: operator =>
  136.     !operator
  137.       ? Promise.reject(new errors.Operator_idMustReferToADefinedOperator())
  138.       : Promise.resolve(operator),
  140.   /**
  141.    * @param {dataclasses.CompoundPredicate} root root
  142.    * @param {dataclasses.Predicate} predicateToRemove predicateToRemove
  143.    * @return {Promise<predicateToRemove, errors.ForbiddenCannotRemoveRootCompoundPredicate>} resolve the promise if the invariant pass or yield a `ForbiddenCannotRemoveRootCompoundPredicate` error otherwise
  144.    * @memberof invariants
  145.    * @since 1.0.0
  146.    */
  147.   RemovePredicateMustDifferFromRootPredicate: (root, predicateToRemove) =>
  148.     rules.predicateToRemoveIsRootPredicate(root, predicateToRemove)
  149.       ? Promise.reject(new errors.ForbiddenCannotRemoveRootCompoundPredicate())
  150.       : Promise.resolve(predicateToRemove),
  152.   /**
  153.    * @param {dataclasses.CompoundPredicate} root root
  154.    * @param {dataclasses.Predicate} predicateToRemove predicateToRemove
  155.    * @param {dataclasses.CompoundPredicate} CompoundPredicate CompoundPredicate
  156.    * @param {dataclasses.ComparisonPredicate} ComparisonPredicate ComparisonPredicate
  157.    * @return {Promise<undefined, errors.ForbiddenCannotRemoveLastComparisonPredicate>} resolve the promise if the invariant pass or yield a `RootPredicateMustBeACompoundPredicate` error otherwise
  158.    * @memberof invariants
  159.    * @since 1.0.0
  160.    */
  161.   RemovePredicateCannotBeTheLastComparisonPredicate: (
  162.     root,
  163.     predicateToRemove,
  164.     CompoundPredicate,
  165.     ComparisonPredicate
  166.   ) =>
  167.     ComparisonPredicate.is(predicateToRemove) &&
  168.     rules.predicateToRemoveIsTheLastComparisonPredicate(
  169.       root,
  170.       CompoundPredicate,
  171.       ComparisonPredicate
  172.     )
  173.       ? Promise.reject(
  174.           new errors.ForbiddenCannotRemoveLastComparisonPredicate()
  175.         )
  176.       : Promise.resolve(),
  177. });