@relq/orm 0.1.3 → 0.1.5

package/dist/esm/mysql/select/aggregate-builder.js

@@ -0,0 +1,204 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { MysqlConditionCollector, buildMysqlConditionsSQL } from "../condition/condition-collector.js";
+const NUMERIC_FUNCS = new Set(['COUNT', 'SUM', 'AVG', 'MIN', 'MAX']);
+export class MysqlAggregateQueryBuilder {
+    tableName;
+    groupByColumns = [];
+    entries = [];
+    whereConditions = [];
+    havingConditions = [];
+    orderByColumns = [];
+    limitValue;
+    offsetValue;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    groupBy(...columns) {
+        this.groupByColumns.push(...columns);
+        return this;
+    }
+    count(alias = 'count') {
+        this.entries.push({ func: 'COUNT', column: '*', alias });
+        return this;
+    }
+    countColumn(column, alias) {
+        this.entries.push({ func: 'COUNT', column, alias: alias || column });
+        return this;
+    }
+    countDistinct(column, alias) {
+        this.entries.push({ func: 'COUNT', column, alias: alias || column, distinct: true });
+        return this;
+    }
+    sum(column, alias, filter) {
+        const entry = { func: 'SUM', column, alias: alias || column };
+        if (filter) {
+            const collector = new MysqlConditionCollector();
+            filter(collector);
+            entry.filterConditions = collector.getConditions();
+        }
+        this.entries.push(entry);
+        return this;
+    }
+    avg(column, alias, filter) {
+        const entry = { func: 'AVG', column, alias: alias || column };
+        if (filter) {
+            const collector = new MysqlConditionCollector();
+            filter(collector);
+            entry.filterConditions = collector.getConditions();
+        }
+        this.entries.push(entry);
+        return this;
+    }
+    min(column, alias) {
+        this.entries.push({ func: 'MIN', column, alias: alias || column });
+        return this;
+    }
+    max(column, alias) {
+        this.entries.push({ func: 'MAX', column, alias: alias || column });
+        return this;
+    }
+    groupConcat(column, separator = ', ', alias, orderBy, orderDir = 'ASC') {
+        const entry = {
+            func: 'GROUP_CONCAT',
+            column,
+            alias: alias || column,
+            separator,
+        };
+        if (orderBy) {
+            entry.orderByColumn = orderBy;
+            entry.orderByDirection = orderDir;
+        }
+        this.entries.push(entry);
+        return this;
+    }
+    jsonArrayAgg(column, alias) {
+        this.entries.push({ func: 'JSON_ARRAYAGG', column, alias: alias || column });
+        return this;
+    }
+    bitAnd(column, alias) {
+        this.entries.push({ func: 'BIT_AND', column, alias: alias || column });
+        return this;
+    }
+    bitOr(column, alias) {
+        this.entries.push({ func: 'BIT_OR', column, alias: alias || column });
+        return this;
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof MysqlConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const collector = new MysqlConditionCollector();
+            callbackOrCondition(collector);
+            this.whereConditions.push(...collector.getConditions());
+        }
+        return this;
+    }
+    having(callback) {
+        const collector = new MysqlConditionCollector();
+        callback(collector);
+        this.havingConditions.push(...collector.getConditions());
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByColumns.push({ column, direction });
+        return this;
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    getNumericAliases() {
+        return this.entries
+            .filter(e => NUMERIC_FUNCS.has(e.func))
+            .map(e => e.alias);
+    }
+    getGroupByColumns() {
+        return this.groupByColumns;
+    }
+    toString() {
+        const selectParts = [];
+        for (const col of this.groupByColumns) {
+            selectParts.push(mysqlFormat.ident(col));
+        }
+        for (const entry of this.entries) {
+            selectParts.push(this.buildEntrySQL(entry));
+        }
+        if (selectParts.length === 0) {
+            selectParts.push('COUNT(*) AS `count`');
+        }
+        let query = `SELECT ${selectParts.join(', ')} FROM ${mysqlFormat.ident(this.tableName)}`;
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + buildMysqlConditionsSQL(this.whereConditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            query += ' GROUP BY ' + this.groupByColumns.map(col => mysqlFormat.ident(col)).join(', ');
+        }
+        if (this.havingConditions.length > 0) {
+            query += ' HAVING ' + buildMysqlConditionsSQL(this.havingConditions);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(o => `${mysqlFormat.ident(o.column)} ${o.direction}`)
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += ` LIMIT ${this.limitValue}`;
+        }
+        if (this.offsetValue !== undefined) {
+            query += ` OFFSET ${this.offsetValue}`;
+        }
+        return query;
+    }
+    buildEntrySQL(entry) {
+        let columnExpr;
+        if (entry.column === '*') {
+            columnExpr = '*';
+        }
+        else if (entry.distinct) {
+            columnExpr = `DISTINCT ${mysqlFormat.ident(entry.column)}`;
+        }
+        else {
+            columnExpr = mysqlFormat.ident(entry.column);
+        }
+        if (entry.filterConditions && entry.filterConditions.length > 0) {
+            const filterSQL = buildMysqlConditionsSQL(entry.filterConditions);
+            return this.buildFilteredAggregateSQL(entry.func, columnExpr, filterSQL, entry.alias);
+        }
+        if (entry.func === 'GROUP_CONCAT') {
+            return this.buildGroupConcatSQL(entry);
+        }
+        let sql = `${entry.func}(${columnExpr})`;
+        sql += ` AS ${mysqlFormat.ident(entry.alias)}`;
+        return sql;
+    }
+    buildGroupConcatSQL(entry) {
+        let inner = entry.distinct
+            ? `DISTINCT ${mysqlFormat.ident(entry.column)}`
+            : mysqlFormat.ident(entry.column);
+        if (entry.orderByColumn) {
+            inner += ` ORDER BY ${mysqlFormat.ident(entry.orderByColumn)} ${entry.orderByDirection || 'ASC'}`;
+        }
+        if (entry.separator !== undefined) {
+            inner += ` SEPARATOR ${mysqlFormat.literal(entry.separator)}`;
+        }
+        return `GROUP_CONCAT(${inner}) AS ${mysqlFormat.ident(entry.alias)}`;
+    }
+    buildFilteredAggregateSQL(func, columnExpr, filterSQL, alias) {
+        let caseExpr;
+        if (func === 'COUNT') {
+            caseExpr = `SUM(CASE WHEN ${filterSQL} THEN 1 ELSE 0 END)`;
+        }
+        else if (func === 'AVG' || func === 'MIN' || func === 'MAX') {
+            caseExpr = `${func}(CASE WHEN ${filterSQL} THEN ${columnExpr} ELSE NULL END)`;
+        }
+        else {
+            caseExpr = `${func}(CASE WHEN ${filterSQL} THEN ${columnExpr} ELSE 0 END)`;
+        }
+        return `${caseExpr} AS ${mysqlFormat.ident(alias)}`;
+    }
+}

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

