xcraft-core-pickaxe 0.1.26 → 0.1.29

package/lib/operator-to-sql.js

@@ -185,6 +185,23 @@ 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(' ');
+    if (!whenSql) {
+      return sql(elseValue, context);
+    }
+    return `CASE ${whenSql} ELSE ${sql(elseValue, context)} END`;
+  },
+
   abs({value}, context) {
     return `ABS(${sql(value, context)})`;
   },
@@ -229,7 +246,11 @@ const operators = {
 
   query({query}, context) {
     const {queryToSql} = require('./query-to-sql.js');
-    return `(${queryToSql(query, context.values).sql})`;
+    return `(${
+      queryToSql(query, context.values, {
+        useTableNames: context.useTableNames,
+      }).sql
+    })`;
   },
 
   each({value}, context) {
@@ -266,6 +287,14 @@ const operators = {
     return `${sql(value, context)} DESC`;
   },
 
+  nullsFirst({value}, context) {
+    return `${sql(value, context)} NULLS FIRST`;
+  },
+
+  nullsLast({value}, context) {
+    return `${sql(value, context)} NULLS LAST`;
+  },
+
   count({field, distinct}, context) {
     if (!field) {
       return `COUNT(*)`;
@@ -289,7 +318,13 @@ const operators = {
     return `SUM(${distinct ? 'DISTINCT ' : ''}${sql(field, context)})`;
   },
 
-  groupArray({field}, context) {
+  groupArray({field, orderBy}, context) {
+    if (orderBy) {
+      return `json_group_array(${sql(field, context)} ORDER BY ${sql(
+        orderBy,
+        context
+      )})`;
+    }
     return `json_group_array(${sql(field, context)})`;
   },
 };

package/lib/operators.js

@@ -206,14 +206,14 @@ const operators = {
   and(...conditions) {
     return /** @type {const} */ ({
       operator: 'and',
-      conditions,
+      conditions: conditions.map(op),
     });
   },
 
   or(...conditions) {
     return /** @type {const} */ ({
       operator: 'or',
-      conditions,
+      conditions: conditions.map(op),
     });
   },
 
@@ -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} */ ({
@@ -339,6 +350,20 @@ const operators = {
     });
   },
 
+  nullsFirst(value) {
+    return /** @type {const} */ ({
+      operator: 'nullsFirst',
+      value,
+    });
+  },
+
+  nullsLast(value) {
+    return /** @type {const} */ ({
+      operator: 'nullsLast',
+      value,
+    });
+  },
+
   count(field, distinct) {
     return /** @type {const} */ ({
       operator: 'count',
@@ -375,10 +400,11 @@ const operators = {
     });
   },
 
-  groupArray(field) {
+  groupArray(field, orderBy) {
     return /** @type {const} */ ({
       operator: 'groupArray',
       field,
+      orderBy,
     });
   },
 };

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

@@ -8,6 +8,8 @@ const {
   union,
   UnionType,
   any,
+  string,
+  StringType,
 } = require('xcraft-core-stones');
 const $o = require('./operators.js');
 const {
@@ -17,6 +19,7 @@ const {
   NumberPick,
   makePick,
   ArrayPick,
+  StringPick,
 } = require('./picks.js');
 const {getPickOrValueType} = require('./pick-or-value.js');
 
@@ -29,6 +32,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,
 
@@ -48,7 +56,7 @@ const pickOperators = {
   },
 
   /**
-   * @param {BooleanPick[]} conditions
+   * @param {(BooleanPick | boolean)[]} conditions
    * @returns {BooleanPick}
    */
   and(...conditions) {
@@ -56,7 +64,7 @@ const pickOperators = {
   },
 
   /**
-   * @param {BooleanPick[]} conditions
+   * @param {(BooleanPick | boolean)[]} conditions
    * @returns {BooleanPick}
    */
   or(...conditions) {
@@ -76,6 +84,55 @@ 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));
+  },
+
+  /**
+   * @template {StringPick | string} T
+   * @typedef {T extends StringPick<infer U> ? U : T} StringValue
+   */
+
+  /**
+   * @template {(StringPick | string)[]} T
+   * @typedef {{[K in keyof T]: StringValue<T[K]>}} StringValues
+   */
+
+  /**
+   * @template {string[]} T
+   * @typedef {T extends [infer First extends string, ...infer Rest extends string[]] ?  `${First}${ConcatStringLiterals<Rest>}`: ''} ConcatStringLiterals
+   */
+
+  /**
+   * @template {(StringPick | string)[]} T
+   * @param {T} values
+   * @returns {StringPick<ConcatStringLiterals<StringValues<T>>>}
+   */
+  stringConcat(...values) {
+    const type = /** @type {StringType<ConcatStringLiterals<StringValues<T>>>} */ (string);
+    return new StringPick(type, $o.stringConcat(...values));
+  },
+
   /**
    * @param {BasePick} [field]
    * @param {boolean} [distinct]
@@ -117,9 +174,10 @@ const pickOperators = {
   /**
    * @template {AnyTypeOrShape} T
    * @param {ValuePick<T>} field
+   * @param {BasePick} [orderBy]
    */
-  groupArray(field) {
-    return new ArrayPick(array(field.type), $o.groupArray(field));
+  groupArray(field, orderBy) {
+    return new ArrayPick(array(field.type), $o.groupArray(field, orderBy));
   },
 };
 

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));
+  }
 }
 
 /**
@@ -430,6 +438,53 @@ class ArrayPick extends BasePick {
     );
   }
 
+  /**
+   * @param {(value: PickOf<T>) => BooleanPick} func
+   */
+  filter(func) {
+    return new ArrayPick(
+      this.type,
+      $o.query({
+        from: $o.each(this.expression),
+        select: [$o.groupArray($o.eachValue())],
+        where: func(makePick(this.type.valuesType, $o.eachValue())),
+      })
+    );
+  }
+
+  /**
+   * @template {AnyTypeOrShape} U
+   * @param {(value: PickOf<T>) => BasePick<U>} func
+   */
+  map(func) {
+    const newValuePick = func(makePick(this.type.valuesType, $o.eachValue()));
+    return new ArrayPick(
+      array(newValuePick.type),
+      $o.query({
+        from: $o.each(this.expression),
+        select: [$o.groupArray(newValuePick)],
+      })
+    );
+  }
+
+  /**
+   * @param {(value: PickOf<T>) => BasePick} [func]
+   */
+  sort(func = (pick) => pick) {
+    return new ArrayPick(
+      this.type,
+      $o.query({
+        from: $o.each(this.expression),
+        select: [
+          $o.groupArray(
+            $o.eachValue(),
+            func(makePick(this.type.valuesType, $o.eachValue()))
+          ),
+        ],
+      })
+    );
+  }
+
   /**
    * @param {(value: PickOf<T>) => BooleanPick} func
    */
@@ -467,22 +522,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 +543,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 +572,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, {object: 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/lib/query-to-sql.js

@@ -122,15 +122,17 @@ function groupByFields(groupBy, context) {
 /**
  * @param {QueryObj} query
  * @param {any[] | null} [values]
+ * @param {Partial<ExpressionToSqlContext>} [options]
  * @returns {{sql: string, values: any[] | null}}
  */
-function queryToSql(query, values = []) {
+function queryToSql(query, values = [], options = {}) {
   /** @type {ExpressionToSqlContext} */
   const context = {
     values,
     scope: query.scope,
     useTableNames: query.joins && query.joins.length > 0,
     equalOperator: 'IS',
+    ...options,
   };
   const explain = query.explain ? 'EXPLAIN QUERY PLAN\n' : '';
   const withs = withSql(query.withs, context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xcraft-core-pickaxe",
-  "version": "0.1.26",
+  "version": "0.1.29",
   "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)