@relq/orm 0.1.3 → 0.1.4

package/dist/esm/mysql/clients/shared/mysql-error-parser.js

@@ -0,0 +1,188 @@
+import { RelqConnectionError, RelqQueryError, RelqTimeoutError, RelqConstraintError, RelqSchemaError, RelqDataError, RelqLockError, } from "../../../shared/errors/relq-errors.js";
+export const MYSQL_RECOVERABLE_ERRNOS = new Set([
+    2002,
+    2003,
+    2006,
+    2013,
+    2026,
+]);
+export const MYSQL_CONNECTION_ERROR_ERRNOS = new Set([
+    2002,
+    2003,
+    2006,
+    2013,
+    2026,
+]);
+export const MYSQL_NETWORK_ERROR_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ENOTFOUND',
+    'ESERVFAIL',
+    'ETIMEDOUT',
+    'EPIPE',
+    'EAI_AGAIN',
+    'EHOSTUNREACH',
+    'ECONNABORTED',
+    'ENETUNREACH',
+    'ENETRESET',
+    'PROTOCOL_CONNECTION_LOST',
+]);
+export const MYSQL_TRANSIENT_ERRNOS = new Set([
+    1205,
+    1213,
+]);
+export function isMysqlConnectionError(error) {
+    if (typeof error.errno === 'number' && MYSQL_CONNECTION_ERROR_ERRNOS.has(error.errno)) {
+        return true;
+    }
+    if (typeof error.code === 'string' && MYSQL_NETWORK_ERROR_CODES.has(error.code)) {
+        return true;
+    }
+    if (typeof error.message === 'string') {
+        if (error.message.includes('Connection lost'))
+            return true;
+        if (error.message.includes('connect ECONNREFUSED'))
+            return true;
+        if (error.message.includes('Connection closed'))
+            return true;
+        if (error.message.includes('Cannot enqueue'))
+            return true;
+    }
+    return false;
+}
+export function isMysqlTransientError(error) {
+    if (typeof error.errno === 'number' && MYSQL_TRANSIENT_ERRNOS.has(error.errno)) {
+        return true;
+    }
+    return false;
+}
+export function isMysqlPoolRecoverableError(error) {
+    if (typeof error.errno === 'number' && MYSQL_RECOVERABLE_ERRNOS.has(error.errno)) {
+        return true;
+    }
+    if (typeof error.code === 'string' && MYSQL_NETWORK_ERROR_CODES.has(error.code)) {
+        return true;
+    }
+    if (!error.errno && !error.code)
+        return true;
+    return false;
+}
+export function parseMysqlError(error, sql, isBuilder = true) {
+    const message = error.sqlMessage || error.message || 'MySQL error';
+    const errno = error.errno;
+    const code = error.code;
+    if (isMysqlConnectionError(error)) {
+        return new RelqConnectionError(message, {
+            cause: error,
+            code: code || String(errno),
+            host: error.address,
+            port: error.port,
+        });
+    }
+    if (errno === 1040) {
+        return new RelqConnectionError('Too many database connections. The server has reached its connection limit.', { cause: error, code: code || '1040' });
+    }
+    if (errno === 1045) {
+        return new RelqConnectionError('Authentication failed. Check your database username and password.', { cause: error, code: code || '1045' });
+    }
+    if (errno === 1205) {
+        return new RelqLockError('Lock wait timeout exceeded. Another transaction holds the lock. Retry the operation.', 'lock_timeout', { cause: error, sql: sql || error.sql, code: code || '1205' });
+    }
+    if (message.includes('connect ETIMEDOUT') || message.includes('Connection timeout')) {
+        return new RelqTimeoutError('Connection timed out.', error.timeout || 0, 'connection', error);
+    }
+    if (!isBuilder) {
+        return new RelqQueryError(message, {
+            cause: error, sql: sql || error.sql, code: code || String(errno),
+            detail: error.sqlState ? `SQLSTATE ${error.sqlState}` : undefined,
+        });
+    }
+    if (errno === 1062 || errno === 1022 || errno === 1169) {
+        const dupMatch = message.match(/Duplicate entry '(.+?)' for key '(?:.*\.)?(.+?)'/);
+        const val = dupMatch?.[1];
+        const constraint = dupMatch?.[2];
+        return new RelqConstraintError(`Duplicate value: A record with this value already exists.${val ? ` Value: "${val}".` : ''}${constraint ? ` Constraint: "${constraint}".` : ''}`, 'unique', { cause: error, constraint, value: val, sql: sql || error.sql, code: code || String(errno), detail: message });
+    }
+    if (errno === 1451 || errno === 1217) {
+        const refMatch = message.match(/CONSTRAINT `(.+?)`.*REFERENCES `(.+?)`/);
+        return new RelqConstraintError(`Cannot delete: This record is still referenced by another table.${refMatch ? ` Constraint: "${refMatch[1]}", referenced table: "${refMatch[2]}".` : ''}`, 'foreign_key', { cause: error, constraint: refMatch?.[1], sql: sql || error.sql, code: code || String(errno), detail: message });
+    }
+    if (errno === 1452 || errno === 1216) {
+        const refMatch = message.match(/CONSTRAINT `(.+?)`.*REFERENCES `(.+?)`/);
+        return new RelqConstraintError(`Referenced record not found: The value references a record that doesn't exist.${refMatch ? ` Constraint: "${refMatch[1]}", referenced table: "${refMatch[2]}".` : ''}`, 'foreign_key', { cause: error, constraint: refMatch?.[1], sql: sql || error.sql, code: code || String(errno), detail: message });
+    }
+    if (errno === 1048) {
+        const colMatch = message.match(/Column '(.+?)'/);
+        return new RelqConstraintError(`Required field missing: Column "${colMatch?.[1] || 'unknown'}" cannot be NULL. Provide a value or set a default in your schema.`, 'not_null', { cause: error, column: colMatch?.[1], sql: sql || error.sql, code: code || '1048', detail: message });
+    }
+    if (errno === 1213) {
+        return new RelqLockError('Deadlock detected: Two transactions are waiting for each other. Retry the transaction.', 'deadlock', { cause: error, sql: sql || error.sql, code: code || '1213' });
+    }
+    if (errno === 1146) {
+        const tblMatch = message.match(/Table '(?:.*\.)?(.+?)'/);
+        return new RelqSchemaError(`Table "${tblMatch?.[1] || 'unknown'}" does not exist. Check your schema definition or run migrations.`, 'table', { cause: error, objectName: tblMatch?.[1], sql: sql || error.sql, code: code || '1146' });
+    }
+    if (errno === 1054) {
+        const colMatch = message.match(/Unknown column '(.+?)'/);
+        return new RelqSchemaError(`Column "${colMatch?.[1] || 'unknown'}" does not exist. Check column name spelling in your schema and query.`, 'column', { cause: error, objectName: colMatch?.[1], sql: sql || error.sql, code: code || '1054' });
+    }
+    if (errno === 1064 || errno === 1149) {
+        return new RelqSchemaError(`SQL syntax error: ${message}. This may indicate a bug in the query builder — please report it.`, 'column', { cause: error, sql: sql || error.sql, code: code || '1064', hint: 'If you are using db.raw(), check your SQL syntax.' });
+    }
+    if (errno === 1050) {
+        const tblMatch = message.match(/Table '(.+?)'/);
+        return new RelqSchemaError(`Table "${tblMatch?.[1] || 'unknown'}" already exists.`, 'table', { cause: error, objectName: tblMatch?.[1], sql: sql || error.sql, code: code || '1050' });
+    }
+    if (errno === 1049) {
+        return new RelqSchemaError(`Database does not exist. Check your database name in the connection config.`, 'schema', { cause: error, sql: sql || error.sql, code: code || '1049' });
+    }
+    if (errno === 1406) {
+        const colMatch = message.match(/column '(.+?)'/);
+        return new RelqDataError(`Value too long for column "${colMatch?.[1] || 'unknown'}". Shorten the value or increase the column length.`, 'too_long', { cause: error, column: colMatch?.[1], sql: sql || error.sql, code: code || '1406' });
+    }
+    if (errno === 1264) {
+        const colMatch = message.match(/column '(.+?)'/);
+        return new RelqDataError(`Numeric value out of range for column "${colMatch?.[1] || 'unknown'}".`, 'out_of_range', { cause: error, column: colMatch?.[1], sql: sql || error.sql, code: code || '1264' });
+    }
+    if (errno === 1292 || errno === 1366) {
+        return new RelqDataError(`Invalid value: ${message}. Check that the value matches the column type.`, 'invalid_type', { cause: error, sql: sql || error.sql, code: code || String(errno) });
+    }
+    if (errno === 1265) {
+        const colMatch = message.match(/column '(.+?)'/);
+        return new RelqDataError(`Data truncated for column "${colMatch?.[1] || 'unknown'}". The value doesn't fit the column type.`, 'too_long', { cause: error, column: colMatch?.[1], sql: sql || error.sql, code: code || '1265' });
+    }
+    if (errno === 1365) {
+        return new RelqDataError('Division by zero in query.', 'division_by_zero', { cause: error, sql: sql || error.sql, code: code || '1365' });
+    }
+    if (errno === 1364) {
+        const colMatch = message.match(/Field '(.+?)'/);
+        return new RelqConstraintError(`Required field missing: Column "${colMatch?.[1] || 'unknown'}" has no default value. Provide a value or set a default in your schema.`, 'not_null', { cause: error, column: colMatch?.[1], sql: sql || error.sql, code: code || '1364', detail: message });
+    }
+    if (errno === 1044 || errno === 1142 || errno === 1143 || errno === 1227) {
+        return new RelqSchemaError(`Permission denied: ${message}. Check that your database user has the required privileges.`, 'table', { cause: error, sql: sql || error.sql, code: code || String(errno) });
+    }
+    if (errno === 1052) {
+        const colMatch = message.match(/Column '(.+?)'/);
+        return new RelqSchemaError(`Ambiguous column "${colMatch?.[1] || 'unknown'}": The column exists in multiple tables. Qualify it with a table name or alias.`, 'column', { cause: error, objectName: colMatch?.[1], sql: sql || error.sql, code: code || '1052' });
+    }
+    if (errno === 1058 || errno === 1136) {
+        return new RelqDataError(`Column count mismatch: The number of columns doesn't match the number of values. ${message}`, 'invalid_type', { cause: error, sql: sql || error.sql, code: code || String(errno) });
+    }
+    if (errno === 1109) {
+        const tblMatch = message.match(/Unknown table '(.+?)'/);
+        return new RelqSchemaError(`Table "${tblMatch?.[1] || 'unknown'}" not found. Check table name spelling.`, 'table', { cause: error, objectName: tblMatch?.[1], sql: sql || error.sql, code: code || '1109' });
+    }
+    if (errno === 1046) {
+        return new RelqSchemaError('No database selected. Set the database name in your connection config.', 'schema', { cause: error, sql: sql || error.sql, code: code || '1046' });
+    }
+    if (errno === 1153) {
+        return new RelqQueryError('Packet too large: The query or data exceeds max_allowed_packet. Reduce batch size or increase the limit.', { cause: error, sql: sql || error.sql, code: code || '1153' });
+    }
+    if (errno === 1179) {
+        return new RelqQueryError('This command cannot be executed inside a transaction.', { cause: error, sql: sql || error.sql, code: code || '1179' });
+    }
+    return new RelqQueryError(message, {
+        cause: error, sql: sql || error.sql, code: code || String(errno),
+        detail: error.sqlState ? `SQLSTATE ${error.sqlState}` : undefined,
+    });
+}

