xcraft-core-pickaxe 0.1.24 → 0.1.26

package/lib/examples.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-inner-declarations */
 // @ts-check
-const {operatorToSql} = require('./operator-to-sql.js');
+const {expressionToSql} = require('./operator-to-sql.js');
 const {
   string,
   number,
@@ -80,8 +80,8 @@ example1: {
     user.get('address').get('streetName').eq('Mine road')
   );
 
-  console.log(operatorToSql(filter1));
-  console.log(operatorToSql(filter2));
+  console.log(expressionToSql(filter1));
+  console.log(expressionToSql(filter2));
 }
 
 example2: {

package/lib/level-set-utils.js

@@ -1,9 +1,10 @@
 /* eslint-disable jsdoc/require-returns */
 // @ts-check
 
-const $ = require('xcraft-core-pickaxe/lib/operators.js');
+const {pickOperators: $} = require('xcraft-core-pickaxe/lib/pick-operators.js');
 const {RecordPick, ValuePick} = require('./picks.js');
 const {StringType, NumberType} = require('xcraft-core-stones');
+const {pickFromValue} = require('./pick-or-value.js');
 
 /**
  * @typedef {Record<string, number>} LevelSet
@@ -36,7 +37,7 @@ function levelSetHasValue2(set, key, value) {
  */
 function levelSetIsEmpty(set) {
   if (!(set instanceof RecordPick)) {
-    return $.value(Object.keys(set).length === 0);
+    return pickFromValue(Object.keys(set).length === 0);
   }
   return set.keys().length.eq(0);
 }

package/lib/operator-to-sql.js

@@ -1,12 +1,9 @@
 // @ts-check
 
-const {isAnyPick} = require('./picks.js');
+const {isAnyPick, BasePick} = require('./picks.js');
 
 /**
- * @typedef {import("./operators.js").Operator} Operator
- */
-/**
- * @typedef {import('./picks.js').AnyPick} AnyPick
+ * @typedef {import("./operators.js").Expression} Expression
  */
 
 function escape(value) {
@@ -16,6 +13,16 @@ function escape(value) {
   return value;
 }
 
+function squashValueAndPath(value, path) {
+  if (value) {
+    const operatorName = value.operator;
+    if (operatorName === 'get') {
+      return squashValueAndPath(value.value, [value.path, ...path]);
+    }
+  }
+  return [value, path];
+}
+
 const operators = {
   unsafeSql({sql}, context) {
     return sql;
@@ -60,6 +67,8 @@ const operators = {
     // TODO: try values.push(path) => '?'
     // return `json_extract(${field}, ${sql(path, values)})`;
 
+    [value, path] = squashValueAndPath(value, path);
+
     if (value) {
       return `json_extract(${sql(value, context)}, ${escape(
         '$.' + path.join('.')
@@ -165,6 +174,17 @@ const operators = {
     return `(${sqlConditions.join(' OR ')})`;
   },
 
+  ifNull({a, b}, context) {
+    return `IFNULL(${sql(a, context)},${sql(b, context)})`;
+  },
+
+  if({condition, a, b}, context) {
+    return `IF(${sql(condition, context)},${sql(a, context)},${sql(
+      b,
+      context
+    )})`;
+  },
+
   abs({value}, context) {
     return `ABS(${sql(value, context)})`;
   },
@@ -275,14 +295,14 @@ const operators = {
 };
 
 /**
- * @param {Operator | AnyPick} operatorOrPick
- * @returns {Operator}
+ * @param {Expression | BasePick} expressionOrPick
+ * @returns {Expression}
  */
-function getOperator(operatorOrPick) {
-  if (isAnyPick(operatorOrPick)) {
-    return operatorOrPick.value;
+function getExpression(expressionOrPick) {
+  if (isAnyPick(expressionOrPick)) {
+    return expressionOrPick.expression;
   }
-  return operatorOrPick;
+  return expressionOrPick;
 }
 
 /**
@@ -291,24 +311,24 @@ function getOperator(operatorOrPick) {
  *   scope?: any,
  *   useTableNames?: boolean,
  *   equalOperator: 'IS' | '=',
- * }} OperatorToSqlContext
+ * }} ExpressionToSqlContext
  */
 
 /**
- * @param {Operator | AnyPick} operatorOrPick
- * @param {OperatorToSqlContext} context
+ * @param {Expression | BasePick} expressionOrPick
+ * @param {ExpressionToSqlContext} context
  * @returns {string}
  */
-function sql(operatorOrPick, context) {
-  const operator = getOperator(operatorOrPick);
-  const operatorName = operator.operator;
+function sql(expressionOrPick, context) {
+  const expression = getExpression(expressionOrPick);
+  const operatorName = expression.operator;
   if (!(operatorName in operators)) {
-    throw new Error(`Unknown operator '${JSON.stringify(operator)}'`);
+    throw new Error(`Unknown operator for '${JSON.stringify(expression)}'`);
   }
-  return operators[operatorName](operator, context);
+  return operators[operatorName](expression, context);
 }
 
-function operatorToSql(operator) {
+function expressionToSql(operator) {
   const context = {
     values: [],
   };
@@ -320,5 +340,5 @@ function operatorToSql(operator) {
 
 module.exports = {
   sql,
-  operatorToSql,
+  expressionToSql,
 };

package/lib/operators.js

@@ -1,12 +1,7 @@
 /* eslint-disable jsdoc/require-returns */
 // @ts-check
 
-const {number, array} = require('xcraft-core-stones');
-
-/**
- * @template {AnyTypeOrShape} T
- * @typedef {import("./picks.js").ValuePick<T>} ValuePick
- */
+const {number} = require('xcraft-core-stones');
 
 function op(value) {
   if (value === null) {
@@ -19,9 +14,9 @@ function op(value) {
   if (type === 'object' && 'operator' in value) {
     return value;
   }
-  const {isAnyPick} = require('./picks.js');
+  const {isAnyPick} = /** @type {any} */ (require('./picks.js'));
   if (isAnyPick(value)) {
-    return value.value;
+    return value.expression;
   }
 
   throw new Error(`Bad value '${value}'`);
@@ -222,6 +217,23 @@ const operators = {
     });
   },
 
+  ifNull(a, b) {
+    return /** @type {const} */ ({
+      operator: 'ifNull',
+      a,
+      b,
+    });
+  },
+
+  if(condition, a, b) {
+    return /** @type {const} */ ({
+      operator: 'if',
+      condition: op(condition),
+      a: op(a),
+      b: op(b),
+    });
+  },
+
   abs(value) {
     value = op(value);
     return /** @type {const} */ ({
@@ -330,69 +342,43 @@ const operators = {
   count(field, distinct) {
     return /** @type {const} */ ({
       operator: 'count',
-      type: number,
       field,
       distinct,
     });
   },
 
-  /**
-   * @template {AnyTypeOrShape} T
-   * @param {ValuePick<T>} field
-   */
   avg(field) {
     return /** @type {const} */ ({
       operator: 'avg',
-      type: field.type,
-      field: field.value,
+      field,
     });
   },
 
-  /**
-   * @template {AnyTypeOrShape} T
-   * @param {ValuePick<T>} field
-   */
   max(field) {
     return /** @type {const} */ ({
       operator: 'max',
-      type: field.type,
-      field: field.value,
+      field,
     });
   },
 
-  /**
-   * @template {AnyTypeOrShape} T
-   * @param {ValuePick<T>} field
-   */
   min(field) {
     return /** @type {const} */ ({
       operator: 'min',
-      type: field.type,
-      field: field.value,
+      field,
     });
   },
 
-  /**
-   * @template {AnyTypeOrShape} T
-   * @param {ValuePick<T>} field
-   */
   sum(field) {
     return /** @type {const} */ ({
       operator: 'sum',
-      type: field.type,
-      field: field.value,
+      field,
     });
   },
 
-  /**
-   * @template {AnyTypeOrShape} T
-   * @param {ValuePick<T>} field
-   */
   groupArray(field) {
     return /** @type {const} */ ({
       operator: 'groupArray',
-      type: array(field.type),
-      field: field.value,
+      field,
     });
   },
 };
@@ -407,17 +393,7 @@ const operators = {
  */
 
 /**
- * @typedef {Values<{[k in keyof typeof operators] : ReturnType<typeof operators[k]>}>} Operator
- */
-
-/**
- * @typedef {Operators["count"] | Operators["avg"] | Operators["max"] | Operators["min"] | Operators["sum"] | Operators["groupArray"]} Aggregator
- */
-/**
- * @typedef {Operators["eq"] | Operators["neq"] | Operators["and"] | Operators["or"] | Operators["not"] | Operators["gt"] | Operators["gte"] | Operators["lt"] | Operators["lte"] | Operators["in"] | Operators["includes"] | Operators["some"] | Operators["glob"] | Operators["like"] | Operators["match"] | Operators["unsafeSql"]} BooleanOperator
- */
-/**
- * @typedef {Operators["abs"] | Operators["plus"] | Operators["minus"]} MathOperator
+ * @typedef {Values<{[k in keyof typeof operators] : ReturnType<typeof operators[k]>}>} Expression
  */
 
 module.exports = operators;

package/lib/optional-object-type.js

@@ -0,0 +1,38 @@
+/**
+ * @template {AnyTypeOrShape} T
+ * @typedef {T extends OptionType ? T : OptionType<T>} WrapOption
+ */
+
+const {toObjectType, OptionType, option} = require('xcraft-core-stones');
+
+/**
+ * @template {ObjectShape} T
+ * @typedef {{[K in keyof T]: WrapOption<T[K]>}} OptionalObjectShape
+ */
+
+/**
+ * @template {ObjectShape} T
+ * @param {ObjectType<T>} type
+ * @returns {ObjectType<OptionalObjectShape<T>>}
+ */
+function optionalObjectType(type) {
+  return type.map((subType) =>
+    subType instanceof OptionType ? subType : option(subType)
+  );
+}
+
+/**
+ * @template {AnyObjectShape} T
+ * @param {T} shape
+ * @returns {OptionalObjectShape<GetShape<T>>}
+ */
+function optionalObjectShape(shape) {
+  const type = toObjectType(shape);
+  const optionalType = optionalObjectType(type);
+  return optionalType.properties;
+}
+
+module.exports = {
+  optionalObjectType,
+  optionalObjectShape,
+};

package/lib/pick-operators.js

@@ -0,0 +1,128 @@
+/* eslint-disable jsdoc/require-returns */
+// @ts-check
+
+const {
+  array,
+  number,
+  boolean,
+  union,
+  UnionType,
+  any,
+} = require('xcraft-core-stones');
+const $o = require('./operators.js');
+const {
+  BasePick,
+  ValuePick,
+  BooleanPick,
+  NumberPick,
+  makePick,
+  ArrayPick,
+} = require('./picks.js');
+const {getPickOrValueType} = require('./pick-or-value.js');
+
+/**
+ * @typedef {import('./pick-or-value.js').PickOrValue} PickOrValue
+ */
+
+/**
+ * @template {PickOrValue} T
+ * @typedef {import('./pick-or-value.js').PickOrValueType<T>} PickOrValueType
+ */
+
+const pickOperators = {
+  ...$o,
+
+  /**
+   * @param {string} sql
+   */
+  unsafeSql(sql) {
+    return new BasePick(any, $o.unsafeSql(sql));
+  },
+
+  /**
+   * @param {BooleanPick} value
+   * @returns {BooleanPick}
+   */
+  not(value) {
+    return new BooleanPick(boolean, $o.not(value));
+  },
+
+  /**
+   * @param {BooleanPick[]} conditions
+   * @returns {BooleanPick}
+   */
+  and(...conditions) {
+    return new BooleanPick(boolean, $o.and(...conditions));
+  },
+
+  /**
+   * @param {BooleanPick[]} conditions
+   * @returns {BooleanPick}
+   */
+  or(...conditions) {
+    return new BooleanPick(boolean, $o.or(...conditions));
+  },
+
+  /**
+   * @template {PickOrValue} T
+   * @template {PickOrValue} U
+   * @param {BooleanPick} condition
+   * @param {T} a
+   * @param {U} b
+   * @returns {ValuePick<UnionType<[PickOrValueType<T>, PickOrValueType<U>]>>}
+   */
+  if(condition, a, b) {
+    const newType = union(getPickOrValueType(a), getPickOrValueType(b));
+    return new ValuePick(newType, $o.if(condition, a, b));
+  },
+
+  /**
+   * @param {BasePick} [field]
+   * @param {boolean} [distinct]
+   */
+  count(field, distinct) {
+    return new NumberPick(number, $o.count(field, distinct));
+  },
+
+  /**
+   * @param {NumberPick} field
+   */
+  avg(field) {
+    return new NumberPick(number, $o.avg(field));
+  },
+
+  /**
+   * @template {AnyTypeOrShape} T
+   * @param {ValuePick<T>} field
+   */
+  max(field) {
+    return makePick(field.type, $o.max(field));
+  },
+
+  /**
+   * @template {AnyTypeOrShape} T
+   * @param {ValuePick<T>} field
+   */
+  min(field) {
+    return makePick(field.type, $o.min(field));
+  },
+
+  /**
+   * @param {NumberPick} field
+   */
+  sum(field) {
+    return new NumberPick(number, $o.sum(field));
+  },
+
+  /**
+   * @template {AnyTypeOrShape} T
+   * @param {ValuePick<T>} field
+   */
+  groupArray(field) {
+    return new ArrayPick(array(field.type), $o.groupArray(field));
+  },
+};
+
+module.exports = {
+  pickOperators,
+};

package/lib/pick-or-value.js

@@ -0,0 +1,76 @@
+/* eslint-disable jsdoc/require-returns */
+// @ts-check
+
+const {
+  number,
+  NumberType,
+  string,
+  StringType,
+  boolean,
+  BooleanType,
+} = require('xcraft-core-stones');
+const {BasePick, makeTypePick} = require('./picks.js');
+const $o = require('./operators.js');
+
+/**
+ * @typedef {string | number | boolean} PickValue
+ */
+
+/**
+ * @typedef {BasePick<any> | PickValue} PickOrValue
+ */
+
+/**
+ * @template {PickValue} T
+ * @typedef {T extends boolean ? BooleanType : T extends number ? NumberType : T extends string ? StringType : never} GetValueType
+ */
+
+/**
+ * @template {PickOrValue} T
+ * @typedef {T extends BasePick<infer U> ? U : T extends PickValue ? GetValueType<T> : never} PickOrValueType
+ */
+
+/**
+ * @template {PickValue} T
+ * @param {T} value
+ * @returns {GetValueType<T>}
+ */
+function getValueType(value) {
+  if (typeof value === 'string') {
+    return /** @type {any} */ (string);
+  }
+  if (typeof value === 'number') {
+    return /** @type {any} */ (number);
+  }
+  if (typeof value === 'boolean') {
+    return /** @type {any} */ (boolean);
+  }
+  throw new Error('Unknown value type');
+}
+
+/**
+ * @template {PickOrValue} T
+ * @param {T} pickOrValue
+ * @returns {PickOrValueType<T>}
+ */
+function getPickOrValueType(pickOrValue) {
+  if (pickOrValue instanceof BasePick) {
+    return pickOrValue.type;
+  }
+  return /** @type {any} */ (getValueType(pickOrValue));
+}
+
+/**
+ * @template {PickValue} T
+ * @param {T} value
+ */
+function pickFromValue(value) {
+  const type = getValueType(value);
+  return makeTypePick(type, $o.value(value));
+}
+
+module.exports = {
+  getPickOrValueType,
+  getValueType,
+  pickFromValue,
+};