@stamhoofd/sql 2.1.1

package/package.json

@@ -0,0 +1,15 @@
+{
+    "name": "@stamhoofd/sql",
+    "version": "2.1.1",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "license": "UNLICENCED",
+    "sideEffects": false,
+    "files": [
+        "src"
+    ],
+    "scripts": {
+        "build": "tsc -b",
+        "build:full": "rm -rf ./dist && yarn build"
+    }
+}

package/src/SQL.ts

@@ -0,0 +1,58 @@
+import { SQLExpression } from "./SQLExpression";
+import { SQLSelect } from "./SQLSelect";
+import { SQLColumnExpression, SQLSafeValue, SQLTableExpression, SQLWildcardSelectExpression, scalarToSQLExpression } from "./SQLExpressions";
+import { SQLJoin, SQLJoinType } from "./SQLJoin";
+import { SQLJsonExtract } from "./SQLJsonExpressions";
+
+class StaticSQL {
+    wildcard(namespace?: string) {
+        return new SQLWildcardSelectExpression(namespace)
+    }
+
+    column(namespace: string, column: string): SQLColumnExpression;
+    column(column: string): SQLColumnExpression;
+    column(namespaceOrColumn: string, column?: string): SQLColumnExpression {
+        if (column === undefined) {
+            return new SQLColumnExpression(namespaceOrColumn)
+        }
+        return new SQLColumnExpression(namespaceOrColumn, column)
+    }
+
+    jsonValue(column: SQLExpression, path: string): SQLJsonExtract {
+        return new SQLJsonExtract(column, new SQLSafeValue(path))
+    }
+
+    table(namespace: string, table: string): SQLTableExpression;
+    table(table: string): SQLTableExpression;
+    table(namespaceOrTable: string, table?: string): SQLTableExpression {
+        if (table === undefined) {
+            return new SQLTableExpression(namespaceOrTable)
+        }
+        return new SQLTableExpression(namespaceOrTable, table)
+    }
+
+    select(...columns: SQLExpression[]): InstanceType<typeof SQLSelect> {
+        if (columns.length === 0) {
+            return new SQLSelect(this.wildcard())
+        }
+        return new SQLSelect(...columns)
+    }
+
+    leftJoin(table: SQLExpression) {
+        return new SQLJoin(SQLJoinType.Left, table)
+    }
+
+    rightJoin(table: SQLExpression) {
+        return new SQLJoin(SQLJoinType.Right, table)
+    }
+
+    innerJoin(table: SQLExpression) {
+        return new SQLJoin(SQLJoinType.Inner, table)
+    }
+
+    join(table: SQLExpression) {
+        return new SQLJoin(SQLJoinType.Inner, table)
+    }
+}
+
+export const SQL = new StaticSQL();

package/src/SQLExpression.ts

@@ -0,0 +1,30 @@
+export type SQLExpressionOptions = {
+    defaultNamespace?: string
+};
+
+export type NormalizedSQLQuery = {query: string; params: any[]}
+export type SQLQuery = NormalizedSQLQuery|string
+
+export function joinSQLQuery(queries: (SQLQuery|undefined|null)[], seperator?: string): NormalizedSQLQuery {
+    queries = queries.filter(q => q !== undefined && q !== null)
+    return {
+        query: queries.map(q => typeof q === 'string' ? q : q!.query).join(seperator ?? ''),
+        params: queries.flatMap(q => typeof q === 'string' ? [] : q!.params)
+    }
+}
+
+export function normalizeSQLQuery(q: SQLQuery): NormalizedSQLQuery {
+    return {
+        query: typeof q === 'string' ? q : q.query,
+        params: typeof q === 'string' ? [] : q.params
+    }
+}
+
+
+export interface SQLExpression {
+    getSQL(options?: SQLExpressionOptions): SQLQuery
+}
+
+export function isSQLExpression(obj: unknown): obj is SQLExpression {
+    return typeof obj === 'object' && obj !== null && !!(obj as any).getSQL && typeof (obj as any).getSQL === 'function'
+}

package/src/SQLExpressions.ts

