@relq/orm 0.1.3 → 0.1.4

package/dist/esm/mysql/condition/json-path-proxy.js

@@ -0,0 +1,513 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+const TERMINAL_METHODS = new Set([
+    'equal', 'notEqual',
+    'greaterThan', 'greaterThanOrEqual',
+    'lessThan', 'lessThanOrEqual',
+    'between',
+    'in', 'notIn',
+    'like', 'ilike', 'startsWith', 'endsWith',
+    'contains',
+    'regex', 'iregex',
+    'before', 'after',
+    'isNull', 'isNotNull',
+    'containedBy',
+    'hasKey', 'hasAnyKeys', 'hasAllKeys',
+    'typeOf',
+]);
+const ARRAY_TERMINAL_METHODS = new Set([
+    'length', 'isEmpty', 'isNotEmpty',
+    'contains', 'containsAll', 'containsAny',
+    'some', 'every',
+]);
+const ELEMENT_TERMINALS = new Set([
+    'equal', 'notEqual',
+    'isNull', 'isNotNull',
+    'in', 'notIn',
+    'greaterThan', 'greaterThanOrEqual',
+    'lessThan', 'lessThanOrEqual',
+    'between',
+    'like', 'ilike', 'startsWith', 'endsWith',
+    'contains',
+    'regex', 'iregex',
+    'before', 'after',
+    'containedBy',
+    'hasKey', 'hasAnyKeys', 'hasAllKeys',
+    'typeOf',
+]);
+const PROXY_TRAP_IGNORE = new Set([
+    'then', 'toJSON', 'valueOf', 'toString',
+    'constructor', 'prototype', '__proto__',
+    'inspect', 'nodeType',
+    'asymmetricMatch',
+    '$$typeof',
+]);
+export function createMysqlJsonColumnProxy(parent) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            return createMysqlJsonPathProxy(prop, [], parent);
+        }
+    });
+}
+function createMysqlJsonPathProxy(column, path, parent) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            const propName = prop;
+            if (TERMINAL_METHODS.has(propName)) {
+                return (...args) => {
+                    parent.conditions.push({
+                        method: 'mysql_json_proxy',
+                        column,
+                        values: { path: [...path], op: propName, args }
+                    });
+                    return parent;
+                };
+            }
+            if (propName === 'array') {
+                return createMysqlJsonArrayProxy(column, path, parent);
+            }
+            return createMysqlJsonPathProxy(column, [...path, propName], parent);
+        }
+    });
+}
+function createMysqlJsonArrayProxy(column, path, parent) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            const propName = prop;
+            if (propName === 'some') {
+                return (callback) => {
+                    const subConditions = [];
+                    const elementProxy = createMysqlJsonArrayElementProxy(subConditions);
+                    callback(elementProxy);
+                    parent.conditions.push({
+                        method: 'mysql_json_proxy',
+                        column,
+                        values: { path: [...path], op: 'array_some', args: [{ conditions: subConditions }] }
+                    });
+                    return parent;
+                };
+            }
+            if (propName === 'every') {
+                return (callback) => {
+                    const subConditions = [];
+                    const elementProxy = createMysqlJsonArrayElementProxy(subConditions);
+                    callback(elementProxy);
+                    parent.conditions.push({
+                        method: 'mysql_json_proxy',
+                        column,
+                        values: { path: [...path], op: 'array_every', args: [{ conditions: subConditions }] }
+                    });
+                    return parent;
+                };
+            }
+            if (ARRAY_TERMINAL_METHODS.has(propName)) {
+                return (...args) => {
+                    parent.conditions.push({
+                        method: 'mysql_json_proxy',
+                        column,
+                        values: { path: [...path], op: `array_${propName}`, args }
+                    });
+                    return parent;
+                };
+            }
+            return undefined;
+        }
+    });
+}
+function createMysqlJsonArrayElementProxy(conditions, path = []) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            const name = prop;
+            if (ELEMENT_TERMINALS.has(name)) {
+                return (...args) => {
+                    conditions.push({ path: [...path], op: name, args });
+                };
+            }
+            return createMysqlJsonArrayElementProxy(conditions, [...path, name]);
+        }
+    });
+}
+export function buildMysqlJsonProxySQL(condition) {
+    const { column, values } = condition;
+    const { path, op, args } = values;
+    if (!column)
+        return '';
+    if (op.startsWith('array_')) {
+        return buildMysqlArrayOpSQL(column, path, op, args);
+    }
+    if (path.length === 0) {
+        return buildMysqlColumnLevelSQL(column, op, args);
+    }
+    return buildMysqlPathLevelSQL(column, path, op, args);
+}
+function toMysqlPath(segments) {
+    if (segments.length === 0)
+        return '$';
+    return '$.' + segments.join('.');
+}
+function jsonExtract(column, path) {
+    return `JSON_EXTRACT(${mysqlFormat.ident(column)}, ${mysqlFormat.literal(toMysqlPath(path))})`;
+}
+function jsonUnquoteExtract(column, path) {
+    return `JSON_UNQUOTE(${jsonExtract(column, path)})`;
+}
+function buildMysqlColumnLevelSQL(column, op, args) {
+    const col = mysqlFormat.ident(column);
+    switch (op) {
+        case 'contains':
+            return `JSON_CONTAINS(${col}, ${mysqlFormat.literal(JSON.stringify(args[0]))})`;
+        case 'containedBy':
+            return `JSON_CONTAINS(${mysqlFormat.literal(JSON.stringify(args[0]))}, ${col})`;
+        case 'hasKey':
+            return `JSON_EXTRACT(${col}, ${mysqlFormat.literal('$.' + args[0])}) IS NOT NULL`;
+        case 'hasAnyKeys': {
+            const checks = args[0].map(k => `JSON_EXTRACT(${col}, ${mysqlFormat.literal('$.' + k)}) IS NOT NULL`);
+            return `(${checks.join(' OR ')})`;
+        }
+        case 'hasAllKeys': {
+            const checks = args[0].map(k => `JSON_EXTRACT(${col}, ${mysqlFormat.literal('$.' + k)}) IS NOT NULL`);
+            return `(${checks.join(' AND ')})`;
+        }
+        case 'isNull':
+            return `${col} IS NULL`;
+        case 'isNotNull':
+            return `${col} IS NOT NULL`;
+        case 'equal':
+            return `${col} = CAST(${mysqlFormat.literal(JSON.stringify(args[0]))} AS JSON)`;
+        case 'notEqual':
+            return `${col} != CAST(${mysqlFormat.literal(JSON.stringify(args[0]))} AS JSON)`;
+        case 'typeOf':
+            return `JSON_TYPE(${col}) = ${mysqlFormat.literal(args[0])}`;
+        default:
+            return '';
+    }
+}
+function buildMysqlPathLevelSQL(column, path, op, args) {
+    const textExpr = jsonUnquoteExtract(column, path);
+    const jsonExpr = jsonExtract(column, path);
+    switch (op) {
+        case 'equal':
+            if (typeof args[0] === 'number' || typeof args[0] === 'boolean' || args[0] === null) {
+                return `${jsonExpr} = ${mysqlFormat.literal(args[0])}`;
+            }
+            if (typeof args[0] === 'object' && args[0] !== null) {
+                return `${jsonExpr} = CAST(${mysqlFormat.literal(JSON.stringify(args[0]))} AS JSON)`;
+            }
+            return `${textExpr} = ${mysqlFormat.literal(args[0])}`;
+        case 'notEqual':
+            if (typeof args[0] === 'number' || typeof args[0] === 'boolean' || args[0] === null) {
+                return `${jsonExpr} != ${mysqlFormat.literal(args[0])}`;
+            }
+            if (typeof args[0] === 'object' && args[0] !== null) {
+                return `${jsonExpr} != CAST(${mysqlFormat.literal(JSON.stringify(args[0]))} AS JSON)`;
+            }
+            return `${textExpr} != ${mysqlFormat.literal(args[0])}`;
+        case 'greaterThan':
+            return typeof args[0] === 'number'
+                ? `${jsonExpr} > ${args[0]}`
+                : `${textExpr} > ${mysqlFormat.literal(args[0])}`;
+        case 'greaterThanOrEqual':
+            return typeof args[0] === 'number'
+                ? `${jsonExpr} >= ${args[0]}`
+                : `${textExpr} >= ${mysqlFormat.literal(args[0])}`;
+        case 'lessThan':
+            return typeof args[0] === 'number'
+                ? `${jsonExpr} < ${args[0]}`
+                : `${textExpr} < ${mysqlFormat.literal(args[0])}`;
+        case 'lessThanOrEqual':
+            return typeof args[0] === 'number'
+                ? `${jsonExpr} <= ${args[0]}`
+                : `${textExpr} <= ${mysqlFormat.literal(args[0])}`;
+        case 'between':
+            return typeof args[0] === 'number'
+                ? `${jsonExpr} BETWEEN ${args[0]} AND ${args[1]}`
+                : `${textExpr} BETWEEN ${mysqlFormat.literal(args[0])} AND ${mysqlFormat.literal(args[1])}`;
+        case 'in': {
+            const vals = args[0].map(v => mysqlFormat.literal(v)).join(', ');
+            return typeof args[0]?.[0] === 'number'
+                ? `${jsonExpr} IN (${vals})`
+                : `${textExpr} IN (${vals})`;
+        }
+        case 'notIn': {
+            const vals = args[0].map(v => mysqlFormat.literal(v)).join(', ');
+            return typeof args[0]?.[0] === 'number'
+                ? `${jsonExpr} NOT IN (${vals})`
+                : `${textExpr} NOT IN (${vals})`;
+        }
+        case 'like':
+            return `${textExpr} LIKE ${mysqlFormat.literal(args[0])}`;
+        case 'ilike':
+            return `LOWER(${textExpr}) LIKE LOWER(${mysqlFormat.literal(args[0])})`;
+        case 'startsWith':
+            return `${textExpr} LIKE ${mysqlFormat.literal(`${args[0]}%`)}`;
+        case 'endsWith':
+            return `${textExpr} LIKE ${mysqlFormat.literal(`%${args[0]}`)}`;
+        case 'contains':
+            if (typeof args[0] === 'string') {
+                return `${textExpr} LIKE ${mysqlFormat.literal(`%${args[0]}%`)}`;
+            }
+            return `JSON_CONTAINS(${jsonExpr}, ${mysqlFormat.literal(JSON.stringify(args[0]))})`;
+        case 'regex':
+            return `REGEXP_LIKE(${textExpr}, ${mysqlFormat.literal(args[0])}, 'c')`;
+        case 'iregex':
+            return `REGEXP_LIKE(${textExpr}, ${mysqlFormat.literal(args[0])}, 'i')`;
+        case 'before':
+            return `${textExpr} < ${mysqlFormat.literal(args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'after':
+            return `${textExpr} > ${mysqlFormat.literal(args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'isNull':
+            return `(${jsonExpr} IS NULL OR JSON_TYPE(${jsonExpr}) = 'NULL')`;
+        case 'isNotNull':
+            return `(${jsonExpr} IS NOT NULL AND JSON_TYPE(${jsonExpr}) != 'NULL')`;
+        case 'containedBy':
+            return `JSON_CONTAINS(${mysqlFormat.literal(JSON.stringify(args[0]))}, ${jsonExpr})`;
+        case 'hasKey':
+            return `JSON_EXTRACT(${jsonExpr}, ${mysqlFormat.literal('$.' + args[0])}) IS NOT NULL`;
+        case 'hasAnyKeys': {
+            const checks = args[0].map(k => `JSON_EXTRACT(${jsonExpr}, ${mysqlFormat.literal('$.' + k)}) IS NOT NULL`);
+            return `(${checks.join(' OR ')})`;
+        }
+        case 'hasAllKeys': {
+            const checks = args[0].map(k => `JSON_EXTRACT(${jsonExpr}, ${mysqlFormat.literal('$.' + k)}) IS NOT NULL`);
+            return `(${checks.join(' AND ')})`;
+        }
+        case 'typeOf':
+            return `JSON_TYPE(${jsonExpr}) = ${mysqlFormat.literal(args[0])}`;
+        default:
+            return '';
+    }
+}
+function buildMysqlArrayOpSQL(column, path, op, args) {
+    const col = mysqlFormat.ident(column);
+    const mysqlPath = toMysqlPath(path);
+    const source = path.length === 0
+        ? col
+        : `JSON_EXTRACT(${col}, ${mysqlFormat.literal(mysqlPath)})`;
+    switch (op) {
+        case 'array_length': {
+            const [operator, value] = args;
+            return `JSON_LENGTH(${source}) ${operator} ${value}`;
+        }
+        case 'array_isEmpty':
+            return `JSON_LENGTH(${source}) = 0`;
+        case 'array_isNotEmpty':
+            return `JSON_LENGTH(${source}) > 0`;
+        case 'array_contains':
+            return `JSON_CONTAINS(${source}, ${mysqlFormat.literal(JSON.stringify(args[0]))})`;
+        case 'array_containsAll':
+            return `JSON_CONTAINS(${source}, ${mysqlFormat.literal(JSON.stringify(args[0]))})`;
+        case 'array_containsAny': {
+            const elements = args[0];
+            const conditions = elements.map(el => `JSON_CONTAINS(${source}, ${mysqlFormat.literal(JSON.stringify(el))})`);
+            return `(${conditions.join(' OR ')})`;
+        }
+        case 'array_some': {
+            const { conditions } = args[0];
+            return buildMysqlJsonTableQuantifiedSQL(col, mysqlPath, conditions, 'some');
+        }
+        case 'array_every': {
+            const { conditions } = args[0];
+            return buildMysqlJsonTableQuantifiedSQL(col, mysqlPath, conditions, 'every');
+        }
+        default:
+            return '';
+    }
+}
+function buildMysqlJsonTableQuantifiedSQL(col, mysqlPath, conditions, quantifier) {
+    if (conditions.length === 0)
+        return '';
+    const whereClauses = conditions.map(c => buildMysqlElementSQL(c));
+    const validClauses = whereClauses.filter(Boolean);
+    if (validClauses.length === 0)
+        return '';
+    const whereClause = validClauses.join(' AND ');
+    const arrayPath = mysqlPath === '$' ? '$[*]' : `${mysqlPath}[*]`;
+    const jsonTable = `JSON_TABLE(${col}, ${mysqlFormat.literal(arrayPath)} COLUMNS (_elem JSON PATH '$')) AS jt`;
+    if (quantifier === 'some') {
+        return `EXISTS (SELECT 1 FROM ${jsonTable} WHERE ${whereClause})`;
+    }
+    return `NOT EXISTS (SELECT 1 FROM ${jsonTable} WHERE NOT (${whereClause}))`;
+}
+function buildMysqlElementSQL(cond) {
+    const { path, op, args } = cond;
+    if (path.length === 0) {
+        return buildMysqlScalarElementSQL(op, args);
+    }
+    return buildMysqlNestedElementSQL(path, op, args);
+}
+function buildMysqlScalarElementSQL(op, args) {
+    const elemJson = 'jt._elem';
+    const elemText = `JSON_UNQUOTE(${elemJson})`;
+    switch (op) {
+        case 'equal':
+            if (typeof args[0] === 'number' || typeof args[0] === 'boolean') {
+                return `${elemJson} = ${mysqlFormat.literal(args[0])}`;
+            }
+            return `${elemText} = ${mysqlFormat.literal(args[0])}`;
+        case 'notEqual':
+            if (typeof args[0] === 'number') {
+                return `${elemJson} != ${mysqlFormat.literal(args[0])}`;
+            }
+            return `${elemText} != ${mysqlFormat.literal(args[0])}`;
+        case 'greaterThan':
+            return `${elemJson} > ${args[0]}`;
+        case 'greaterThanOrEqual':
+            return `${elemJson} >= ${args[0]}`;
+        case 'lessThan':
+            return `${elemJson} < ${args[0]}`;
+        case 'lessThanOrEqual':
+            return `${elemJson} <= ${args[0]}`;
+        case 'between':
+            return typeof args[0] === 'number'
+                ? `${elemJson} BETWEEN ${args[0]} AND ${args[1]}`
+                : `${elemText} BETWEEN ${mysqlFormat.literal(args[0])} AND ${mysqlFormat.literal(args[1])}`;
+        case 'in': {
+            const vals = args[0].map(v => mysqlFormat.literal(v)).join(', ');
+            return typeof args[0]?.[0] === 'number'
+                ? `${elemJson} IN (${vals})`
+                : `${elemText} IN (${vals})`;
+        }
+        case 'notIn': {
+            const vals = args[0].map(v => mysqlFormat.literal(v)).join(', ');
+            return `${elemText} NOT IN (${vals})`;
+        }
+        case 'like':
+            return `${elemText} LIKE ${mysqlFormat.literal(args[0])}`;
+        case 'ilike':
+            return `LOWER(${elemText}) LIKE LOWER(${mysqlFormat.literal(args[0])})`;
+        case 'startsWith':
+            return `${elemText} LIKE ${mysqlFormat.literal(`${args[0]}%`)}`;
+        case 'endsWith':
+            return `${elemText} LIKE ${mysqlFormat.literal(`%${args[0]}`)}`;
+        case 'contains':
+            if (typeof args[0] === 'string') {
+                return `${elemText} LIKE ${mysqlFormat.literal(`%${args[0]}%`)}`;
+            }
+            return `JSON_CONTAINS(${elemJson}, ${mysqlFormat.literal(JSON.stringify(args[0]))})`;
+        case 'regex':
+            return `REGEXP_LIKE(${elemText}, ${mysqlFormat.literal(args[0])}, 'c')`;
+        case 'iregex':
+            return `REGEXP_LIKE(${elemText}, ${mysqlFormat.literal(args[0])}, 'i')`;
+        case 'before':
+            return `${elemText} < ${mysqlFormat.literal(args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'after':
+            return `${elemText} > ${mysqlFormat.literal(args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'isNull':
+            return `(${elemJson} IS NULL OR JSON_TYPE(${elemJson}) = 'NULL')`;
+        case 'isNotNull':
+            return `(${elemJson} IS NOT NULL AND JSON_TYPE(${elemJson}) != 'NULL')`;
+        case 'containedBy':
+            return `JSON_CONTAINS(${mysqlFormat.literal(JSON.stringify(args[0]))}, ${elemJson})`;
+        case 'hasKey':
+            return `JSON_EXTRACT(${elemJson}, ${mysqlFormat.literal('$.' + args[0])}) IS NOT NULL`;
+        case 'hasAnyKeys': {
+            const checks = args[0].map(k => `JSON_EXTRACT(${elemJson}, ${mysqlFormat.literal('$.' + k)}) IS NOT NULL`);
+            return `(${checks.join(' OR ')})`;
+        }
+        case 'hasAllKeys': {
+            const checks = args[0].map(k => `JSON_EXTRACT(${elemJson}, ${mysqlFormat.literal('$.' + k)}) IS NOT NULL`);
+            return `(${checks.join(' AND ')})`;
+        }
+        case 'typeOf':
+            return `JSON_TYPE(${elemJson}) = ${mysqlFormat.literal(args[0])}`;
+        default:
+            return '';
+    }
+}
+function buildMysqlNestedElementSQL(path, op, args) {
+    const fieldPath = '$.' + path.join('.');
+    const elemJson = `JSON_EXTRACT(jt._elem, ${mysqlFormat.literal(fieldPath)})`;
+    const elemText = `JSON_UNQUOTE(${elemJson})`;
+    switch (op) {
+        case 'equal':
+            if (typeof args[0] === 'number' || typeof args[0] === 'boolean') {
+                return `${elemJson} = ${mysqlFormat.literal(args[0])}`;
+            }
+            if (typeof args[0] === 'object' && args[0] !== null) {
+                return `${elemJson} = CAST(${mysqlFormat.literal(JSON.stringify(args[0]))} AS JSON)`;
+            }
+            return `${elemText} = ${mysqlFormat.literal(args[0])}`;
+        case 'notEqual':
+            if (typeof args[0] === 'number') {
+                return `${elemJson} != ${mysqlFormat.literal(args[0])}`;
+            }
+            if (typeof args[0] === 'object' && args[0] !== null) {
+                return `${elemJson} != CAST(${mysqlFormat.literal(JSON.stringify(args[0]))} AS JSON)`;
+            }
+            return `${elemText} != ${mysqlFormat.literal(args[0])}`;
+        case 'greaterThan':
+            return `${elemJson} > ${args[0]}`;
+        case 'greaterThanOrEqual':
+            return `${elemJson} >= ${args[0]}`;
+        case 'lessThan':
+            return `${elemJson} < ${args[0]}`;
+        case 'lessThanOrEqual':
+            return `${elemJson} <= ${args[0]}`;
+        case 'between':
+            return typeof args[0] === 'number'
+                ? `${elemJson} BETWEEN ${args[0]} AND ${args[1]}`
+                : `${elemText} BETWEEN ${mysqlFormat.literal(args[0])} AND ${mysqlFormat.literal(args[1])}`;
+        case 'in': {
+            const vals = args[0].map(v => mysqlFormat.literal(v)).join(', ');
+            return typeof args[0]?.[0] === 'number'
+                ? `${elemJson} IN (${vals})`
+                : `${elemText} IN (${vals})`;
+        }
+        case 'notIn': {
+            const vals = args[0].map(v => mysqlFormat.literal(v)).join(', ');
+            return `${elemText} NOT IN (${vals})`;
+        }
+        case 'like':
+            return `${elemText} LIKE ${mysqlFormat.literal(args[0])}`;
+        case 'ilike':
+            return `LOWER(${elemText}) LIKE LOWER(${mysqlFormat.literal(args[0])})`;
+        case 'startsWith':
+            return `${elemText} LIKE ${mysqlFormat.literal(`${args[0]}%`)}`;
+        case 'endsWith':
+            return `${elemText} LIKE ${mysqlFormat.literal(`%${args[0]}`)}`;
+        case 'contains':
+            if (typeof args[0] === 'string') {
+                return `${elemText} LIKE ${mysqlFormat.literal(`%${args[0]}%`)}`;
+            }
+            return `JSON_CONTAINS(${elemJson}, ${mysqlFormat.literal(JSON.stringify(args[0]))})`;
+        case 'regex':
+            return `REGEXP_LIKE(${elemText}, ${mysqlFormat.literal(args[0])}, 'c')`;
+        case 'iregex':
+            return `REGEXP_LIKE(${elemText}, ${mysqlFormat.literal(args[0])}, 'i')`;
+        case 'before':
+            return `${elemText} < ${mysqlFormat.literal(args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'after':
+            return `${elemText} > ${mysqlFormat.literal(args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'isNull':
+            return `(${elemJson} IS NULL OR JSON_TYPE(${elemJson}) = 'NULL')`;
+        case 'isNotNull':
+            return `(${elemJson} IS NOT NULL AND JSON_TYPE(${elemJson}) != 'NULL')`;
+        case 'containedBy':
+            return `JSON_CONTAINS(${mysqlFormat.literal(JSON.stringify(args[0]))}, ${elemJson})`;
+        case 'hasKey':
+            return `JSON_EXTRACT(${elemJson}, ${mysqlFormat.literal('$.' + args[0])}) IS NOT NULL`;
+        case 'hasAnyKeys': {
+            const checks = args[0].map(k => `JSON_EXTRACT(${elemJson}, ${mysqlFormat.literal('$.' + k)}) IS NOT NULL`);
+            return `(${checks.join(' OR ')})`;
+        }
+        case 'hasAllKeys': {
+            const checks = args[0].map(k => `JSON_EXTRACT(${elemJson}, ${mysqlFormat.literal('$.' + k)}) IS NOT NULL`);
+            return `(${checks.join(' AND ')})`;
+        }
+        case 'typeOf':
+            return `JSON_TYPE(${elemJson}) = ${mysqlFormat.literal(args[0])}`;
+        default:
+            return '';
+    }
+}

package/dist/esm/mysql/count/count-builder.js

@@ -0,0 +1,102 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { MysqlConditionCollector, buildMysqlConditionsSQL, buildMysqlConditionSQL } from "../condition/condition-collector.js";
+export class MysqlCountBuilder {
+    tableName;
+    countGroups = [];
+    whereConditions = [];
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    group(name, callback, options) {
+        const conditionBuilder = new MysqlConditionCollector();
+        callback(conditionBuilder);
+        let aggregateFunction = 'COUNT';
+        let column;
+        if (options) {
+            if (options.distinct) {
+                aggregateFunction = 'COUNT_DISTINCT';
+                column = options.distinct;
+            }
+            else if (options.sum) {
+                aggregateFunction = 'SUM';
+                column = options.sum;
+            }
+            else if (options.avg) {
+                aggregateFunction = 'AVG';
+                column = options.avg;
+            }
+            else if (options.min) {
+                aggregateFunction = 'MIN';
+                column = options.min;
+            }
+            else if (options.max) {
+                aggregateFunction = 'MAX';
+                column = options.max;
+            }
+        }
+        this.countGroups.push({
+            name,
+            conditions: conditionBuilder.getConditions(),
+            aggregateFunction,
+            column
+        });
+        return this;
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof MysqlConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const conditionBuilder = new MysqlConditionCollector();
+            callbackOrCondition(conditionBuilder);
+            this.whereConditions.push(...conditionBuilder.getConditions());
+        }
+        return this;
+    }
+    toString() {
+        let selectColumns;
+        if (this.countGroups.length > 0) {
+            selectColumns = this.countGroups.map(group => this.buildGroupSQL(group));
+        }
+        else {
+            selectColumns = ['COUNT(*) AS `count`'];
+        }
+        let query = `SELECT ${selectColumns.join(', ')} FROM ${mysqlFormat.ident(this.tableName)}`;
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + buildMysqlConditionsSQL(this.whereConditions);
+        }
+        return query;
+    }
+    buildGroupSQL(group) {
+        const conditionsSQL = group.conditions.map(c => buildMysqlConditionSQL(c)).join(' AND ');
+        const alias = mysqlFormat.ident(group.name);
+        if (group.conditions.length === 0) {
+            if (group.aggregateFunction === 'COUNT_DISTINCT' && group.column) {
+                return `COUNT(DISTINCT ${mysqlFormat.ident(group.column)}) AS ${alias}`;
+            }
+            const funcName = group.aggregateFunction === 'COUNT_DISTINCT' ? 'COUNT' : group.aggregateFunction;
+            const col = group.column ? mysqlFormat.ident(group.column) : '*';
+            return `${funcName}(${col}) AS ${alias}`;
+        }
+        switch (group.aggregateFunction) {
+            case 'COUNT':
+                return `SUM(CASE WHEN ${conditionsSQL} THEN 1 ELSE 0 END) AS ${alias}`;
+            case 'COUNT_DISTINCT': {
+                const col = group.column ? mysqlFormat.ident(group.column) : '*';
+                return `COUNT(DISTINCT CASE WHEN ${conditionsSQL} THEN ${col} END) AS ${alias}`;
+            }
+            case 'SUM': {
+                const sumCol = group.column ? mysqlFormat.ident(group.column) : '*';
+                return `SUM(CASE WHEN ${conditionsSQL} THEN ${sumCol} ELSE 0 END) AS ${alias}`;
+            }
+            case 'AVG':
+            case 'MIN':
+            case 'MAX': {
+                const col = group.column ? mysqlFormat.ident(group.column) : '*';
+                return `${group.aggregateFunction}(CASE WHEN ${conditionsSQL} THEN ${col} ELSE NULL END) AS ${alias}`;
+            }
+            default:
+                return `COUNT(*) AS ${alias}`;
+        }
+    }
+}

package/dist/esm/mysql/count/index.js

@@ -0,0 +1 @@
+export { MysqlCountBuilder } from "./count-builder.js";