@relq/orm 0.1.0

package/dist/cjs/pubsub/listener-connection.cjs

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerConnection = void 0;
+const node_events_1 = require("node:events");
+const pg_1 = require("../addon/pg.cjs");
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+class ListenerConnection extends node_events_1.EventEmitter {
+    client = null;
+    config;
+    connected = false;
+    connecting = false;
+    subscriptions = new Map();
+    reconnectTimeout = null;
+    isClosing = false;
+    reconnectDelay = 1000;
+    maxReconnectDelay = 30000;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async subscribe(channel) {
+        if (!this.connected && !this.connecting) {
+            await this.connect();
+        }
+        else if (this.connecting) {
+            await this.waitForConnection();
+        }
+        let channelSub = this.subscriptions.get(channel);
+        if (!channelSub) {
+            channelSub = { subscribers: [], retryCount: 0 };
+            this.subscriptions.set(channel, channelSub);
+            await this.executeListen(channel);
+        }
+        const emitter = new node_events_1.EventEmitter();
+        channelSub.subscribers.push(emitter);
+        const subscription = {
+            on(event, listener) {
+                emitter.on(event, listener);
+                return this;
+            },
+            close: async () => {
+                emitter.removeAllListeners();
+                const sub = this.subscriptions.get(channel);
+                if (sub) {
+                    const index = sub.subscribers.indexOf(emitter);
+                    if (index !== -1) {
+                        sub.subscribers.splice(index, 1);
+                    }
+                    if (sub.subscribers.length === 0) {
+                        this.subscriptions.delete(channel);
+                        if (this.connected) {
+                            try {
+                                await this.client?.query(`UNLISTEN ${pg_format_1.default.ident(channel)}`);
+                            }
+                            catch (err) {
+                            }
+                        }
+                        if (this.subscriptions.size === 0) {
+                            await this.close();
+                        }
+                    }
+                }
+            }
+        };
+        return subscription;
+    }
+    async connect() {
+        if (this.connected || this.connecting)
+            return;
+        this.connecting = true;
+        this.isClosing = false;
+        try {
+            this.client = new pg_1.Client(this.config);
+            this.client.on('notification', (msg) => {
+                if (msg.channel && msg.payload) {
+                    this.dispatch(msg.channel, msg.payload);
+                }
+            });
+            this.client.on('error', (err) => {
+                this.emit('error', err);
+                if (!this.isClosing) {
+                    this.handleDisconnect();
+                }
+            });
+            this.client.on('end', () => {
+                if (!this.isClosing) {
+                    this.handleDisconnect();
+                }
+            });
+            await this.client.connect();
+            this.connected = true;
+            this.connecting = false;
+            this.reconnectDelay = 1000;
+            await this.resubscribeAll();
+            this.emit('connect');
+        }
+        catch (err) {
+            this.connecting = false;
+            this.handleDisconnect();
+            throw err;
+        }
+    }
+    async waitForConnection() {
+        return new Promise((resolve, reject) => {
+            const onConnect = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (err) => {
+                cleanup();
+                reject(err);
+            };
+            const cleanup = () => {
+                this.removeListener('connect', onConnect);
+                this.removeListener('error', onError);
+            };
+            this.on('connect', onConnect);
+            this.on('error', onError);
+        });
+    }
+    dispatch(channel, payload) {
+        const sub = this.subscriptions.get(channel);
+        if (sub) {
+            let data = payload;
+            try {
+                data = JSON.parse(payload);
+            }
+            catch {
+            }
+            sub.subscribers.forEach(emitter => emitter.emit('notification', data));
+        }
+    }
+    async executeListen(channel) {
+        if (this.client && this.connected) {
+            await this.client.query(`LISTEN ${pg_format_1.default.ident(channel)}`);
+        }
+    }
+    async resubscribeAll() {
+        for (const channel of this.subscriptions.keys()) {
+            try {
+                await this.executeListen(channel);
+            }
+            catch (err) {
+                console.error(`Failed to resubscribe to ${channel}:`, err);
+            }
+        }
+    }
+    handleDisconnect() {
+        this.connected = false;
+        this.client = null;
+        if (this.isClosing)
+            return;
+        if (this.reconnectTimeout)
+            clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = setTimeout(() => {
+            console.log('Reconnecting listener...');
+            this.connect().catch(err => {
+                console.error('Reconnect failed:', err);
+                this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+                this.handleDisconnect();
+            });
+        }, this.reconnectDelay);
+        this.reconnectTimeout.unref();
+    }
+    async close() {
+        this.isClosing = true;
+        if (this.reconnectTimeout)
+            clearTimeout(this.reconnectTimeout);
+        if (this.client) {
+            await this.client.end();
+            this.client = null;
+        }
+        this.connected = false;
+        this.subscriptions.clear();
+    }
+}
+exports.ListenerConnection = ListenerConnection;