@@ -0,0 +1,246 @@
+import { isSQLExpression, joinSQLQuery, SQLExpression, SQLExpressionOptions, SQLQuery } from "./SQLExpression";
+import {Database} from "@simonbackx/simple-database"
+
+export type SQLScalarValue = string|number|boolean|Date;
+export type SQLDynamicExpression = SQLScalarValue|SQLScalarValue[]|null|SQLExpression
+
+export function scalarToSQLJSONExpression(s: SQLScalarValue|null): SQLExpression {
+    if (s === null) {
+        return new SQLJSONValue(null)
+    }
+
+    if (s === true) {
+        return new SQLJSONValue(true)
+    }
+
+    if (s === false) {
+        return new SQLJSONValue(false)
+    }
+
+    return new SQLScalar(s)
+}
+
+export function scalarToSQLExpression(s: SQLScalarValue|null): SQLExpression {
+    if (s === null) {
+        return new SQLNull()
+    }
+
+    return new SQLScalar(s)
+}
+
+export function readDynamicSQLExpression(s: SQLDynamicExpression): SQLExpression {
+    if (Array.isArray(s)) {
+        return new SQLArray(s)
+    }
+    if (s === null) {
+        return new SQLNull()
+    }
+
+    if (typeof s === 'object' && !(s instanceof Date)) {
+        return s;
+    }
+
+    return new SQLScalar(s)
+}
+
+export class SQLCount implements SQLExpression {
+    expression: SQLExpression|null
+
+    constructor(expression: SQLExpression|null = null) {
+        this.expression = expression
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'COUNT(',
+                this.expression ? this.expression.getSQL(options) : '*',
+            ')'
+        ])
+    }
+}
+
+export class SQLSelectAs implements SQLExpression {
+    expression: SQLExpression
+    as: SQLAlias
+
+    constructor(expression: SQLExpression, as: SQLAlias) {
+        this.expression = expression
+        this.as = as;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            this.expression.getSQL(options),
+            ' AS ',
+            this.as.getSQL(options)
+        ])
+    }
+}
+
+export class SQLAlias implements SQLExpression {
+    name: string;
+
+    constructor(name: string) {
+        this.name = name
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return Database.escapeId(this.name) ;
+    }
+}
+
+
+export class SQLConcat implements SQLExpression {
+    expressions: SQLExpression[];
+
+    constructor(...expressions: SQLExpression[]) {
+        this.expressions = expressions
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'CONCAT(',
+            joinSQLQuery(this.expressions.map(e => e.getSQL(options)), ', '),
+            ')'
+        ])
+    }
+}
+
+
+export class SQLAge implements SQLExpression {
+    expression: SQLExpression;
+
+    constructor(expression: SQLExpression) {
+        this.expression = expression
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'TIMESTAMPDIFF(YEAR, ',
+            this.expression.getSQL(options),
+            ', CURDATE())'
+        ])
+    }
+}
+
+export class SQLJSONValue implements SQLExpression {
+    value: null|true|false;
+
+    constructor(value: null|true|false) {
+        this.value = value;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return "CAST('"+JSON.stringify(this.value)+"' AS JSON)";
+    }
+}
+
+export class SQLNull implements SQLExpression {
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return 'NULL';
+    }
+}
+
+export class SQLNow implements SQLExpression {
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return 'NOW()';
+    }
+}
+
+export class SQLScalar implements SQLExpression {
+    value: SQLScalarValue;
+
+    constructor(value: SQLScalarValue) {
+        this.value = value
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return {
+            query: '?',
+            params: [this.value]
+        }
+    }
+}
+
+export class SQLSafeValue implements SQLExpression {
+    value: string|number;
+
+    constructor(value: string|number) {
+        this.value = value
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return JSON.stringify(this.value);
+    }
+}
+
+
+export class SQLArray implements SQLExpression {
+    value: SQLScalarValue[];
+
+    constructor(value: SQLScalarValue[]) {
+        this.value = value
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return {
+            query: '(?)',
+            params: [this.value]
+        }
+    }
+}
+
+export class SQLWildcardSelectExpression implements SQLExpression {
+    namespace?: string;
+
+    constructor(namespace?: string) {
+        this.namespace = namespace
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return Database.escapeId(this.namespace ?? options?.defaultNamespace ?? '') + '.*'
+    }
+}
+
+export class SQLColumnExpression implements SQLExpression {
+    namespace?: string;
+    column: string;
+
+    constructor(namespace: string, column: string);
+    constructor(column: string);
+    constructor(namespaceOrColumn: string, column?: string) {
+        if (column === undefined) {
+            this.column = namespaceOrColumn;
+            return;
+        }
+        this.namespace = namespaceOrColumn
+        this.column = column
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return Database.escapeId(this.namespace ?? options?.defaultNamespace ?? '') + '.' + Database.escapeId(this.column)
+    }
+}
+
+export class SQLTableExpression implements SQLExpression {
+    namespace?: string;
+    table: string;
+
+    constructor(namespace: string, table: string);
+    constructor(table: string);
+    constructor(namespaceOrTable: string, table?: string) {
+        if (table === undefined) {
+            this.table = namespaceOrTable;
+            return;
+        }
+        this.namespace = namespaceOrTable
+        this.table = table
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        if (!this.namespace) {
+            return Database.escapeId(this.table)
+        }
+        return Database.escapeId(this.table) + ' ' + Database.escapeId(this.namespace)
+    }
+}

package/src/SQLJoin.ts

@@ -0,0 +1,40 @@
+import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from "./SQLExpression";
+import { SQLWhere, addWhereHelpers } from "./SQLWhere";
+
+export enum SQLJoinType {
+    Left = "Left",
+    Right = "Right",
+    Inner = "Inner",
+    Outer = "Outer"
+}
+
+export class JoinBase implements SQLExpression {
+    type = SQLJoinType.Left
+    table: SQLExpression;
+    _where: SQLWhere|null = null;
+
+    constructor(type: SQLJoinType, table: SQLExpression) {
+        this.type = type;
+        this.table = table;
+    }
+
+    private getJoinPrefix(): string {
+        switch (this.type) {
+            case SQLJoinType.Left: return 'LEFT JOIN';
+            case SQLJoinType.Right: return 'RIGHT JOIN';
+            case SQLJoinType.Inner: return 'JOIN';
+            case SQLJoinType.Outer: return 'OUTER JOIN';
+        }
+    }
+
+    getSQL(options?: SQLExpressionOptions | undefined): SQLQuery {
+        return joinSQLQuery([
+            this.getJoinPrefix(),
+            this.table?.getSQL(),
+            this._where ? 'ON' : undefined,
+            this._where?.getSQL()
+        ], ' ')
+    }
+}
+
+export const SQLJoin = addWhereHelpers(JoinBase)

