@rebasepro/common 0.6.1 → 0.8.0

package/src/data/buildRebaseData.ts

@@ -6,128 +6,13 @@ import {
     FindResponse,
     Entity,
     EntityValues,
-    FilterValues,
     WhereFilterOp,
-    WhereFieldValue,
-    WhereFilterOpShort,
     LogicalCondition,
     WhereValue
 } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
 import { QueryBuilder } from "./query_builder";
-
-/**
- * Convert where-clause filter object to the internal DataDriver FilterValues format.
- *
- * Supports multiple value formats:
- * - PostgREST string: { status: "eq.published", age: "gte.18" }
- * - Equality shorthand: { company_profile_id: null, status: "active", age: 18 }
- * - Tuple syntax: { age: [">=", 18], role: ["in", ["admin", "editor"]] }
- *
- * Internal:  { status: ["==", "published"], age: [">=", 18] }
- */
-function convertWhereToFilter(where?: Record<string, WhereFieldValue>): FilterValues<string> | undefined {
-    if (!where) return undefined;
-
-    const operatorMap: Record<string, WhereFilterOp> = {
-        "eq": "==",
-        "neq": "!=",
-        "gt": ">",
-        "gte": ">=",
-        "lt": "<",
-        "lte": "<=",
-        "in": "in",
-        "nin": "not-in",
-        "not-in": "not-in",
-        "cs": "array-contains",
-        "csa": "array-contains-any",
-        "==": "==",
-"!=": "!=",
-        ">": ">",
-">=": ">=",
-        "<": "<",
-"<=": "<=",
-        "array-contains": "array-contains",
-        "array-contains-any": "array-contains-any"
-    };
-
-    const filter: FilterValues<string> = {};
-
-    for (const [field, rawValue] of Object.entries(where)) {
-        // Handle null → equality
-        if (rawValue === null) {
-            filter[field] = ["==", null];
-            continue;
-        }
-
-        // Handle boolean → equality
-        if (typeof rawValue === "boolean") {
-            filter[field] = ["==", rawValue];
-            continue;
-        }
-
-        // Handle number → equality
-        if (typeof rawValue === "number") {
-            filter[field] = ["==", rawValue];
-            continue;
-        }
-
-        // Handle tuple or array of tuples
-        if (Array.isArray(rawValue)) {
-            const conditions: [WhereFilterOpShort, unknown][] = Array.isArray(rawValue[0])
-                ? (rawValue as [WhereFilterOpShort, unknown][])
-                : [rawValue as [WhereFilterOpShort, unknown]];
-
-            const mappedConditions: [WhereFilterOp, unknown][] = conditions.map(([rawOp, val]) => {
-                const mappedOp = operatorMap[rawOp] ?? "==";
-                return [mappedOp, val];
-            });
-
-            filter[field] = Array.isArray(rawValue[0]) ? mappedConditions : mappedConditions[0];
-            continue;
-        }
-
-        // Handle PostgREST string format: "op.value"
-        if (typeof rawValue === "string") {
-            const dotIndex = rawValue.indexOf(".");
-            if (dotIndex === -1) {
-                // Plain string equality
-                filter[field] = ["==", rawValue];
-                continue;
-            }
-
-            const op = rawValue.substring(0, dotIndex);
-            let value: unknown = rawValue.substring(dotIndex + 1);
-
-            // Parse list values like "(admin,editor)"
-            if (typeof value === "string" && value.startsWith("(") && value.endsWith(")")) {
-                value = value.slice(1, -1).split(",").map((v: string) => v.trim());
-            }
-
-            // Parse null string
-            if (value === "null") {
-                value = null;
-            }
-            // Parse boolean strings
-            else if (value === "true") {
-                value = true;
-            } else if (value === "false") {
-                value = false;
-            }
-            // Try to parse numbers
-            else if (typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "") {
-                value = Number(value);
-            }
-
-            const mappedOp = operatorMap[op];
-            if (mappedOp) {
-                filter[field] = [mappedOp, value];
-            }
-        }
-    }
-
-    return Object.keys(filter).length > 0 ? filter : undefined;
-}
+import { deserializeFilter } from "./filter-dialect";
 
 /**
  * Parse an orderBy string like "created_at:desc" into [field, direction].
@@ -147,11 +32,14 @@ function createDriverAccessor<M extends Record<string, unknown> = Record<string,
     const accessor: CollectionAccessor<M> = {
         async find(params?: FindParams): Promise<FindResponse<M>> {
             const orderParsed = parseOrderBy(params?.orderBy);
+            // Ensure filters are in canonical [op, value] format even if passed as PostgREST strings
+            const filter = params?.where ? deserializeFilter(params.where as any) : undefined;
+            
             const entities = await driver.fetchCollection<M>({
                 path: slug,
                 limit: params?.limit,
                 offset: params?.offset,
-                filter: convertWhereToFilter(params?.where),
+                filter,
                 orderBy: orderParsed?.[0],
                 order: orderParsed?.[1],
                 searchString: params?.searchString
@@ -208,9 +96,10 @@ values: {} as Record<string, unknown> }
 
         count: driver.countEntities
             ? async (params?: FindParams): Promise<number> => {
+                const filter = params?.where ? deserializeFilter(params.where as any) : undefined;
                 return driver.countEntities!({
                     path: slug,
-                    filter: convertWhereToFilter(params?.where)
+                    filter
                 });
             }
             : undefined,
@@ -224,7 +113,7 @@ values: {} as Record<string, unknown> }
                     path: slug,
                     limit: params?.limit,
                     offset: params?.offset,
-                    filter: convertWhereToFilter(params?.where),
+                    filter: params?.where,
                     orderBy: orderParsed?.[0],
                     order: orderParsed?.[1],
                     searchString: params?.searchString,
@@ -254,7 +143,7 @@ values: {} as Record<string, unknown> }
             } : undefined,
 
         // Fluent Query Builder
-        where(columnOrCondition: string | LogicalCondition, operator?: WhereFilterOpShort, value?: unknown) {
+        where(columnOrCondition: string | LogicalCondition, operator?: WhereFilterOp, value?: unknown) {
             const builder = new QueryBuilder<M>(accessor);
             if (typeof columnOrCondition === "object") {
                 return builder.where(columnOrCondition);

package/src/data/buildRoutedRebaseData.ts

@@ -0,0 +1,97 @@
+import { RebaseData, CollectionAccessor } from "@rebasepro/types";
+import { toSnakeCase } from "@rebasepro/utils";
+
+/**
+ * Parameters for {@link buildRoutedRebaseData}.
+ */
+export interface RoutedRebaseDataParams {
+    /**
+     * The default data source. Handles every collection that does not
+     * resolve to an entry in `sources` (i.e. server-transport collections,
+     * which ride the Rebase client).
+     */
+    defaultData: RebaseData;
+
+    /**
+     * Per-data-source {@link RebaseData} instances for direct and custom
+     * transports, keyed by data-source key (e.g. `"analytics"`). Server-
+     * mediated sources are not listed here — they fall through to
+     * `defaultData`.
+     */
+    sources: Record<string, RebaseData>;
+
+    /**
+     * Resolve the data-source key for a given collection slug or path.
+     * Typically backed by the collection registry + `resolveDataSource`
+     * (`resolveDataSource(registry.getCollection(path), defs).key`).
+     *
+     * Return `undefined` (or a key absent from `sources`) to route to the
+     * default data source.
+     */
+    resolveKey: (slugOrPath: string) => string | undefined;
+}
+
+/**
+ * Build a {@link RebaseData} that routes each collection to the right
+ * backend based on its resolved data source.
+ *
+ * `.collection(path)` (and dynamic `data.products`-style access) resolves the
+ * collection's data-source key via `resolveKey` and delegates to the matching
+ * entry in `sources`, falling back to `defaultData` when there is no match.
+ * Because routing keys off the *path being accessed*, a reference widget
+ * inside a Firestore form that points at a Postgres collection is still
+ * served by Postgres — routing follows the target, not the ancestor.
+ *
+ * When `sources` is empty this returns `defaultData` untouched, so the
+ * single-driver setup keeps identical behaviour and identity (important for
+ * effect dependencies that key off the data instance).
+ *
+ * @example
+ * const data = buildRoutedRebaseData({
+ *     defaultData: client.data,
+ *     sources: { analytics: buildRebaseData(firestoreDriver) },
+ *     resolveKey: (path) => resolveDataSource(registry.getCollection(path), defs).key
+ * });
+ * await data.products.find();        // → default (server / Postgres)
+ * await data.events.find();          // → Firestore, if `events.dataSource === "analytics"`
+ */
+export function buildRoutedRebaseData({
+    defaultData,
+    sources,
+    resolveKey
+}: RoutedRebaseDataParams): RebaseData {
+
+    // Fast path: nothing to route → return the default untouched (preserves
+    // referential identity for effect dependencies).
+    if (!sources || Object.keys(sources).length === 0) {
+        return defaultData;
+    }
+
+    function resolve(slugOrPath: string): RebaseData {
+        const key = resolveKey(slugOrPath);
+        if (key && sources[key]) return sources[key];
+        return defaultData;
+    }
+
+    function getAccessor(slugOrPath: string): CollectionAccessor {
+        return resolve(slugOrPath).collection(slugOrPath);
+    }
+
+    const target = {
+        collection: getAccessor
+    } as RebaseData;
+
+    return new Proxy(target, {
+        get(_target, prop: string | symbol) {
+            if (prop === "collection") return getAccessor;
+            // Ignore Symbol properties (e.g. Symbol.toPrimitive, Symbol.iterator)
+            if (typeof prop === "symbol") return undefined;
+            // Ignore internal JS properties
+            if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return undefined;
+
+            // Convert camelCase property names to snake_case slugs, mirroring
+            // buildRebaseData so dynamic access routes consistently.
+            return getAccessor(toSnakeCase(prop));
+        }
+    });
+}