package/dist/cjs/raw/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlFragment = exports.sql = exports.RawQueryBuilder = void 0;
+var raw_query_builder_1 = require("./raw-query-builder.cjs");
+Object.defineProperty(exports, "RawQueryBuilder", { enumerable: true, get: function () { return raw_query_builder_1.RawQueryBuilder; } });
+var sql_template_1 = require("./sql-template.cjs");
+Object.defineProperty(exports, "sql", { enumerable: true, get: function () { return sql_template_1.sql; } });
+Object.defineProperty(exports, "SqlFragment", { enumerable: true, get: function () { return sql_template_1.SqlFragment; } });

package/dist/cjs/raw/raw-query-builder.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawQueryBuilder = void 0;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+const relq_errors_1 = require("../shared/errors/relq-errors.cjs");
+class RawQueryBuilder {
+    query;
+    params;
+    constructor(query, params = []) {
+        this.query = query;
+        this.params = params;
+    }
+    toString() {
+        if (!this.query || typeof this.query !== 'string' || this.query.trim() === '') {
+            throw new relq_errors_1.RelqQueryError(`Invalid query provided: ${this.query === null ? 'null' : this.query === undefined ? 'undefined' : 'empty string'}`, { hint: 'Provide a valid SQL query string' });
+        }
+        const result = this.params.length > 0 ? (0, pg_format_1.default)(this.query, ...this.params) : this.query;
+        if (!result || typeof result !== 'string') {
+            throw new relq_errors_1.RelqQueryError(`format() returned invalid result: ${result === null ? 'null' : result === undefined ? 'undefined' : typeof result}`, { sql: this.query });
+        }
+        return result;
+    }
+}
+exports.RawQueryBuilder = RawQueryBuilder;

package/dist/cjs/raw/sql-template.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlFragment = void 0;
+exports.sql = sql;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+class SqlFragment {
+    text;
+    _isSqlFragment = true;
+    constructor(text) {
+        this.text = text;
+    }
+    toString() {
+        return this.text;
+    }
+}
+exports.SqlFragment = SqlFragment;
+function sqlIdentifier(name) {
+    return new SqlFragment(pg_format_1.default.ident(name));
+}
+function sqlRaw(text) {
+    return new SqlFragment(text);
+}
+function sql(strings, ...values) {
+    let result = '';
+    for (let i = 0; i < strings.length; i++) {
+        result += strings[i];
+        if (i < values.length) {
+            const value = values[i];
+            result += formatValue(value);
+        }
+    }
+    return new SqlFragment(result);
+}
+function formatValue(value) {
+    if (value && value._isSqlFragment === true) {
+        return value.text;
+    }
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    if (value instanceof Date) {
+        return (0, pg_format_1.default)('%L', value.toISOString());
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return 'ARRAY[]';
+        }
+        const escaped = value.map(v => formatValue(v)).join(', ');
+        return `(${escaped})`;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'bigint') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return (0, pg_format_1.default)('%L', value);
+    }
+    if (typeof value === 'object') {
+        return (0, pg_format_1.default)('%L', JSON.stringify(value)) + '::jsonb';
+    }
+    return (0, pg_format_1.default)('%L', String(value));
+}
+sql.id = sqlIdentifier;
+sql.raw = sqlRaw;
+sql.fragment = sqlRaw;

