xcraft-core-pickaxe 0.1.27 → 0.1.30

package/lib/operator-to-sql.js

@@ -3,6 +3,7 @@
 const {isAnyPick, BasePick} = require('./picks.js');
 
 /**
+ * @typedef {import("./query-builder.js").DbTable} DbTable
  * @typedef {import("./operators.js").Expression} Expression
  */
 
@@ -103,6 +104,14 @@ const operators = {
     return `LENGTH(${sql(value, context)})`;
   },
 
+  lower({value}, context) {
+    return `LOWER(${sql(value, context)})`;
+  },
+
+  upper({value}, context) {
+    return `UPPER(${sql(value, context)})`;
+  },
+
   substr({value, start, length}, context) {
     const valueSql = sql(value, context);
     const startSql = sql(start, context);
@@ -192,11 +201,14 @@ const operators = {
         if (!conditionSql) {
           return '';
         }
-        return `WHEN (${conditionSql}) THEN (${sql(value, context)})`;
+        return `WHEN (${conditionSql}) THEN ${sql(value, context)}`;
       })
       .filter(Boolean)
       .join(' ');
-    return `CASE ${whenSql} ELSE (${sql(elseValue, context)}) END`;
+    if (!whenSql) {
+      return sql(elseValue, context);
+    }
+    return `CASE ${whenSql} ELSE ${sql(elseValue, context)} END`;
   },
 
   abs({value}, context) {
@@ -243,7 +255,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) {
@@ -280,6 +296,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(*)`;
@@ -303,7 +327,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)})`;
   },
 };
@@ -322,6 +352,7 @@ function getExpression(expressionOrPick) {
 /**
  * @typedef {{
  *   values: any[] | null,
+ *   tablesUsed: DbTable[],
  *   scope?: any,
  *   useTableNames?: boolean,
  *   equalOperator: 'IS' | '=',
@@ -345,6 +376,7 @@ function sql(expressionOrPick, context) {
 function expressionToSql(operator) {
   const context = {
     values: [],
+    tablesUsed: [],
   };
   return {
     sql: sql(operator, context),

package/lib/operators.js

@@ -90,6 +90,20 @@ const operators = {
     });
   },
 
+  lower(value) {
+    return /** @type {const} */ ({
+      operator: 'lower',
+      value: op(value),
+    });
+  },
+
+  upper(value) {
+    return /** @type {const} */ ({
+      operator: 'upper',
+      value: op(value),
+    });
+  },
+
   substr(value, start, length) {
     value = op(value);
     start = op(start);
@@ -206,14 +220,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),
     });
   },
 
@@ -350,6 +364,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',
@@ -386,10 +414,11 @@ const operators = {
     });
   },
 
-  groupArray(field) {
+  groupArray(field, orderBy) {
     return /** @type {const} */ ({
       operator: 'groupArray',
       field,
+      orderBy,
     });
   },
 };

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');
 
