xcraft-core-pickaxe 0.1.0 → 0.1.1

package/lib/examples.js

@@ -9,6 +9,7 @@ const {
   dateTime,
   any,
   value,
+  record,
 } = require('xcraft-core-stones');
 const $ = require('./operators.js');
 const {queryToSql} = require('./query-to-sql.js');
@@ -24,6 +25,7 @@ class TestUserShape {
     streetName = string;
     townName = string;
   };
+  skills = record(string, number);
 }
 
 const TestUserShape2 = {
@@ -110,21 +112,49 @@ example3: {
   console.log(queryToSql(builder.query));
 }
 
+/**
+ * @template {AnyObjectShape} T
+ * @param {T} shape
+ * @returns {ScopedFromQuery<GetShape<T>>}
+ */
+function queryAction(shape) {
+  const builder = new QueryBuilder()
+    .db('test_db')
+    .from('test_table', ActionShape(shape))
+    .scope((row) => row.field('action').get('payload').get('state'));
+  return /** @type {ScopedFromQuery<GetShape<T>>} */ (builder);
+}
+
 example4: {
-  /**
-   * @template {AnyObjectShape} T
-   * @param {T} shape
-   * @returns {ScopedFromQuery<t<T>>}
-   */
-  function queryAction(shape) {
-    const builder = new QueryBuilder()
-      .db('test_db')
-      .from('test_table', ActionShape(shape))
-      .scope((row) => row.field('action').get('payload').get('state'));
-    return /** @type {ScopedFromQuery<t<T>>} */ (builder);
-  }
-
-  const builder = queryAction(TestUserShape).fields(['firstname', 'age']);
+  const builder = queryAction(TestUserShape)
+    .fields(['firstname', 'age'])
+    .where((user) => user.get('address').get('streetName').eq('toto'))
+    .orderBy((user) => [user.get('age'), user.get('firstname')]);
+
+  console.log(queryToSql(builder.query));
+}
+
+example5: {
+  const builder = queryAction(TestUserShape)
+    .fields(['firstname', 'age'])
+    .where((user, $) =>
+      $.and(
+        user.get('mails').length.gt(0),
+        user.get('mails').some((mail) => mail.like('%@example.com'))
+      )
+    );
+
+  console.log(queryToSql(builder.query));
+}
+
+example6: {
+  const builder = queryAction(TestUserShape)
+    .fields(['firstname', 'age'])
+    .where((user, $) =>
+      user
+        .get('skills')
+        .some((value, key) => $.or(value.eq(42), key.eq('test')))
+    );
 
   console.log(queryToSql(builder.query));
 }

package/lib/operator-to-sql.js

@@ -1,5 +1,14 @@
 // @ts-check
 
+const {isAnyPick} = require('./picks.js');
+
+/**
+ * @typedef {import("./operators.js").Operator} Operator
+ */
+/**
+ * @typedef {import('./picks.js').AnyPick} AnyPick
+ */
+
 function escape(value) {
   if (typeof value === 'string') {
     return `'${value.replace(/'/g, "''")}'`;
@@ -9,6 +18,9 @@ function escape(value) {
 
 const operators = {
   value({value}, values) {
+    if (typeof value === 'boolean') {
+      return value ? 'TRUE' : 'FALSE';
+    }
     values.push(value);
     return '?';
   },
@@ -19,13 +31,22 @@ const operators = {
 
   field({field}, values) {
     // Note: field is not validated
-    return `${field}`;
+    if (typeof field === 'string') {
+      return `${field}`;
+    }
+    return sql(field, values);
+  },
+
+  as({value, name}, values) {
+    return `${sql(value, values)} AS ${escape(name)}`;
   },
 
   get({value, path}, values) {
     // TODO: try values.push(path) => '?'
     // return `json_extract(${field}, ${sql(path, values)})`;
-    return `json_extract(${sql(value)}, '$.' || ${escape(path.join('.'))})`;
+    return `json_extract(${sql(value, values)}, '$.' || ${escape(
+      path.join('.')
+    )})`;
   },
 
   not({value}, values) {
@@ -93,10 +114,14 @@ const operators = {
       .join(' OR ')})`;
   },
 
+  length({list}, values) {
+    return `json_array_length(${sql(list, values)})`;
+  },
+
   includes({list, value}, values) {
     return `EXISTS (
       SELECT *
-      FROM json_each(${list})
+      FROM json_each(${sql(list, values)})
       WHERE json_each.value = ${sql(value, values)}
     )`;
   },
@@ -104,24 +129,55 @@ const operators = {
   some({list, condition}, values) {
     return `EXISTS (
       SELECT *
-      FROM json_each(${list})
+      FROM json_each(${sql(list, values)})
       WHERE ${sql(condition, values)}
     )`;
   },
 
-  someValue(_, values) {
+  eachValue(_, values) {
     return 'json_each.value';
   },
 
-  keys() {},
+  eachKey(_, values) {
+    return 'json_each.key';
+  },
+
+  keys({obj}, values) {
+    return `(SELECT json_group_array(json_each.key) FROM json_each(${sql(
+      obj,
+      values
+    )}))`;
+  },
 
-  length() {},
+  values({obj}, values) {
+    return `(SELECT json_group_array(json_each.value) FROM json_each(${sql(
+      obj,
+      values
+    )}))`;
+  },
 };
 
-function sql(operator, values) {
+/**
+ * @param {Operator | AnyPick} operatorOrPick
+ * @returns {Operator}
+ */
+function getOperator(operatorOrPick) {
+  if (isAnyPick(operatorOrPick)) {
+    return operatorOrPick.value;
+  }
+  return operatorOrPick;
+}
+
+/**
+ * @param {Operator | AnyPick} operatorOrPick
+ * @param {any[]} values
+ * @returns {string}
+ */
+function sql(operatorOrPick, values) {
+  const operator = getOperator(operatorOrPick);
   const operatorName = operator.operator;
   if (!(operatorName in operators)) {
-    throw new Error(`Unknown operator '${operator}'`);
+    throw new Error(`Unknown operator '${JSON.stringify(operator)}'`);
   }
   return operators[operatorName](operator, values);
 }

package/lib/operators.js

@@ -36,6 +36,14 @@ const operators = {
     });
   },
 
+  as(value, name) {
+    return /** @type {const} */ ({
+      operator: 'as',
+      value,
+      name,
+    });
+  },
+
   get(value, path) {
     return /** @type {const} */ ({
       operator: 'get',
@@ -152,6 +160,13 @@ const operators = {
     });
   },
 
+  length(list) {
+    return /** @type {const} */ ({
+      operator: 'length',
+      list,
+    });
+  },
+
   includes(list, value) {
     value = op(value);
     return /** @type {const} */ ({
@@ -169,9 +184,29 @@ const operators = {
     });
   },
 
-  someValue() {
+  eachValue() {
+    return /** @type {const} */ ({
+      operator: 'eachValue',
+    });
+  },
+
+  eachKey() {
+    return /** @type {const} */ ({
+      operator: 'eachKey',
+    });
+  },
+
+  keys(obj) {
+    return /** @type {const} */ ({
+      operator: 'keys',
+      obj,
+    });
+  },
+
+  values(obj) {
     return /** @type {const} */ ({
-      operator: 'someValue',
+      operator: 'values',
+      obj,
     });
   },
 };

package/lib/picks.js

@@ -6,6 +6,12 @@ const {
   ObjectType,
   Type,
   getTypeInstance,
+  array,
+  ObjectMapType,
+  RecordType,
+  number,
+  StringType,
+  string,
 } = require('xcraft-core-stones');
 
 const $o = require('./operators.js');
@@ -17,13 +23,6 @@ const $o = require('./operators.js');
  * @typedef {import('./operators.js').Operator} Operator
  */
 
-/**
- * @typedef {boolean | number | bigint | string | symbol | undefined | null} primitive
- */
-/**
- * @typedef {primitive | Function | Date | Error | RegExp} Builtin
- */
-
 /**
  * @typedef {(keyof any)} PathElement
  */
@@ -32,26 +31,29 @@ const $o = require('./operators.js');
  */
 
 /**
- * @typedef {{field: Operators["someValue"] | (keyof any), path: Path}} Context
+ * @template T
+ * @template {keyof T} K
+ * @typedef {Pick<T, K>[keyof Pick<T, K>]} SelectValues
  */
 
 /**
- * @template T
- * @typedef {0 extends (1 & T) ? true : never} IsAny
+ * @typedef {{
+ *   field: (keyof any) | SelectValues<Operators, "eachValue" | "eachKey" | "keys" | "values" | "length">,
+ *   path: Path
+ * }} Context
  */
 
 /**
- * @typedef {ValuePick<any> | ArrayPick<any> | ObjectPick<any>} AnyPick
+ * @typedef {ValuePick<any> | ArrayPick<any> | ObjectPick<any> | RecordPick<any,any>} AnyPick
  */
 
 /**
- * @template T
- * @typedef {true extends IsAny<T> ? AnyPick : [T] extends [Builtin] ? ValuePick<T> : [T] extends [Array<infer V>] ? ArrayPick<V> : [T] extends [{}] ? ObjectPick<T> : never} PickOf
+ * @template {Type} T
+ * @typedef { [T] extends [ArrayType<infer V>] ? ArrayPick<V> : [T] extends [ObjectType<infer S>] ? ObjectPick<S> : [T] extends [ObjectMapType<infer V>] ? RecordPick<StringType,V> : [T] extends [RecordType<infer K,infer V>] ? RecordPick<K,V> : ValuePick<T>} PickOfType
  */
-
 /**
- * @template {{}} T
- * @typedef {ObjectType<{[K in keyof T] : Type<T[K]>}>} ObjectTypeOf
+ * @template {AnyTypeOrShape} T
+ * @typedef {PickOfType<GetType<T>>} PickOf
  */
 
 /**
@@ -67,16 +69,16 @@ function contextWithPath(context, path) {
 }
 
 /**
- * @template T
+ * @template {AnyTypeOrShape} T
  */
 class ValuePick {
-  /** @type {Type<T>} */
+  /** @type {T} */
   #type;
   /** @type {Context} */
   #context;
 
   /**
-   * @param {Type<T>} type
+   * @param {T} type
    * @param {Context} context
    */
   constructor(type, context) {
@@ -97,56 +99,56 @@ class ValuePick {
   }
 
   /**
-   * @param {T | ValuePick<T>} value
+   * @param {t<T> | ValuePick<T>} value
    */
   eq(value) {
     return $o.eq(this.value, value);
   }
 
   /**
-   * @param {T | ValuePick<T>} value
+   * @param {t<T> | ValuePick<T>} value
    */
   neq(value) {
     return $o.neq(this.value, value);
   }
 
   /**
-   * @param {T | ValuePick<T>} value
+   * @param {t<T> | ValuePick<T>} value
    */
   gte(value) {
     return $o.gte(this.value, value);
   }
 
   /**
-   * @param {T | ValuePick<T>} value
+   * @param {t<T> | ValuePick<T>} value
    */
   gt(value) {
     return $o.gt(this.value, value);
   }
 
   /**
-   * @param {T | ValuePick<T>} value
+   * @param {t<T> | ValuePick<T>} value
    */
   lte(value) {
     return $o.lte(this.value, value);
   }
 
   /**
-   * @param {T | ValuePick<T>} value
+   * @param {t<T> | ValuePick<T>} value
    */
   lt(value) {
     return $o.lt(this.value, value);
   }
 
   /**
-   * @param {(T | ValuePick<T>)[]} list
+   * @param {(t<T> | ValuePick<T>)[]} list
    */
   in(list) {
     return $o.in(this.value, list);
   }
 
   /**
-   * @param {string | ValuePick<string>} value
+   * @param {string | ValuePick<StringType>} value
    */
   like(value) {
     return $o.like(this.value, value);
@@ -154,16 +156,16 @@ class ValuePick {
 }
 
 /**
- * @template {{}} T
+ * @template {ObjectShape} T
  */
 class ObjectPick {
-  /** @type {ObjectTypeOf<T>} */
+  /** @type {ObjectType<T>} */
   #type;
   /** @type {Context} */
   #context;
 
   /**
-   * @param {ObjectTypeOf<T>} type
+   * @param {ObjectType<T>} type
    * @param {Context} context
    */
   constructor(type, context) {
@@ -189,24 +191,117 @@ class ObjectPick {
    * @returns {PickOf<T[K]>}
    */
   get(key) {
-    return makeTypePick(
-      getTypeInstance(this.#type.properties[key]),
+    return makePick(
+      this.#type.properties[key],
       contextWithPath(this.#context, key)
     );
   }
+
+  /**
+   * @param {t<T[keyof T]> | ValuePick<T[keyof T]>} value
+   */
+  includes(value) {
+    return $o.includes(this.value, value);
+  }
 }
 
 /**
- * @template T
+ * @template {AnyTypeOrShape} K
+ * @template {AnyTypeOrShape} V
+ */
+class RecordPick {
+  /** @type {RecordType<K,V>} */
+  #type;
+  /** @type {Context} */
+  #context;
+
+  /**
+   * @param {RecordType<K,V>} type
+   * @param {Context} context
+   */
+  constructor(type, context) {
+    this.#type = type;
+    this.#context = context;
+  }
+
+  get value() {
+    const {field, path} = this.#context;
+    if (path.length > 0) {
+      return $o.get($o.field(field), path);
+    }
+    return $o.field(field);
+  }
+
+  get type() {
+    return this.#type;
+  }
+
+  /**
+   * @param {t<K>} key
+   * @returns {PickOf<V>}
+   */
+  get(key) {
+    return makePick(this.#type.valuesType, contextWithPath(this.#context, key));
+  }
+
+  /**
+   * @param {t<V> | ValuePick<V>} value
+   */
+  includes(value) {
+    return $o.includes(this.value, value);
+  }
+
+  /**
+   * @param {(value: PickOf<V>, key: PickOf<K>) => Operator} func
+   */
+  some(func) {
+    return $o.some(
+      this.value,
+      func(
+        makePick(this.#type.valuesType, {
+          field: $o.eachValue(),
+          path: [],
+        }),
+        makePick(this.#type.keysType, {
+          field: $o.eachKey(),
+          path: [],
+        })
+      )
+    );
+  }
+
+  /**
+   * @returns {ArrayPick<K>}
+   */
+  keys() {
+    return new ArrayPick(array(this.#type.keysType), {
+      field: $o.keys(this.value),
+      path: [],
+    });
+  }
+
+  /**
+   * @returns {ArrayPick<V>}
+   */
+  values() {
+    return new ArrayPick(array(this.#type.valuesType), {
+      field: $o.values(this.value),
+      path: [],
+    });
+  }
+}
+
+/**
+ * @template {AnyTypeOrShape} T
  */
 class ArrayPick {
-  /** @type {ArrayType<Type<T>>} */
+  /** @type {ArrayType<T>} */
   #type;
   /** @type {Context} */
   #context;
 
   /**
-   * @param {ArrayType<Type<T>>} type
+   * @param {ArrayType<T>} type
    * @param {Context} context
    */
   constructor(type, context) {
@@ -228,14 +323,21 @@ class ArrayPick {
    * @returns {PickOf<T>}
    */
   get(index) {
-    return makeTypePick(
-      getTypeInstance(this.#type.valuesType),
+    return makePick(
+      this.#type.valuesType,
       contextWithPath(this.#context, index)
     );
   }
 
+  get length() {
+    return new ValuePick(number, {
+      field: $o.length(this.value),
+      path: [],
+    });
+  }
+
   /**
-   * @param {T | ValuePick<T>} value
+   * @param {t<T> | ValuePick<T>} value
    */
   includes(value) {
     return $o.includes(this.value, value);
@@ -248,8 +350,8 @@ class ArrayPick {
     return $o.some(
       this.value,
       func(
-        makeTypePick(getTypeInstance(this.#type.valuesType), {
-          field: $o.someValue(),
+        makePick(this.#type.valuesType, {
+          field: $o.eachValue(),
           path: [],
         })
       )
@@ -265,19 +367,20 @@ function isAnyPick(value) {
   return (
     value instanceof ValuePick ||
     value instanceof ObjectPick ||
+    value instanceof RecordPick ||
     value instanceof ArrayPick
   );
 }
 
 /**
- * @template {Record<string,any>} T
+ * @template {ObjectShape} T
  */
 class RowPick {
-  /** @type {ObjectTypeOf<T>} */
+  /** @type {ObjectType<T>} */
   #type;
 
   /**
-   * @param {ObjectTypeOf<T>} type
+   * @param {ObjectType<T>} type
    */
   constructor(type) {
     this.#type = type;
@@ -293,18 +396,15 @@ class RowPick {
       field: fieldName,
       path: [],
     };
-    return makeTypePick(
-      getTypeInstance(this.#type.properties[fieldName]),
-      context
-    );
+    return makePick(this.#type.properties[fieldName], context);
   }
 }
 
 /**
- * @template T
- * @param {Type<T>} type
+ * @template {Type} T
+ * @param {T} type
  * @param {Context} context
- * @returns {PickOf<T>}
+ * @returns {PickOfType<T>}
  */
 function makeTypePick(type, context) {
   if (type instanceof ArrayType) {
@@ -313,6 +413,13 @@ function makeTypePick(type, context) {
   if (type instanceof ObjectType) {
     return /** @type {any} */ (new ObjectPick(type, context));
   }
+  if (type instanceof ObjectMapType) {
+    const newType = new RecordType(string, type.valuesType);
+    return /** @type {any} */ (new RecordPick(newType, context));
+  }
+  if (type instanceof RecordType) {
+    return /** @type {any} */ (new RecordPick(type, context));
+  }
   return /** @type {any} */ (new ValuePick(type, context));
 }
 
@@ -320,7 +427,7 @@ function makeTypePick(type, context) {
  * @template {AnyTypeOrShape} T
  * @param {T} typeOrShape
  * @param {Context} context
- * @returns {PickOf<t<T>>}
+ * @returns {PickOf<T>}
  */
 function makePick(typeOrShape, context) {
   const type = getTypeInstance(typeOrShape);
@@ -328,8 +435,8 @@ function makePick(typeOrShape, context) {
 }
 
 /**
- * @template {Record<string,any>} T
- * @param {ObjectTypeOf<T>} type
+ * @template {ObjectShape} T
+ * @param {ObjectType<T>} type
  * @returns {RowPick<T>}
  */
 function rowPick(type) {

package/lib/query-builder.js

@@ -1,16 +1,18 @@
 // @ts-check
 
-const {ObjectType, getTypeInstance} = require('xcraft-core-stones');
+const {ObjectType, ArrayType, toObjectType} = require('xcraft-core-stones');
 const operators = require('./operators.js');
 const {rowPick, ValuePick, RowPick, ObjectPick} = require('./picks.js');
 const {queryToSql} = require('./query-to-sql.js');
-
 /**
  * @typedef {import("./operators.js").Operator} Operator
  */
+/**
+ * @typedef {import("./operators.js").Operators} Operators
+ */
 
 /**
- * @template T
+ * @template {AnyTypeOrShape} T
  * @typedef {import("./picks.js").PickOf<T>} PickOf
  */
 /**
@@ -19,17 +21,13 @@ const {queryToSql} = require('./query-to-sql.js');
 /**
  * @typedef {import("./picks.js").Path} Path
  */
-/**
- * @template {{}} T
- * @typedef {import("./picks.js").ObjectTypeOf<T>} ObjectTypeOf
- */
 
 /**
  * @typedef {{
  *   db: string,
  *   from: string,
  *   scope?: ObjectPick<any>
- *   select: AnyPick[] | Record<string, AnyPick> | AnyPick,
+ *   select: Record<string, AnyPick>,
  *   selectOneField?: boolean,
  *   where?: Operator,
  *   orderBy?: ValuePick<any> | ValuePick<any>[]
@@ -64,9 +62,73 @@ class FinalQuery {
     this.#queryParts = queryParts;
   }
 
+  #useRaw() {
+    return Boolean(this.#queryParts.selectOneField);
+  }
+
   #getStatement() {
     const {sql, values} = queryToSql(this.#queryParts);
-    return this.#database.prepare(sql).bind(values);
+    return this.#database.prepare(sql).bind(values).raw(this.#useRaw());
+  }
+
+  #parseValue(value) {
+    return JSON.parse(value);
+  }
+
+  #identity(value) {
+    return value;
+  }
+
+  #getMapper(type) {
+    if (type instanceof ArrayType || type instanceof ObjectType) {
+      return this.#parseValue;
+    }
+    return this.#identity;
+  }
+
+  #getMappers() {
+    const select = this.#queryParts.select;
+    const mappers = Object.fromEntries(
+      Object.entries(select).map(([name, selectValue]) => [
+        name,
+        this.#getMapper(selectValue.type),
+      ])
+    );
+    return mappers;
+  }
+
+  #getRawMappers() {
+    const select = this.#queryParts.select;
+    const mappers = Object.values(select).map((selectValue) =>
+      this.#getMapper(selectValue.type)
+    );
+    return mappers;
+  }
+
+  #mapRow(row, mappers) {
+    for (const [name, value] of Object.entries(row)) {
+      row[name] = mappers[name](value);
+    }
+    return row;
+  }
+
+  #mapRawRow(row, mappers) {
+    for (const [i, value] of row.entries()) {
+      row[i] = mappers[i](value);
+    }
+    return row;
+  }
+
+  #getMapRow() {
+    if (this.#useRaw()) {
+      const mappers = this.#getRawMappers();
+      if (this.#queryParts.selectOneField) {
+        return (row) => (row ? this.#mapRawRow(row, mappers)[0] : row);
+      }
+      return (row) => row && this.#mapRawRow(row, mappers);
+    }
+    const mappers = this.#getMappers();
+    return (row) => row && this.#mapRow(row, mappers);
   }
 
   /**
@@ -80,39 +142,32 @@ class FinalQuery {
    * @returns {R}
    */
   get() {
-    const result = this.#getStatement().get();
-    if (result && this.#queryParts.selectOneField) {
-      return Object.values(result)[0];
-    }
-    return result;
+    const mapRow = this.#getMapRow();
+    const row = this.#getStatement().get();
+    return mapRow(row);
   }
 
   /**
    * @returns {R[]}
    */
   all() {
-    if (this.#queryParts.selectOneField) {
-      return Array.from(this.#getStatement().raw().iterate(), (row) => row[0]);
-    }
-    return this.#getStatement().all();
+    const mapRow = this.#getMapRow();
+    return Array.from(this.#getStatement().iterate(), mapRow);
   }
 
   /**
    * @returns {Generator<R>}
    */
   *iterate() {
-    if (this.#queryParts.selectOneField) {
-      for (const row of this.#getStatement().raw().iterate()) {
-        yield row[0];
-      }
-      return;
+    const mapRow = this.#getMapRow();
+    for (const row of this.#getStatement().iterate()) {
+      yield mapRow(row);
     }
-    yield* this.#getStatement().iterate();
   }
 }
 
 /**
- * @template {Record<string, any>} T
+ * @template {ObjectShape} T
  * @template R
  * @extends {FinalQuery<R>}
  */
@@ -123,7 +178,7 @@ class ScopedSelectQuery extends FinalQuery {
 
   /**
    * @param {*} database
-   * @param {ObjectTypeOf<T>} type
+   * @param {ObjectType<T>} type
    * @param {QueryParts<'db' | 'from' | 'select' | 'scope'>} queryParts
    */
   constructor(database, type, queryParts) {
@@ -161,7 +216,7 @@ class ScopedSelectQuery extends FinalQuery {
 }
 
 /**
- * @template {Record<string, any>} T
+ * @template {ObjectShape} T
  * @template R
  * @extends {FinalQuery<R>}
  */
@@ -172,7 +227,7 @@ class SelectQuery extends FinalQuery {
 
   /**
    * @param {*} database
-   * @param {ObjectTypeOf<T>} type
+   * @param {ObjectType<T>} type
    * @param {QueryParts<'db' | 'from' | 'select'>} queryParts
    */
   constructor(database, type, queryParts) {
@@ -211,7 +266,7 @@ class SelectQuery extends FinalQuery {
 }
 
 /**
- * @template {Record<string, any>} T
+ * @template {ObjectShape} T
  */
 class ScopedFromQuery {
   #database;
@@ -220,7 +275,7 @@ class ScopedFromQuery {
 
   /**
    * @param {*} database
-   * @param {ObjectTypeOf<T>} type
+   * @param {ObjectType<T>} type
    * @param {QueryParts<'db' | 'from' | 'scope'>} queryParts
    */
   constructor(database, type, queryParts) {
@@ -233,13 +288,13 @@ class ScopedFromQuery {
    * Select field
    * @template {keyof T} F
    * @param {F} value
-   * @returns {ScopedSelectQuery<T, T[F]>}
+   * @returns {ScopedSelectQuery<T, t<T[F]>>}
    */
   field(value) {
     const scope = this.#queryParts.scope;
     const queryParts = {
       ...this.#queryParts,
-      select: scope.get(value),
+      select: {[value]: scope.get(value)},
       selectOneField: true,
     };
     return new ScopedSelectQuery(this.#database, this.#type, queryParts);
@@ -249,26 +304,30 @@ class ScopedFromQuery {
    * Select fields
    * @template {(keyof T)[]} F
    * @param {F} values
-   * @returns {ScopedSelectQuery<T, flatten<Pick<T, F[number]>>>}
+   * @returns {ScopedSelectQuery<T, t<Pick<T, F[number]>>>}
    */
   fields(values) {
     const scope = this.#queryParts.scope;
     const queryParts = {
       ...this.#queryParts,
-      select: values.map((value) => scope.get(value)),
+      select: Object.fromEntries(
+        values.map((value) => [value, scope.get(value)])
+      ),
     };
     return new ScopedSelectQuery(this.#database, this.#type, queryParts);
   }
 
   /**
-   * @template {Record<string, any>} R
-   * @param {(obj: ObjectPick<T>) => {[K in keyof R]: PickOf<R[K]>}} fct
-   * @returns {ScopedSelectQuery<T, R>}
+   * @template {Record<string, AnyPick>} R
+   * @param {(obj: ObjectPick<T>) => R} fct
+   * @returns {ScopedSelectQuery<T, t<{[K in keyof R]: R[K]["type"]}>>}
    */
   select(fct) {
     const scope = this.#queryParts.scope;
-    const selectedFields = fct(scope);
-    const queryParts = {...this.#queryParts, select: selectedFields};
+    const queryParts = {
+      ...this.#queryParts,
+      select: fct(scope),
+    };
     return new ScopedSelectQuery(this.#database, this.#type, queryParts);
   }
 
@@ -287,7 +346,7 @@ class ScopedFromQuery {
 }
 
 /**
- * @template {Record<string, any>} T
+ * @template {ObjectShape} T
  */
 class FromQuery {
   #database;
@@ -296,7 +355,7 @@ class FromQuery {
 
   /**
    * @param {*} database
-   * @param {ObjectTypeOf<T>} type
+   * @param {ObjectType<T>} type
    * @param {QueryParts<'db' | 'from'>} queryParts
    */
   constructor(database, type, queryParts) {
@@ -306,7 +365,7 @@ class FromQuery {
   }
 
   /**
-   * @template {{}} U
+   * @template {ObjectShape} U
    * @param {(obj: RowPick<T>) => ObjectPick<U>} fct
    * @returns {ScopedFromQuery<U>}
    */
@@ -323,25 +382,29 @@ class FromQuery {
    * Select fields
    * @template {(keyof T)[]} F
    * @param {F} fields
-   * @returns {SelectQuery<T, flatten<Pick<T, F[number]>>>}
+   * @returns {SelectQuery<T, t<Pick<T, F[number]>>>}
    */
   fields(fields) {
     const row = rowPick(this.#type);
     const queryParts = {
       ...this.#queryParts,
-      select: fields.map((fieldName) => row.field(fieldName)),
+      select: Object.fromEntries(
+        fields.map((fieldName) => [fieldName, row.field(fieldName)])
+      ),
     };
     return new SelectQuery(this.#database, this.#type, queryParts);
   }
 
   /**
-   * @template {Record<string, any>} R
-   * @param {(obj: RowPick<T>) => {[K in keyof R]: PickOf<R[K]>}} fct
-   * @returns {SelectQuery<T, R>}
+   * @template {Record<string, AnyPick>} R
+   * @param {(obj: RowPick<T>) => R} fct
+   * @returns {SelectQuery<T, t<{[K in keyof R]: R[K]["type"]}>>}
    */
   select(fct) {
-    const selectedFields = fct(rowPick(this.#type));
-    const queryParts = {...this.#queryParts, select: selectedFields};
+    const queryParts = {
+      ...this.#queryParts,
+      select: fct(rowPick(this.#type)),
+    };
     return new SelectQuery(this.#database, this.#type, queryParts);
   }
 
@@ -378,15 +441,15 @@ class DbQuery {
    * @template {AnyObjectShape} T
    * @param {string} tableName
    * @param {T} shape
-   * @returns {FromQuery<t<T>>}
+   * @returns {FromQuery<GetShape<T>>}
    */
   from(tableName, shape) {
-    const type = getTypeInstance(shape);
+    const type = toObjectType(shape);
     const queryParts = {
       ...this.#queryParts,
       from: tableName,
     };
-    return /** @type {any} */ (new FromQuery(this.#database, type, queryParts));
+    return new FromQuery(this.#database, type, queryParts);
   }
 }
 

package/lib/query-to-sql.js

@@ -4,7 +4,6 @@
  */
 
 const {sql} = require('./operator-to-sql.js');
-const {isAnyPick} = require('./picks.js');
 
 /**
  * @param {QueryObj["select"]} select
@@ -12,14 +11,8 @@ const {isAnyPick} = require('./picks.js');
  * @returns {string}
  */
 function selectFields(select, values) {
-  if (Array.isArray(select)) {
-    return select.map((rep) => sql(rep.value, values)).join(', ');
-  }
-  if (isAnyPick(select)) {
-    return sql(select.value, values);
-  }
   return Object.entries(select)
-    .map(([name, rep]) => `${sql(rep.value, values)} AS ${name}`)
+    .map(([name, value]) => `${sql(value, values)} AS ${name}`)
     .join(', ');
 }
 

package/package.json

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