package/dist/cjs/select/aggregate-builder.cjs

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateQueryBuilder = void 0;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const NUMERIC_FUNCS = new Set(['COUNT', 'SUM', 'AVG', 'MIN', 'MAX']);
+class AggregateQueryBuilder {
+    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 condition_collector_1.ConditionCollector();
+            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 condition_collector_1.ConditionCollector();
+            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;
+    }
+    arrayAgg(column, alias) {
+        this.entries.push({ func: 'ARRAY_AGG', column, alias: alias || column });
+        return this;
+    }
+    stringAgg(column, delimiter = ', ', alias) {
+        this.entries.push({ func: 'STRING_AGG', column, alias: alias || column, delimiter });
+        return this;
+    }
+    jsonAgg(column, alias) {
+        this.entries.push({ func: 'JSON_AGG', column, alias: alias || column });
+        return this;
+    }
+    jsonbAgg(column, alias) {
+        this.entries.push({ func: 'JSONB_AGG', column, alias: alias || column });
+        return this;
+    }
+    boolAnd(column, alias) {
+        this.entries.push({ func: 'BOOL_AND', column, alias: alias || column });
+        return this;
+    }
+    boolOr(column, alias) {
+        this.entries.push({ func: 'BOOL_OR', column, alias: alias || column });
+        return this;
+    }
+    where(callback) {
+        const collector = new condition_collector_1.ConditionCollector();
+        callback(collector);
+        this.whereConditions.push(...collector.getConditions());
+        return this;
+    }
+    having(callback) {
+        const collector = new condition_collector_1.ConditionCollector();
+        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(pg_format_1.default.ident(col));
+        }
+        for (const entry of this.entries) {
+            selectParts.push(this.buildEntrySQL(entry));
+        }
+        if (selectParts.length === 0) {
+            selectParts.push('COUNT(*) AS count');
+        }
+        let query = (0, pg_format_1.default)('SELECT %s FROM %I', selectParts.join(', '), this.tableName);
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(this.whereConditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            query += ' GROUP BY ' + this.groupByColumns.map(col => pg_format_1.default.ident(col)).join(', ');
+        }
+        if (this.havingConditions.length > 0) {
+            query += ' HAVING ' + (0, condition_collector_1.buildConditionsSQL)(this.havingConditions);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(o => `${pg_format_1.default.ident(o.column)} ${o.direction}`)
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += (0, pg_format_1.default)(' LIMIT %s', this.limitValue);
+        }
+        if (this.offsetValue !== undefined) {
+            query += (0, pg_format_1.default)(' OFFSET %s', this.offsetValue);
+        }
+        return query;
+    }
+    buildEntrySQL(entry) {
+        let columnExpr;
+        if (entry.column === '*') {
+            columnExpr = '*';
+        }
+        else if (entry.distinct) {
+            columnExpr = `DISTINCT ${pg_format_1.default.ident(entry.column)}`;
+        }
+        else if (entry.func === 'STRING_AGG' && entry.delimiter) {
+            columnExpr = `${pg_format_1.default.ident(entry.column)}, ${pg_format_1.default.literal(entry.delimiter)}`;
+        }
+        else {
+            columnExpr = pg_format_1.default.ident(entry.column);
+        }
+        let sql = `${entry.func}(${columnExpr})`;
+        if (entry.filterConditions && entry.filterConditions.length > 0) {
+            const filterSQL = (0, condition_collector_1.buildConditionsSQL)(entry.filterConditions);
+            sql += ` FILTER (WHERE ${filterSQL})`;
+        }
+        sql += ` AS ${pg_format_1.default.ident(entry.alias)}`;
+        return sql;
+    }
+}
+exports.AggregateQueryBuilder = AggregateQueryBuilder;