@@ -53,7 +56,7 @@ const pickOperators = {
   },
 
   /**
-   * @param {BooleanPick[]} conditions
+   * @param {(BooleanPick | boolean)[]} conditions
    * @returns {BooleanPick}
    */
   and(...conditions) {
@@ -61,7 +64,7 @@ const pickOperators = {
   },
 
   /**
-   * @param {BooleanPick[]} conditions
+   * @param {(BooleanPick | boolean)[]} conditions
    * @returns {BooleanPick}
    */
   or(...conditions) {
@@ -105,6 +108,31 @@ const pickOperators = {
     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]
@@ -146,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/picks.js

@@ -86,6 +86,14 @@ class ValuePick extends BasePick {
     super(type, expression);
   }
 
+  /**
+   * @template {AnyTypeOrShape} T
+   * @param {T} type
+   */
+  as(type) {
+    return makePick(type, this.expression);
+  }
+
   /**
    * @template {AnyObjectShape} T
    * @param {T} shape
@@ -179,6 +187,14 @@ class StringPick extends ValuePick {
     return new NumberPick(number, $o.stringLength(this.expression));
   }
 
+  lower() {
+    return new StringPick(this.type, $o.lower(this.expression));
+  }
+
+  upper() {
+    return new StringPick(this.type, $o.upper(this.expression));
+  }
+
   /**
    * @param {number | BasePick<NumberType>} start
    * @param {number | BasePick<NumberType>} [length]
@@ -438,6 +454,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
    */

package/lib/query-builder.js

@@ -1,5 +1,6 @@
 // @ts-check
 
+const path = require('node:path');
 const {
   ObjectType,
   ArrayType,
@@ -43,11 +44,15 @@ const partialObjectShape = require('./partial-object-shape.js');
  */
 
 /**
- * @typedef {{db?: string, table: string, alias?: string} | {db?: undefined, table: Subquery, alias?: string}} TableAndAlias
+ * @typedef {{db?: string, dbId?: string, table: string, alias?: string}} DbTable
  */
 
 /**
- * @typedef {string | Subquery | TableAndAlias} QueryTable
+ * @typedef {{db?: undefined, dbId?: undefined, table: Subquery, alias?: string}} SubqueryAndAlias
+ */
+
+/**
+ * @typedef {string | Subquery | DbTable | SubqueryAndAlias} QueryTable
  */
 
 /**
@@ -55,6 +60,7 @@ const partialObjectShape = require('./partial-object-shape.js');
  * @template {AnyObjectShape} U
  * @typedef {{
  *   db?: string,
+ *   dbId?: string,
  *   table: string,
  *   alias?: string,
  *   shape?: T,
@@ -281,9 +287,15 @@ function getTableName(table) {
  * @template {AnyObjectShape} T
  * @param {AnyTableSchema} tableSchema
  * @param {T} shape
- * @returns {{pick: RowPick<GetShape<T>>, condition: BooleanPick | null}}
+ * @returns {{table: DbTable, pick: RowPick<GetShape<T>>, condition: BooleanPick | null}}
  */
 function useTableSchema(tableSchema, shape) {
+  const table = {
+    db: tableSchema.db,
+    dbId: tableSchema.dbId,
+    table: tableSchema.table,
+    alias: tableSchema.alias,
+  };
   const type = toObjectType(shape);
   const tableName = getTableName(tableSchema);
   let pick = rowPick(type, tableName);
@@ -295,7 +307,7 @@ function useTableSchema(tableSchema, shape) {
     }
     pick = tableSchema.scope(basePick).toRowPick();
   }
-  return {pick, condition};
+  return {table, pick, condition};
 }
 
 /**
@@ -456,6 +468,15 @@ class FinalQuery {
     return queryToSql(this.#queryParts, null).sql;
   }
 
+  json() {
+    const {sql, values, tables} = queryToSql(this.#queryParts);
+    return {sql, values, tables};
+  }
+
+  getMapRow() {
+    return this.#getMapRow();
+  }
+
   /**
    * @returns {R | undefined}
    */
@@ -693,14 +714,14 @@ class FromQuery {
    */
   _join(joinOperator, tableName, shape, joinFct, mergePicks) {
     const tableSchema = this.#getTableSchema(tableName, shape);
-    const {pick, condition} = useTableSchema(tableSchema, shape);
+    const {table, pick, condition} = useTableSchema(tableSchema, shape);
 
     const joinCondition = joinFct(...this.#picks, pick, pickOperators);
     const queryParts = {
       ...this.#queryParts,
       joins: mergeJoin(this.#queryParts.joins, {
         operator: joinOperator,
-        table: tableSchema,
+        table,
         constraint: condition
           ? pickOperators.and(condition, joinCondition)
           : joinCondition,
@@ -845,7 +866,7 @@ class FromQuery {
   }
 
   /**
-   * @returns {SelectQuery<T, T[number]>}
+   * @returns {SelectQuery<T, {object: T[number]}>}
    */
   selectAll() {
     const isRoot = this.#picks.every((pick) => pick.isRoot());
@@ -945,12 +966,11 @@ class QueryBuilder {
    */
   from(tableName, shape) {
     const tableSchema = this.#getTableSchema(tableName, shape);
-    const from = tableSchema;
+    const {table, pick, condition} = useTableSchema(tableSchema, shape);
     const queryParts = {
-      from,
+      from: table,
       withs: this.#withs,
     };
-    const {pick, condition} = useTableSchema(tableSchema, shape);
     if (condition) {
       queryParts.where = condition;
     }
@@ -966,4 +986,5 @@ class QueryBuilder {
 module.exports = {
   QueryBuilder,
   FromQuery,
+  FinalQuery,
 };

package/lib/query-to-sql.js

@@ -1,5 +1,6 @@
 // @ts-check
 /**
+ * @typedef {import("./query-builder.js").DbTable} DbTable
  * @typedef {import("./query-builder.js").QueryObj} QueryObj
  * @typedef {import("./operator-to-sql.js").ExpressionToSqlContext} ExpressionToSqlContext
  */
@@ -21,7 +22,8 @@ function withSql(withs, context) {
     .map(({name, query}) => {
       let sql = '';
       sql += `${name} AS (\n`;
-      sql += queryToSql(query, context.values).sql;
+      sql += queryToSql(query, context.values, {tablesUsed: context.tablesUsed})
+        .sql;
       sql += '\n)';
       return sql;
     })
@@ -37,6 +39,7 @@ function withSql(withs, context) {
 function tableSql(table, context) {
   // Note: table is not validated
   if (typeof table === 'string') {
+    context.tablesUsed.push({table});
     return table;
   }
   if (!('table' in table)) {
@@ -44,6 +47,7 @@ function tableSql(table, context) {
   }
   let resultSql = '';
   if (typeof table.table === 'string') {
+    context.tablesUsed.push(table);
     if (typeof table.db === 'string') {
       resultSql += `${table.db}.`;
     }
@@ -122,15 +126,18 @@ function groupByFields(groupBy, context) {
 /**
  * @param {QueryObj} query
  * @param {any[] | null} [values]
- * @returns {{sql: string, values: any[] | null}}
+ * @param {Partial<ExpressionToSqlContext>} [options]
+ * @returns {{sql: string, values: any[] | null, tables: DbTable[]}}
  */
-function queryToSql(query, values = []) {
+function queryToSql(query, values = [], options = {}) {
   /** @type {ExpressionToSqlContext} */
   const context = {
     values,
+    tablesUsed: [],
     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);
@@ -167,7 +174,7 @@ function queryToSql(query, values = []) {
     }
     result += '\n' + `OFFSET ${query.offset}`;
   }
-  return {sql: result, values};
+  return {sql: result, values, tables: context.tablesUsed};
 }
 
 module.exports = {

package/package.json

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

package/test/sql.spec.js

@@ -412,9 +412,9 @@ describe('xcraft.pickaxe', function () {
         id,
         (firstname || lastname) AS fullname,
         CASE
-          WHEN age < 13 THEN 'kid'
-          WHEN age < 18 THEN 'teenager'
-          WHEN age < 65 THEN 'adult'
+          WHEN (age < 13) THEN 'kid'
+          WHEN (age < 18) THEN 'teenager'
+          WHEN (age < 65) THEN 'adult'
           ELSE 'elder'
         END AS kind
       FROM test_table