xcraft-core-pickaxe 0.1.0

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*.{js,jsx,json}]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 80

package/.eslintrc.js

@@ -0,0 +1,39 @@
+'use strict';
+
+module.exports = {
+  root: true,
+  parserOptions: {
+    sourceType: 'module',
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+  env: {
+    browser: true,
+    es2022: true,
+    mocha: true,
+    node: true,
+  },
+  plugins: ['react', 'babel', 'jsdoc'],
+  extends: [
+    'prettier',
+    'eslint:recommended',
+    'plugin:react/recommended',
+    'plugin:jsdoc/recommended',
+  ],
+  rules: {
+    // Other rules
+    'no-console': 'off',
+    'eqeqeq': 'error',
+    'react/display-name': 'off',
+    'no-unused-vars': [
+      'error',
+      {
+        vars: 'all',
+        args: 'none',
+        ignoreRestSiblings: true,
+        destructuredArrayIgnorePattern: '^_',
+      },
+    ],
+  },
+};

package/.zou-flow

@@ -0,0 +1,2 @@
+[update-version]
+	package-json = package.json

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Xcraft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# xcraft-core-pickaxe
+
+Convenient tool to extract well shaped objects from deep data mines.

package/lib/examples.js

@@ -0,0 +1,130 @@
+/* eslint-disable no-inner-declarations */
+// @ts-check
+const {operatorToSql} = require('./operator-to-sql.js');
+const {
+  string,
+  number,
+  array,
+  object,
+  dateTime,
+  any,
+  value,
+} = require('xcraft-core-stones');
+const $ = require('./operators.js');
+const {queryToSql} = require('./query-to-sql.js');
+const {QueryBuilder, ScopedFromQuery} = require('./query-builder.js');
+const {makePick} = require('./picks.js');
+
+class TestUserShape {
+  firstname = string;
+  lastname = string;
+  age = number;
+  mails = array(string);
+  address = class {
+    streetName = string;
+    townName = string;
+  };
+}
+
+const TestUserShape2 = {
+  firstname: string,
+  lastname: string,
+  age: number,
+  mails: array(string),
+  address: class {
+    streetName = string;
+    townName = string;
+  },
+};
+
+const TestUserShape3 = object({
+  firstname: string,
+  lastname: string,
+  age: number,
+  mails: array(string),
+  address: class {
+    streetName = string;
+    townName = string;
+  },
+});
+
+/**
+ * @param {AnyObjectShape} shape
+ */
+function ActionShape(shape) {
+  return object({
+    name: string,
+    action: object({
+      meta: any,
+      payload: object({
+        state: shape,
+      }),
+      type: value('test'),
+    }),
+    timestamp: dateTime,
+  });
+}
+
+example1: {
+  const user = makePick(TestUserShape, {field: 'value', path: []});
+
+  const filter1 = user.get('firstname').eq('toto');
+
+  const userIds = ['user@toto', 'user@tata'];
+  const filter2 = $.and(
+    user.get('firstname').eq('Toto'),
+    user.get('age').eq(42),
+    user.get('lastname').in(userIds),
+    user.get('address').get('streetName').eq('Mine road')
+  );
+
+  console.log(operatorToSql(filter1));
+  console.log(operatorToSql(filter2));
+}
+
+example2: {
+  const userIds = ['user@toto', 'user@tata'];
+  const builder = new QueryBuilder()
+    .db('test_db')
+    .from('test_table', TestUserShape3)
+    .fields(['firstname', 'age'])
+    .where((user, $) =>
+      $.and(
+        user.field('firstname').eq('Toto'),
+        user.field('age').eq(42),
+        user.field('lastname').in(userIds),
+        user.field('address').get('streetName').eq('Mine road')
+      )
+    );
+
+  console.log(queryToSql(builder.query));
+}
+
+example3: {
+  const builder = new QueryBuilder()
+    .db('test_db')
+    .from('test_table', ActionShape(TestUserShape))
+    .scope((row) => row.field('action').get('payload').get('state'))
+    .fields(['firstname', 'age']);
+
+  console.log(queryToSql(builder.query));
+}
+
+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']);
+
+  console.log(queryToSql(builder.query));
+}

