xcraft-core-pickaxe 0.1.26 → 0.1.27

package/lib/operator-to-sql.js

@@ -185,6 +185,20 @@ const operators = {
     )})`;
   },
 
+  case({whenConditions, elseValue}, context) {
+    const whenSql = whenConditions
+      .map(([condition, value]) => {
+        const conditionSql = sql(condition, context);
+        if (!conditionSql) {
+          return '';
+        }
+        return `WHEN (${conditionSql}) THEN (${sql(value, context)})`;
+      })
+      .filter(Boolean)
+      .join(' ');
+    return `CASE ${whenSql} ELSE (${sql(elseValue, context)}) END`;
+  },
+
   abs({value}, context) {
     return `ABS(${sql(value, context)})`;
   },

package/lib/operators.js

@@ -234,6 +234,17 @@ const operators = {
     });
   },
 
+  case(whenConditions, elseValue) {
+    return /** @type {const} */ ({
+      operator: 'case',
+      whenConditions: whenConditions.map(([condition, value]) => [
+        op(condition),
+        op(value),
+      ]),
+      elseValue: op(elseValue),
+    });
+  },
+
   abs(value) {
     value = op(value);
     return /** @type {const} */ ({

package/lib/partial-object-shape.js

@@ -0,0 +1,17 @@
+const {ObjectType} = require('xcraft-core-stones');
+
+/**
+ * @template {ObjectType} T
+ * @template {(keyof T["properties"])[]} F
+ * @param {T} objectType
+ * @param {F} fields
+ * @returns {Pick<T["properties"], F[number]>}
+ */
+function partialObjectShape(objectType, fields) {
+  const properties = objectType.properties;
+  return /** @type {Pick<T["properties"], F[number]>} */ (Object.fromEntries(
+    fields.map((fieldName) => [fieldName, properties[fieldName]])
+  ));
+}
+
+module.exports = partialObjectShape;

package/lib/pick-operators.js

@@ -29,6 +29,11 @@ const {getPickOrValueType} = require('./pick-or-value.js');
  * @typedef {import('./pick-or-value.js').PickOrValueType<T>} PickOrValueType
  */
 
+/**
+ * @template {PickOrValue[]} T
+ * @typedef {{[K in keyof T]: PickOrValueType<T[K]>}} PickOrValueTypes
+ */
+
 const pickOperators = {
   ...$o,
 
@@ -76,6 +81,30 @@ const pickOperators = {
     return new ValuePick(newType, $o.if(condition, a, b));
   },
 
+  /**
+   * @template {PickOrValue[]} T
+   * @typedef {{[K in keyof T]: [BooleanPick | boolean, T[K]]}} CaseConditions
+   */
+
+  /**
+   * @template {[PickOrValue, ...PickOrValue[]]} T
+   * @template {PickOrValue} U
+   * @param {[...CaseConditions<T>, U]} conditions
+   * @returns {ValuePick<UnionType<[...PickOrValueTypes<T>, PickOrValueType<U>]>>}
+   */
+  case(...conditions) {
+    const whenConditions = /** @type {CaseConditions<T>} */ (
+      //
+      conditions.slice(0, -1)
+    );
+    const whenTypes = /** @type {PickOrValueTypes<T>} */ (whenConditions.map(
+      (condition) => getPickOrValueType(condition[1])
+    ));
+    const elseValue = /** @type {U} */ (conditions.at(-1));
+    const newType = union(...whenTypes, getPickOrValueType(elseValue));
+    return new ValuePick(newType, $o.case(whenConditions, elseValue));
+  },
+
   /**
    * @param {BasePick} [field]
    * @param {boolean} [distinct]

package/lib/pick-or-value.js

@@ -6,6 +6,7 @@ const {
   NumberType,
   string,
   StringType,
+  ValueType,
   boolean,
   BooleanType,
 } = require('xcraft-core-stones');
@@ -13,7 +14,7 @@ const {BasePick, makeTypePick} = require('./picks.js');
 const $o = require('./operators.js');
 
 /**
- * @typedef {string | number | boolean} PickValue
+ * @typedef {string | number | boolean | null} PickValue
  */
 
 /**
@@ -22,7 +23,7 @@ const $o = require('./operators.js');
 
 /**
  * @template {PickValue} T
- * @typedef {T extends boolean ? BooleanType : T extends number ? NumberType : T extends string ? StringType : never} GetValueType
+ * @typedef {T extends boolean ? BooleanType : T extends number ? NumberType : T extends string ? StringType<T> : T extends null ? ValueType<null> : never} GetValueType
  */
 
 /**
@@ -45,6 +46,9 @@ function getValueType(value) {
   if (typeof value === 'boolean') {
     return /** @type {any} */ (boolean);
   }
+  if (value === null) {
+    return /** @type {any} */ (new ValueType(null));
+  }
   throw new Error('Unknown value type');
 }
 

package/lib/picks.js

@@ -186,6 +186,14 @@ class StringPick extends ValuePick {
   substr(start, length) {
     return new StringPick(string, $o.substr(this.expression, start, length));
   }
+
+  /**
+   * @param {(StringPick | string)[]} values
+   * @returns {StringPick}
+   */
+  concat(...values) {
+    return new StringPick(string, $o.stringConcat(this.expression, ...values));
+  }
 }
 
 /**
@@ -467,22 +475,19 @@ function isAnyPick(value) {
  * @extends {BasePick<ObjectType<T>>}
  */
 class RowPick extends BasePick {
-  /**
-   * @type {string | null}
-   */
-  #tableName = null;
+  #context;
 
   /**
    * @param {ObjectType<T>} type
-   * @param {{expression: Expression} | {tableName: string}} context
+   * @param {{expression: Expression} | {tableName: string} | null} context
    */
   constructor(type, context) {
-    if ('expression' in context) {
+    if (context && 'expression' in context) {
       super(type, context.expression);
     } else {
       super(type, null);
-      this.#tableName = context.tableName;
     }
+    this.#context = context;
   }
 
   /**
@@ -491,10 +496,16 @@ class RowPick extends BasePick {
    * @returns {PickOf<T[K]>}
    */
   field(fieldName) {
-    if (this.#tableName) {
+    if (!this.#context) {
       return makePick(
         this.type.properties[fieldName],
-        $o.field(fieldName, this.#tableName)
+        $o.field(fieldName, null)
+      );
+    }
+    if ('tableName' in this.#context) {
+      return makePick(
+        this.type.properties[fieldName],
+        $o.field(fieldName, this.#context.tableName)
       );
     }
     return makePick(
@@ -514,16 +525,11 @@ class RowPick extends BasePick {
   }
 
   isRoot() {
-    return Boolean(this.#tableName);
+    return Boolean(!this.#context || 'tableName' in this.#context);
   }
 
   toOptional() {
-    return new RowPick(
-      optionalObjectType(this.type),
-      this.#tableName
-        ? {tableName: this.#tableName}
-        : {expression: this.expression}
-    );
+    return new RowPick(optionalObjectType(this.type), this.#context);
   }
 }
 

package/lib/query-builder.js

@@ -22,6 +22,7 @@ const {
 } = require('./picks.js');
 const {joinOperators} = require('./join-operators.js');
 const {queryToSql} = require('./query-to-sql.js');
+const partialObjectShape = require('./partial-object-shape.js');
 
 /**
  * @typedef {import("./operators.js").Operators} Operators
@@ -74,18 +75,108 @@ const {queryToSql} = require('./query-to-sql.js');
  */
 
 /**
- * @typedef {BasePick} SelectValue
+ * @template {BasePick} T
+ * @typedef {T["type"]} PickType
  */
 /**
- * @template T
- * @typedef {T extends SelectValue ? T["type"]: never} SelectValueType
+ * @typedef {[BasePick, ...BasePick[]]} SelectPicksTuple
+ * @typedef {Record<string, BasePick>} SelectPicksObject
  */
 /**
- * @typedef {Record<string, SelectValue> | [SelectValue, ...SelectValue[]]} SelectResult
+ * @typedef {SelectPicksObject | SelectPicksTuple} SelectPicks
  */
+
+/**
+ * @template {SelectPicksTuple} T
+ * @typedef {{[K in keyof T]: PickType<T[K]>}} SelectTypeTuple
+ */
+/**
+ * @template {SelectPicksTuple} T
+ * @param {T} selectPicks
+ * @returns {SelectTypeTuple<T>}
+ */
+function selectTypeTuple(selectPicks) {
+  return /** @type {SelectTypeTuple<T>} */ (selectPicks.map(
+    (result) => result.type
+  ));
+}
+
+/**
+ * @template {SelectPicksObject} T
+ * @typedef {flatten<{[K in keyof T]: PickType<T[K]>}>} SelectTypeObject
+ */
+/**
+ * @template {SelectPicksObject} T
+ * @param {T} selectPicks
+ * @returns {SelectTypeObject<T>}
+ */
+function selectTypeObject(selectPicks) {
+  return /** @type {SelectTypeObject<T>} */ (Object.fromEntries(
+    Object.entries(selectPicks).map(([name, pick]) => [name, pick.type])
+  ));
+}
+
+/**
+ * @template {SelectPicks} T
+ * @typedef {T extends SelectPicksTuple ? {values: SelectTypeTuple<T>} : T extends SelectPicksObject ? {object: SelectTypeObject<T>} : never} SelectResultOf
+ */
+/**
+ * @template {SelectPicks} T
+ * @param {T} selectPicks
+ * @returns {SelectResultOf<T>}
+ */
+function selectResultOf(selectPicks) {
+  if (Array.isArray(selectPicks)) {
+    return /** @type {SelectResultOf<T>} */ ({
+      values: selectTypeTuple(selectPicks),
+    });
+  }
+  return /** @type {SelectResultOf<T>} */ ({
+    object: selectTypeObject(selectPicks),
+  });
+}
+
+/**
+ * @typedef {{value: AnyTypeOrShape}} SelectResultValue
+ * @typedef {{values: [AnyTypeOrShape, ...AnyTypeOrShape[]]}} SelectResultValues
+ * @typedef {{object: Record<string, AnyTypeOrShape>}} SelectResultObject
+ */
+
+/**
+ * @typedef {SelectResultValue | SelectResultValues | SelectResultObject} SelectResult
+ */
+
+/**
+ * @template {SelectResult} T
+ * @typedef {T extends SelectResultObject ? RowPick<T['object']> : null} SelectResultPick
+ */
+
 /**
  * @template {SelectResult} T
- * @typedef {{[K in keyof T]: t<SelectValueType<T[K]>>}} QueryResultOf
+ * @param {T} selectResult
+ * @returns {SelectResultPick<T>}
+ */
+function selectResultPick(selectResult) {
+  if ('object' in selectResult) {
+    const rowPick = new RowPick(object(selectResult.object), null);
+    return /** @type {SelectResultPick<T>} */ (rowPick);
+  }
+  return /** @type {SelectResultPick<T>} */ (null);
+}
+
+/**
+ * @template {SelectResultValues['values']} T
+ * @typedef {{[K in keyof T]: t<T[K]>}} QueryReturnValues
+ */
+
+/**
+ * @template {SelectResultObject['object']} T
+ * @typedef {flatten<{[K in keyof T]: t<T[K]>}>} QueryReturnObject
+ */
+
+/**
+ * @template {SelectResult} T
+ * @typedef {T extends SelectResultValue ? t<T['value']> : T extends SelectResultValues ? QueryReturnValues<T['values']> : T extends SelectResultObject ? QueryReturnObject<T['object']> : never} QueryReturn
  */
 
 /**
@@ -157,6 +248,12 @@ function getTableName(table) {
  * @typedef {[...objs: WrapRowPick<T>, operators: typeof pickOperators]} FctArgs
  */
 
+/**
+ * @template {[...ObjectShape[], ObjectShape]} T
+ * @template {SelectResult} Q
+ * @typedef {[...objs: WrapRowPick<T>, operators: typeof pickOperators, selectFields: SelectResultPick<Q>]} FctArgs2
+ */
+
 /**
  * @typedef {{
  *   explain?: boolean,
@@ -164,7 +261,7 @@ function getTableName(table) {
  *   from: QueryTable,
  *   scope?: ObjectPick<any>
  *   joins?: JoinsResult[],
- *   select: SelectResult | '*',
+ *   select: SelectPicks | '*',
  *   selectOneField?: boolean,
  *   distinct?: boolean,
  *   where?: BooleanPick,
@@ -426,23 +523,26 @@ class FinalQuery {
 
 /**
  * @template {[...ObjectShape[], ObjectShape]} T
- * @template R
- * @extends {FinalQuery<R>}
+ * @template {SelectResult} S
+ * @extends {FinalQuery<QueryReturn<S>>}
  */
 class SelectQuery extends FinalQuery {
   #database;
   #picks;
+  #selectPick;
   #queryParts;
 
   /**
    * @param {WrapRowPick<T>} picks
+   * @param {SelectResultPick<S>} selectPick
    * @param {QueryParts<'from' | 'select'>} queryParts
    * @param {*} database
    */
-  constructor(picks, queryParts, database) {
+  constructor(picks, selectPick, queryParts, database) {
     super(database, queryParts);
     this.#database = database;
     this.#picks = picks;
+    this.#selectPick = selectPick;
     this.#queryParts = queryParts;
   }
 
@@ -451,77 +551,107 @@ class SelectQuery extends FinalQuery {
   }
 
   /**
-   * @returns {SelectQuery<T,R>}
+   * @returns {SelectQuery<T,S>}
    */
   distinct() {
     const queryParts = {
       ...this.#queryParts,
       distinct: true,
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    return new SelectQuery(
+      this.#picks,
+      this.#selectPick,
+      queryParts,
+      this.#database
+    );
   }
 
   /**
-   * @param {(...args: FctArgs<T>) => BooleanPick} fct
-   * @returns {SelectQuery<T,R>}
+   * @param {(...args: FctArgs2<T,S>) => BooleanPick} fct
+   * @returns {SelectQuery<T,S>}
    */
   where(fct) {
     const queryParts = {
       ...this.#queryParts,
       where: mergeWhere(
         this.#queryParts.where,
-        fct(...this.#picks, pickOperators)
+        fct(...this.#picks, pickOperators, this.#selectPick)
       ),
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    return new SelectQuery(
+      this.#picks,
+      this.#selectPick,
+      queryParts,
+      this.#database
+    );
   }
 
   /**
-   * @param {(...args: FctArgs<T>) => OrderByResult} fct
-   * @returns {SelectQuery<T,R>}
+   * @param {(...args: FctArgs2<T,S>) => OrderByResult} fct
+   * @returns {SelectQuery<T,S>}
    */
   orderBy(fct) {
     const queryParts = {
       ...this.#queryParts,
-      orderBy: fct(...this.#picks, pickOperators),
+      orderBy: fct(...this.#picks, pickOperators, this.#selectPick),
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    return new SelectQuery(
+      this.#picks,
+      this.#selectPick,
+      queryParts,
+      this.#database
+    );
   }
 
   /**
-   * @param {(...args: FctArgs<T>) => GroupByResult} fct
-   * @returns {SelectQuery<T,R>}
+   * @param {(...args: FctArgs2<T,S>) => GroupByResult} fct
+   * @returns {SelectQuery<T,S>}
    */
   groupBy(fct) {
     const queryParts = {
       ...this.#queryParts,
-      groupBy: fct(...this.#picks, pickOperators),
+      groupBy: fct(...this.#picks, pickOperators, this.#selectPick),
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    return new SelectQuery(
+      this.#picks,
+      this.#selectPick,
+      queryParts,
+      this.#database
+    );
   }
 
   /**
    * @param {number} count
-   * @returns {SelectQuery<T,R>}
+   * @returns {SelectQuery<T,S>}
    */
   limit(count) {
     const queryParts = {
       ...this.#queryParts,
       limit: count,
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    return new SelectQuery(
+      this.#picks,
+      this.#selectPick,
+      queryParts,
+      this.#database
+    );
   }
 
   /**
    * @param {number} count
-   * @returns {SelectQuery<T,R>}
+   * @returns {SelectQuery<T,S>}
    */
   offset(count) {
     const queryParts = {
       ...this.#queryParts,
       offset: count,
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    return new SelectQuery(
+      this.#picks,
+      this.#selectPick,
+      queryParts,
+      this.#database
+    );
   }
 }
 
@@ -587,12 +717,6 @@ class FromQuery {
     );
   }
 
-  /**
-   * @template {AnyObjectShape} U
-   * @template {[...ObjectShape[], ObjectShape]} V
-   * @typedef {(tableName: string, shape: U, joinFct: (...args: FctArgs<AllShapes<T,U>>) => BooleanPick) => FromQuery<V>} JoinFunction
-   */
-
   /**
    * @template {AnyObjectShape} U
    * @param {string} tableName
@@ -672,7 +796,7 @@ class FromQuery {
    * Select field
    * @template {keyof (T[0])} F
    * @param {F} field
-   * @returns {SelectQuery<T, t<T[0][F]>>}
+   * @returns {SelectQuery<T, {value: T[0][F]}>}
    */
   field(field) {
     /** @type {RowPick<T[0]>} */
@@ -682,14 +806,14 @@ class FromQuery {
       select: {[field]: row.field(field)},
       selectOneField: true,
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    return new SelectQuery(this.#picks, null, queryParts, this.#database);
   }
 
   /**
    * Select fields
    * @template {(keyof T[0])[]} F
    * @param {F} fields
-   * @returns {SelectQuery<T, t<Pick<T[0], F[number]>>>}
+   * @returns {SelectQuery<T, {object: Pick<T[0], F[number]>}>}
    */
   fields(fields) {
     /** @type {RowPick<T[0]>} */
@@ -700,43 +824,43 @@ class FromQuery {
         fields.map((fieldName) => [fieldName, row.field(fieldName)])
       ),
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    const shape = partialObjectShape(row.type, fields);
+    const selectPick = selectResultPick({object: shape});
+    return new SelectQuery(this.#picks, selectPick, queryParts, this.#database);
   }
 
   /**
-   * @template {SelectResult} R
-   * @param {(...args: FctArgs<T>) => R} fct
-   * @returns {SelectQuery<T, QueryResultOf<R>>}
+   * @template {SelectPicks} U
+   * @param {(...args: FctArgs<T>) => U} fct
+   * @returns {SelectQuery<T, SelectResultOf<U>>}
    */
   select(fct) {
+    const selectPicks = fct(...this.#picks, pickOperators);
     const queryParts = {
       ...this.#queryParts,
-      select: fct(...this.#picks, pickOperators),
+      select: selectPicks,
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    const selectPick = selectResultPick(selectResultOf(selectPicks));
+    return new SelectQuery(this.#picks, selectPick, queryParts, this.#database);
   }
 
   /**
-   * @returns {SelectQuery<T, t<T[number]>>}
+   * @returns {SelectQuery<T, T[number]>}
    */
   selectAll() {
     const isRoot = this.#picks.every((pick) => pick.isRoot());
-    /** @type {QueryObj["select"]} */
-    let select;
-    if (isRoot) {
-      select = '*';
-    } else {
-      select = Object.fromEntries(
-        this.#picks.flatMap((pick) =>
-          Object.keys(pick.type.properties).map((key) => [key, pick.get(key)])
-        )
-      );
-    }
+    const selectPicks = Object.fromEntries(
+      this.#picks.flatMap((pick) =>
+        Object.keys(pick.type.properties).map((key) => [key, pick.get(key)])
+      )
+    );
     const queryParts = {
       ...this.#queryParts,
-      select,
+      select: isRoot ? /** @type {const} */ ('*') : selectPicks,
     };
-    return new SelectQuery(this.#picks, queryParts, this.#database);
+    /** @type {RowPick<T[number]>} */
+    const selectPick = selectResultPick(selectResultOf(selectPicks));
+    return new SelectQuery(this.#picks, selectPick, queryParts, this.#database);
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xcraft-core-pickaxe",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "Query builder",
   "main": "index.js",
   "scripts": {

package/test/sql.spec.js

@@ -388,6 +388,45 @@ describe('xcraft.pickaxe', function () {
     expect(trimSql(result.sql)).to.be.equal(trimSql(sql));
   });
 
+  it('reuse selected value', function () {
+    const builder = new QueryBuilder()
+      .from('test_table', TestUserShape)
+      .select((user, $) => ({
+        id: user.get('id'),
+        fullname: user.get('firstname').concat(user.get('lastname')),
+        kind: $.case(
+          [user.get('age').lt(13), 'kid'],
+          [user.get('age').lt(18), 'teenager'],
+          [user.get('age').lt(65), 'adult'],
+          'elder'
+        ),
+      }))
+      .where((user, $, fields) =>
+        $.or(fields.get('fullname').length.gt(10), fields.get('kind').eq('kid'))
+      );
+
+    const result = queryToSql(builder.query, null);
+
+    const sql = `
+      SELECT
+        id,
+        (firstname || lastname) AS fullname,
+        CASE
+          WHEN age < 13 THEN 'kid'
+          WHEN age < 18 THEN 'teenager'
+          WHEN age < 65 THEN 'adult'
+          ELSE 'elder'
+        END AS kind
+      FROM test_table
+      WHERE (
+        LENGTH(fullname) > 10 OR
+        kind IS 'kid'
+      )
+    `;
+
+    expect(trimSql(result.sql)).to.be.equal(trimSql(sql));
+  });
+
   it('join tables', function () {
     const builder = new QueryBuilder()
       .from('users', TestUserShape)