@relq/orm 0.1.3 → 0.1.5

package/dist/cjs/mysql/clients/shared/mysql-base.cjs

@@ -0,0 +1,362 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlBase = void 0;
+exports.loadMysql2 = loadMysql2;
+const relq_errors_1 = require("../../../shared/errors/relq-errors.cjs");
+const relq_base_1 = require("../../../core/relq-base.cjs");
+const methods_1 = require("../../../core/helpers/methods.cjs");
+const mysql_dialect_1 = require("./mysql-dialect.cjs");
+const mysql_error_parser_1 = require("./mysql-error-parser.cjs");
+const mysql_table_accessor_1 = require("../../shared/mysql-table-accessor.cjs");
+const MysqlConnectedRawQueryBuilder_1 = require("../../helpers/MysqlConnectedRawQueryBuilder.cjs");
+const native_cte_builder_1 = require("../../../core/cte/native-cte-builder.cjs");
+const cte_types_1 = require("../../../core/cte/cte-types.cjs");
+const condition_collector_1 = require("../../condition/condition-collector.cjs");
+const methods_2 = require("../../../core/helpers/methods.cjs");
+const mysql_format_1 = __importDefault(require("./mysql-format.cjs"));
+let mysql2Module = null;
+async function loadMysql2() {
+    if (!mysql2Module) {
+        try {
+            const mod = await Promise.resolve().then(() => __importStar(require("../../utils/addon/mysql/mysql2.cjs")));
+            mysql2Module = (mod.default || mod);
+            return mysql2Module;
+        }
+        catch (error) {
+            throw new relq_errors_1.RelqConfigError('Failed to load "mysql2" module. Install it with:\n' +
+                '  npm install mysql2\n' +
+                '  # or\n' +
+                '  bun add mysql2', { field: 'mysql2', value: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    return mysql2Module;
+}
+class MysqlBase extends relq_base_1.RelqBase {
+    sqlDialect = mysql_dialect_1.mysqlDialect;
+    pool;
+    conn;
+    usePooling;
+    clientConnected = false;
+    mysqlConfig;
+    poolErrorHandler;
+    constructor(schema, config) {
+        super(schema, config);
+        this.mysqlConfig = config;
+        this.usePooling = this.determineMysqlPoolingStrategy();
+    }
+    async _initialize() {
+        const mysql2 = await loadMysql2();
+        const connectionConfig = this.buildConnectionConfig();
+        if (this.usePooling) {
+            this.pool = mysql2.createPool({
+                ...connectionConfig,
+                waitForConnections: true,
+                connectionLimit: 10,
+                queueLimit: 0,
+                enableKeepAlive: true,
+                keepAliveInitialDelay: 10000,
+            });
+            this.setupPoolErrorHandling();
+            (0, methods_1.debugLog)(this.mysqlConfig, 'MySQL pool created', {
+                host: connectionConfig.host,
+                port: connectionConfig.port,
+                database: connectionConfig.database,
+            });
+        }
+        else {
+            this.conn = await mysql2.createConnection(connectionConfig);
+            this.clientConnected = true;
+            this.conn.on('error', (err) => {
+                this.clientConnected = false;
+                this.emitter.emit('error', err);
+            });
+            (0, methods_1.debugLog)(this.mysqlConfig, 'MySQL single connection created');
+        }
+    }
+    async _query(sql, isBuilder = true) {
+        const executeQuery = async () => {
+            if (this.pool) {
+                const [rows, fields] = await this.pool.execute(sql);
+                return this.toDriverResult(rows, fields, sql);
+            }
+            else if (this.conn) {
+                if (!this.clientConnected) {
+                    throw new relq_errors_1.RelqConnectionError('MySQL connection is closed');
+                }
+                const [rows, fields] = await this.conn.execute(sql);
+                return this.toDriverResult(rows, fields, sql);
+            }
+            else {
+                throw new relq_errors_1.RelqConfigError('No MySQL connection available');
+            }
+        };
+        try {
+            return await executeQuery();
+        }
+        catch (error) {
+            if ((0, mysql_error_parser_1.isMysqlConnectionError)(error) && !this.usePooling && this.conn) {
+                this.clientConnected = false;
+                try {
+                    await this.reconnectSingleClient();
+                    const [rows, fields] = await this.conn.execute(sql);
+                    return this.toDriverResult(rows, fields, sql);
+                }
+                catch {
+                    throw (0, mysql_error_parser_1.parseMysqlError)(error, sql, isBuilder);
+                }
+            }
+            throw (0, mysql_error_parser_1.parseMysqlError)(error, sql, isBuilder);
+        }
+    }
+    async _acquireClient() {
+        if (this.pool) {
+            const conn = await this.pool.getConnection();
+            return { client: conn, release: () => conn.release() };
+        }
+        else if (this.conn) {
+            return { client: this.conn, release: () => { } };
+        }
+        else {
+            throw new relq_errors_1.RelqConnectionError('No MySQL connection available');
+        }
+    }
+    async _close() {
+        if (this.pool) {
+            if (this.poolErrorHandler) {
+                this.pool.removeListener('error', this.poolErrorHandler);
+            }
+            this.pool.removeAllListeners();
+            await this.pool.end();
+            this.pool = undefined;
+        }
+        else if (this.conn) {
+            this.conn.removeAllListeners();
+            await this.conn.end();
+            this.conn = undefined;
+            this.clientConnected = false;
+        }
+    }
+    toDriverResult(rows, fields, sql) {
+        const command = this.detectCommand(sql);
+        if (Array.isArray(rows)) {
+            return {
+                rows: rows,
+                rowCount: rows.length,
+                command,
+                fields: (fields || []).map((f) => ({
+                    name: f.name,
+                    dataTypeID: f.columnType,
+                    typeName: f.type,
+                })),
+            };
+        }
+        const header = rows;
+        return {
+            rows: [],
+            rowCount: header.affectedRows ?? null,
+            command,
+            fields: [],
+        };
+    }
+    detectCommand(sql) {
+        const trimmed = sql.trimStart().toUpperCase();
+        if (trimmed.startsWith('SELECT'))
+            return 'SELECT';
+        if (trimmed.startsWith('INSERT'))
+            return 'INSERT';
+        if (trimmed.startsWith('UPDATE'))
+            return 'UPDATE';
+        if (trimmed.startsWith('DELETE'))
+            return 'DELETE';
+        if (trimmed.startsWith('REPLACE'))
+            return 'REPLACE';
+        if (trimmed.startsWith('CREATE'))
+            return 'CREATE';
+        if (trimmed.startsWith('ALTER'))
+            return 'ALTER';
+        if (trimmed.startsWith('DROP'))
+            return 'DROP';
+        if (trimmed.startsWith('EXPLAIN'))
+            return 'EXPLAIN';
+        if (trimmed.startsWith('SHOW'))
+            return 'SHOW';
+        if (trimmed.startsWith('DESCRIBE') || trimmed.startsWith('DESC'))
+            return 'DESCRIBE';
+        if (trimmed.startsWith('SET'))
+            return 'SET';
+        if (trimmed.startsWith('BEGIN') || trimmed.startsWith('START'))
+            return 'BEGIN';
+        if (trimmed.startsWith('COMMIT'))
+            return 'COMMIT';
+        if (trimmed.startsWith('ROLLBACK'))
+            return 'ROLLBACK';
+        return 'UNKNOWN';
+    }
+    buildConnectionConfig() {
+        const config = this.mysqlConfig;
+        return {
+            host: config.host || process.env['MYSQL_HOST'] || 'localhost',
+            port: config.port || Number(process.env['MYSQL_PORT']) || 3306,
+            user: config.user || process.env['MYSQL_USER'] || 'root',
+            password: config.password || process.env['MYSQL_PASSWORD'] || '',
+            database: config.database || process.env['MYSQL_DATABASE'],
+            ssl: config.ssl || undefined,
+            supportBigNumbers: true,
+            bigNumberStrings: true,
+            timezone: '+00:00',
+            dateStrings: false,
+        };
+    }
+    determineMysqlPoolingStrategy() {
+        return true;
+    }
+    setupPoolErrorHandling() {
+        if (!this.pool)
+            return;
+        this.poolErrorHandler = (err) => {
+            this.emitter.emit('error', err);
+            if ((0, mysql_error_parser_1.isMysqlPoolRecoverableError)(err)) {
+                const logLevel = this.mysqlConfig.logLevel ?? 'info';
+                if (logLevel !== 'silent') {
+                    console.warn('[Relq MySQL Pool] Recoverable connection error (pool will auto-recover):', {
+                        code: err.errno || err.code,
+                        message: err.message,
+                        action: 'Connection removed from pool, will be replaced on next query',
+                    });
+                }
+                return;
+            }
+            const logLevel = this.mysqlConfig.logLevel ?? 'info';
+            if (logLevel !== 'silent') {
+                console.error('[Relq MySQL Pool] Pool error:', {
+                    code: err.errno || err.code,
+                    message: err.message,
+                });
+            }
+        };
+        this.pool.on('error', this.poolErrorHandler);
+    }
+    async reconnectSingleClient() {
+        const mysql2 = await loadMysql2();
+        const connectionConfig = this.buildConnectionConfig();
+        if (this.conn) {
+            try {
+                this.conn.removeAllListeners();
+                this.conn.destroy();
+            }
+            catch { }
+        }
+        this.conn = await mysql2.createConnection(connectionConfig);
+        this.clientConnected = true;
+        this.conn.on('error', (err) => {
+            this.clientConnected = false;
+            this.emitter.emit('error', err);
+        });
+        this.emitter.emit('connect', this.conn);
+    }
+    async lastInsertId() {
+        await this.ensureInitialized();
+        const result = await this._query('SELECT LAST_INSERT_ID() AS `id`');
+        const raw = result.rows[0]?.id;
+        return typeof raw === 'string' ? BigInt(raw) : BigInt(raw);
+    }
+    async executeRaw(sql, params) {
+        await this.ensureInitialized();
+        const execute = async () => {
+            if (this.pool) {
+                return await this.pool.execute(sql, params);
+            }
+            else if (this.conn) {
+                return await this.conn.execute(sql, params);
+            }
+            else {
+                throw new relq_errors_1.RelqConnectionError('No MySQL connection available');
+            }
+        };
+        try {
+            const [rows, fields] = await execute();
+            return this.toDriverResult(rows, fields, sql);
+        }
+        catch (error) {
+            throw (0, mysql_error_parser_1.parseMysqlError)(error, sql);
+        }
+    }
+    get table() {
+        return (0, mysql_table_accessor_1.createMysqlTableAccessor)(this, this.schema);
+    }
+    raw(query, ...params) {
+        return new MysqlConnectedRawQueryBuilder_1.MysqlConnectedRawQueryBuilder(query, params, this);
+    }
+    async transaction(callback, options) {
+        const { executeMysqlTransaction } = await Promise.resolve().then(() => __importStar(require("../../helpers/MysqlConnectedTransactionBuilder.cjs")));
+        return executeMysqlTransaction(this, callback, options);
+    }
+    cte() {
+        return new native_cte_builder_1.NativeCTEBuilder(this, (0, cte_types_1.createMysqlCTEDialect)(), (relq) => (0, mysql_table_accessor_1.createMysqlTableAccessor)(relq, this._getSchema()));
+    }
+    async ctAs(tableName, query, options = {}) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        const temp = options.temporary ? 'TEMPORARY ' : '';
+        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
+        const sql = `CREATE ${temp}TABLE ${ifNotExists}${mysql_format_1.default.ident(tableName)} AS ${queryStr}`;
+        await this[methods_2.INTERNAL].executeQuery(sql);
+    }
+    async explain(query, options = {}) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        const prefix = options.analyze ? 'EXPLAIN ANALYZE' : 'EXPLAIN';
+        const sql = `${prefix} ${queryStr}`;
+        const { result } = await this._executeQuery(sql);
+        return result.rows;
+    }
+    scalar(scalars) {
+        const { MysqlConnectedScalarSelectBuilder } = require("../../select/scalar-select-builder.cjs");
+        const schema = this._getSchema();
+        return new MysqlConnectedScalarSelectBuilder(scalars, schema, {
+            executeSelectOne: this[methods_2.INTERNAL].executeSelect.bind(this),
+            hasColumnMapping: this._hasColumnMapping.bind(this),
+            transformToDbColumns: this._transformToDbColumns.bind(this)
+        });
+    }
+    where(tableName) {
+        const collector = new condition_collector_1.MysqlConditionCollector();
+        collector._tableName = tableName;
+        return collector;
+    }
+}
+exports.MysqlBase = MysqlBase;

package/dist/cjs/mysql/clients/shared/mysql-dialect.cjs

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mysqlDialect = exports.MysqlDialect = void 0;
+exports.getMysqlDialectCapabilities = getMysqlDialectCapabilities;
+const MYSQL_VARIANT_CAPABILITIES = {
+    mysql: {
+        supportsReturning: false,
+        supportsForeignKeys: true,
+        supportsCtesRecursive: true,
+        supportsWindowFunctions: true,
+        supportsJsonTable: true,
+        supportsExplainAnalyze: true,
+        supportsCheckConstraints: true,
+        supportsGeneratedColumns: true,
+        supportsInvisibleColumns: true,
+        defaultCharset: 'utf8mb4',
+        defaultCollation: 'utf8mb4_0900_ai_ci',
+    },
+    mariadb: {
+        supportsReturning: true,
+        supportsForeignKeys: true,
+        supportsCtesRecursive: true,
+        supportsWindowFunctions: true,
+        supportsJsonTable: false,
+        supportsExplainAnalyze: true,
+        supportsCheckConstraints: true,
+        supportsGeneratedColumns: true,
+        supportsInvisibleColumns: true,
+        defaultCharset: 'utf8mb4',
+        defaultCollation: 'utf8mb4_uca1400_ai_ci',
+    },
+    planetscale: {
+        supportsReturning: false,
+        supportsForeignKeys: false,
+        supportsCtesRecursive: true,
+        supportsWindowFunctions: true,
+        supportsJsonTable: true,
+        supportsExplainAnalyze: true,
+        supportsCheckConstraints: true,
+        supportsGeneratedColumns: true,
+        supportsInvisibleColumns: false,
+        defaultCharset: 'utf8mb4',
+        defaultCollation: 'utf8mb4_0900_ai_ci',
+    },
+};
+function getMysqlDialectCapabilities(variant) {
+    return MYSQL_VARIANT_CAPABILITIES[variant];
+}
+class MysqlDialect {
+    name = 'mysql';
+    quoteIdentifier(name) {
+        if (name === '*')
+            return '*';
+        if (name.includes('.')) {
+            return name.split('.').map(p => p === '*' ? '*' : `\`${p.replace(/`/g, '``')}\``).join('.');
+        }
+        return `\`${name.replace(/`/g, '``')}\``;
+    }
+    quoteString(value) {
+        return `'${value.replace(/'/g, "''")}'`;
+    }
+    formatBoolean(value) {
+        return value ? 'TRUE' : 'FALSE';
+    }
+    returning(columns) {
+        return `RETURNING ${columns.map(c => c === '*' ? '*' : this.quoteIdentifier(c)).join(', ')}`;
+    }
+    upsert(_conflictColumns, updateColumns) {
+        const sets = Object.keys(updateColumns)
+            .map(c => `${this.quoteIdentifier(c)} = VALUES(${this.quoteIdentifier(c)})`)
+            .join(', ');
+        return `ON DUPLICATE KEY UPDATE ${sets}`;
+    }
+    distinctOn(_columns) {
+        throw new Error('DISTINCT ON is not supported in MySQL. Use GROUP BY with ANY_VALUE() instead.');
+    }
+    lateralSubquery(_subquery, _alias) {
+        throw new Error('LATERAL JOIN is not used in MySQL family. Use correlated subqueries instead.');
+    }
+    jsonAgg(expression, alias) {
+        return `COALESCE(JSON_ARRAYAGG(${expression}), JSON_ARRAY()) AS ${this.quoteIdentifier(alias)}`;
+    }
+    rowToJson(alias) {
+        return `JSON_OBJECT(${alias}.*)`;
+    }
+    explain(query, options) {
+        const parts = ['EXPLAIN'];
+        if (options.format) {
+            parts.push(`FORMAT = ${options.format.toUpperCase()}`);
+        }
+        if (options.analyze) {
+            parts.push('ANALYZE');
+        }
+        return `${parts.join(' ')} ${query}`;
+    }
+    typeCast(expression, targetType) {
+        return `CAST(${expression} AS ${targetType})`;
+    }
+    currentTimestamp() {
+        return 'NOW()';
+    }
+    randomUuid() {
+        return 'UUID()';
+    }
+    supports(capability) {
+        return MYSQL_BASE_CAPABILITIES[capability] === true;
+    }
+    transformSql(sql) {
+        return sql;
+    }
+}
+exports.MysqlDialect = MysqlDialect;
+exports.mysqlDialect = new MysqlDialect();
+const MYSQL_BASE_CAPABILITIES = {
+    returning: false,
+    lateral: false,
+    distinctOn: false,
+    listenNotify: false,
+    pooling: true,
+    cursors: true,
+    jsonb: false,
+    arrays: false,
+    ranges: false,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: false,
+    storedProcedures: true,
+    triggers: true,
+    sequences: false,
+    copy: false,
+    vacuum: false,
+    identifierQuote: '`',
+    parameterStyle: 'question',
+};