dataclasses/columns.js

  1. const { mergeAll } = require('ramda');
  2. const $_type = require('./$_type');
  4. /**
  5.  * Target type definition
  6.  * @typedef {Object} Target
  7.  * @memberof dataclasses
  8.  */
  10. /**
  11.  * Create a new target
  12.  * @param {object} target
  13.  * @param {string} target.target_id - unique id for this target
  14.  * @param {string} target.label - label that will be displayed for this target
  15.  * @param {string} target.type_id - the type_id name this target has
  16.  * @return {Target} {@link dataclasses.Target}
  17.  * @memberof dataclasses
  18.  */
  19. function Target(target) {
  20.   // target MUST at least have the attributes bellow
  21.   const { target_id, label, type_id } = target;
  22.   return mergeAll([$_type('Target'), { target_id, label, type_id }, target]);
  23. }
  25. /**
  26.  * A type operator
  27.  * @typedef Operator
  28.  * @memberof dataclasses
  29.  */
  31. /**
  32.  * Create a new operator
  33.  * @param {object} operator
  34.  * @param {string} operator.operator_id - unique id for this operator
  35.  * @param {string} operator.label - label that will be displayed for this operator
  36.  * @return {Operator} {@link dataclasses.Operator}
  37.  * @memberof dataclasses
  38.  */
  39. function Operator(operator) {
  40.   // operator MUST at least have the attributes bellow
  41.   const { operator_id, label } = operator;
  42.   return mergeAll([
  43.     $_type('Operator'),
  44.     {
  45.       operator_id,
  46.       label,
  47.     },
  48.     operator,
  49.   ]);
  50. }
  52. /**
  53.  * Defines a target type
  54.  * @typedef Type
  55.  * @memberof dataclasses
  56.  */
  58. /**
  59.  * Create a new type
  60.  * @param {Object} type
  61.  * @param {string} type.type_id
  62.  * @param {string[]} type.operator_ids
  63.  * @return {Type} {@link dataclasses.Type}
  64.  * @memberof dataclasses
  65.  */
  66. function Type(type) {
  67.   // operator MUST at least have the attributes bellow
  68.   const { type_id, operator_ids } = type;
  69.   return mergeAll([
  70.     $_type('Type'),
  71.     {
  72.       type_id,
  73.       operator_ids,
  74.     },
  75.     type,
  76.   ]);
  77. }
  79. /**
  80.  * Create a new type logical type
  81.  * Logical types or used in CompoundPredicates
  82.  * @param {Object} logic The predicate logic
  83.  * @param {string} type.logicalType_id
  84.  * @param {string} type.label
  85.  * @memberof dataclasses
  86.  */
  87. function LogicalType(logicalType) {
  88.   // logicalType MUST at least have the attributes bellow
  89.   const { logicalType_id, label } = logicalType;
  90.   return mergeAll([
  91.     $_type('LogicalType'),
  92.     {
  93.       logicalType_id,
  94.       label,
  95.     },
  96.     logicalType,
  97.   ]);
  98. }
  100. module.exports = { Type, Target, Operator, LogicalType };