package/src/SQLJsonExpressions.ts

@@ -0,0 +1,111 @@
+import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from "./SQLExpression";
+import { SQLSafeValue } from "./SQLExpressions";
+
+/**
+ * Same as target->path, JSON_EXTRACT(target, path)
+ */
+export class SQLJsonExtract implements SQLExpression {
+    target: SQLExpression
+    path: SQLExpression
+
+    constructor(target: SQLExpression, path: SQLExpression) {
+        this.target = target;
+        this.path = path;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'JSON_EXTRACT(',
+                this.target.getSQL(options),
+                ',',
+                this.path.getSQL(options),
+            ')'
+        ])
+    }
+}
+
+/**
+ * JSON_SEARCH(json_doc, one_or_all, search_str[, escape_char[, path] ...])
+ */
+export class SQLJsonSearch implements SQLExpression {
+    target: SQLExpression
+    oneOrAll: 'one'|'all'
+    searchStr: SQLExpression;
+    path: SQLExpression|null;
+
+    constructor(target: SQLExpression, oneOrAll: 'one'|'all', searchStr: SQLExpression, path: SQLExpression|null = null) {
+        this.target = target;
+        this.oneOrAll = oneOrAll;
+        this.searchStr = searchStr;
+        this.path = path;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'JSON_SEARCH(',
+                this.target.getSQL(options),
+                ',',
+                new SQLSafeValue(this.oneOrAll).getSQL(options),
+                ',',
+                this.searchStr.getSQL(options),
+                ...(this.path ? [
+                    ',', 
+                    this.path.getSQL(options)
+                ] : []),
+            ')'
+        ])
+    }
+}
+
+/**
+ * JSON_CONTAINS(target, candidate[, path])
+ */
+export class SQLJsonContains implements SQLExpression {
+    target: SQLExpression
+    candidate: SQLExpression;
+    path: SQLExpression|null;
+
+    constructor(target: SQLExpression, candidate: SQLExpression, path: SQLExpression|null = null) {
+        this.target = target;
+        this.candidate = candidate;
+        this.path = path;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'JSON_CONTAINS(',
+                this.target.getSQL(options),
+                ',',
+                this.candidate.getSQL(options),
+                ...(this.path ? [
+                    ',', 
+                    this.path.getSQL(options)
+                ] : []),
+            ')'
+        ])
+    }
+}
+
+
+/**
+ * JSON_CONTAINS(json_doc1, json_doc2)
+ */
+export class SQLJsonOverlaps implements SQLExpression {
+    jsonDoc1: SQLExpression
+    jsonDoc2: SQLExpression;
+
+    constructor(jsonDoc1: SQLExpression, jsonDoc2: SQLExpression) {
+        this.jsonDoc1 = jsonDoc1;
+        this.jsonDoc2 = jsonDoc2;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'JSON_OVERLAPS(',
+                this.jsonDoc1.getSQL(options),
+                ',',
+                this.jsonDoc2.getSQL(options),
+            ')'
+        ])
+    }
+}

package/src/SQLOrderBy.ts

@@ -0,0 +1,63 @@
+import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from "./SQLExpression";
+
+type GConstructor<T = {}> = new (...args: any[]) => T;
+type Orderable = GConstructor<{ _orderBy: SQLOrderBy|null }>;
+
+export function addOrderByHelpers<TBase extends Orderable>(Base: TBase) {
+    return class extends Base {
+        
+        orderBy(orderBy: SQLOrderBy)
+        orderBy(column: SQLExpression, direction?: SQLOrderByDirection) 
+        orderBy(columnOrOrderBy: SQLExpression, direction?: SQLOrderByDirection) {
+            let o = columnOrOrderBy as SQLOrderBy
+            if (!(columnOrOrderBy instanceof SQLOrderBy)) {
+                o = new SQLOrderBy({column: columnOrOrderBy, direction: direction ?? 'ASC'})
+            }
+
+            if (this._orderBy) {
+                this._orderBy.add(o)
+            } else {
+                this._orderBy = o;
+            }
+
+            return this;
+        }
+    }
+}
+
+
+export type SQLOrderByDirection = 'ASC' | 'DESC';
+export class SQLOrderBy implements SQLExpression {
+    orderBy: {column: SQLExpression, direction: SQLOrderByDirection}[] = [];
+
+    constructor(...orderBy: {column: SQLExpression, direction: SQLOrderByDirection}[]) {
+        this.orderBy = orderBy
+    }
+
+    static combine(orderBy: SQLOrderBy[]) {
+        return new SQLOrderBy(...orderBy.flatMap(o => o.orderBy))
+    }
+
+    add(orderBy: SQLOrderBy) {
+        this.orderBy.push(...orderBy.orderBy)
+    }
+
+    getSQL(options?: SQLExpressionOptions | undefined): SQLQuery {
+        if (this.orderBy.length === 0) {
+            return '';
+        }
+
+        return joinSQLQuery([
+            'ORDER BY ',
+            joinSQLQuery(
+                this.orderBy.map(o => {
+                    return joinSQLQuery([
+                        o.column.getSQL(options),
+                        o.direction
+                    ], ' ')
+                }), 
+                ', '
+            )
+        ])
+    }
+}