@@ -0,0 +1,9 @@
+export { MysqlSelectBuilder } from "./select-builder.js";
+export { MYSQL_JOIN_INTERNAL, MYSQL_JOIN_SETUP } from "./join-internals.js";
+export { createMysqlTableProxy, createMysqlJoinCallbackParams, mysqlColumnRefToSQL, mysqlColumnRefToSQLUnqualified, mysqlColumnRefsEqual, isMysqlColumnRef } from "./table-proxy.js";
+export { MysqlSqlExpression, MysqlAggregateFunctions } from "./sql-expression.js";
+export { MysqlJoinConditionBuilder, createMysqlJoinConditionBuilder } from "./join-condition-builder.js";
+export { MysqlJoinManyBuilder, createMysqlJoinManyBuilder } from "./join-builder.js";
+export { MysqlAggregateQueryBuilder } from "./aggregate-builder.js";
+export { MysqlScalarQueryBuilderImpl, createMysqlScalarTableAccessor } from "./scalar-query-builder.js";
+export { MysqlScalarSelectBuilder, MysqlConnectedScalarSelectBuilder } from "./scalar-select-builder.js";

package/dist/esm/mysql/select/join-builder.js

@@ -0,0 +1,198 @@
+import { MysqlJoinConditionBuilder } from "./join-condition-builder.js";
+import { mysqlColumnRefToSQL, mysqlColumnRefToSQLUnqualified } from "./table-proxy.js";
+import { MysqlConditionCollector, buildMysqlConditionsSQL } from "../condition/condition-collector.js";
+import mysqlFormat from "../clients/shared/mysql-format.js";
+export class MysqlJoinManyBuilder extends MysqlJoinConditionBuilder {
+    orderBySpecs = [];
+    selectColumns = [];
+    limitValue;
+    offsetValue;
+    groupByColumns = [];
+    havingConditions = [];
+    selectRefs(columns) {
+        this.selectColumns = columns;
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderBySpecs.push({ column, direction });
+        return this;
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    groupBy(...columns) {
+        this.groupByColumns.push(...columns);
+        return this;
+    }
+    having(callback) {
+        const collector = new MysqlConditionCollector();
+        callback(collector);
+        this.havingConditions.push(...collector.getConditions());
+        return this;
+    }
+    hasQueryModifiers() {
+        return (this.orderBySpecs.length > 0 ||
+            this.selectColumns.length > 0 ||
+            this.limitValue !== undefined ||
+            this.offsetValue !== undefined ||
+            this.groupByColumns.length > 0 ||
+            this.havingConditions.length > 0);
+    }
+    getSelectColumns() {
+        return [...this.selectColumns];
+    }
+    getOrderBySpecs() {
+        return [...this.orderBySpecs];
+    }
+    getLimit() {
+        return this.limitValue;
+    }
+    getOffset() {
+        return this.offsetValue;
+    }
+    toCorrelatedSubquerySQL(rightTable, rightAlias, leftAlias) {
+        const selectPart = this.buildSelectPart();
+        const fromPart = mysqlFormat.ident(rightTable);
+        const wherePart = this.buildWherePart(leftAlias);
+        const groupByPart = this.buildGroupByPart();
+        const havingPart = this.buildHavingPart();
+        const orderByPart = this.buildOrderByPart();
+        const limitPart = this.buildLimitPart();
+        let innerQuery = `SELECT ${selectPart} FROM ${fromPart}`;
+        if (wherePart) {
+            innerQuery += ` WHERE ${wherePart}`;
+        }
+        if (groupByPart) {
+            innerQuery += ` GROUP BY ${groupByPart}`;
+        }
+        if (havingPart) {
+            innerQuery += ` HAVING ${havingPart}`;
+        }
+        if (orderByPart) {
+            innerQuery += ` ORDER BY ${orderByPart}`;
+        }
+        if (limitPart) {
+            innerQuery += limitPart;
+        }
+        const jsonObjectParts = this.buildJsonObjectParts();
+        let wrappedQuery;
+        if (jsonObjectParts) {
+            wrappedQuery = `SELECT COALESCE(JSON_ARRAYAGG(JSON_OBJECT(${jsonObjectParts})), CAST('[]' AS JSON)) AS ${mysqlFormat.ident(rightAlias)} FROM (${innerQuery}) AS \`sub\``;
+        }
+        else {
+            wrappedQuery = `SELECT COALESCE(JSON_ARRAYAGG(\`sub\`.\`__json\`), CAST('[]' AS JSON)) AS ${mysqlFormat.ident(rightAlias)} FROM (SELECT JSON_OBJECT(${this.buildAutoJsonObjectSQL(rightTable)}) AS \`__json\` FROM (${innerQuery}) AS \`inner_sub\`) AS \`sub\``;
+        }
+        return `(${wrappedQuery})`;
+    }
+    toSubquerySQL(rightTable, leftAlias) {
+        const selectPart = this.buildSelectPart();
+        const fromPart = mysqlFormat.ident(rightTable);
+        const wherePart = this.buildWherePart(leftAlias);
+        const groupByPart = this.buildGroupByPart();
+        const havingPart = this.buildHavingPart();
+        const orderByPart = this.buildOrderByPart();
+        const limitPart = this.buildLimitPart();
+        let query = `SELECT ${selectPart} FROM ${fromPart}`;
+        if (wherePart) {
+            query += ` WHERE ${wherePart}`;
+        }
+        if (groupByPart) {
+            query += ` GROUP BY ${groupByPart}`;
+        }
+        if (havingPart) {
+            query += ` HAVING ${havingPart}`;
+        }
+        if (orderByPart) {
+            query += ` ORDER BY ${orderByPart}`;
+        }
+        if (limitPart) {
+            query += limitPart;
+        }
+        return query;
+    }
+    buildSelectPart() {
+        if (this.selectColumns.length === 0) {
+            return '*';
+        }
+        return this.selectColumns
+            .map(col => mysqlColumnRefToSQLUnqualified(col))
+            .join(', ');
+    }
+    buildWherePart(_leftAlias) {
+        const parts = [];
+        for (const cond of this.conditions) {
+            if (cond.type === 'using' || cond.type === 'raw') {
+                if (cond.raw)
+                    parts.push(cond.raw);
+                continue;
+            }
+            if (cond.type === 'ilike') {
+                const leftSQL = mysqlColumnRefToSQL(cond.left);
+                const rightSQL = this.formatRightSide(cond.right);
+                parts.push(`LOWER(${leftSQL}) LIKE LOWER(${rightSQL})`);
+                continue;
+            }
+            const leftSQL = mysqlColumnRefToSQL(cond.left);
+            const rightSQL = this.formatRightSide(cond.right);
+            parts.push(`${leftSQL} ${cond.operator} ${rightSQL}`);
+        }
+        if (this.whereConditions.length > 0) {
+            const whereSQL = buildMysqlConditionsSQL(this.whereConditions);
+            if (whereSQL) {
+                parts.push(whereSQL);
+            }
+        }
+        return parts.length > 0 ? parts.join(' AND ') : null;
+    }
+    buildGroupByPart() {
+        if (this.groupByColumns.length === 0) {
+            return null;
+        }
+        return this.groupByColumns
+            .map(col => mysqlColumnRefToSQLUnqualified(col))
+            .join(', ');
+    }
+    buildHavingPart() {
+        if (this.havingConditions.length === 0) {
+            return null;
+        }
+        return buildMysqlConditionsSQL(this.havingConditions);
+    }
+    buildOrderByPart() {
+        if (this.orderBySpecs.length === 0) {
+            return null;
+        }
+        return this.orderBySpecs
+            .map(spec => `${mysqlColumnRefToSQLUnqualified(spec.column)} ${spec.direction}`)
+            .join(', ');
+    }
+    buildLimitPart() {
+        let sql = '';
+        if (this.limitValue !== undefined) {
+            sql += ` LIMIT ${this.limitValue}`;
+        }
+        if (this.offsetValue !== undefined) {
+            sql += ` OFFSET ${this.offsetValue}`;
+        }
+        return sql;
+    }
+    buildJsonObjectParts() {
+        if (this.selectColumns.length === 0) {
+            return null;
+        }
+        return this.selectColumns
+            .map(col => `${mysqlFormat.literal(col.$sqlColumn)}, \`sub\`.${mysqlColumnRefToSQLUnqualified(col)}`)
+            .join(', ');
+    }
+    buildAutoJsonObjectSQL(_rightTable) {
+        return "'__all', \`inner_sub\`.*";
+    }
+}
+export function createMysqlJoinManyBuilder() {
+    return new MysqlJoinManyBuilder();
+}

package/dist/esm/mysql/select/join-condition-builder.js

@@ -0,0 +1,197 @@
+import { mysqlColumnRefToSQL, isMysqlColumnRef } from "./table-proxy.js";
+import { MysqlConditionCollector, buildMysqlConditionsSQL } from "../condition/condition-collector.js";
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { MYSQL_JOIN_INTERNAL } from "./join-internals.js";
+export class MysqlJoinConditionBuilder {
+    conditions = [];
+    whereConditions = [];
+    selectedColumns;
+    flatConfig;
+    equal(left, right) {
+        this.conditions.push({
+            type: 'equal',
+            left,
+            right,
+            operator: '='
+        });
+        return this;
+    }
+    notEqual(left, right) {
+        this.conditions.push({
+            type: 'notEqual',
+            left,
+            right,
+            operator: '!='
+        });
+        return this;
+    }
+    greaterThan(left, right) {
+        this.conditions.push({
+            type: 'greaterThan',
+            left,
+            right,
+            operator: '>'
+        });
+        return this;
+    }
+    lessThan(left, right) {
+        this.conditions.push({
+            type: 'lessThan',
+            left,
+            right,
+            operator: '<'
+        });
+        return this;
+    }
+    greaterThanOrEqual(left, right) {
+        this.conditions.push({
+            type: 'greaterThanOrEqual',
+            left,
+            right,
+            operator: '>='
+        });
+        return this;
+    }
+    lessThanOrEqual(left, right) {
+        this.conditions.push({
+            type: 'lessThanOrEqual',
+            left,
+            right,
+            operator: '<='
+        });
+        return this;
+    }
+    like(left, right) {
+        this.conditions.push({
+            type: 'like',
+            left,
+            right,
+            operator: 'LIKE'
+        });
+        return this;
+    }
+    ilike(left, right) {
+        this.conditions.push({
+            type: 'ilike',
+            left,
+            right,
+            operator: 'LIKE'
+        });
+        return this;
+    }
+    using(...columns) {
+        this.conditions.push({
+            type: 'using',
+            columns: columns
+        });
+        return this;
+    }
+    where(callback) {
+        const collector = new MysqlConditionCollector();
+        callback(collector);
+        this.whereConditions.push(...collector.getConditions());
+        return this;
+    }
+    select(...args) {
+        if (args.length === 1 && Array.isArray(args[0])) {
+            this.selectedColumns = args[0];
+        }
+        else {
+            this.selectedColumns = args;
+        }
+        return this;
+    }
+    flat() {
+        if (!this.selectedColumns || this.selectedColumns.length === 0) {
+            throw new Error('Relq: .flat() requires .select() with explicit columns.');
+        }
+        this.flatConfig = { mode: 'prefix' };
+        return this;
+    }
+    get [MYSQL_JOIN_INTERNAL]() {
+        return {
+            toSQL: () => this.internalToSQL(),
+            isUsingJoin: () => this.internalIsUsingJoin(),
+            getUsingColumns: () => this.internalGetUsingColumns(),
+            toUsingSQL: () => this.internalToUsingSQL(),
+            getConditions: () => [...this.conditions],
+            getWhereConditions: () => [...this.whereConditions],
+            hasConditions: () => this.conditions.length > 0,
+            hasWhereConditions: () => this.whereConditions.length > 0,
+            getSelectedColumns: () => this.selectedColumns ?? null,
+            getFlatConfig: () => this.flatConfig ?? null,
+        };
+    }
+    internalToSQL() {
+        const parts = [];
+        for (const cond of this.conditions) {
+            switch (cond.type) {
+                case 'using':
+                    break;
+                case 'raw':
+                    parts.push(cond.raw);
+                    break;
+                case 'ilike': {
+                    const leftSQL = mysqlColumnRefToSQL(cond.left);
+                    const rightSQL = this.formatRightSide(cond.right);
+                    parts.push(`LOWER(${leftSQL}) LIKE LOWER(${rightSQL})`);
+                    break;
+                }
+                default: {
+                    const leftSQL = mysqlColumnRefToSQL(cond.left);
+                    const rightSQL = this.formatRightSide(cond.right);
+                    parts.push(`${leftSQL} ${cond.operator} ${rightSQL}`);
+                    break;
+                }
+            }
+        }
+        if (this.whereConditions.length > 0) {
+            const whereSQL = buildMysqlConditionsSQL(this.whereConditions);
+            if (whereSQL) {
+                parts.push(whereSQL);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    internalIsUsingJoin() {
+        return this.conditions.length === 1 && this.conditions[0].type === 'using';
+    }
+    internalGetUsingColumns() {
+        if (!this.internalIsUsingJoin())
+            return null;
+        return this.conditions[0].columns || null;
+    }
+    internalToUsingSQL() {
+        const columns = this.internalGetUsingColumns();
+        if (!columns)
+            return null;
+        return `USING (${columns.map(c => mysqlFormat.ident(c)).join(', ')})`;
+    }
+    formatRightSide(right) {
+        if (isMysqlColumnRef(right)) {
+            return mysqlColumnRefToSQL(right);
+        }
+        if (right === null) {
+            return 'NULL';
+        }
+        if (typeof right === 'boolean') {
+            return right ? 'true' : 'false';
+        }
+        if (typeof right === 'number') {
+            return String(right);
+        }
+        if (typeof right === 'string') {
+            return mysqlFormat.literal(right);
+        }
+        if (right instanceof Date) {
+            return mysqlFormat.literal(right.toISOString());
+        }
+        if (Array.isArray(right)) {
+            return `(${right.map(v => this.formatRightSide(v)).join(', ')})`;
+        }
+        return mysqlFormat.literal(JSON.stringify(right));
+    }
+}
+export function createMysqlJoinConditionBuilder() {
+    return new MysqlJoinConditionBuilder();
+}

package/dist/esm/mysql/select/join-internals.js

@@ -0,0 +1,2 @@
+export const MYSQL_JOIN_INTERNAL = Symbol.for('mysql-join-internal');
+export const MYSQL_JOIN_SETUP = Symbol.for('mysql-join-setup');