package/lib/operator-to-sql.js

@@ -0,0 +1,140 @@
+// @ts-check
+
+function escape(value) {
+  if (typeof value === 'string') {
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  return value;
+}
+
+const operators = {
+  value({value}, values) {
+    values.push(value);
+    return '?';
+  },
+
+  null(_, values) {
+    return 'NULL';
+  },
+
+  field({field}, values) {
+    // Note: field is not validated
+    return `${field}`;
+  },
+
+  get({value, path}, values) {
+    // TODO: try values.push(path) => '?'
+    // return `json_extract(${field}, ${sql(path, values)})`;
+    return `json_extract(${sql(value)}, '$.' || ${escape(path.join('.'))})`;
+  },
+
+  not({value}, values) {
+    return `NOT ${sql(value, values)}`;
+  },
+
+  stringConcat({values: list}, values) {
+    return `(${list
+      .map((value) => sql(value, values))
+      .filter(Boolean)
+      .join(' || ')})`;
+  },
+
+  eq({a, b}, values) {
+    return `${sql(a, values)} = ${sql(b, values)}`;
+  },
+
+  neq({a, b}, values) {
+    return `${sql(a, values)} <> ${sql(b, values)}`;
+  },
+
+  gte({a, b}, values) {
+    return `${sql(a, values)} >= ${sql(b, values)}`;
+  },
+
+  gt({a, b}, values) {
+    return `${sql(a, values)} > ${sql(b, values)}`;
+  },
+
+  lte({a, b}, values) {
+    return `${sql(a, values)} <= ${sql(b, values)}`;
+  },
+
+  lt({a, b}, values) {
+    return `${sql(a, values)} < ${sql(b, values)}`;
+  },
+
+  in({value, list}, values) {
+    return `${sql(value, values)} IN (${list
+      .map((v) => sql(v, values))
+      .join(',')})`;
+  },
+
+  like({value, pattern}, values) {
+    return `${sql(value, values)} LIKE ${sql(pattern, values)}`;
+  },
+
+  and({conditions}, values) {
+    if (conditions.length === 0) {
+      return '';
+    }
+    return `(${conditions
+      .map((condition) => sql(condition, values))
+      .filter(Boolean)
+      .join(' AND ')})`;
+  },
+
+  or({conditions}, values) {
+    if (conditions.length === 0) {
+      return '';
+    }
+    return `(${conditions
+      .map((condition) => sql(condition, values))
+      .filter(Boolean)
+      .join(' OR ')})`;
+  },
+
+  includes({list, value}, values) {
+    return `EXISTS (
+      SELECT *
+      FROM json_each(${list})
+      WHERE json_each.value = ${sql(value, values)}
+    )`;
+  },
+
+  some({list, condition}, values) {
+    return `EXISTS (
+      SELECT *
+      FROM json_each(${list})
+      WHERE ${sql(condition, values)}
+    )`;
+  },
+
+  someValue(_, values) {
+    return 'json_each.value';
+  },
+
+  keys() {},
+
+  length() {},
+};
+
+function sql(operator, values) {
+  const operatorName = operator.operator;
+  if (!(operatorName in operators)) {
+    throw new Error(`Unknown operator '${operator}'`);
+  }
+  return operators[operatorName](operator, values);
+}
+
+function operatorToSql(operator) {
+  const values = [];
+  return {
+    sql: sql(operator, values),
+    values,
+  };
+}
+
+module.exports = {
+  sql,
+  operatorToSql,
+};

package/lib/operators.js

@@ -0,0 +1,192 @@
+// @ts-check
+
+function op(value) {
+  if (value === null) {
+    return operators.null();
+  }
+  const type = typeof value;
+  if (['string', 'number', 'boolean'].includes(type)) {
+    return operators.value(value);
+  }
+  if (type === 'object' && 'operator' in value) {
+    return value;
+  }
+
+  throw new Error(`Bad value '${value}'`);
+}
+
+const operators = {
+  value(value) {
+    return /** @type {const} */ ({
+      operator: 'value',
+      value,
+    });
+  },
+
+  null() {
+    return /** @type {const} */ ({
+      operator: 'null',
+    });
+  },
+
+  field(field) {
+    return /** @type {const} */ ({
+      operator: 'field',
+      field,
+    });
+  },
+
+  get(value, path) {
+    return /** @type {const} */ ({
+      operator: 'get',
+      value,
+      path,
+    });
+  },
+
+  not(value) {
+    return /** @type {const} */ ({
+      operator: 'not',
+      value,
+    });
+  },
+
+  stringConcat(...values) {
+    values = values.map(op);
+    return /** @type {const} */ ({
+      operator: 'stringConcat',
+      values,
+    });
+  },
+
+  eq(a, b) {
+    a = op(a);
+    b = op(b);
+    return /** @type {const} */ ({
+      operator: 'eq',
+      a,
+      b,
+    });
+  },
+
+  neq(a, b) {
+    a = op(a);
+    b = op(b);
+    return /** @type {const} */ ({
+      operator: 'neq',
+      a,
+      b,
+    });
+  },
+
+  gte(a, b) {
+    a = op(a);
+    b = op(b);
+    return /** @type {const} */ ({
+      operator: 'gte',
+      a,
+      b,
+    });
+  },
+
+  gt(a, b) {
+    a = op(a);
+    b = op(b);
+    return /** @type {const} */ ({
+      operator: 'gt',
+      a,
+      b,
+    });
+  },
+
+  lte(a, b) {
+    a = op(a);
+    b = op(b);
+    return /** @type {const} */ ({
+      operator: 'lte',
+      a,
+      b,
+    });
+  },
+
+  lt(a, b) {
+    a = op(a);
+    b = op(b);
+    return /** @type {const} */ ({
+      operator: 'lt',
+      a,
+      b,
+    });
+  },
+
+  in(value, list) {
+    list = list.map(op);
+    return /** @type {const} */ ({
+      operator: 'in',
+      value,
+      list,
+    });
+  },
+
+  like(value, pattern) {
+    value = op(value);
+    pattern = op(pattern);
+    return /** @type {const} */ ({
+      operator: 'like',
+      value,
+      pattern,
+    });
+  },
+
+  and(...conditions) {
+    return /** @type {const} */ ({
+      operator: 'and',
+      conditions,
+    });
+  },
+
+  or(...conditions) {
+    return /** @type {const} */ ({
+      operator: 'or',
+      conditions,
+    });
+  },
+
+  includes(list, value) {
+    value = op(value);
+    return /** @type {const} */ ({
+      operator: 'includes',
+      list,
+      value,
+    });
+  },
+
+  some(list, condition) {
+    return /** @type {const} */ ({
+      operator: 'some',
+      list,
+      condition,
+    });
+  },
+
+  someValue() {
+    return /** @type {const} */ ({
+      operator: 'someValue',
+    });
+  },
+};
+
+/**
+ * @template T
+ * @typedef {T[keyof T]} Values
+ */
+
+/**
+ * @typedef {{[k in keyof typeof operators] : ReturnType<typeof operators[k]>}} Operators
+ */
+
+/**
+ * @typedef {Values<{[k in keyof typeof operators] : ReturnType<typeof operators[k]>}>} Operator
+ */
+
+module.exports = operators;

package/lib/picks.js

@@ -0,0 +1,348 @@
+/* eslint-disable jsdoc/require-returns */
+// @ts-check
+
+const {
+  ArrayType,
+  ObjectType,
+  Type,
+  getTypeInstance,
+} = require('xcraft-core-stones');
+
+const $o = require('./operators.js');
+
+/**
+ * @typedef {import('./operators.js').Operators} Operators
+ */
+/**
+ * @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
+ */
+/**
+ * @typedef {PathElement[]} Path
+ */
+
+/**
+ * @typedef {{field: Operators["someValue"] | (keyof any), path: Path}} Context
+ */
+
+/**
+ * @template T
+ * @typedef {0 extends (1 & T) ? true : never} IsAny
+ */
+
+/**
+ * @typedef {ValuePick<any> | ArrayPick<any> | ObjectPick<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 {{}} T
+ * @typedef {ObjectType<{[K in keyof T] : Type<T[K]>}>} ObjectTypeOf
+ */
+
+/**
+ * @param {Context} context
+ * @param {PathElement} path
+ * @returns {Context}
+ */
+function contextWithPath(context, path) {
+  return {
+    ...context,
+    path: [...context.path, path],
+  };
+}
+
+/**
+ * @template T
+ */
+class ValuePick {
+  /** @type {Type<T>} */
+  #type;
+  /** @type {Context} */
+  #context;
+
+  /**
+   * @param {Type<T>} 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 | ValuePick<T>} value
+   */
+  eq(value) {
+    return $o.eq(this.value, value);
+  }
+
+  /**
+   * @param {T | ValuePick<T>} value
+   */
+  neq(value) {
+    return $o.neq(this.value, value);
+  }
+
+  /**
+   * @param {T | ValuePick<T>} value
+   */
+  gte(value) {
+    return $o.gte(this.value, value);
+  }
+
+  /**
+   * @param {T | ValuePick<T>} value
+   */
+  gt(value) {
+    return $o.gt(this.value, value);
+  }
+
+  /**
+   * @param {T | ValuePick<T>} value
+   */
+  lte(value) {
+    return $o.lte(this.value, value);
+  }
+
+  /**
+   * @param {T | ValuePick<T>} value
+   */
+  lt(value) {
+    return $o.lt(this.value, value);
+  }
+
+  /**
+   * @param {(T | ValuePick<T>)[]} list
+   */
+  in(list) {
+    return $o.in(this.value, list);
+  }
+
+  /**
+   * @param {string | ValuePick<string>} value
+   */
+  like(value) {
+    return $o.like(this.value, value);
+  }
+}
+
+/**
+ * @template {{}} T
+ */
+class ObjectPick {
+  /** @type {ObjectTypeOf<T>} */
+  #type;
+  /** @type {Context} */
+  #context;
+
+  /**
+   * @param {ObjectTypeOf<T>} 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;
+  }
+
+  /**
+   * @template {keyof T} K
+   * @param {K} key
+   * @returns {PickOf<T[K]>}
+   */
+  get(key) {
+    return makeTypePick(
+      getTypeInstance(this.#type.properties[key]),
+      contextWithPath(this.#context, key)
+    );
+  }
+}
+
+/**
+ * @template T
+ */
+class ArrayPick {
+  /** @type {ArrayType<Type<T>>} */
+  #type;
+  /** @type {Context} */
+  #context;
+
+  /**
+   * @param {ArrayType<Type<T>>} type
+   * @param {Context} context
+   */
+  constructor(type, context) {
+    this.#type = type;
+    this.#context = context;
+  }
+
+  get value() {
+    const {field, path} = this.#context;
+    return $o.get($o.field(field), path);
+  }
+
+  get type() {
+    return this.#type;
+  }
+
+  /**
+   * @param {number} index
+   * @returns {PickOf<T>}
+   */
+  get(index) {
+    return makeTypePick(
+      getTypeInstance(this.#type.valuesType),
+      contextWithPath(this.#context, index)
+    );
+  }
+
+  /**
+   * @param {T | ValuePick<T>} value
+   */
+  includes(value) {
+    return $o.includes(this.value, value);
+  }
+
+  /**
+   * @param {(value: PickOf<T>) => Operator} func
+   */
+  some(func) {
+    return $o.some(
+      this.value,
+      func(
+        makeTypePick(getTypeInstance(this.#type.valuesType), {
+          field: $o.someValue(),
+          path: [],
+        })
+      )
+    );
+  }
+}
+
+/**
+ * @param {{}} value
+ * @returns {value is AnyPick}
+ */
+function isAnyPick(value) {
+  return (
+    value instanceof ValuePick ||
+    value instanceof ObjectPick ||
+    value instanceof ArrayPick
+  );
+}
+
+/**
+ * @template {Record<string,any>} T
+ */
+class RowPick {
+  /** @type {ObjectTypeOf<T>} */
+  #type;
+
+  /**
+   * @param {ObjectTypeOf<T>} type
+   */
+  constructor(type) {
+    this.#type = type;
+  }
+
+  /**
+   * @template {keyof T} K
+   * @param {K} fieldName
+   * @returns {PickOf<T[K]>}
+   */
+  field(fieldName) {
+    const context = {
+      field: fieldName,
+      path: [],
+    };
+    return makeTypePick(
+      getTypeInstance(this.#type.properties[fieldName]),
+      context
+    );
+  }
+}
+
+/**
+ * @template T
+ * @param {Type<T>} type
+ * @param {Context} context
+ * @returns {PickOf<T>}
+ */
+function makeTypePick(type, context) {
+  if (type instanceof ArrayType) {
+    return /** @type {any} */ (new ArrayPick(type, context));
+  }
+  if (type instanceof ObjectType) {
+    return /** @type {any} */ (new ObjectPick(type, context));
+  }
+  return /** @type {any} */ (new ValuePick(type, context));
+}
+
+/**
+ * @template {AnyTypeOrShape} T
+ * @param {T} typeOrShape
+ * @param {Context} context
+ * @returns {PickOf<t<T>>}
+ */
+function makePick(typeOrShape, context) {
+  const type = getTypeInstance(typeOrShape);
+  return /** @type {any} */ (makeTypePick(type, context));
+}
+
+/**
+ * @template {Record<string,any>} T
+ * @param {ObjectTypeOf<T>} type
+ * @returns {RowPick<T>}
+ */
+function rowPick(type) {
+  return new RowPick(type);
+}
+
+module.exports = {
+  makeTypePick,
+  makePick,
+  rowPick,
+  isAnyPick,
+  ValuePick,
+  ObjectPick,
+  ArrayPick,
+  RowPick,
+};

package/lib/query-builder.js

@@ -0,0 +1,415 @@
+// @ts-check
+
+const {ObjectType, getTypeInstance} = 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
+ */
+
+/**
+ * @template T
+ * @typedef {import("./picks.js").PickOf<T>} PickOf
+ */
+/**
+ * @typedef {import("./picks.js").AnyPick} AnyPick
+ */
+/**
+ * @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,
+ *   selectOneField?: boolean,
+ *   where?: Operator,
+ *   orderBy?: ValuePick<any> | ValuePick<any>[]
+ * }} QueryObj
+ */
+
+/**
+ * @template {keyof QueryObj} K
+ * @typedef {flatten<Pick<Required<QueryObj>, K> & Omit<Partial<QueryObj>, K>>} QueryParts
+ */
+
+function mergeWhere(currentWhere, newWhere) {
+  if (!currentWhere) {
+    return newWhere;
+  }
+  return operators.and(currentWhere, newWhere);
+}
+
+/**
+ * @template R
+ */
+class FinalQuery {
+  #database;
+  #queryParts;
+
+  /**
+   * @param {*} database
+   * @param {QueryParts<'db' | 'from' | 'select'>} queryParts
+   */
+  constructor(database, queryParts) {
+    this.#database = database;
+    this.#queryParts = queryParts;
+  }
+
+  #getStatement() {
+    const {sql, values} = queryToSql(this.#queryParts);
+    return this.#database.prepare(sql).bind(values);
+  }
+
+  /**
+   * @returns {QueryObj}
+   */
+  get query() {
+    return this.#queryParts;
+  }
+
+  /**
+   * @returns {R}
+   */
+  get() {
+    const result = this.#getStatement().get();
+    if (result && this.#queryParts.selectOneField) {
+      return Object.values(result)[0];
+    }
+    return result;
+  }
+
+  /**
+   * @returns {R[]}
+   */
+  all() {
+    if (this.#queryParts.selectOneField) {
+      return Array.from(this.#getStatement().raw().iterate(), (row) => row[0]);
+    }
+    return this.#getStatement().all();
+  }
+
+  /**
+   * @returns {Generator<R>}
+   */
+  *iterate() {
+    if (this.#queryParts.selectOneField) {
+      for (const row of this.#getStatement().raw().iterate()) {
+        yield row[0];
+      }
+      return;
+    }
+    yield* this.#getStatement().iterate();
+  }
+}
+
+/**
+ * @template {Record<string, any>} T
+ * @template R
+ * @extends {FinalQuery<R>}
+ */
+class ScopedSelectQuery extends FinalQuery {
+  #database;
+  #type;
+  #queryParts;
+
+  /**
+   * @param {*} database
+   * @param {ObjectTypeOf<T>} type
+   * @param {QueryParts<'db' | 'from' | 'select' | 'scope'>} queryParts
+   */
+  constructor(database, type, queryParts) {
+    super(database, queryParts);
+    this.#database = database;
+    this.#type = type;
+    this.#queryParts = queryParts;
+  }
+
+  /**
+   * @param {(obj: ObjectPick<T>, $: typeof operators) => Operator} fct
+   * @returns {ScopedSelectQuery<T,R>}
+   */
+  where(fct) {
+    const scope = this.#queryParts.scope;
+    const queryParts = {
+      ...this.#queryParts,
+      where: mergeWhere(this.#queryParts.where, fct(scope, operators)),
+    };
+    return new ScopedSelectQuery(this.#database, this.#type, queryParts);
+  }
+
+  /**
+   * @param {(obj: ObjectPick<T>, $: typeof operators) => ValuePick<any> | ValuePick<any>[]} fct
+   * @returns {ScopedSelectQuery<T,R>}
+   */
+  orderBy(fct) {
+    const scope = this.#queryParts.scope;
+    const queryParts = {
+      ...this.#queryParts,
+      orderBy: fct(scope, operators),
+    };
+    return new ScopedSelectQuery(this.#database, this.#type, queryParts);
+  }
+}
+
+/**
+ * @template {Record<string, any>} T
+ * @template R
+ * @extends {FinalQuery<R>}
+ */
+class SelectQuery extends FinalQuery {
+  #database;
+  #type;
+  #queryParts;
+
+  /**
+   * @param {*} database
+   * @param {ObjectTypeOf<T>} type
+   * @param {QueryParts<'db' | 'from' | 'select'>} queryParts
+   */
+  constructor(database, type, queryParts) {
+    super(database, queryParts);
+    this.#database = database;
+    this.#type = type;
+    this.#queryParts = queryParts;
+  }
+
+  /**
+   * @param {(obj: RowPick<T>, $: typeof operators) => Operator} fct
+   * @returns {SelectQuery<T,R>}
+   */
+  where(fct) {
+    const queryParts = {
+      ...this.#queryParts,
+      where: mergeWhere(
+        this.#queryParts.where,
+        fct(rowPick(this.#type), operators)
+      ),
+    };
+    return new SelectQuery(this.#database, this.#type, queryParts);
+  }
+
+  /**
+   * @param {(obj: RowPick<T>, $: typeof operators) => ValuePick<any> | ValuePick<any>[]} fct
+   * @returns {SelectQuery<T,R>}
+   */
+  orderBy(fct) {
+    const queryParts = {
+      ...this.#queryParts,
+      orderBy: fct(rowPick(this.#type), operators),
+    };
+    return new SelectQuery(this.#database, this.#type, queryParts);
+  }
+}
+
+/**
+ * @template {Record<string, any>} T
+ */
+class ScopedFromQuery {
+  #database;
+  #type;
+  #queryParts;
+
+  /**
+   * @param {*} database
+   * @param {ObjectTypeOf<T>} type
+   * @param {QueryParts<'db' | 'from' | 'scope'>} queryParts
+   */
+  constructor(database, type, queryParts) {
+    this.#database = database;
+    this.#type = type;
+    this.#queryParts = queryParts;
+  }
+
+  /**
+   * Select field
+   * @template {keyof T} F
+   * @param {F} value
+   * @returns {ScopedSelectQuery<T, T[F]>}
+   */
+  field(value) {
+    const scope = this.#queryParts.scope;
+    const queryParts = {
+      ...this.#queryParts,
+      select: scope.get(value),
+      selectOneField: true,
+    };
+    return new ScopedSelectQuery(this.#database, this.#type, queryParts);
+  }
+
+  /**
+   * Select fields
+   * @template {(keyof T)[]} F
+   * @param {F} values
+   * @returns {ScopedSelectQuery<T, flatten<Pick<T, F[number]>>>}
+   */
+  fields(values) {
+    const scope = this.#queryParts.scope;
+    const queryParts = {
+      ...this.#queryParts,
+      select: values.map((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>}
+   */
+  select(fct) {
+    const scope = this.#queryParts.scope;
+    const selectedFields = fct(scope);
+    const queryParts = {...this.#queryParts, select: selectedFields};
+    return new ScopedSelectQuery(this.#database, this.#type, queryParts);
+  }
+
+  /**
+   * @param {(obj: ObjectPick<T>, $: typeof operators) => Operator} fct
+   * @returns {ScopedFromQuery<T>}
+   */
+  where(fct) {
+    const scope = this.#queryParts.scope;
+    const queryParts = {
+      ...this.#queryParts,
+      where: mergeWhere(this.#queryParts.where, fct(scope, operators)),
+    };
+    return new ScopedFromQuery(this.#database, this.#type, queryParts);
+  }
+}
+
+/**
+ * @template {Record<string, any>} T
+ */
+class FromQuery {
+  #database;
+  #type;
+  #queryParts;
+
+  /**
+   * @param {*} database
+   * @param {ObjectTypeOf<T>} type
+   * @param {QueryParts<'db' | 'from'>} queryParts
+   */
+  constructor(database, type, queryParts) {
+    this.#database = database;
+    this.#type = type;
+    this.#queryParts = queryParts;
+  }
+
+  /**
+   * @template {{}} U
+   * @param {(obj: RowPick<T>) => ObjectPick<U>} fct
+   * @returns {ScopedFromQuery<U>}
+   */
+  scope(fct) {
+    const value = fct(rowPick(this.#type));
+    const queryParts = {
+      ...this.#queryParts,
+      scope: value,
+    };
+    return new ScopedFromQuery(this.#database, value.type, queryParts);
+  }
+
+  /**
+   * Select fields
+   * @template {(keyof T)[]} F
+   * @param {F} fields
+   * @returns {SelectQuery<T, flatten<Pick<T, F[number]>>>}
+   */
+  fields(fields) {
+    const row = rowPick(this.#type);
+    const queryParts = {
+      ...this.#queryParts,
+      select: fields.map((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>}
+   */
+  select(fct) {
+    const selectedFields = fct(rowPick(this.#type));
+    const queryParts = {...this.#queryParts, select: selectedFields};
+    return new SelectQuery(this.#database, this.#type, queryParts);
+  }
+
+  /**
+   * @param {(obj: RowPick<T>, $: typeof operators) => Operator} fct
+   * @returns {FromQuery<T>}
+   */
+  where(fct) {
+    const queryParts = {
+      ...this.#queryParts,
+      where: mergeWhere(
+        this.#queryParts.where,
+        fct(rowPick(this.#type), operators)
+      ),
+    };
+    return new FromQuery(this.#database, this.#type, queryParts);
+  }
+}
+
+class DbQuery {
+  #database;
+  #queryParts;
+
+  /**
+   * @param {*} database
+   * @param {QueryParts<'db'>} queryParts
+   */
+  constructor(database, queryParts) {
+    this.#database = database;
+    this.#queryParts = queryParts;
+  }
+
+  /**
+   * @template {AnyObjectShape} T
+   * @param {string} tableName
+   * @param {T} shape
+   * @returns {FromQuery<t<T>>}
+   */
+  from(tableName, shape) {
+    const type = getTypeInstance(shape);
+    const queryParts = {
+      ...this.#queryParts,
+      from: tableName,
+    };
+    return /** @type {any} */ (new FromQuery(this.#database, type, queryParts));
+  }
+}
+
+class QueryBuilder {
+  #database;
+
+  /**
+   * @param {*} [database]
+   */
+  constructor(database) {
+    this.#database = database;
+  }
+
+  db(dbName) {
+    const queryParts = {
+      db: dbName,
+    };
+    return new DbQuery(this.#database, queryParts);
+  }
+}
+
+module.exports = {
+  QueryBuilder,
+  FromQuery,
+  ScopedFromQuery,
+};

package/lib/query-to-sql.js

@@ -0,0 +1,57 @@
+// @ts-check
+/**
+ * @typedef {import("./query-builder.js").QueryObj} QueryObj
+ */
+
+const {sql} = require('./operator-to-sql.js');
+const {isAnyPick} = require('./picks.js');
+
+/**
+ * @param {QueryObj["select"]} select
+ * @param {any[]} values
+ * @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}`)
+    .join(', ');
+}
+
+/**
+ * @param {NonNullable<QueryObj["orderBy"]>} orderBy
+ * @param {any[]} values
+ * @returns {string}
+ */
+function orderByFields(orderBy, values) {
+  if (Array.isArray(orderBy)) {
+    return orderBy.map((rep) => sql(rep.value, values)).join(', ');
+  }
+  return sql(orderBy.value, values);
+}
+
+/**
+ * @param {QueryObj} query
+ * @returns {{sql: string, values: any[]}}
+ */
+function queryToSql(query) {
+  const values = [];
+  let result = `SELECT ${selectFields(query.select, values)}`;
+  result += '\n' + `FROM ${query.from}`;
+  if (query.where) {
+    result += '\n' + `WHERE ${sql(query.where, values)}`;
+  }
+  if (query.orderBy) {
+    result += '\n' + `ORDER BY ${orderByFields(query.orderBy, values)}`;
+  }
+  return {sql: result, values};
+}
+
+module.exports = {
+  queryToSql,
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "xcraft-core-pickaxe",
+  "version": "0.1.0",
+  "description": "Query builder",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Xcraft-Inc/xcraft-core-pickaxe.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Xcraft-Inc/xcraft-core-pickaxe/issues"
+  },
+  "homepage": "https://github.com/Xcraft-Inc/xcraft-core-pickaxe#readme",
+  "dependencies": {
+    "xcraft-core-stones": "^0.4.0"
+  },
+  "devDependencies": {
+    "prettier": "2.0.4",
+    "xcraft-dev-prettier": "^2.0.0",
+    "xcraft-dev-rules": "^4.1.0"
+  },
+  "prettier": "xcraft-dev-prettier"
+}