package/src/SQLSelect.ts

@@ -0,0 +1,160 @@
+import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery, normalizeSQLQuery } from "./SQLExpression";
+import { SQLOrderBy, addOrderByHelpers } from "./SQLOrderBy";
+import { SQLWhere, addWhereHelpers } from "./SQLWhere";
+import {Database, SQLResultNamespacedRow} from "@simonbackx/simple-database"
+import {SQLJoin} from './SQLJoin'
+import { SQLAlias, SQLCount, SQLSelectAs, SQLWildcardSelectExpression } from "./SQLExpressions";
+
+class SelectBase implements SQLExpression {
+    _columns: SQLExpression[]
+    _from: SQLExpression;
+
+    _limit: number|null = null;
+    _offset: number|null = null;
+
+    _where: SQLWhere|null = null;
+    _orderBy: SQLOrderBy|null = null;
+    _joins: (InstanceType<typeof SQLJoin>)[] = [];
+
+    constructor(...columns: SQLExpression[]) {
+        this._columns = columns;
+    }
+
+    clone(): this {
+        const c = new SQLSelect(...this._columns)
+        Object.assign(c, this);
+        return c as any;
+    }
+
+    from(table: SQLExpression): this {
+        this._from = table;
+        return this;
+    }
+
+    join(join: InstanceType<typeof SQLJoin>): this {
+        this._joins.push(join);
+        return this;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        const query: SQLQuery[] = [
+            'SELECT'
+        ]
+
+        options = options ?? {}
+        options.defaultNamespace = (this._from as any).namespace ?? (this._from as any).table ?? undefined;
+
+        const columns = this._columns.map(c => c.getSQL(options))
+        query.push(
+            joinSQLQuery(columns, ', ')
+        )
+
+        query.push(
+            'FROM' 
+        )
+
+        query.push(this._from.getSQL(options));
+
+        query.push(...this._joins.map(j => j.getSQL(options)))
+
+        if (this._where) {
+            query.push('WHERE')
+            query.push(this._where.getSQL(options))
+        }
+
+        if (this._orderBy) {
+            query.push(this._orderBy.getSQL(options))
+        }
+
+
+        if (this._limit !== null) {
+            query.push('LIMIT ' + this._limit)
+            if (this._offset !== null && this._offset !== 0) {
+                query.push('OFFSET ' + this._offset)
+            }
+        }
+        
+        return joinSQLQuery(query, ' ');
+    }
+
+    limit(limit: number|null, offset: number|null = null): this {
+        this._limit = limit;
+        this._offset = offset;
+        return this;
+    }
+
+    async fetch(): Promise<SQLResultNamespacedRow[]> {
+        const {query, params} = normalizeSQLQuery(this.getSQL())
+
+        console.log(query, params);
+        const [rows] = await Database.select(query, params, {nestTables: true});
+
+        // Now map aggregated queries to the correct namespace
+        for (const row of rows) {
+            if (row['']) {
+                for (const column in row['']) {
+                    const splitted = column.split('__');
+                    if (splitted.length <= 1) {
+                        console.warn('Aggregated column without namespace', column)
+                        continue;
+                    }
+                    const namespace = splitted[0];
+                    const name = splitted[1];
+                    row[namespace] = row[namespace] ?? {};
+                    row[namespace][name] = row[''][column];
+                }
+                delete row[''];
+            }
+        }
+        return rows;
+    }
+
+    first(required: false): Promise<SQLResultNamespacedRow|null>
+    first(required: true): Promise<SQLResultNamespacedRow>
+    async first(required = true): Promise<SQLResultNamespacedRow|null>  {
+        const rows = await this.limit(1).fetch();
+        if (rows.length === 0) {
+            if (required) {
+                throw new Error('Required ' + this._from)
+            }
+            return null;
+        }
+        return rows[0]
+    }
+
+    async count(): Promise<number> {
+        this._columns = [
+            new SQLSelectAs(
+                new SQLCount(), 
+                new SQLAlias('c')
+            )
+        ]
+        this._offset = null;
+        this._limit = null;
+        this._orderBy = null;
+
+        const {query, params} = normalizeSQLQuery(this.getSQL());
+        console.log(query, params);
+
+        const [rows] = await Database.select(query, params, {nestTables: true});
+        if (rows.length === 1) {
+            const row = rows[0];
+            if ('' in row) {
+                const namespaced = row[''];
+                if ('c' in namespaced) {
+                    const value = namespaced['c'];
+                    if (typeof value === 'number' && Number.isInteger(value)) {
+                        return value;
+                    }
+                }
+            }
+        }
+        console.warn('Invalid count SQL response', rows);
+        return 0;
+    }
+}
+
+export const SQLSelect = addOrderByHelpers(
+    addWhereHelpers(SelectBase)
+)
+