package/src/data/filter-dialect.ts

@@ -0,0 +1,318 @@
+/**
+ * REST wire-format adapter for the unified filter system.
+ *
+ * This module is the ONLY code in the entire codebase that knows about
+ * PostgREST-style dot-syntax strings (`eq.active`, `gt.18`, `in.(a,b)`).
+ * Everything else speaks `FilterValues` exclusively.
+ *
+ * @module
+ */
+
+import {
+    WhereFilterOp,
+    FilterValues,
+    CANONICAL_TO_REST,
+    REST_TO_CANONICAL,
+    RestFilterOp,
+    toCanonicalOp,
+    LogicalCondition,
+    FilterCondition
+} from "@rebasepro/types";
+
+// ---------------------------------------------------------------------------
+// Value coercion (querystring → typed JS values)
+// ---------------------------------------------------------------------------
+
+/**
+ * Coerce a raw querystring value to its natural JS type.
+ * - `"true"` / `"false"` → boolean
+ * - `"null"` → null
+ * - Numeric strings → number
+ * - Everything else → string (unchanged)
+ */
+function coerceValue(raw: string): unknown {
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+    if (raw === "null") return null;
+    if (raw !== "" && !isNaN(Number(raw))) return Number(raw);
+    return raw;
+}
+
+/**
+ * Serialize a JS value to its querystring representation.
+ */
+function stringifyValue(value: unknown): string {
+    if (value === null) return "null";
+    if (typeof value === "boolean") return String(value);
+    return String(value);
+}
+
+// ---------------------------------------------------------------------------
+// Serialize: FilterValues → REST querystring
+// ---------------------------------------------------------------------------
+
+/**
+ * Serialize a single condition tuple to a PostgREST dot-string.
+ *
+ * @example
+ * serializeTuple(["==", "active"])           // "eq.active"
+ * serializeTuple(["in", ["admin","editor"]]) // "in.(admin,editor)"
+ * serializeTuple([">=", 18])                 // "gte.18"
+ */
+function serializeTuple(tuple: [WhereFilterOp, unknown] | unknown): string {
+    // If it's already a string, it might be a PostgREST string (with dot)
+    // or a raw value (without dot). In both cases, existing tests expect
+    // them to be passed through or treated as simple equality if no dot.
+    if (typeof tuple === "string") {
+        if (tuple.includes(".")) {
+            const dotIndex = tuple.indexOf(".");
+            const prefix = tuple.substring(0, dotIndex);
+            if ((REST_TO_CANONICAL as any)[prefix]) {
+                return tuple;
+            }
+        }
+        return tuple;
+    }
+
+    // If it's NOT a canonical tuple [WhereFilterOp, value], treat as equality.
+    if (!Array.isArray(tuple) || tuple.length !== 2 || typeof tuple[0] !== "string" || !(CANONICAL_TO_REST as any)[tuple[0]]) {
+        return `eq.${stringifyValue(tuple)}`;
+    }
+
+    const [op, value] = tuple as [WhereFilterOp, unknown];
+    const restOp = CANONICAL_TO_REST[op];
+
+    if (Array.isArray(value)) {
+        const items = value.map(stringifyValue).join(",");
+        return `${restOp}.(${items})`;
+    }
+
+    return `${restOp}.${stringifyValue(value)}`;
+}
+
+/**
+ * Convert `FilterValues` to a PostgREST-style querystring record.
+ *
+ * - Single conditions produce a string value.
+ * - Multiple conditions on the same field produce a string array (repeated params).
+ *
+ * @example
+ * serializeFilter({ status: ["==", "active"] })
+ * // → { status: "eq.active" }
+ *
+ * serializeFilter({ age: [[">=", 18], ["<", 65]] })
+ * // → { age: ["gte.18", "lt.65"] }
+ */
+export function serializeFilter(
+    filter: FilterValues<string> | Record<string, any>
+): Record<string, string | string[]> {
+    const result: Record<string, string | string[]> = {};
+
+    for (const [field, condition] of Object.entries(filter)) {
+        if (condition === undefined) continue;
+
+        // Multiple conditions on the same field: array of tuples
+        // We detect this by checking if the first element is also an array.
+        if (Array.isArray(condition) && condition.length > 0 && Array.isArray(condition[0])) {
+            result[field] = (condition as any[]).map(serializeTuple);
+        } else {
+            // Single condition (could be a tuple, a raw value, or an already-serialized string)
+            result[field] = serializeTuple(condition);
+        }
+    }
+
+    return result;
+}
+
+// ---------------------------------------------------------------------------
+// Deserialize: REST querystring → FilterValues
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a single PostgREST dot-string into a `[WhereFilterOp, unknown]` tuple.
+ *
+ * If the string doesn't match a known operator prefix, falls back to
+ * `["==", originalString]` (treating the whole string as an equality value).
+ */
+function deserializeSingle(raw: string): [WhereFilterOp, unknown] {
+    const dotIndex = raw.indexOf(".");
+    if (dotIndex === -1) {
+        // No dot → equality on the raw value (coerced)
+        return ["==", coerceValue(raw)];
+    }
+
+    const prefix = raw.substring(0, dotIndex);
+    const rest = raw.substring(dotIndex + 1);
+
+    // Check if the prefix is a known REST operator
+    const canonicalOp = (REST_TO_CANONICAL as Record<string, WhereFilterOp | undefined>)[prefix];
+    if (!canonicalOp) {
+        // Not a known operator (e.g., email "user@host.com" or version "1.2.3")
+        // Treat the entire string as an equality value
+        return ["==", raw];
+    }
+
+    // Parse list values: "(admin,editor)" → ["admin", "editor"]
+    if (rest.startsWith("(") && rest.endsWith(")")) {
+        const items = rest.slice(1, -1).split(",").map(s => coerceValue(s.trim()));
+        return [canonicalOp, items];
+    }
+
+    return [canonicalOp, coerceValue(rest)];
+}
+
+/**
+ * Convert a PostgREST-style querystring record to `FilterValues`.
+ *
+ * - String values are parsed as single conditions.
+ * - String arrays (repeated query params) become multiple conditions on the same field.
+ *
+ * @example
+ * deserializeFilter({ status: "eq.active" })
+ * // → { status: ["==", "active"] }
+ *
+ * deserializeFilter({ age: ["gte.18", "lt.65"] })
+ * // → { age: [[">=", 18], ["<", 65]] }
+ */
+export function deserializeFilter(
+    query: Record<string, any>
+): FilterValues<string> {
+    const result: FilterValues<string> = {};
+
+    for (const [field, raw] of Object.entries(query)) {
+        if (raw === undefined) continue;
+
+        // If it's already a canonical tuple [op, value], keep it as is
+        if (Array.isArray(raw) && raw.length === 2 && typeof raw[0] === "string" && toCanonicalOp(raw[0]) === raw[0]) {
+            result[field] = raw as [WhereFilterOp, unknown];
+            continue;
+        }
+
+        if (Array.isArray(raw)) {
+            if (raw.length === 0) continue;
+            
+            // Check if it's an array of canonical tuples
+            if (Array.isArray(raw[0]) && raw[0].length === 2 && typeof raw[0][0] === "string" && toCanonicalOp(raw[0][0]) === raw[0][0]) {
+                result[field] = raw as [WhereFilterOp, unknown][];
+                continue;
+            }
+
+            if (raw.length === 1) {
+                result[field] = typeof raw[0] === "string" ? deserializeSingle(raw[0]) : ["==", raw[0]];
+            } else {
+                // If the elements are strings, they might be PostgREST dot-strings (repeated params)
+                if (typeof raw[0] === "string" && raw[0].includes(".")) {
+                    result[field] = raw.map(r => typeof r === "string" ? deserializeSingle(r) : (["==", r] as [WhereFilterOp, unknown])) as [WhereFilterOp, unknown][];
+                } else {
+                    // Otherwise assume it's a list of values for an implicit "in" or just multiple conditions
+                    result[field] = ["in", raw];
+                }
+            }
+        } else if (typeof raw === "string") {
+            result[field] = deserializeSingle(raw);
+        } else {
+            result[field] = ["==", raw];
+        }
+    }
+
+    return result;
+}
+
+// ---------------------------------------------------------------------------
+// Logical conditions: serialize / deserialize
+// ---------------------------------------------------------------------------
+
+/**
+ * Serialize a `LogicalCondition` or `FilterCondition` to its wire-format string.
+ *
+ * @example
+ * serializeLogicalCondition({ column: "status", operator: "==", value: "active" })
+ * // → "status.eq.active"
+ *
+ * serializeLogicalCondition({ type: "or", conditions: [...] })
+ * // → "or(status.eq.active,status.eq.pending)"
+ */
+export function serializeLogicalCondition(
+    cond: LogicalCondition | FilterCondition
+): string {
+    if ("type" in cond) {
+        // LogicalCondition (and/or)
+        const inner = (cond.conditions ?? [])
+            .map(serializeLogicalCondition)
+            .join(",");
+        return `${cond.type}(${inner})`;
+    }
+
+    // FilterCondition
+    const restOp = (CANONICAL_TO_REST as any)[cond.operator] || "eq";
+    if (Array.isArray(cond.value)) {
+        const items = cond.value.map(stringifyValue).join(",");
+        return `${cond.column}.${restOp}.(${items})`;
+    }
+    return `${cond.column}.${restOp}.${stringifyValue(cond.value)}`;
+}
+
+/**
+ * Parse a logical condition wire-format string back into a
+ * `LogicalCondition` or `FilterCondition`.
+ *
+ * @example
+ * deserializeLogicalCondition("status.eq.active")
+ * // → { column: "status", operator: "==", value: "active" }
+ *
+ * deserializeLogicalCondition("or(status.eq.active,age.gte.18)")
+ * // → { type: "or", conditions: [...] }
+ */
+export function deserializeLogicalCondition(
+    str: string
+): LogicalCondition | FilterCondition {
+    // Check for logical group: "and(...)" or "or(...)"
+    const logicalMatch = str.match(/^(and|or)\((.+)\)$/);
+    if (logicalMatch) {
+        const type = logicalMatch[1] as "and" | "or";
+        const innerStr = logicalMatch[2];
+
+        // Split on commas that are not inside parentheses
+        const conditions: (LogicalCondition | FilterCondition)[] = [];
+        let depth = 0;
+        let start = 0;
+        for (let i = 0; i < innerStr.length; i++) {
+            if (innerStr[i] === "(") depth++;
+            else if (innerStr[i] === ")") depth--;
+            else if (innerStr[i] === "," && depth === 0) {
+                conditions.push(deserializeLogicalCondition(innerStr.slice(start, i)));
+                start = i + 1;
+            }
+        }
+        conditions.push(deserializeLogicalCondition(innerStr.slice(start)));
+
+        return { type, conditions };
+    }
+
+    // FilterCondition: "column.op.value"
+    const firstDot = str.indexOf(".");
+    if (firstDot === -1) {
+        return { column: str, operator: "==", value: true };
+    }
+
+    const column = str.substring(0, firstDot);
+    const rest = str.substring(firstDot + 1);
+
+    const secondDot = rest.indexOf(".");
+    if (secondDot === -1) {
+        // "column.value" — treat as equality
+        return { column, operator: "==", value: coerceValue(rest) };
+    }
+
+    const opStr = rest.substring(0, secondDot);
+    let valueStr = rest.substring(secondDot + 1);
+    const operator = toCanonicalOp(opStr) ?? "==";
+
+    // Parse list values
+    if (valueStr.startsWith("(") && valueStr.endsWith(")")) {
+        const items = valueStr.slice(1, -1).split(",").map(s => coerceValue(s.trim()));
+        return { column, operator, value: items };
+    }
+
+    return { column, operator, value: coerceValue(valueStr) };
+}

