@relq/orm 0.1.0

package/dist/esm/core/helpers/ConnectedSelectBuilder.js

@@ -0,0 +1,327 @@
+import { INTERNAL } from "./methods.js";
+import { executeTypeSafeJoin, executeTypeSafeJoinMany, executeTypeSafeJoinManyThrough } from "./select-joins.js";
+import { executeCursorEach, executePagination } from "./select-pagination.js";
+import { requireCapability } from "./capability-guard.js";
+import { createTableAccessor } from "../shared/table-accessor.js";
+import { AggregateFunctions } from "../../select/sql-expression.js";
+import { createTableProxy } from "../../select/table-proxy.js";
+import { resolveForeignKey } from "../../utils/fk-resolver.js";
+export class ConnectedSelectBuilder {
+    builder;
+    relq;
+    tableName;
+    columns;
+    schemaKey;
+    constructor(builder, relq, tableName, columns, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.columns = columns;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    get joinCtx() {
+        return { relq: this.relq, builder: this.builder, tableName: this.tableName, schemaKey: this.schemaKey };
+    }
+    get paginationCtx() {
+        return { relq: this.relq, builder: this.builder, tableName: this.tableName };
+    }
+    setupColumnResolver() {
+        const internal = this.relq[INTERNAL];
+        const tableKey = this.schemaKey || this.tableName;
+        const tableDef = internal.getTableDef(tableKey);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
+    }
+    transformJoinResults(rows) {
+        const joins = this.builder.getStructuredJoins();
+        if (joins.length === 0) {
+            return rows;
+        }
+        const internal = this.relq[INTERNAL];
+        return rows.map(row => {
+            if (!row || typeof row !== 'object')
+                return row;
+            const transformed = { ...row };
+            for (const join of joins) {
+                const alias = join.alias;
+                const nestedData = transformed[alias];
+                if (nestedData === null || nestedData === undefined) {
+                    continue;
+                }
+                const joinedTableDef = internal.getTableDef(join.schemaKey || alias) || internal.getTableDef(join.table);
+                if (!joinedTableDef) {
+                    continue;
+                }
+                const tableColumns = joinedTableDef.$columns || joinedTableDef;
+                const dbToProp = new Map();
+                const propTypes = new Map();
+                for (const [propName, colDef] of Object.entries(tableColumns)) {
+                    const dbColName = colDef?.$columnName ?? propName;
+                    dbToProp.set(dbColName, propName);
+                    const snakeCase = propName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+                    if (snakeCase !== propName && !dbToProp.has(snakeCase)) {
+                        dbToProp.set(snakeCase, propName);
+                    }
+                    const sqlType = colDef?.$sqlType || (typeof colDef?.$type === 'string' ? colDef.$type : undefined);
+                    if (sqlType) {
+                        propTypes.set(propName, sqlType.toLowerCase());
+                    }
+                }
+                if (Array.isArray(nestedData)) {
+                    transformed[alias] = nestedData.map((item) => this.transformNestedObject(item, dbToProp, propTypes));
+                }
+                else {
+                    transformed[alias] = this.transformNestedObject(nestedData, dbToProp, propTypes);
+                }
+            }
+            return transformed;
+        });
+    }
+    transformNestedObject(obj, dbToProp, propTypes) {
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            const propName = dbToProp.get(key) ?? key;
+            result[propName] = propTypes ? this.coerceValue(value, propTypes.get(propName)) : value;
+        }
+        return result;
+    }
+    coerceValue(value, sqlType) {
+        if (value === null || value === undefined || !sqlType)
+            return value;
+        switch (sqlType) {
+            case 'timestamp':
+            case 'timestamptz':
+            case 'timestamp without time zone':
+            case 'timestamp with time zone':
+                return typeof value === 'string' ? new Date(value) : value;
+            case 'bigint':
+            case 'int8':
+                return typeof value === 'number' ? BigInt(value) : typeof value === 'string' ? BigInt(value) : value;
+            default:
+                return value;
+        }
+    }
+    where(callback) {
+        this.builder.where((q) => {
+            q._tables = createTableAccessor(this.relq, this.relq.schema);
+            return callback(q);
+        });
+        return this;
+    }
+    orderBy(column, direction) {
+        const dbColumn = this.relq[INTERNAL].hasColumnMapping()
+            ? Object.keys(this.relq[INTERNAL].transformToDbColumns(this.tableName, { [column]: true }))[0]
+            : column;
+        this.builder.orderBy(dbColumn, direction);
+        return this;
+    }
+    orderByNulls(column, direction, nulls) {
+        const dbColumn = this.relq[INTERNAL].hasColumnMapping()
+            ? Object.keys(this.relq[INTERNAL].transformToDbColumns(this.tableName, { [column]: true }))[0]
+            : column;
+        this.builder.orderByNulls(dbColumn, direction, nulls);
+        return this;
+    }
+    limit(count) {
+        this.builder.limit(count);
+        return this;
+    }
+    offset(count) {
+        this.builder.offset(count);
+        return this;
+    }
+    groupBy(...columns) {
+        const dbColumns = this.relq[INTERNAL].hasColumnMapping()
+            ? columns.map(col => Object.keys(this.relq[INTERNAL].transformToDbColumns(this.tableName, { [col]: true }))[0])
+            : columns;
+        this.builder.groupBy(...dbColumns);
+        return this;
+    }
+    having(callback) {
+        this.builder.having(callback);
+        return this;
+    }
+    include(callback) {
+        const agg = new AggregateFunctions();
+        const internal = this.relq[INTERNAL];
+        const schema = internal.getSchema() || {};
+        const sourceSchemaKey = this.schemaKey || this.tableName;
+        const sourceAlias = this.builder.getTableIdentifier();
+        const tableProxies = new Proxy({}, {
+            get(_, tableKey) {
+                if (typeof tableKey === 'symbol')
+                    return undefined;
+                const tableDef = schema[tableKey];
+                const tableName = tableDef?.$name || tableKey;
+                const alias = tableKey === sourceSchemaKey ? sourceAlias : tableKey;
+                return createTableProxy(tableName, alias, tableDef);
+            }
+        });
+        const expressions = callback(agg, tableProxies);
+        for (const [alias, expr] of Object.entries(expressions)) {
+            this.builder.addIncludeExpression(alias, expr.sql);
+        }
+        return this;
+    }
+    join(tableOrAlias, callback) {
+        executeTypeSafeJoin(this.joinCtx, 'JOIN', tableOrAlias, callback);
+        return this;
+    }
+    leftJoin(tableOrAlias, callback) {
+        executeTypeSafeJoin(this.joinCtx, 'LEFT JOIN', tableOrAlias, callback);
+        return this;
+    }
+    rightJoin(tableOrAlias, callback) {
+        executeTypeSafeJoin(this.joinCtx, 'RIGHT JOIN', tableOrAlias, callback);
+        return this;
+    }
+    innerJoin(tableOrAlias, callback) {
+        executeTypeSafeJoin(this.joinCtx, 'INNER JOIN', tableOrAlias, callback);
+        return this;
+    }
+    joinSubquery(alias, subquery, onClause) {
+        const subquerySQL = typeof subquery === 'string' ? subquery : subquery.toString();
+        this.builder.addRawJoin(`JOIN (${subquerySQL}) AS "${alias}" ON ${onClause}`);
+        return this;
+    }
+    leftJoinSubquery(alias, subquery, onClause) {
+        const subquerySQL = typeof subquery === 'string' ? subquery : subquery.toString();
+        this.builder.addRawJoin(`LEFT JOIN (${subquerySQL}) AS "${alias}" ON ${onClause}`);
+        return this;
+    }
+    joinMany(tableOrAlias, callbackOrOptions, throughCallback) {
+        requireCapability(this.relq, 'lateral', 'LATERAL JOIN (joinMany)', 'Use separate queries for one-to-many relationships');
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            executeTypeSafeJoinManyThrough(this.joinCtx, 'JOIN', tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            executeTypeSafeJoinMany(this.joinCtx, 'JOIN', tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    leftJoinMany(tableOrAlias, callbackOrOptions, throughCallback) {
+        requireCapability(this.relq, 'lateral', 'LATERAL JOIN (leftJoinMany)', 'Use separate queries for one-to-many relationships');
+        if (callbackOrOptions && typeof callbackOrOptions === 'object' && 'through' in callbackOrOptions) {
+            executeTypeSafeJoinManyThrough(this.joinCtx, 'LEFT JOIN', tableOrAlias, callbackOrOptions.through, throughCallback);
+        }
+        else {
+            executeTypeSafeJoinMany(this.joinCtx, 'LEFT JOIN', tableOrAlias, callbackOrOptions);
+        }
+        return this;
+    }
+    with(table) {
+        executeTypeSafeJoin(this.joinCtx, 'LEFT JOIN', table);
+        return this;
+    }
+    withMany(table, options) {
+        requireCapability(this.relq, 'lateral', 'LATERAL JOIN (withMany)', 'Use separate queries for one-to-many relationships');
+        if (options && 'through' in options) {
+            executeTypeSafeJoinManyThrough(this.joinCtx, 'LEFT JOIN', table, options.through);
+            return this;
+        }
+        const internal = this.relq[INTERNAL];
+        const schema = internal.getSchema();
+        const relations = internal.getRelations();
+        if (!schema || !relations) {
+            throw new Error(`Cannot use .withMany('${table}') without schema and relations config. ` +
+                `Use .leftJoinMany() with an explicit callback instead.`);
+        }
+        const sourceKey = this.schemaKey || this.tableName;
+        const fk = resolveForeignKey(relations, schema, sourceKey, table);
+        if (!fk) {
+            throw new Error(`No FK relationship found between "${sourceKey}" and "${table}". ` +
+                `Use .leftJoinMany() with explicit join conditions instead.`);
+        }
+        executeTypeSafeJoinMany(this.joinCtx, 'LEFT JOIN', table, (on, right, left) => {
+            const rightCol = right[fk.toColumn];
+            const leftCol = left[fk.fromColumn];
+            return on.equal(rightCol, leftCol);
+        });
+        return this;
+    }
+    distinct() {
+        this.builder.distinct();
+        return this;
+    }
+    distinctOn(...columns) {
+        requireCapability(this.relq, 'distinctOn', 'DISTINCT ON', 'Use GROUP BY with appropriate aggregation instead');
+        this.builder.distinctOn(...columns);
+        return this;
+    }
+    union(query) {
+        this.builder.union(typeof query === 'string' ? query : query.toString());
+        return this;
+    }
+    unionAll(query) {
+        this.builder.unionAll(typeof query === 'string' ? query : query.toString());
+        return this;
+    }
+    intersect(query) {
+        this.builder.intersect(typeof query === 'string' ? query : query.toString());
+        return this;
+    }
+    except(query) {
+        this.builder.except(typeof query === 'string' ? query : query.toString());
+        return this;
+    }
+    forUpdate() {
+        this.builder.forUpdate();
+        return this;
+    }
+    forUpdateSkipLocked() {
+        requireCapability(this.relq, 'forUpdateSkipLocked', 'FOR UPDATE SKIP LOCKED', 'Use FOR UPDATE without SKIP LOCKED');
+        this.builder.forUpdateSkipLocked();
+        return this;
+    }
+    forShare() {
+        this.builder.forShare();
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async all(withMetadata, _asRequired) {
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeSelect(sql, this.tableName);
+        const transformedData = this.transformJoinResults(result.data);
+        if (withMetadata) {
+            return { data: transformedData, metadata: result.metadata };
+        }
+        return transformedData;
+    }
+    async get(withMetadata, _asRequired) {
+        this.builder.limit(1);
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeSelectOne(sql, this.tableName);
+        const transformedData = result.data ? this.transformJoinResults([result.data])[0] : null;
+        if (withMetadata) {
+            return { data: transformedData, metadata: result.metadata };
+        }
+        return transformedData;
+    }
+    async value(column) {
+        this.builder.limit(1);
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeSelectOne(sql, this.tableName);
+        return result.data?.[column] ?? null;
+    }
+    async each(callback, options = {}) {
+        requireCapability(this.relq, 'cursors', 'Cursor-based iteration (each)', 'Use pagination() instead of each() for row-by-row processing');
+        return executeCursorEach(this.paginationCtx, callback, options);
+    }
+    async pagination(options) {
+        return executePagination(this.paginationCtx, options, (opts) => this.pagination(opts));
+    }
+}

package/dist/esm/core/helpers/ConnectedTransactionBuilder.js

@@ -0,0 +1,100 @@
+import { ConnectedRawQueryBuilder } from "./ConnectedRawQueryBuilder.js";
+import { createTableAccessor } from "../shared/table-accessor.js";
+import { INTERNAL } from "./methods.js";
+export class TransactionClient {
+    client;
+    relq;
+    schema;
+    constructor(client, relq) {
+        this.client = client;
+        this.relq = relq;
+        const internal = this.relq[INTERNAL];
+        this.schema = internal.getSchema?.() ?? this.relq.schema;
+    }
+    get dialect() { return this.relq.dialect; }
+    get capabilities() { return this.relq.capabilities; }
+    get table() {
+        return createTableAccessor(this, this.schema);
+    }
+    raw(query, ...params) {
+        return new ConnectedRawQueryBuilder(query, params, this);
+    }
+    get [INTERNAL]() {
+        const parentInternal = this.relq[INTERNAL];
+        const queryViaClient = async (sql) => {
+            const start = performance.now();
+            const pgResult = await this.client.query(sql);
+            return {
+                result: {
+                    rows: pgResult.rows,
+                    rowCount: pgResult.rowCount,
+                    command: pgResult.command,
+                    fields: pgResult.fields?.map((f) => ({ name: f.name, dataTypeID: f.dataTypeID })) ?? [],
+                },
+                duration: performance.now() - start,
+            };
+        };
+        const buildMetadata = (result, duration) => ({
+            rowCount: result.rowCount,
+            command: result.command,
+            duration,
+            fields: result.fields,
+        });
+        return {
+            executeQuery: queryViaClient,
+            async executeSelect(sql, tableName) {
+                const { result, duration } = await queryViaClient(sql);
+                const rows = tableName
+                    ? parentInternal.transformResultsFromDb(tableName, result.rows)
+                    : result.rows;
+                return { data: rows, metadata: buildMetadata(result, duration) };
+            },
+            async executeSelectOne(sql, tableName) {
+                const { result, duration } = await queryViaClient(sql);
+                const row = result.rows[0]
+                    ? (tableName ? parentInternal.transformFromDbColumns(tableName, result.rows[0]) : result.rows[0])
+                    : null;
+                return { data: row, metadata: buildMetadata(result, duration) };
+            },
+            async executeCount(sql) {
+                const { result, duration } = await queryViaClient(sql);
+                const count = result.rows[0]?.count ? parseInt(result.rows[0].count, 10) : 0;
+                return { count, metadata: buildMetadata(result, duration) };
+            },
+            async executeRun(sql) {
+                const { result, duration } = await queryViaClient(sql);
+                return { success: true, metadata: buildMetadata(result, duration) };
+            },
+            transformToDbColumns: parentInternal.transformToDbColumns,
+            transformFromDbColumns: parentInternal.transformFromDbColumns,
+            transformResultsFromDb: parentInternal.transformResultsFromDb,
+            hasColumnMapping: parentInternal.hasColumnMapping,
+            validateData: parentInternal.validateData,
+            getSchema: parentInternal.getSchema,
+            getRelations: parentInternal.getRelations,
+            getTableDef: parentInternal.getTableDef,
+            getClientForCursor: async () => ({ client: this.client, release: () => { } }),
+        };
+    }
+}
+export async function executeTransaction(relq, callback) {
+    await relq.ensureInitialized();
+    const { client, release } = await relq[INTERNAL].getClientForCursor();
+    try {
+        await client.query('BEGIN');
+        const tx = new TransactionClient(client, relq);
+        const result = await callback(tx);
+        await client.query('COMMIT');
+        return result;
+    }
+    catch (error) {
+        try {
+            await client.query('ROLLBACK');
+        }
+        catch { }
+        throw error;
+    }
+    finally {
+        release();
+    }
+}

package/dist/esm/core/helpers/ConnectedUpdateBuilder.js

@@ -0,0 +1,75 @@
+import { INTERNAL } from "./methods.js";
+import { ReturningExecutor } from "./ReturningExecutor.js";
+import { requireCapability } from "./capability-guard.js";
+import { createTableAccessor } from "../shared/table-accessor.js";
+export class ConnectedUpdateBuilder {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
+        this.builder.setColumnTypeResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (!columnDef) {
+                return undefined;
+            }
+            const type = columnDef.$type;
+            if (typeof type !== 'string') {
+                return undefined;
+            }
+            const isArray = columnDef.$array === true;
+            const baseType = type.replace(/\[\]$/, '').toLowerCase();
+            return { type: baseType, isArray };
+        });
+    }
+    where(callback) {
+        this.builder.where((q) => {
+            q._tables = createTableAccessor(this.relq, this.relq.schema);
+            return callback(q);
+        });
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        this.relq[INTERNAL].validateData(this.builder.tableName, this.builder.updateData, 'update');
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+    returning(columns) {
+        if (columns === null) {
+            return this;
+        }
+        requireCapability(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the UPDATE to retrieve modified data');
+        this.builder.returning(columns);
+        return new ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
+    }
+}

package/dist/esm/core/helpers/PaginateBuilder.js

@@ -0,0 +1,174 @@
+import { CountBuilder } from "../../count/count-builder.js";
+import { RelqQueryError } from "../../../shared/errors/relq-errors.js";
+import { SelectBuilder } from "../../select/select-builder.js";
+import { INTERNAL } from "./methods.js";
+export class PaginateBuilder {
+    relq;
+    tableName;
+    columns;
+    whereClause;
+    orderByClause;
+    constructor(relq, tableName, columns, whereClause, orderByClause) {
+        this.relq = relq;
+        this.tableName = tableName;
+        this.columns = columns;
+        this.whereClause = whereClause;
+        this.orderByClause = orderByClause;
+    }
+    async paging(options) {
+        const page = options.page ?? 1;
+        const perPage = options.perPage;
+        const shouldCount = options.count ?? true;
+        if (page < 1) {
+            throw new RelqQueryError('page must be >= 1', { hint: 'Page numbers are 1-indexed' });
+        }
+        if (perPage < 1) {
+            throw new RelqQueryError('perPage must be >= 1');
+        }
+        const columnsToSelect = this.columns && this.columns.length > 0 ? this.columns : ['*'];
+        const orderByArr = this.orderByClause
+            ? (Array.isArray(this.orderByClause[0]) ? this.orderByClause : [this.orderByClause])
+            : [];
+        const selectBuilder = new SelectBuilder(this.tableName, columnsToSelect);
+        if (this.whereClause) {
+            selectBuilder.where(this.whereClause);
+        }
+        for (const [column, direction] of orderByArr) {
+            const dbColumn = this.relq[INTERNAL].transformToDbColumns(this.tableName, { [column]: true });
+            selectBuilder.orderBy(Object.keys(dbColumn)[0] || column, direction);
+        }
+        let total = 0;
+        if (shouldCount) {
+            const countBuilder = new CountBuilder(this.tableName);
+            if (this.whereClause) {
+                countBuilder.where(this.whereClause);
+            }
+            const countResult = await this.relq[INTERNAL].executeCount(countBuilder.toString());
+            total = countResult.count;
+        }
+        const offset = (page - 1) * perPage;
+        selectBuilder.limit(perPage);
+        selectBuilder.offset(offset);
+        const result = await this.relq[INTERNAL].executeSelect(selectBuilder.toString(), this.tableName);
+        const totalPages = Math.ceil(total / perPage);
+        const hasNext = page < totalPages;
+        const hasPrev = page > 1;
+        const pagination = {
+            page,
+            perPage,
+            total,
+            totalPages,
+        };
+        if (hasNext) {
+            pagination.hasNext = true;
+            pagination.nextPage = page + 1;
+            Object.defineProperty(pagination, 'loadNext', {
+                value: () => this.paging({ ...options, page: page + 1 }),
+                enumerable: false
+            });
+        }
+        else {
+            pagination.hasNext = false;
+        }
+        if (hasPrev) {
+            pagination.hasPrev = true;
+            pagination.prevPage = page - 1;
+            Object.defineProperty(pagination, 'loadPrev', {
+                value: () => this.paging({ ...options, page: page - 1 }),
+                enumerable: false
+            });
+        }
+        else {
+            pagination.hasPrev = false;
+        }
+        Object.defineProperty(pagination, 'toJSON', {
+            value: () => ({ page, perPage, total, totalPages, hasNext: pagination.hasNext, hasPrev: pagination.hasPrev, nextPage: pagination.nextPage, prevPage: pagination.prevPage }),
+            enumerable: false
+        });
+        return { data: result.data, pagination };
+    }
+    async offset(options) {
+        const position = options.position ?? 0;
+        const shouldCount = options.count ?? false;
+        if (position < 0) {
+            throw new RelqQueryError('position must be >= 0');
+        }
+        let limit;
+        if (options.shuffleLimit) {
+            const [min, max] = options.shuffleLimit;
+            if (min < 1 || max < 1) {
+                throw new RelqQueryError('shuffleLimit values must be >= 1', { hint: 'Use [min, max] where both are >= 1' });
+            }
+            if (min > max) {
+                throw new RelqQueryError('shuffleLimit[0] must be <= shuffleLimit[1]', { hint: 'Use [min, max] format where min <= max' });
+            }
+            limit = Math.floor(Math.random() * (max - min + 1)) + min;
+        }
+        else {
+            const limitValue = options.limit;
+            if (limitValue !== undefined && limitValue < 1) {
+                throw new RelqQueryError('limit must be >= 1');
+            }
+            limit = limitValue ?? 50;
+        }
+        const columnsToSelect = this.columns && this.columns.length > 0 ? this.columns : ['*'];
+        const orderByArr = this.orderByClause
+            ? (Array.isArray(this.orderByClause[0]) ? this.orderByClause : [this.orderByClause])
+            : [];
+        const selectBuilder = new SelectBuilder(this.tableName, columnsToSelect);
+        if (this.whereClause) {
+            selectBuilder.where(this.whereClause);
+        }
+        for (const [column, direction] of orderByArr) {
+            const dbColumn = this.relq[INTERNAL].transformToDbColumns(this.tableName, { [column]: true });
+            selectBuilder.orderBy(Object.keys(dbColumn)[0] || column, direction);
+        }
+        let total = 0;
+        if (shouldCount) {
+            const countBuilder = new CountBuilder(this.tableName);
+            if (this.whereClause) {
+                countBuilder.where(this.whereClause);
+            }
+            const countResult = await this.relq[INTERNAL].executeCount(countBuilder.toString());
+            total = countResult.count;
+        }
+        selectBuilder.limit(limit + 1);
+        selectBuilder.offset(position);
+        const result = await this.relq[INTERNAL].executeSelect(selectBuilder.toString(), this.tableName);
+        const hasMore = result.data.length > limit;
+        const data = hasMore ? result.data.slice(0, limit) : result.data;
+        const hasPrev = position > 0;
+        const pagination = {
+            position,
+            limit,
+            total,
+        };
+        if (hasMore) {
+            pagination.hasMore = true;
+            pagination.nextPos = position + limit;
+            Object.defineProperty(pagination, 'loadNext', {
+                value: () => this.offset({ ...options, position: position + limit }),
+                enumerable: false
+            });
+        }
+        else {
+            pagination.hasMore = false;
+        }
+        if (hasPrev) {
+            pagination.hasPrev = true;
+            pagination.prevPos = Math.max(0, position - limit);
+            Object.defineProperty(pagination, 'loadPrev', {
+                value: () => this.offset({ ...options, position: Math.max(0, position - limit) }),
+                enumerable: false
+            });
+        }
+        else {
+            pagination.hasPrev = false;
+        }
+        Object.defineProperty(pagination, 'toJSON', {
+            value: () => ({ position, limit, total, hasMore: pagination.hasMore, hasPrev: pagination.hasPrev, nextPos: pagination.nextPos, prevPos: pagination.prevPos }),
+            enumerable: false
+        });
+        return { data, pagination };
+    }
+}