package/src/SQLWhere.ts

@@ -0,0 +1,339 @@
+import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery, normalizeSQLQuery } from "./SQLExpression";
+import { SQLArray, SQLDynamicExpression, SQLNull, readDynamicSQLExpression } from "./SQLExpressions";
+
+type GConstructor<T = {}> = new (...args: any[]) => T;
+type Whereable = GConstructor<{ _where: SQLWhere|null }>;
+
+export type ParseWhereArguments = [
+    where: SQLWhere
+] | [
+    whereOrColumn: SQLExpression, 
+    sign: SQLWhereSign, 
+    value: SQLDynamicExpression
+] | [
+    whereOrColumn: SQLExpression, 
+    value: SQLDynamicExpression
+]
+
+export function addWhereHelpers<TBase extends Whereable>(Base: TBase) {
+    return class extends Base {
+        parseWhere(...[whereOrColumn, signOrValue, value]: ParseWhereArguments): SQLWhere {
+            if (signOrValue === undefined) {
+                return whereOrColumn as SQLWhere;
+            }
+
+            if (value !== undefined) {
+                return new SQLWhereEqual(
+                    whereOrColumn, 
+                    signOrValue as SQLWhereSign, 
+                    readDynamicSQLExpression(value)
+                )
+            }
+            return new SQLWhereEqual(
+                whereOrColumn, 
+                SQLWhereSign.Equal,
+                readDynamicSQLExpression(signOrValue)
+            )
+        }
+
+        where<T>(this: T, ...args: ParseWhereArguments): T {
+            const w = (this as any).parseWhere(...args);
+            if (!(this as any)._where) {
+                (this as any)._where = w;
+                return this;
+            }
+            (this as any)._where = (this as any)._where.and(w);
+            return this;
+        }
+
+        andWhere(...args: ParseWhereArguments) {
+            return this.where(...args)
+        }
+
+        orWhere(...args: ParseWhereArguments) {
+            const w = this.parseWhere(...args);
+            if (!this._where) {
+                this._where = w;
+                return this;
+            }
+            this._where = this._where.or(w);
+            return this;
+        }
+
+        whereNot(...args: ParseWhereArguments) {
+            const w = new SQLWhereNot(this.parseWhere(...args));
+            if (!this._where) {
+                this._where = w;
+                return this;
+            }
+            this._where = this._where.and(w);
+            return this;
+        }
+
+        andWhereNot(...args: ParseWhereArguments) {
+            return this.whereNot(...args)
+        }
+
+        orWhereNot(...args: ParseWhereArguments) {
+             const w = new SQLWhereNot(this.parseWhere(...args));
+            if (!this._where) {
+                this._where = w;
+                return this;
+            }
+            this._where = this._where.or(w);
+            return this;
+        }
+    }
+}
+
+export abstract class SQLWhere implements SQLExpression {
+    and(...where: SQLWhere[]): SQLWhere {
+        return new SQLWhereAnd([this, ...where]);
+    }
+
+    or(...where: SQLWhere[]): SQLWhere {
+        return new SQLWhereOr([this, ...where]);
+    }
+
+    get isSingle(): boolean {
+        return false;
+    }
+
+    abstract getSQL(options?: SQLExpressionOptions): SQLQuery
+}
+
+export enum SQLWhereSign {
+    Equal = '=',
+    Greater = '>',
+    Less = '<',
+    NotEqual = '!='
+}
+
+export class SQLWhereEqual extends SQLWhere {
+    column: SQLExpression;
+    sign = SQLWhereSign.Equal
+    value: SQLExpression;
+    
+    constructor (column: SQLExpression, sign: SQLWhereSign, value: SQLExpression)
+    constructor (column: SQLExpression, value: SQLExpression)
+    constructor (column: SQLExpression, signOrValue: SQLExpression | SQLWhereSign, value?: SQLExpression) {
+        super()
+        this.column = column;
+
+        if (value !== undefined) {
+            this.value = value;
+            this.sign = signOrValue as SQLWhereSign;
+        } else {
+            this.value = signOrValue as SQLExpression;
+        }
+    }
+
+    clone(): this {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const c = (new (this.constructor as any)(this.column, this.sign, this.value)) as this
+        Object.assign(c, this);
+        return c;
+    }
+
+    get isSingle(): boolean {
+        return true;
+    }
+
+    inverted(): this {
+        return this.clone().invert()
+    }
+
+    invert(): this {
+        switch (this.sign) {
+            case SQLWhereSign.Equal: this.sign = SQLWhereSign.NotEqual; break;
+            case SQLWhereSign.NotEqual: this.sign = SQLWhereSign.Equal; break;
+            case SQLWhereSign.Greater: this.sign = SQLWhereSign.Less; break;
+            case SQLWhereSign.Less: this.sign = SQLWhereSign.Greater; break;
+        }
+        return this;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        if (this.value instanceof SQLArray) {
+            if (this.sign !== SQLWhereSign.Equal && this.sign !== SQLWhereSign.NotEqual) {
+                throw new Error('Unsupported sign for array: ' + this.sign);
+            }
+
+            return joinSQLQuery([
+                this.column.getSQL(options),
+                ` ${(this.sign === SQLWhereSign.NotEqual) ? 'NOT IN' : 'IN'} `,
+                this.value.getSQL(options)
+            ])
+        }
+
+
+        if (this.value instanceof SQLNull) {
+            if (this.sign !== SQLWhereSign.Equal && this.sign !== SQLWhereSign.NotEqual) {
+                throw new Error('Unsupported sign for NULL: ' + this.sign);
+            }
+
+            return joinSQLQuery([
+                this.column.getSQL(options),
+                ` IS ${(this.sign === SQLWhereSign.NotEqual) ? 'NOT ' : ''} `,
+                this.value.getSQL(options)
+            ])
+        }
+
+        return joinSQLQuery([
+            this.column.getSQL(options),
+            ` ${this.sign} `,
+            this.value.getSQL(options)
+        ])
+    }
+}
+
+export class SQLWhereLike extends SQLWhere {
+    column: SQLExpression;
+    notLike = false;
+    value: SQLExpression;
+    
+    constructor (column: SQLExpression, value: SQLExpression)  {
+        super()
+        this.column = column;
+        this.value = value
+    }
+
+    static escape(str: string) {
+        return str.replace(/([%_])/g, '\\$1')
+    }
+
+    clone(): this {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const c = (new (this.constructor as any)(this.column, this.value)) as this
+        Object.assign(c, this);
+        return c;
+    }
+
+    get isSingle(): boolean {
+        return true;
+    }
+
+    inverted(): this {
+        return this.clone().invert()
+    }
+
+    invert(): this {
+        this.notLike = !this.notLike
+        return this;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            this.column.getSQL(options),
+            ` ${this.notLike ? 'NOT LIKE' : 'LIKE'} `,
+            this.value.getSQL(options)
+        ])
+    }
+}
+
+export class SQLWhereExists extends SQLWhere {
+    subquery: SQLExpression;
+    notExists = false;
+    
+    constructor (subquery: SQLExpression)  {
+        super()
+        this.subquery = subquery;
+    }
+
+    clone(): this {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const c = (new (this.constructor as any)(this.subquery)) as this
+        Object.assign(c, this);
+        return c;
+    }
+
+    get isSingle(): boolean {
+        return true;
+    }
+
+    inverted(): this {
+        return this.clone().invert()
+    }
+
+    invert(): this {
+        this.notExists = !this.notExists
+        return this;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            `${this.notExists ? 'NOT EXISTS' : 'EXISTS'} (`,
+            this.subquery.getSQL({...options}),
+            `)`,
+        ])
+    }
+}
+
+export class SQLWhereAnd extends SQLWhere {
+    children: SQLWhere[]
+
+    constructor (children: SQLWhere[]) {
+        super()
+        this.children = children;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery(
+            this.children.map(c => {
+                if (c.isSingle) {
+                    return c.getSQL(options)
+                }
+                return joinSQLQuery(['(', c.getSQL(options), ')'])
+            }), 
+            ' AND '
+        )
+    }
+}
+
+export class SQLWhereOr extends SQLWhere {
+    children: SQLWhere[]
+
+    constructor (children: SQLWhere[]) {
+        super()
+        this.children = children;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery(
+            this.children.map(c => {
+                if (c.isSingle) {
+                    return c.getSQL(options)
+                }
+                return joinSQLQuery(['(', c.getSQL(options), ')'])
+            }), 
+            ' OR '
+        )
+    }
+}
+
+export class SQLWhereNot extends SQLWhere {
+    a: SQLWhere
+
+    constructor (a: SQLWhere) {
+        super()
+        this.a = a;
+    }
+
+    get isSingle(): boolean {
+        return this.a.isSingle;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        // Optimize query
+        if (this.a instanceof SQLWhereEqual) {
+            return this.a.inverted().getSQL(options);
+        }
+
+        const sqlA = normalizeSQLQuery(this.a.getSQL(options));
+
+        return {
+            query: `NOT (${sqlA.query})`, 
+            params: sqlA.params
+        }
+    }
+}