package/src/data/query_builder.ts

@@ -1,4 +1,4 @@
-import { FindParams, Entity, FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator, LogicalCondition, WhereValue, FilterCondition } from "@rebasepro/types";
+import { FindParams, Entity, FindResponse, CollectionAccessor, QueryBuilderInterface, WhereFilterOp, LogicalCondition, WhereValue, FilterCondition } from "@rebasepro/types";
 
 export function or(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition {
     return { type: "or",
@@ -10,7 +10,7 @@ export function and(...conditions: (FilterCondition | LogicalCondition)[]): Logi
 conditions };
 }
 
-export function cond(column: string, operator: FilterOperator, value: unknown): FilterCondition {
+export function cond(column: string, operator: WhereFilterOp, value: unknown): FilterCondition {
     return { column,
 operator,
 value };
@@ -26,9 +26,9 @@ export class QueryBuilder<M extends Record<string, unknown> = Record<string, unk
      * @example
      * client.collection('users').where('age', '>=', 18).find()
      */
-    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): this;
+    where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): this;
     where(logicalCondition: LogicalCondition): this;
-    where(columnOrCondition: string | LogicalCondition, operator?: FilterOperator, value?: unknown): this {
+    where(columnOrCondition: string | LogicalCondition, operator?: WhereFilterOp, value?: unknown): this {
         // Handle LogicalCondition signature
         if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
             this.params.logical = columnOrCondition as LogicalCondition;
@@ -40,18 +40,18 @@ export class QueryBuilder<M extends Record<string, unknown> = Record<string, unk
         }
 
         const column = columnOrCondition as string;
-        const condition: [FilterOperator, unknown] = [operator!, value];
+        const condition: [WhereFilterOp, unknown] = [operator!, value];
         const existing = this.params.where[column];
 
         if (existing === undefined) {
             this.params.where[column] = condition;
         } else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) {
-            (this.params.where[column] as [FilterOperator, unknown][]).push(condition);
+            (this.params.where[column] as [WhereFilterOp, unknown][]).push(condition);
         } else {
             // Convert existing single tuple/value into array of tuples
-            let firstCondition: [FilterOperator, unknown];
+            let firstCondition: [WhereFilterOp, unknown];
             if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") {
-                firstCondition = existing as [FilterOperator, unknown];
+                firstCondition = existing as [WhereFilterOp, unknown];
             } else {
                 firstCondition = ["==", existing];
             }
@@ -66,8 +66,8 @@ export class QueryBuilder<M extends Record<string, unknown> = Record<string, unk
      * @example
      * client.collection('users').orderBy('createdAt', 'desc').find()
      */
-    orderBy(column: keyof M & string, ascending: "asc" | "desc" = "asc"): this {
-        this.params.orderBy = `${column}:${ascending}`;
+    orderBy(column: keyof M & string, direction: "asc" | "desc" = "asc"): this {
+        this.params.orderBy = `${column}:${direction}`;
         return this;
     }