package/dist/esm/mysql/clients/shared/mysql-format.js

@@ -0,0 +1,92 @@
+const MYSQL_RESERVED = new Set([
+    'ADD', 'ALL', 'ALTER', 'ANALYZE', 'AND', 'AS', 'ASC', 'BEFORE', 'BETWEEN',
+    'BIGINT', 'BINARY', 'BLOB', 'BOTH', 'BY', 'CALL', 'CASCADE', 'CASE', 'CHANGE',
+    'CHAR', 'CHARACTER', 'CHECK', 'COLLATE', 'COLUMN', 'CONDITION', 'CONSTRAINT',
+    'CONTINUE', 'CONVERT', 'CREATE', 'CROSS', 'CURRENT_DATE', 'CURRENT_TIME',
+    'CURRENT_TIMESTAMP', 'CURRENT_USER', 'CURSOR', 'DATABASE', 'DATABASES', 'DAY_HOUR',
+    'DAY_MICROSECOND', 'DAY_MINUTE', 'DAY_SECOND', 'DEC', 'DECIMAL', 'DECLARE',
+    'DEFAULT', 'DELAYED', 'DELETE', 'DESC', 'DESCRIBE', 'DETERMINISTIC', 'DISTINCT',
+    'DISTINCTROW', 'DIV', 'DOUBLE', 'DROP', 'DUAL', 'EACH', 'ELSE', 'ELSEIF',
+    'ENCLOSED', 'ESCAPED', 'EXISTS', 'EXIT', 'EXPLAIN', 'FALSE', 'FETCH', 'FLOAT',
+    'FLOAT4', 'FLOAT8', 'FOR', 'FORCE', 'FOREIGN', 'FROM', 'FULLTEXT', 'GRANT',
+    'GROUP', 'HAVING', 'HIGH_PRIORITY', 'HOUR_MICROSECOND', 'HOUR_MINUTE', 'HOUR_SECOND',
+    'IF', 'IGNORE', 'IN', 'INDEX', 'INFILE', 'INNER', 'INOUT', 'INSENSITIVE', 'INSERT',
+    'INT', 'INT1', 'INT2', 'INT3', 'INT4', 'INT8', 'INTEGER', 'INTERVAL', 'INTO',
+    'IS', 'ITERATE', 'JOIN', 'KEY', 'KEYS', 'KILL', 'LEADING', 'LEAVE', 'LEFT',
+    'LIKE', 'LIMIT', 'LINEAR', 'LINES', 'LOAD', 'LOCALTIME', 'LOCALTIMESTAMP', 'LOCK',
+    'LONG', 'LONGBLOB', 'LONGTEXT', 'LOOP', 'LOW_PRIORITY', 'MATCH', 'MEDIUMBLOB',
+    'MEDIUMINT', 'MEDIUMTEXT', 'MIDDLEINT', 'MINUTE_MICROSECOND', 'MINUTE_SECOND', 'MOD',
+    'MODIFIES', 'NATURAL', 'NOT', 'NO_WRITE_TO_BINLOG', 'NULL', 'NUMERIC', 'ON',
+    'OPTIMIZE', 'OPTION', 'OPTIONALLY', 'OR', 'ORDER', 'OUT', 'OUTER', 'OUTFILE',
+    'PRECISION', 'PRIMARY', 'PROCEDURE', 'PURGE', 'RANGE', 'READ', 'READS', 'REAL',
+    'REFERENCES', 'REGEXP', 'RELEASE', 'RENAME', 'REPEAT', 'REPLACE', 'REQUIRE',
+    'RESTRICT', 'RETURN', 'REVOKE', 'RIGHT', 'RLIKE', 'SCHEMA', 'SCHEMAS',
+    'SECOND_MICROSECOND', 'SELECT', 'SENSITIVE', 'SEPARATOR', 'SET', 'SHOW', 'SMALLINT',
+    'SPATIAL', 'SPECIFIC', 'SQL', 'SQLEXCEPTION', 'SQLSTATE', 'SQLWARNING',
+    'SQL_BIG_RESULT', 'SQL_CALC_FOUND_ROWS', 'SQL_SMALL_RESULT', 'SSL', 'STARTING',
+    'STRAIGHT_JOIN', 'TABLE', 'TERMINATED', 'THEN', 'TINYBLOB', 'TINYINT', 'TINYTEXT',
+    'TO', 'TRAILING', 'TRIGGER', 'TRUE', 'UNDO', 'UNION', 'UNIQUE', 'UNLOCK',
+    'UNSIGNED', 'UPDATE', 'USAGE', 'USE', 'USING', 'UTC_DATE', 'UTC_TIME',
+    'UTC_TIMESTAMP', 'VALUES', 'VARBINARY', 'VARCHAR', 'VARYING', 'WHEN', 'WHERE',
+    'WHILE', 'WITH', 'WRITE', 'XOR', 'YEAR_MONTH', 'ZEROFILL',
+    'CUME_DIST', 'DENSE_RANK', 'EMPTY', 'EXCEPT', 'FIRST_VALUE', 'GROUPING', 'GROUPS',
+    'JSON_TABLE', 'LAG', 'LAST_VALUE', 'LATERAL', 'LEAD', 'NTH_VALUE', 'NTILE',
+    'OF', 'OVER', 'PERCENT_RANK', 'RANK', 'RECURSIVE', 'ROW', 'ROWS',
+    'ROW_NUMBER', 'SYSTEM', 'WINDOW',
+]);
+function ident(value) {
+    if (Array.isArray(value)) {
+        return value.map(v => quoteIdentifier(v)).join(', ');
+    }
+    return quoteIdentifier(value);
+}
+function quoteIdentifier(value) {
+    if (value === '*')
+        return '*';
+    if (value.includes('.')) {
+        return value.split('.').map(p => p === '*' ? '*' : `\`${escapeBackticks(p)}\``).join('.');
+    }
+    return `\`${escapeBackticks(value)}\``;
+}
+function escapeBackticks(value) {
+    return value.replace(/`/g, '``');
+}
+function literal(value) {
+    if (value === null || value === undefined)
+        return 'NULL';
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (typeof value === 'number')
+        return String(value);
+    if (value instanceof Date)
+        return `'${value.toISOString()}'`;
+    if (Array.isArray(value)) {
+        return `(${value.map(v => literal(v)).join(', ')})`;
+    }
+    const str = String(value);
+    return `'${str.replace(/'/g, "''").replace(/\\/g, '\\\\')}'`;
+}
+function mysqlFormat(fmt, ...args) {
+    let argIdx = 0;
+    return fmt.replace(/%([ILs%])/g, (match, type) => {
+        if (type === '%')
+            return '%';
+        if (argIdx >= args.length) {
+            throw new Error(`mysqlFormat: missing argument for ${match}`);
+        }
+        const val = args[argIdx++];
+        switch (type) {
+            case 'I': return ident(val);
+            case 'L': return literal(val);
+            case 's': return String(val);
+            default: return match;
+        }
+    });
+}
+mysqlFormat.isReserved = (word) => {
+    return MYSQL_RESERVED.has(word.toUpperCase());
+};
+mysqlFormat.ident = ident;
+mysqlFormat.literal = literal;
+export default mysqlFormat;
+export { ident as mysqlIdent, literal as mysqlLiteral };