package/src/filters/SQLFilter.ts

@@ -0,0 +1,264 @@
+import { SimpleError } from "@simonbackx/simple-errors";
+import { StamhoofdFilter, StamhoofdKeyFilterValue } from "@stamhoofd/structures";
+import { SQL } from "../SQL";
+import { SQLExpression } from "../SQLExpression";
+import { SQLArray, SQLColumnExpression, SQLNull, SQLSafeValue, SQLScalarValue, scalarToSQLExpression, scalarToSQLJSONExpression } from "../SQLExpressions";
+import { SQLJsonContains, SQLJsonOverlaps, SQLJsonSearch } from "../SQLJsonExpressions";
+import { SQLSelect } from "../SQLSelect";
+import { SQLWhere, SQLWhereAnd, SQLWhereEqual, SQLWhereExists, SQLWhereLike, SQLWhereNot, SQLWhereOr, SQLWhereSign } from "../SQLWhere";
+
+export type SQLFilterCompiler = (filter: StamhoofdFilter, filters: SQLFilterDefinitions) => SQLWhere|null;
+export type SQLFilterDefinitions = Record<string, SQLFilterCompiler>
+
+export function andSQLFilterCompiler(filter: StamhoofdFilter, filters: SQLFilterDefinitions): SQLWhere {
+    const runners = compileSQLFilter(filter, filters);
+    return new SQLWhereAnd(runners)
+}
+
+export function orSQLFilterCompiler(filter: StamhoofdFilter, filters: SQLFilterDefinitions): SQLWhere {
+    const runners = compileSQLFilter(filter, filters);
+    return new SQLWhereOr(runners)
+}
+
+export function notSQLFilterCompiler(filter: StamhoofdFilter, filters: SQLFilterDefinitions): SQLWhere {
+    const andRunner = andSQLFilterCompiler(filter, filters);
+    return new SQLWhereNot(andRunner)
+}
+
+function guardScalar(s: any): asserts s is SQLScalarValue|null  {
+    if (typeof s !== 'string' && typeof s !== 'number' && typeof s !== 'boolean' && !(s instanceof Date) && s !== null) {
+        throw new Error('Invalid scalar value')
+    }
+
+}
+
+function guardNotNullScalar(s: any): asserts s is SQLScalarValue  {
+    if (typeof s !== 'string' && typeof s !== 'number' && typeof s !== 'boolean' && !(s instanceof Date)) {
+        throw new Error('Invalid scalar value')
+    }
+}
+
+function guardString(s: any): asserts s is string  {
+    if (typeof s !== 'string') {
+        throw new Error('Invalid string value')
+    }
+}
+
+export function createSQLRelationFilterCompiler(baseSelect: InstanceType<typeof SQLSelect> & SQLExpression, definitions: SQLFilterDefinitions): SQLFilterCompiler {
+    return (filter: StamhoofdFilter) => {
+        const f = filter as any;
+
+        if ('$elemMatch' in f) {
+            const w = compileToSQLFilter(f['$elemMatch'], definitions)
+            const q = baseSelect.clone().where(w);
+            return new SQLWhereExists(q)
+        }
+
+        throw new Error('Invalid filter')
+    }
+}
+
+// Already joined, but creates a namespace
+export function createSQLFilterNamespace(definitions: SQLFilterDefinitions): SQLFilterCompiler {
+    return (filter: StamhoofdFilter) => {
+        return andSQLFilterCompiler(filter, definitions)
+    }
+}
+
+export function createSQLExpressionFilterCompiler(sqlExpression: SQLExpression, normalizeValue?: (v: SQLScalarValue|null) => SQLScalarValue|null, isJSONValue = false, isJSONObject = false): SQLFilterCompiler {
+    const norm = normalizeValue ?? ((v) => v);
+    const convertToExpression = isJSONValue ? scalarToSQLJSONExpression : scalarToSQLExpression
+
+    return (filter: StamhoofdFilter, filters: SQLFilterDefinitions) => {
+        if (typeof filter === 'string' || typeof filter === 'number' || typeof filter === 'boolean' || filter === null || filter === undefined) {
+            filter = {
+                $eq: filter
+            }
+        }
+
+        if (Array.isArray(filter)) {
+            throw new Error('Unexpected array in filter')
+        }
+
+        
+        const f = filter as any;
+
+        if ('$eq' in f) {
+            guardScalar(f.$eq);
+
+            if (isJSONObject) {
+                const v = norm(f.$eq);
+
+                // if (typeof v === 'string') {
+                //     return new SQLWhereEqual(
+                //         new SQLJsonSearch(sqlExpression, 'one', convertToExpression(v)), 
+                //         SQLWhereSign.NotEqual, 
+                //         new SQLNull()
+                //     );
+                // }
+
+                // else
+                return new SQLWhereEqual(
+                    new SQLJsonContains(
+                        sqlExpression, 
+                        convertToExpression(JSON.stringify(v))
+                    ), 
+                    SQLWhereSign.Equal, 
+                    new SQLSafeValue(1)
+                );
+            }
+            return new SQLWhereEqual(sqlExpression, SQLWhereSign.Equal, convertToExpression(norm(f.$eq)));
+        }
+
+        if ('$in' in f) {
+            if (!Array.isArray(f.$in)) {
+                throw new SimpleError({
+                    code: 'invalid_filter',
+                    message: 'Expected array at $in filter'
+                })
+            }
+
+            if (f.$in.length === 0) {
+                return new SQLWhereEqual(new SQLSafeValue(1), SQLWhereSign.Equal, new SQLSafeValue(0));
+            }
+
+            const v = f.$in.map(a => norm(a));
+
+            if (isJSONObject) {
+                // else
+                return new SQLWhereEqual(
+                    new SQLJsonOverlaps(
+                        sqlExpression, 
+                        convertToExpression(JSON.stringify(v))
+                    ), 
+                    SQLWhereSign.Equal, 
+                    new SQLSafeValue(1)
+                );
+            }
+            return new SQLWhereEqual(sqlExpression, SQLWhereSign.Equal, new SQLArray(v));
+        }
+
+        if ('$neq' in f) {
+            guardScalar(f.$neq);
+
+            if (isJSONObject) {
+                const v = norm(f.$eq);
+
+                // if (typeof v === 'string') {
+                //     return new SQLWhereEqual(
+                //         new SQLJsonSearch(sqlExpression, 'one', convertToExpression(v)), 
+                //         SQLWhereSign.Equal, 
+                //         new SQLNull()
+                //     );
+                // }
+
+                // else
+                return new SQLWhereEqual(
+                    new SQLJsonContains(
+                        sqlExpression, 
+                        convertToExpression(JSON.stringify(v))
+                    ), 
+                    SQLWhereSign.Equal, 
+                    new SQLSafeValue(0)
+                );
+            }
+            return new SQLWhereEqual(sqlExpression, SQLWhereSign.NotEqual, convertToExpression(norm(f.$neq)));
+        }
+
+        if ('$gt' in f) {
+            guardScalar(f.$gt);
+
+            if (isJSONObject) {
+                throw new Error('Greater than is not supported in this place')
+            }
+
+            if (f.$gt === null) {
+                // > null is same as not equal to null (everything is larger than null in mysql) - to be consistent with order by behaviour
+                return new SQLWhereEqual(sqlExpression, SQLWhereSign.NotEqual, convertToExpression(null));
+            }
+            return new SQLWhereEqual(sqlExpression, SQLWhereSign.Greater, convertToExpression(norm(f.$gt)));
+        }
+
+        if ('$lt' in f) {
+            guardScalar(f.$lt);
+
+            if (isJSONObject) {
+                throw new Error('Less than is not supported in this place')
+            }
+
+            if (f.$lt === null) {
+                // < null is always nothing, there is nothing smaller than null in MySQL - to be consistent with order by behaviour
+                return new SQLWhereEqual(new SQLSafeValue(1), SQLWhereSign.Equal, new SQLSafeValue(0));
+            }
+            return new SQLWhereEqual(sqlExpression, SQLWhereSign.Less, convertToExpression(norm(f.$lt)));
+        }
+
+        if ('$contains' in f) {
+            guardString(f.$contains);
+
+            if (isJSONObject) {
+                return new SQLWhereEqual(
+                    new SQLJsonSearch(
+                        sqlExpression, 
+                        'one',
+                        convertToExpression(
+                            '%'+SQLWhereLike.escape(f.$contains)+'%'
+                        )
+                    ), 
+                    SQLWhereSign.NotEqual, 
+                    new SQLNull()
+                );
+            }
+            
+            return new SQLWhereLike(
+                sqlExpression, 
+                convertToExpression(
+                    '%'+SQLWhereLike.escape(f.$contains)+'%'
+                )
+            );
+        }
+
+        throw new Error('Invalid filter ' + JSON.stringify(f))
+    }
+}
+
+export function createSQLColumnFilterCompiler(name: string | SQLColumnExpression, normalizeValue?: (v: SQLScalarValue|null) => SQLScalarValue|null): SQLFilterCompiler {
+    const column = name instanceof SQLColumnExpression ? name : SQL.column(name);
+    return createSQLExpressionFilterCompiler(column, normalizeValue)
+}
+
+export const baseSQLFilterCompilers: SQLFilterDefinitions = {
+    '$and': andSQLFilterCompiler,
+    '$or': orSQLFilterCompiler,
+    '$not': notSQLFilterCompiler,
+}
+
+function compileSQLFilter(filter: StamhoofdFilter, definitions: SQLFilterDefinitions): SQLWhere[] {
+    if (filter === undefined) {
+        return [];
+    }
+
+    const runners: SQLWhere[] = []
+
+    for (const f of (Array.isArray(filter) ? filter : [filter])) {
+        if (!f) {
+            continue;
+        }
+        for (const key of Object.keys(f)) {
+            const filter = definitions[key];
+            if (!filter) {
+                throw new Error('Unsupported filter ' + key)
+            }
+
+            const s = filter(f[key] as StamhoofdFilter, definitions)
+            if (s === undefined || s === null) {
+                throw new Error('Unsupported filter value for ' + key)
+            }
+            runners.push(s);
+        }
+    }
+
+    return runners
+}
+
+export const compileToSQLFilter = andSQLFilterCompiler

package/src/filters/SQLSorter.ts

@@ -0,0 +1,29 @@
+import { PlainObject } from "@simonbackx/simple-encoding";
+import { SortDefinition, SortList } from "@stamhoofd/structures";
+
+import { SQLOrderBy, SQLOrderByDirection } from "../SQLOrderBy";
+
+export type SQLSortDefinition<T, B extends PlainObject = PlainObject> = SortDefinition<T, B> & {
+    toSQL(direction: SQLOrderByDirection): SQLOrderBy
+};
+
+export type SQLSortDefinitions<T = any> = Record<string, SQLSortDefinition<T>>
+
+export function compileToSQLSorter(sortBy: SortList, definitions: SQLSortDefinitions): SQLOrderBy {
+    const sorters: SQLOrderBy[] = [];
+    
+    for (const s of sortBy) {
+        const d = definitions[s.key];
+        if (!d) {
+            throw new Error('Unknown sort key ' + s.key)
+        }
+
+        sorters.push(d.toSQL(s.order));
+    }
+
+    if (sorters.length === 0) {
+        throw new Error('No sortBy passed')
+    }
+
+    return SQLOrderBy.combine(sorters)
+}