package/dist/cjs/select/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJoinManyBuilder = exports.JoinManyBuilder = exports.createJoinConditionBuilder = exports.JoinConditionBuilder = exports.isColumnRef = exports.columnRefToSQLUnqualified = exports.columnRefToSQL = exports.createTableProxy = exports.SelectBuilder = void 0;
+var select_builder_1 = require("./select-builder.cjs");
+Object.defineProperty(exports, "SelectBuilder", { enumerable: true, get: function () { return select_builder_1.SelectBuilder; } });
+var table_proxy_1 = require("./table-proxy.cjs");
+Object.defineProperty(exports, "createTableProxy", { enumerable: true, get: function () { return table_proxy_1.createTableProxy; } });
+Object.defineProperty(exports, "columnRefToSQL", { enumerable: true, get: function () { return table_proxy_1.columnRefToSQL; } });
+Object.defineProperty(exports, "columnRefToSQLUnqualified", { enumerable: true, get: function () { return table_proxy_1.columnRefToSQLUnqualified; } });
+Object.defineProperty(exports, "isColumnRef", { enumerable: true, get: function () { return table_proxy_1.isColumnRef; } });
+var join_condition_builder_1 = require("./join-condition-builder.cjs");
+Object.defineProperty(exports, "JoinConditionBuilder", { enumerable: true, get: function () { return join_condition_builder_1.JoinConditionBuilder; } });
+Object.defineProperty(exports, "createJoinConditionBuilder", { enumerable: true, get: function () { return join_condition_builder_1.createJoinConditionBuilder; } });
+var join_builder_1 = require("./join-builder.cjs");
+Object.defineProperty(exports, "JoinManyBuilder", { enumerable: true, get: function () { return join_builder_1.JoinManyBuilder; } });
+Object.defineProperty(exports, "createJoinManyBuilder", { enumerable: true, get: function () { return join_builder_1.createJoinManyBuilder; } });

package/dist/cjs/select/join-builder.cjs

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinManyBuilder = void 0;
+exports.createJoinManyBuilder = createJoinManyBuilder;
+const join_condition_builder_1 = require("./join-condition-builder.cjs");
+const table_proxy_1 = require("./table-proxy.cjs");
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+class JoinManyBuilder extends join_condition_builder_1.JoinConditionBuilder {
+    orderBySpecs = [];
+    selectColumns = [];
+    limitValue;
+    offsetValue;
+    groupByColumns = [];
+    havingConditions = [];
+    selectRefs(columns) {
+        this.selectColumns = columns;
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderBySpecs.push({ column, direction });
+        return this;
+    }
+    orderByNulls(column, direction, nulls) {
+        this.orderBySpecs.push({ column, direction, nulls });
+        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 condition_collector_1.ConditionCollector();
+        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;
+    }
+    toLateralSQL(rightTable, rightAlias, leftAlias) {
+        const selectPart = this.buildSelectPart();
+        const fromPart = pg_format_1.default.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 wrappedQuery = `SELECT COALESCE(json_agg(sub.*), '[]'::json) as ${pg_format_1.default.ident(rightAlias)} FROM (${innerQuery}) sub`;
+        return `(${wrappedQuery})`;
+    }
+    toSubquerySQL(rightTable, leftAlias) {
+        const selectPart = this.buildSelectPart();
+        const fromPart = pg_format_1.default.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 => (0, table_proxy_1.columnRefToSQLUnqualified)(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;
+            }
+            const leftSQL = (0, table_proxy_1.columnRefToSQL)(cond.left);
+            const rightSQL = this.formatRightSide(cond.right);
+            parts.push(`${leftSQL} ${cond.operator} ${rightSQL}`);
+        }
+        if (this.whereConditions.length > 0) {
+            const whereSQL = (0, condition_collector_1.buildConditionsSQL)(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 => (0, table_proxy_1.columnRefToSQLUnqualified)(col))
+            .join(', ');
+    }
+    buildHavingPart() {
+        if (this.havingConditions.length === 0) {
+            return null;
+        }
+        return (0, condition_collector_1.buildConditionsSQL)(this.havingConditions);
+    }
+    buildOrderByPart() {
+        if (this.orderBySpecs.length === 0) {
+            return null;
+        }
+        return this.orderBySpecs
+            .map(spec => {
+            let sql = `${(0, table_proxy_1.columnRefToSQLUnqualified)(spec.column)} ${spec.direction}`;
+            if (spec.nulls) {
+                sql += ` NULLS ${spec.nulls}`;
+            }
+            return sql;
+        })
+            .join(', ');
+    }
+    buildLimitPart() {
+        let sql = '';
+        if (this.limitValue !== undefined) {
+            sql += ` LIMIT ${this.limitValue}`;
+        }
+        if (this.offsetValue !== undefined) {
+            sql += ` OFFSET ${this.offsetValue}`;
+        }
+        return sql;
+    }
+}
+exports.JoinManyBuilder = JoinManyBuilder;
+function createJoinManyBuilder() {
+    return new JoinManyBuilder();
+}