package/dist/esm/mysql/clients/shared/mysql-type-coercion.js

@@ -0,0 +1,6 @@
+import { deserializeMysqlValue, serializeMysqlValue, deserializeMysqlRow, deserializeMysqlRows, serializeMysqlRow, extractMysqlSchemaColumns, } from "../../utils/type-coercion.js";
+export const mysqlTypeCoercion = {
+    deserializeValue: deserializeMysqlValue,
+    serializeValue: serializeMysqlValue,
+};
+export { deserializeMysqlValue as mysqlDeserializeValue, serializeMysqlValue as mysqlSerializeValue, deserializeMysqlRow as mysqlDeserializeRow, deserializeMysqlRows as mysqlDeserializeRows, serializeMysqlRow as mysqlSerializeRow, extractMysqlSchemaColumns as mysqlExtractSchemaColumns, };

package/dist/esm/mysql/condition/condition-collector.js

@@ -0,0 +1,368 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { buildMysqlJsonConditionSQL } from "./json-condition-builder.js";
+import { createMysqlJsonColumnProxy, buildMysqlJsonProxySQL } from "./json-path-proxy.js";
+import { MysqlFulltextConditionCollector, buildMysqlFulltextConditionSQL } from "./fulltext-condition-builder.js";
+export class MysqlConditionCollector {
+    conditions = [];
+    _tables;
+    _tableName;
+    _fulltext;
+    get json() {
+        return createMysqlJsonColumnProxy(this);
+    }
+    get fulltext() {
+        if (!this._fulltext) {
+            this._fulltext = new MysqlFulltextConditionCollector(this);
+        }
+        return this._fulltext;
+    }
+    equal(column, value) {
+        this.conditions.push({ method: 'equal', column, values: value });
+        return this;
+    }
+    notEqual(column, value) {
+        this.conditions.push({ method: 'notEqual', column, values: value });
+        return this;
+    }
+    lessThan(column, value) {
+        this.conditions.push({ method: 'lessThan', column, values: value });
+        return this;
+    }
+    lessThanEqual(column, value) {
+        this.conditions.push({ method: 'lessThanEqual', column, values: value });
+        return this;
+    }
+    greaterThan(column, value) {
+        this.conditions.push({ method: 'greaterThan', column, values: value });
+        return this;
+    }
+    greaterThanEqual(column, value) {
+        this.conditions.push({ method: 'greaterThanEqual', column, values: value });
+        return this;
+    }
+    isNull(column) {
+        this.conditions.push({ method: 'isNull', column });
+        return this;
+    }
+    isNotNull(column) {
+        this.conditions.push({ method: 'isNotNull', column });
+        return this;
+    }
+    between(column, start, end) {
+        this.conditions.push({ method: 'between', column, values: [start, end] });
+        return this;
+    }
+    notBetween(column, start, end) {
+        this.conditions.push({ method: 'notBetween', column, values: [start, end] });
+        return this;
+    }
+    startsWith(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'startsWithI' : 'startsWith',
+            column,
+            values: value
+        });
+        return this;
+    }
+    notStartsWith(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'notStartsWithI' : 'notStartsWith',
+            column,
+            values: value
+        });
+        return this;
+    }
+    endsWith(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'endsWithI' : 'endsWith',
+            column,
+            values: value
+        });
+        return this;
+    }
+    notEndsWith(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'notEndsWithI' : 'notEndsWith',
+            column,
+            values: value
+        });
+        return this;
+    }
+    contains(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'containsI' : 'contains',
+            column,
+            values: value
+        });
+        return this;
+    }
+    notContains(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'notContainsI' : 'notContains',
+            column,
+            values: value
+        });
+        return this;
+    }
+    like(column, pattern) {
+        this.conditions.push({ method: 'like', column, values: pattern });
+        return this;
+    }
+    notLike(column, pattern) {
+        this.conditions.push({ method: 'notLike', column, values: pattern });
+        return this;
+    }
+    ilike(column, pattern) {
+        this.conditions.push({ method: 'ilike', column, values: pattern });
+        return this;
+    }
+    notIlike(column, pattern) {
+        this.conditions.push({ method: 'notIlike', column, values: pattern });
+        return this;
+    }
+    regex(column, pattern) {
+        this.conditions.push({ method: 'regex', column, values: pattern });
+        return this;
+    }
+    iregex(column, pattern) {
+        this.conditions.push({ method: 'iregex', column, values: pattern });
+        return this;
+    }
+    notRegex(column, pattern) {
+        this.conditions.push({ method: 'notRegex', column, values: pattern });
+        return this;
+    }
+    notIregex(column, pattern) {
+        this.conditions.push({ method: 'notIregex', column, values: pattern });
+        return this;
+    }
+    isTrue(column) {
+        this.conditions.push({ method: 'isTrue', column });
+        return this;
+    }
+    isFalse(column) {
+        this.conditions.push({ method: 'isFalse', column });
+        return this;
+    }
+    nullSafeEqual(column, value) {
+        this.conditions.push({ method: 'nullSafeEqual', column, values: value });
+        return this;
+    }
+    nullSafeNotEqual(column, value) {
+        this.conditions.push({ method: 'nullSafeNotEqual', column, values: value });
+        return this;
+    }
+    search(column, value) {
+        this.conditions.push({ method: 'search', column, values: value });
+        return this;
+    }
+    notSearch(column, value) {
+        this.conditions.push({ method: 'notSearch', column, values: value });
+        return this;
+    }
+    greaterThanOrEqual(column, value) {
+        return this.greaterThanEqual(column, value);
+    }
+    lessThanOrEqual(column, value) {
+        return this.lessThanEqual(column, value);
+    }
+    notNull(column) {
+        return this.isNotNull(column);
+    }
+    in(column, values) {
+        if (typeof values === 'function') {
+            const subquery = values(this._tables);
+            this.conditions.push({ method: 'in', column, values: subquery.toString() });
+        }
+        else if (!Array.isArray(values) && typeof values === 'object' && values !== null && 'toString' in values) {
+            this.conditions.push({ method: 'in', column, values: values.toString() });
+        }
+        else {
+            this.conditions.push({ method: 'in', column, values });
+        }
+        return this;
+    }
+    notIn(column, values) {
+        if (typeof values === 'function') {
+            const subquery = values(this._tables);
+            this.conditions.push({ method: 'notIn', column, values: subquery.toString() });
+        }
+        else if (!Array.isArray(values) && typeof values === 'object' && values !== null && 'toString' in values) {
+            this.conditions.push({ method: 'notIn', column, values: values.toString() });
+        }
+        else {
+            this.conditions.push({ method: 'notIn', column, values });
+        }
+        return this;
+    }
+    exists(subquery) {
+        this.conditions.push({ method: 'exists', values: subquery });
+        return this;
+    }
+    notExists(subquery) {
+        this.conditions.push({ method: 'notExists', values: subquery });
+        return this;
+    }
+    or(callback) {
+        const subBuilder = new MysqlConditionCollector();
+        callback(subBuilder);
+        this.conditions.push({ method: 'or', values: subBuilder.getConditions() });
+        return this;
+    }
+    and(callback) {
+        const subBuilder = new MysqlConditionCollector();
+        callback(subBuilder);
+        this.conditions.push({ method: 'and', values: subBuilder.getConditions() });
+        return this;
+    }
+    not(callback) {
+        const subBuilder = new MysqlConditionCollector();
+        callback(subBuilder);
+        this.conditions.push({ method: 'not', values: subBuilder.getConditions() });
+        return this;
+    }
+    getConditions() {
+        return this.conditions;
+    }
+}
+function formatColumn(column) {
+    if (column.includes('.')) {
+        const parts = column.split('.');
+        return parts.map(p => mysqlFormat.ident(p)).join('.');
+    }
+    return mysqlFormat.ident(column);
+}
+export function buildMysqlConditionSQL(condition) {
+    const { method, column, values } = condition;
+    if (method === 'mysql_json_proxy') {
+        return buildMysqlJsonProxySQL(condition);
+    }
+    if (method.startsWith('json_')) {
+        return buildMysqlJsonConditionSQL(condition);
+    }
+    if (method.startsWith('fulltext_')) {
+        return buildMysqlFulltextConditionSQL(condition);
+    }
+    const col = column ? formatColumn(column) : '';
+    switch (method) {
+        case 'equal':
+            if (Array.isArray(values) && values.length > 1) {
+                return `${col} IN ${mysqlFormat.literal(values)}`;
+            }
+            return `${col} = ${mysqlFormat.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'notEqual':
+            if (Array.isArray(values) && values.length > 1) {
+                return `${col} NOT IN ${mysqlFormat.literal(values)}`;
+            }
+            return `${col} != ${mysqlFormat.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'lessThan':
+            return `${col} < ${mysqlFormat.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'lessThanEqual':
+            return `${col} <= ${mysqlFormat.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'greaterThan':
+            return `${col} > ${mysqlFormat.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'greaterThanEqual':
+            return `${col} >= ${mysqlFormat.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'isNull':
+            return `${col} IS NULL`;
+        case 'isNotNull':
+            return `${col} IS NOT NULL`;
+        case 'between': {
+            const [start, end] = values;
+            return `${col} BETWEEN ${mysqlFormat.literal(start)} AND ${mysqlFormat.literal(end)}`;
+        }
+        case 'notBetween': {
+            const [notStart, notEnd] = values;
+            return `${col} NOT BETWEEN ${mysqlFormat.literal(notStart)} AND ${mysqlFormat.literal(notEnd)}`;
+        }
+        case 'startsWith':
+            return `${col} LIKE ${mysqlFormat.literal(`${values}%`)}`;
+        case 'startsWithI':
+            return `LOWER(${col}) LIKE LOWER(${mysqlFormat.literal(`${values}%`)})`;
+        case 'notStartsWith':
+            return `${col} NOT LIKE ${mysqlFormat.literal(`${values}%`)}`;
+        case 'notStartsWithI':
+            return `LOWER(${col}) NOT LIKE LOWER(${mysqlFormat.literal(`${values}%`)})`;
+        case 'endsWith':
+            return `${col} LIKE ${mysqlFormat.literal(`%${values}`)}`;
+        case 'endsWithI':
+            return `LOWER(${col}) LIKE LOWER(${mysqlFormat.literal(`%${values}`)})`;
+        case 'notEndsWith':
+            return `${col} NOT LIKE ${mysqlFormat.literal(`%${values}`)}`;
+        case 'notEndsWithI':
+            return `LOWER(${col}) NOT LIKE LOWER(${mysqlFormat.literal(`%${values}`)})`;
+        case 'contains':
+            return `${col} LIKE ${mysqlFormat.literal(`%${values}%`)}`;
+        case 'containsI':
+            return `LOWER(${col}) LIKE LOWER(${mysqlFormat.literal(`%${values}%`)})`;
+        case 'notContains':
+            return `${col} NOT LIKE ${mysqlFormat.literal(`%${values}%`)}`;
+        case 'notContainsI':
+            return `LOWER(${col}) NOT LIKE LOWER(${mysqlFormat.literal(`%${values}%`)})`;
+        case 'like':
+            return `${col} LIKE ${mysqlFormat.literal(values)}`;
+        case 'notLike':
+            return `${col} NOT LIKE ${mysqlFormat.literal(values)}`;
+        case 'ilike':
+            return `LOWER(${col}) LIKE LOWER(${mysqlFormat.literal(values)})`;
+        case 'notIlike':
+            return `LOWER(${col}) NOT LIKE LOWER(${mysqlFormat.literal(values)})`;
+        case 'regex':
+            return `REGEXP_LIKE(${col}, ${mysqlFormat.literal(values)}, 'c')`;
+        case 'iregex':
+            return `REGEXP_LIKE(${col}, ${mysqlFormat.literal(values)}, 'i')`;
+        case 'notRegex':
+            return `NOT REGEXP_LIKE(${col}, ${mysqlFormat.literal(values)}, 'c')`;
+        case 'notIregex':
+            return `NOT REGEXP_LIKE(${col}, ${mysqlFormat.literal(values)}, 'i')`;
+        case 'isTrue':
+            return `${col} IS TRUE`;
+        case 'isFalse':
+            return `${col} IS FALSE`;
+        case 'nullSafeEqual':
+            return `${col} <=> ${mysqlFormat.literal(values)}`;
+        case 'nullSafeNotEqual':
+            return `NOT (${col} <=> ${mysqlFormat.literal(values)})`;
+        case 'search':
+            return `MATCH(${col}) AGAINST(${mysqlFormat.literal(values)} IN NATURAL LANGUAGE MODE)`;
+        case 'notSearch':
+            return `NOT MATCH(${col}) AGAINST(${mysqlFormat.literal(values)} IN NATURAL LANGUAGE MODE)`;
+        case 'in': {
+            if (typeof values === 'string') {
+                return `${col} IN (${values})`;
+            }
+            const valueList = Array.isArray(values) ? values : [values];
+            const formattedValues = valueList.map(v => mysqlFormat.literal(v)).join(', ');
+            return `${col} IN (${formattedValues})`;
+        }
+        case 'notIn': {
+            if (typeof values === 'string') {
+                return `${col} NOT IN (${values})`;
+            }
+            const valueList = Array.isArray(values) ? values : [values];
+            const formattedValues = valueList.map(v => mysqlFormat.literal(v)).join(', ');
+            return `${col} NOT IN (${formattedValues})`;
+        }
+        case 'exists':
+            return `EXISTS (${values})`;
+        case 'notExists':
+            return `NOT EXISTS (${values})`;
+        case 'or': {
+            const orConditions = values;
+            return `(${orConditions.map(c => buildMysqlConditionSQL(c)).join(' OR ')})`;
+        }
+        case 'and': {
+            const andConditions = values;
+            return `(${andConditions.map(c => buildMysqlConditionSQL(c)).join(' AND ')})`;
+        }
+        case 'not': {
+            const notConditions = values;
+            return `NOT (${notConditions.map(c => buildMysqlConditionSQL(c)).join(' AND ')})`;
+        }
+        default:
+            return '';
+    }
+}
+export function buildMysqlConditionsSQL(conditions) {
+    return conditions.map(condition => buildMysqlConditionSQL(condition)).join(' AND ');
+}