ng-qubee 3.4.0 → 3.6.0

package/fesm2022/ng-qubee.mjs

@@ -74,11 +74,15 @@ class PaginatedCollection {
  */
 var DriverEnum;
 (function (DriverEnum) {
+    DriverEnum["DRF"] = "drf";
     DriverEnum["JSON_API"] = "json-api";
     DriverEnum["LARAVEL"] = "laravel";
     DriverEnum["NESTJS"] = "nestjs";
+    DriverEnum["NESTJSX_CRUD"] = "nestjsx-crud";
     DriverEnum["POSTGREST"] = "postgrest";
+    DriverEnum["SIEVE"] = "sieve";
     DriverEnum["SPATIE"] = "spatie";
+    DriverEnum["SPRING"] = "spring";
     DriverEnum["STRAPI"] = "strapi";
 })(DriverEnum || (DriverEnum = {}));
 
@@ -124,6 +128,35 @@ class ResponseOptions {
         this.total = options.total || 'total';
     }
 }
+/**
+ * Pre-configured ResponseOptions for the Django REST Framework (DRF) driver
+ *
+ * DRF's `PageNumberPagination` envelope is `{ count, next, previous,
+ * results }`, with no body field naming the current page, per-page, or
+ * last-page. The strategy parses those from the `next` / `previous`
+ * URLs, so the corresponding key paths default to empty strings; the
+ * strategy ignores `options.currentPage`, `options.perPage`,
+ * `options.lastPage`, `options.from`, `options.to`, `options.path`,
+ * `options.firstPageUrl`, and `options.lastPageUrl`.
+ */
+class DrfResponseOptions extends ResponseOptions {
+    constructor(options) {
+        super({
+            currentPage: options.currentPage || '',
+            data: options.data || 'results',
+            firstPageUrl: options.firstPageUrl || '',
+            from: options.from || '',
+            lastPage: options.lastPage || '',
+            lastPageUrl: options.lastPageUrl || '',
+            nextPageUrl: options.nextPageUrl || 'next',
+            path: options.path || '',
+            perPage: options.perPage || '',
+            prevPageUrl: options.prevPageUrl || 'previous',
+            to: options.to || '',
+            total: options.total || 'count'
+        });
+    }
+}
 /**
  * Pre-configured ResponseOptions for the JSON:API driver
  *
@@ -172,6 +205,95 @@ class NestjsResponseOptions extends ResponseOptions {
         });
     }
 }
+/**
+ * Pre-configured ResponseOptions for the @nestjsx/crud driver
+ *
+ * The `getMany` envelope is flat: `{ data, count, total, page,
+ * pageCount }`. `perPage` defaults to the `count` field — the number of
+ * entities on the **current** page, which equals the requested limit on
+ * every page except a partial last one. The envelope carries no
+ * `from`/`to` indices and no navigation links, so those paths default to
+ * empty strings (the strategy derives `from`/`to` and leaves the URLs
+ * `undefined`); consumers can override any path via `IPaginationConfig`.
+ */
+class NestjsxCrudResponseOptions extends ResponseOptions {
+    constructor(options) {
+        super({
+            currentPage: options.currentPage || 'page',
+            data: options.data || 'data',
+            firstPageUrl: options.firstPageUrl || '',
+            from: options.from || '',
+            lastPage: options.lastPage || 'pageCount',
+            lastPageUrl: options.lastPageUrl || '',
+            nextPageUrl: options.nextPageUrl || '',
+            path: options.path || '',
+            perPage: options.perPage || 'count',
+            prevPageUrl: options.prevPageUrl || '',
+            to: options.to || '',
+            total: options.total || 'total'
+        });
+    }
+}
+/**
+ * Pre-configured ResponseOptions for the Sieve (.NET) driver
+ *
+ * Sieve defines no response envelope (it returns an `IQueryable` the
+ * developer wraps), so these defaults target the common hand-rolled
+ * `PagedResult<T>` shape: `{ data, page, pageSize, total, totalPages }`.
+ * Every path is overridable via `IPaginationConfig` — dot notation is
+ * supported, so nested wrappers (`meta.page`, `pagination.total`) map
+ * without subclassing. `from`/`to` default to empty paths and are
+ * derived; the navigation-URL slots resolve to `undefined` unless paths
+ * are provided.
+ */
+class SieveResponseOptions extends ResponseOptions {
+    constructor(options) {
+        super({
+            currentPage: options.currentPage || 'page',
+            data: options.data || 'data',
+            firstPageUrl: options.firstPageUrl || '',
+            from: options.from || '',
+            lastPage: options.lastPage || 'totalPages',
+            lastPageUrl: options.lastPageUrl || '',
+            nextPageUrl: options.nextPageUrl || '',
+            path: options.path || '',
+            perPage: options.perPage || 'pageSize',
+            prevPageUrl: options.prevPageUrl || '',
+            to: options.to || '',
+            total: options.total || 'total'
+        });
+    }
+}
+/**
+ * Pre-configured ResponseOptions for the Spring Data REST driver
+ *
+ * Uses dot-notation paths into the HAL envelope: pagination metadata
+ * lives under `page.*` and navigation links under `_links.*.href`.
+ * `currentPage` points at the **0-indexed** `page.number`; the strategy
+ * adds 1 when reading it. `data` defaults to plain `_embedded` because
+ * the collection key underneath is the resource rel name (e.g.
+ * `_embedded.users`) and cannot be known statically — the strategy picks
+ * the first array inside; pin an exact path via `IPaginationConfig` when
+ * needed. `from`/`to` default to empty paths and are derived.
+ */
+class SpringResponseOptions extends ResponseOptions {
+    constructor(options) {
+        super({
+            currentPage: options.currentPage || 'page.number',
+            data: options.data || '_embedded',
+            firstPageUrl: options.firstPageUrl || '_links.first.href',
+            from: options.from || '',
+            lastPage: options.lastPage || 'page.totalPages',
+            lastPageUrl: options.lastPageUrl || '_links.last.href',
+            nextPageUrl: options.nextPageUrl || '_links.next.href',
+            path: options.path || '',
+            perPage: options.perPage || 'page.size',
+            prevPageUrl: options.prevPageUrl || '_links.prev.href',
+            to: options.to || '',
+            total: options.total || 'page.totalElements'
+        });
+    }
+}
 /**
  * Pre-configured ResponseOptions for the Strapi driver
  *
@@ -199,15 +321,85 @@ class StrapiResponseOptions extends ResponseOptions {
     }
 }
 
+/**
+ * Enum representing the available filter operators for explicit operator
+ * filters
+ *
+ * NestJS encodes these with the `$` prefix at the wire level
+ * (`filter.field=$operator:value`); PostgREST translates them to its own
+ * prefix notation (`col=eq.val`, `col=is.null`, etc.). The enum values are
+ * intentionally the NestJS form; each driver's request strategy is
+ * responsible for mapping them into its own shape.
+ *
+ * `FTS`, `PLFTS`, `PHFTS`, `WFTS` are PostgREST-native full-text search
+ * variants; they throw `UnsupportedFilterOperatorError` on every other
+ * driver that does not recognise them.
+ *
+ * @see https://github.com/ppetzold/nestjs-paginate
+ * @see https://postgrest.org/en/stable/api.html#operators
+ */
+var FilterOperatorEnum;
+(function (FilterOperatorEnum) {
+    FilterOperatorEnum["BTW"] = "$btw";
+    FilterOperatorEnum["CONTAINS"] = "$contains";
+    FilterOperatorEnum["EQ"] = "$eq";
+    FilterOperatorEnum["FTS"] = "$fts";
+    FilterOperatorEnum["GT"] = "$gt";
+    FilterOperatorEnum["GTE"] = "$gte";
+    FilterOperatorEnum["ILIKE"] = "$ilike";
+    FilterOperatorEnum["IN"] = "$in";
+    FilterOperatorEnum["LT"] = "$lt";
+    FilterOperatorEnum["LTE"] = "$lte";
+    FilterOperatorEnum["NOT"] = "$not";
+    FilterOperatorEnum["NULL"] = "$null";
+    FilterOperatorEnum["PHFTS"] = "$phfts";
+    FilterOperatorEnum["PLFTS"] = "$plfts";
+    FilterOperatorEnum["SW"] = "$sw";
+    FilterOperatorEnum["WFTS"] = "$wfts";
+})(FilterOperatorEnum || (FilterOperatorEnum = {}));
+
 var SortEnum;
 (function (SortEnum) {
     SortEnum["ASC"] = "asc";
     SortEnum["DESC"] = "desc";
 })(SortEnum || (SortEnum = {}));
 
-class UnselectableModelError extends Error {
-    constructor(model) {
-        super(`Unselectable Model: the selected model (${model}) is not present neither in the "model" property, nor in the includes object.`);
+/**
+ * Thrown when a filter operator receives a value array of the wrong shape
+ *
+ * Some operators have arity or type constraints that the library enforces
+ * at call time so misuse fails loudly instead of silently emitting invalid
+ * server requests:
+ *
+ * - `BTW` requires exactly two values (min, max).
+ * - `NULL` requires exactly one boolean value (`true` for `IS NULL`,
+ *   `false` for `IS NOT NULL`).
+ *
+ * Operators with looser shape rules leave validation to the server; this
+ * error is reserved for cases where the library itself can detect the
+ * problem unambiguously from the call site.
+ */
+class InvalidFilterOperatorValueError extends Error {
+    /**
+     * @param operator - The operator that rejected the values
+     * @param reason - Short human-readable explanation of the constraint
+     */
+    constructor(operator, reason) {
+        super(`Invalid values for filter operator ${operator}: ${reason}`);
+        this.name = 'InvalidFilterOperatorValueError';
+    }
+}
+
+/**
+ * Error thrown when filter operators are attempted with a driver that does not support them
+ *
+ * Filter operators are only supported by the NestJS driver.
+ * Use `addFilter()` for Spatie implicit equality filters.
+ */
+class UnsupportedFilterOperatorError extends Error {
+    constructor() {
+        super('Filter operators are only supported by the NestJS driver. Use addFilter() for Spatie.');
+        this.name = 'UnsupportedFilterOperatorError';
     }
 }
 
@@ -303,17 +495,439 @@ class AbstractRequestStrategy {
         return state.baseUrl ? `${state.baseUrl}/${state.resource}` : `/${state.resource}`;
     }
     /**
-     * Glue the base URI and the per-driver query-string segments
+     * Glue the base URI and the per-driver query-string segments
+     *
+     * Returns the bare base when no segments were emitted (e.g. PostgREST
+     * in RANGE mode with no filters), otherwise joins with `?` + `&`.
+     *
+     * @param base - The base URI from `_baseUri`
+     * @param segments - The query-string fragments from `parts(...)`
+     * @returns The full URI
+     */
+    join(base, segments) {
+        return segments.length ? `${base}?${segments.join('&')}` : base;
+    }
+}
+
+/**
+ * Request strategy for the Django REST Framework (DRF) driver
+ *
+ * Generates URIs in DRF's flat query-parameter format, augmented by
+ * django-filter's double-underscore lookup convention:
+ *
+ * - Simple filters: `field=value` (multi-value collapses to `field__in=v1,v2`)
+ * - Operator filters: `field__lookup=value` (translated from
+ *   `FilterOperatorEnum` — `GTE`→`__gte`, `ILIKE`→`__icontains`,
+ *   `BTW`→`__range`, `NULL`→`__isnull`, etc.)
+ * - Ordering: `ordering=-field1,field2` (`-` prefix = DESC)
+ * - Search: `search=term` (DRF's SearchFilter)
+ * - Pagination: `page=N&page_size=M` (PageNumberPagination)
+ *
+ * `ordering` and `page_size` are DRF-idiomatic param names and are
+ * intentionally not configurable via `QueryBuilderOptions` — same
+ * precedent as PostgREST's `order` and `offset`. PostgREST's full-text
+ * search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) and the generic
+ * `NOT` have no django-filter equivalent and throw
+ * `UnsupportedFilterOperatorError`.
+ *
+ * @see https://www.django-rest-framework.org/api-guide/filtering/
+ * @see https://django-filter.readthedocs.io/
+ */
+class DrfRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Simple filters, operator filters (django-filter lookups), sorts, and
+     * global search — no per-model fields, no relation includes, no flat
+     * select (django-restql adds it but is not core DRF)
+     */
+    capabilities = {
+        fields: false,
+        filters: true,
+        includes: false,
+        operatorFilters: true,
+        search: true,
+        select: false,
+        sort: true
+    };
+    /**
+     * DRF-native names of the three hardcoded query keys
+     *
+     * `ordering` and `page_size` are DRF/django-filter conventions and are
+     * intentionally not configurable through `QueryBuilderOptions`. `page`
+     * matches the default `QueryBuilderOptions.page`, and `search` matches
+     * the default `QueryBuilderOptions.search`, so those flow through the
+     * shared options object.
+     */
+    static _orderingKey = 'ordering';
+    static _pageSizeKey = 'page_size';
+    /**
+     * Emit DRF-format query-string segments in canonical order:
+     * filters → operator filters → ordering → search → pagination
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns Ordered query-string fragments
+     */
+    parts(state, options) {
+        const out = [];
+        this._appendFilters(state, out);
+        this._appendOperatorFilters(state, out);
+        this._appendOrdering(state, out);
+        this._appendSearch(state, options, out);
+        this._appendPagination(state, options, out);
+        return out;
+    }
+    /**
+     * Append simple filter parameters
+     *
+     * Single-value filters emit `field=value` (django-filter's default
+     * exact match). Multi-value filters collapse to django-filter's
+     * `field__in=v1,v2,v3` form, which is the idiomatic way to express
+     * "value in list" in DRF.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendFilters(state, out) {
+        const keys = Object.keys(state.filters);
+        if (!keys.length) {
+            return;
+        }
+        keys.forEach(key => {
+            const values = state.filters[key];
+            if (!values.length) {
+                return;
+            }
+            if (values.length === 1) {
+                out.push(`${key}=${values[0]}`);
+                return;
+            }
+            out.push(`${key}__in=${values.join(',')}`);
+        });
+    }
+    /**
+     * Append operator-filter parameters as `field__lookup=value`
+     *
+     * Maps each `FilterOperatorEnum` value to a django-filter lookup
+     * suffix. `BTW` expands to `field__range=min,max`; `NULL` emits
+     * `field__isnull=true|false`; the generic `NOT` and PostgREST-only
+     * FTS operators are unsupported.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator has no
+     * django-filter equivalent
+     */
+    _appendOperatorFilters(state, out) {
+        if (!state.operatorFilters.length) {
+            return;
+        }
+        state.operatorFilters.forEach((filter) => {
+            const [suffix, value] = this._formatOperatorPayload(filter);
+            const key = suffix ? `${filter.field}__${suffix}` : filter.field;
+            out.push(`${key}=${value}`);
+        });
+    }
+    /**
+     * Append `ordering=-field1,field2` (django's `-` prefix = DESC)
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendOrdering(state, out) {
+        if (!state.sorts.length) {
+            return;
+        }
+        const pairs = state.sorts.map(sort => `${sort.order === SortEnum.DESC ? '-' : ''}${sort.field}`);
+        out.push(`${DrfRequestStrategy._orderingKey}=${pairs.join(',')}`);
+    }
+    /**
+     * Append `page=N&page_size=M`
+     *
+     * `page` follows `options.page` (default `page`, matching DRF); the
+     * size key is hardcoded to DRF's idiomatic `page_size`.
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendPagination(state, options, out) {
+        out.push(`${options.page}=${state.page}`);
+        out.push(`${DrfRequestStrategy._pageSizeKey}=${state.limit}`);
+    }
+    /**
+     * Append `search=term` when a search term is set
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendSearch(state, options, out) {
+        if (!state.search) {
+            return;
+        }
+        out.push(`${options.search}=${state.search}`);
+    }
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into a
+     * `[suffix, serializedValue]` pair
+     *
+     * The suffix is appended to the field name with a `__` separator on the
+     * wire side (`field__gte=18`). The empty string means "no suffix" —
+     * django-filter's implicit `exact` lookup.
+     *
+     * Mapping:
+     * - `EQ` → `''` (no suffix; default exact match)
+     * - `GT`/`GTE`/`LT`/`LTE`/`CONTAINS` → identity (lowercased name)
+     * - `ILIKE` → `icontains` (closest case-insensitive analog)
+     * - `IN` → `in` with comma-joined values
+     * - `SW` → `startswith`
+     * - `BTW` → `range` with comma-joined `[min, max]` (arity-checked)
+     * - `NULL` → `isnull` with boolean value (arity- and type-checked)
+     * - `NOT` → `UnsupportedFilterOperatorError` (no generic negation in
+     *   django-filter; use `__exclude` on the queryset instead)
+     * - `FTS`/`PLFTS`/`PHFTS`/`WFTS` → `UnsupportedFilterOperatorError`
+     *
+     * @param filter - The operator filter to translate
+     * @returns A `[lookupSuffix, serializedValue]` tuple
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator has no
+     * django-filter equivalent
+     */
+    _formatOperatorPayload(filter) {
+        const { operator, values } = filter;
+        const first = values[0];
+        switch (operator) {
+            case FilterOperatorEnum.EQ: return ['', String(first)];
+            case FilterOperatorEnum.GT: return ['gt', String(first)];
+            case FilterOperatorEnum.GTE: return ['gte', String(first)];
+            case FilterOperatorEnum.LT: return ['lt', String(first)];
+            case FilterOperatorEnum.LTE: return ['lte', String(first)];
+            case FilterOperatorEnum.CONTAINS: return ['contains', String(first)];
+            case FilterOperatorEnum.ILIKE: return ['icontains', String(first)];
+            case FilterOperatorEnum.IN: return ['in', values.join(',')];
+            case FilterOperatorEnum.SW: return ['startswith', String(first)];
+            case FilterOperatorEnum.BTW: {
+                if (values.length !== 2) {
+                    throw new InvalidFilterOperatorValueError(operator, 'BTW requires exactly 2 values (min, max)');
+                }
+                return ['range', values.join(',')];
+            }
+            case FilterOperatorEnum.NULL: {
+                if (values.length !== 1 || typeof first !== 'boolean') {
+                    throw new InvalidFilterOperatorValueError(operator, 'NULL requires exactly 1 boolean value (true → IS NULL, false → IS NOT NULL)');
+                }
+                return ['isnull', String(first)];
+            }
+            case FilterOperatorEnum.NOT:
+            case FilterOperatorEnum.FTS:
+            case FilterOperatorEnum.PHFTS:
+            case FilterOperatorEnum.PLFTS:
+            case FilterOperatorEnum.WFTS:
+                throw new UnsupportedFilterOperatorError();
+        }
+    }
+}
+
+/**
+ * Response strategy for the Django REST Framework (DRF) driver
+ *
+ * Parses DRF `PageNumberPagination` responses:
+ *
+ * ```json
+ * {
+ *   "count": 100,
+ *   "next": "http://api.example.com/items/?page=3",
+ *   "previous": "http://api.example.com/items/?page=1",
+ *   "results": [...]
+ * }
+ * ```
+ *
+ * DRF emits no `current_page` field in the body, so this strategy
+ * **derives** the current page (and the page size) by inspecting the
+ * `next` / `previous` URLs:
+ *
+ * - `previous === null` → current page is **1**.
+ * - `previous` set but has no `?page=N` param → DRF omits `page=1` from
+ *   URLs when the previous page is the first, so we infer **2**.
+ * - `previous` has `?page=N` → current page is **N + 1**.
+ *
+ * Similarly, `perPage` is parsed from any `?page_size=N` query param on
+ * `next` or `previous`, and `lastPage` is computed as
+ * `ceil(count / perPage)`. When `perPage` cannot be discovered (e.g. on a
+ * single-page response that emits both URLs as `null`), `perPage` and
+ * `lastPage` are left undefined.
+ *
+ * Key paths are resolved through `DrfResponseOptions`, which defaults
+ * `data → 'results'`, `total → 'count'`, `nextPageUrl → 'next'`,
+ * `prevPageUrl → 'previous'`. The current-page / per-page / last-page
+ * paths default to empty strings — the strategy ignores `options` for
+ * those slots and uses URL inspection instead.
+ *
+ * @see https://www.django-rest-framework.org/api-guide/pagination/#pagenumberpagination
+ */
+class DrfResponseStrategy {
+    /**
+     * Parse a DRF pagination response into a PaginatedCollection
+     *
+     * @param response - The raw API response body
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paginate(response, options) {
+        const data = response[options.data];
+        const total = response[options.total];
+        const prevPageUrl = (response[options.prevPageUrl] ?? null);
+        const nextPageUrl = (response[options.nextPageUrl] ?? null);
+        const currentPage = this._deriveCurrentPage(prevPageUrl);
+        const perPage = this._derivePerPage(nextPageUrl, prevPageUrl);
+        const lastPage = this._deriveLastPage(total, perPage);
+        const from = this._deriveFrom(currentPage, perPage);
+        const to = this._deriveTo(currentPage, perPage, total);
+        return new PaginatedCollection(data, currentPage, from, to, total, perPage, prevPageUrl ?? undefined, nextPageUrl ?? undefined, lastPage, undefined, undefined);
+    }
+    /**
+     * Derive the current page number from the `previous` URL
+     *
+     * - `null` → page 1
+     * - URL without `?page=N` → page 2 (DRF omits `page=1` from URLs)
+     * - URL with `?page=N` → N + 1
+     *
+     * @param prevPageUrl - The `previous` link from the DRF response, or null
+     * @returns The current page number
+     */
+    _deriveCurrentPage(prevPageUrl) {
+        if (prevPageUrl === null) {
+            return 1;
+        }
+        const prevPage = this._extractPageParam(prevPageUrl);
+        return prevPage === undefined ? 2 : prevPage + 1;
+    }
+    /**
+     * Derive `from` as the 1-indexed offset of the first item on this page
+     *
+     * @param currentPage - The current page number
+     * @param perPage - The page size (may be undefined)
+     * @returns The 1-indexed `from` index, or undefined when perPage is unknown
+     */
+    _deriveFrom(currentPage, perPage) {
+        if (!perPage) {
+            return undefined;
+        }
+        return (currentPage - 1) * perPage + 1;
+    }
+    /**
+     * Derive the last page number as `ceil(total / perPage)`
+     *
+     * Both inputs must be defined; an empty result set (`total === 0`)
+     * yields `lastPage = 0` which the caller treats as "no useful info"
+     * and skips the sync to `NestService.lastPage`.
+     *
+     * @param total - The total item count
+     * @param perPage - The page size
+     * @returns The last page number, or undefined when either input is missing
+     */
+    _deriveLastPage(total, perPage) {
+        if (total === undefined || perPage === undefined || perPage <= 0) {
+            return undefined;
+        }
+        return Math.ceil(total / perPage);
+    }
+    /**
+     * Derive `perPage` by parsing `?page_size=N` from any available URL
+     *
+     * Tries `next` first (page 1 always has a `next` URL with `page_size`
+     * if any non-default size was requested), then falls back to
+     * `previous`. Returns undefined when neither URL contains the param —
+     * the consumer is then on a single-page result with the server's
+     * default page size, which is not introspectable from the body alone.
+     *
+     * @param nextPageUrl - The `next` link from the response, or null
+     * @param prevPageUrl - The `previous` link from the response, or null
+     * @returns The page size, or undefined
+     */
+    _derivePerPage(nextPageUrl, prevPageUrl) {
+        return this._extractPageSizeParam(nextPageUrl) ?? this._extractPageSizeParam(prevPageUrl);
+    }
+    /**
+     * Derive `to` as the 1-indexed offset of the last item on this page
+     *
+     * Clamped to `total` so the last page does not report past the end.
+     *
+     * @param currentPage - The current page number
+     * @param perPage - The page size (may be undefined)
+     * @param total - The total item count (may be undefined)
+     * @returns The 1-indexed `to` index, or undefined when inputs insufficient
+     */
+    _deriveTo(currentPage, perPage, total) {
+        if (perPage === undefined || total === undefined) {
+            return undefined;
+        }
+        return Math.min(currentPage * perPage, total);
+    }
+    /**
+     * Extract the `page` query parameter from a DRF pagination URL
+     *
+     * Returns the integer value of `?page=N`, or undefined when the URL is
+     * malformed or has no `page` param (which, by DRF convention, means
+     * page 1 — the caller infers the semantics).
+     *
+     * @param url - The URL to parse
+     * @returns The integer page value, or undefined
+     */
+    _extractPageParam(url) {
+        const raw = this._extractQueryParam(url, 'page');
+        if (raw === undefined) {
+            return undefined;
+        }
+        const parsed = Number.parseInt(raw, 10);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    /**
+     * Extract the `page_size` query parameter from a DRF pagination URL
+     *
+     * @param url - The URL to parse (or null)
+     * @returns The integer page-size value, or undefined
+     */
+    _extractPageSizeParam(url) {
+        if (url === null) {
+            return undefined;
+        }
+        const raw = this._extractQueryParam(url, 'page_size');
+        if (raw === undefined) {
+            return undefined;
+        }
+        const parsed = Number.parseInt(raw, 10);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    /**
+     * Extract a single query parameter from a URL via the WHATWG URL parser
      *
-     * Returns the bare base when no segments were emitted (e.g. PostgREST
-     * in RANGE mode with no filters), otherwise joins with `?` + `&`.
+     * Returns undefined when the URL is unparseable (relative URL without a
+     * base, or malformed) or when the parameter is absent.
      *
-     * @param base - The base URI from `_baseUri`
-     * @param segments - The query-string fragments from `parts(...)`
-     * @returns The full URI
+     * @param url - The URL to parse
+     * @param name - The query-parameter name to look up
+     * @returns The raw string value of the parameter, or undefined
      */
-    join(base, segments) {
-        return segments.length ? `${base}?${segments.join('&')}` : base;
+    _extractQueryParam(url, name) {
+        try {
+            const parsed = new URL(url);
+            const value = parsed.searchParams.get(name);
+            return value === null ? undefined : value;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+
+class UnselectableModelError extends Error {
+    constructor(model) {
+        super(`Unselectable Model: the selected model (${model}) is not present neither in the "model" property, nor in the includes object.`);
     }
 }
 
@@ -625,6 +1239,39 @@ class LaravelRequestStrategy extends AbstractRequestStrategy {
     }
 }
 
+/**
+ * Base class for response strategies whose pagination metadata is a flat
+ * key-value envelope on the response body
+ *
+ * Laravel's stock pagination and Spatie's `QueryBuilder` both emit the
+ * same flat shape — `{ data, current_page, total, per_page, from, to,
+ * next_page_url, prev_page_url, first_page_url, last_page, last_page_url
+ * }` — and both response strategies were duplicating the byte-identical
+ * `new PaginatedCollection(response[options.X], ...)` body before this
+ * base existed. Concrete classes now extend and provide only the
+ * docstring describing their driver's specific shape (see
+ * `LaravelResponseStrategy`, `SpatieResponseStrategy`).
+ *
+ * Drivers whose pagination metadata is a nested envelope (JSON:API,
+ * NestJS, Strapi) extend `AbstractDotPathResponseStrategy` instead.
+ * Drivers whose metadata comes from HTTP headers (PostgREST) or is
+ * derived from response URLs (DRF) implement `IResponseStrategy`
+ * directly.
+ */
+class AbstractFlatResponseStrategy {
+    /**
+     * Parse a flat-envelope pagination response into a PaginatedCollection
+     *
+     * @param response - The raw API response object
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paginate(response, options) {
+        return new PaginatedCollection(response[options.data], response[options.currentPage], response[options.from], response[options.to], response[options.total], response[options.perPage], response[options.prevPageUrl], response[options.nextPageUrl], response[options.lastPage], response[options.firstPageUrl], response[options.lastPageUrl]);
+    }
+}
+
 /**
  * Response strategy for the Laravel (pagination-only) driver
  *
@@ -637,22 +1284,20 @@ class LaravelRequestStrategy extends AbstractRequestStrategy {
  *   "per_page": 15,
  *   "from": 1,
  *   "to": 15,
- *   ...
+ *   "next_page_url": "...",
+ *   "prev_page_url": "...",
+ *   "first_page_url": "...",
+ *   "last_page": 7,
+ *   "last_page_url": "..."
  * }
  * ```
+ *
+ * The traversal algorithm (flat `response[options.X]` lookups) is
+ * inherited from `AbstractFlatResponseStrategy`; this class exists so
+ * `DriverEnum.LARAVEL` resolves to a distinct identity at the DI layer
+ * even though the parsing logic is shared with Spatie.
  */
-class LaravelResponseStrategy {
-    /**
-     * Parse a flat Laravel pagination response into a PaginatedCollection
-     *
-     * @param response - The raw API response object
-     * @param options - The response key name configuration
-     * @returns A typed PaginatedCollection instance
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    paginate(response, options) {
-        return new PaginatedCollection(response[options.data], response[options.currentPage], response[options.from], response[options.to], response[options.total], response[options.perPage], response[options.prevPageUrl], response[options.nextPageUrl], response[options.lastPage], response[options.firstPageUrl], response[options.lastPageUrl]);
-    }
+class LaravelResponseStrategy extends AbstractFlatResponseStrategy {
 }
 
 /**
@@ -848,86 +1493,290 @@ class NestjsResponseStrategy extends AbstractDotPathResponseStrategy {
 }
 
 /**
- * Enum representing the available filter operators for explicit operator
- * filters
- *
- * NestJS encodes these with the `$` prefix at the wire level
- * (`filter.field=$operator:value`); PostgREST translates them to its own
- * prefix notation (`col=eq.val`, `col=is.null`, etc.). The enum values are
- * intentionally the NestJS form; each driver's request strategy is
- * responsible for mapping them into its own shape.
- *
- * `FTS`, `PLFTS`, `PHFTS`, `WFTS` are PostgREST-native full-text search
- * variants; they throw `UnsupportedFilterOperatorError` on every other
- * driver that does not recognise them.
+ * Request strategy for the @nestjsx/crud driver
  *
- * @see https://github.com/ppetzold/nestjs-paginate
- * @see https://postgrest.org/en/stable/api.html#operators
- */
-var FilterOperatorEnum;
-(function (FilterOperatorEnum) {
-    FilterOperatorEnum["BTW"] = "$btw";
-    FilterOperatorEnum["CONTAINS"] = "$contains";
-    FilterOperatorEnum["EQ"] = "$eq";
-    FilterOperatorEnum["FTS"] = "$fts";
-    FilterOperatorEnum["GT"] = "$gt";
-    FilterOperatorEnum["GTE"] = "$gte";
-    FilterOperatorEnum["ILIKE"] = "$ilike";
-    FilterOperatorEnum["IN"] = "$in";
-    FilterOperatorEnum["LT"] = "$lt";
-    FilterOperatorEnum["LTE"] = "$lte";
-    FilterOperatorEnum["NOT"] = "$not";
-    FilterOperatorEnum["NULL"] = "$null";
-    FilterOperatorEnum["PHFTS"] = "$phfts";
-    FilterOperatorEnum["PLFTS"] = "$plfts";
-    FilterOperatorEnum["SW"] = "$sw";
-    FilterOperatorEnum["WFTS"] = "$wfts";
-})(FilterOperatorEnum || (FilterOperatorEnum = {}));
-
-/**
- * Enum representing the wire-level pagination mechanism
+ * Generates URIs in [@nestjsx/crud's pipe-delimited query format](https://github.com/nestjsx/crud/wiki/Requests):
+ * - Filters: `filter=field||$eq||value` (repeatable; multi-value
+ *   collapses to `filter=field||$in||v1,v2`)
+ * - Operator filters: `filter=field||$op||value` (translated from
+ *   `FilterOperatorEnum` — `CONTAINS`→`$cont`, `ILIKE`→`$contL`,
+ *   `SW`→`$starts`, `BTW`→`$between`, `NOT`→`$ne`/`$notin`,
+ *   `NULL`→`$isnull`/`$notnull` with no value segment)
+ * - Joins: `join=relation` (repeatable, from `addIncludes`)
+ * - Field selection (flat): `fields=col1,col2` (from `addSelect`)
+ * - Sorts: `sort=field,ASC` (repeatable, uppercase direction)
+ * - Pagination (page-based): `page=N&limit=N`
  *
- * `QUERY` (default) — the request strategy emits `limit` and `offset` (or
- * equivalent) query parameters on the URL.
+ * The JSON-shaped `s={...}` search parameter is intentionally out of
+ * scope: it is not a plain search term, so `setSearch` throws
+ * `UnsupportedSearchError` on this driver. PostgREST-native full-text
+ * search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+ * `UnsupportedFilterOperatorError`.
  *
- * `RANGE` — the request strategy omits URL-based pagination and the
- * consumer instead applies HTTP request headers returned by
- * `NgQubeeService.paginationHeaders()`. Currently honoured only by the
- * PostgREST driver, which maps it to `Range-Unit: items` + `Range: 0-9`.
- * Other drivers ignore the setting.
+ * @see https://github.com/nestjsx/crud/wiki/Requests
  */
-var PaginationModeEnum;
-(function (PaginationModeEnum) {
-    PaginationModeEnum["QUERY"] = "query";
-    PaginationModeEnum["RANGE"] = "range";
-})(PaginationModeEnum || (PaginationModeEnum = {}));
+class NestjsxCrudRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Filters, operator filters, joins (`includes`), flat field selection
+     * (`select`), sorts — no per-model fields, no global search (the `s`
+     * parameter is JSON-shaped, not a plain term)
+     */
+    capabilities = {
+        fields: false,
+        filters: true,
+        includes: true,
+        operatorFilters: true,
+        search: false,
+        select: true,
+        sort: true
+    };
+    /**
+     * @nestjsx/crud-native names of the four hardcoded query keys
+     *
+     * The wire format is fixed (the server's `CrudRequestInterceptor`
+     * reads `fields`, `filter`, `join`, and `sort`); these keys are
+     * intentionally not configurable through `QueryBuilderOptions` and
+     * live as private statics so they are visible in one place.
+     */
+    static _fieldsKey = 'fields';
+    static _filterKey = 'filter';
+    static _joinKey = 'join';
+    static _sortKey = 'sort';
+    /**
+     * Pipe delimiter separating field, operator, and value segments
+     */
+    static _separator = '||';
+    /**
+     * Emit @nestjsx/crud-format query-string segments in canonical order:
+     * fields → filters → operator filters → join → sort → limit → page
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration (used
+     * for `page` / `limit`, whose defaults match the wire format; the
+     * `fields` / `filter` / `join` / `sort` keys are fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    parts(state, options) {
+        const out = [];
+        this._appendFields(state, out);
+        this._appendFilters(state, out);
+        this._appendOperatorFilters(state, out);
+        this._appendJoin(state, out);
+        this._appendSort(state, out);
+        this._appendLimit(state, options, out);
+        this._appendPage(state, options, out);
+        return out;
+    }
+    /**
+     * Append `fields=col1,col2` from the flat select array
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendFields(state, out) {
+        if (!state.select.length) {
+            return;
+        }
+        out.push(`${NestjsxCrudRequestStrategy._fieldsKey}=${state.select.join(',')}`);
+    }
+    /**
+     * Append simple filters as repeatable `filter=field||$eq||value` params
+     *
+     * Single-value filters fold to `$eq`; multi-value filters fold to
+     * `$in` with comma-joined values.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendFilters(state, out) {
+        const sep = NestjsxCrudRequestStrategy._separator;
+        Object.keys(state.filters).forEach(field => {
+            const values = state.filters[field];
+            if (!values.length) {
+                return;
+            }
+            const condition = values.length === 1
+                ? `$eq${sep}${values[0]}`
+                : `$in${sep}${values.join(',')}`;
+            out.push(`${NestjsxCrudRequestStrategy._filterKey}=${field}${sep}${condition}`);
+        });
+    }
+    /**
+     * Append `join=relation` params from the includes array
+     *
+     * Per-relation field projection (`join=relation||f1,f2`) is not
+     * expressible through the current state shape and is out of scope.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendJoin(state, out) {
+        state.includes.forEach(relation => {
+            out.push(`${NestjsxCrudRequestStrategy._joinKey}=${relation}`);
+        });
+    }
+    /**
+     * Append the limit parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendLimit(state, options, out) {
+        out.push(`${options.limit}=${state.limit}`);
+    }
+    /**
+     * Append operator filters as repeatable `filter=field||$op||value` params
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendOperatorFilters(state, out) {
+        const sep = NestjsxCrudRequestStrategy._separator;
+        state.operatorFilters.forEach((filter) => {
+            const condition = this._formatOperatorCondition(filter);
+            out.push(`${NestjsxCrudRequestStrategy._filterKey}=${filter.field}${sep}${condition}`);
+        });
+    }
+    /**
+     * Append the page parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendPage(state, options, out) {
+        out.push(`${options.page}=${state.page}`);
+    }
+    /**
+     * Append `sort=field,ASC` params, one per sort rule
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendSort(state, out) {
+        state.sorts.forEach(sort => {
+            const direction = sort.order === SortEnum.DESC ? 'DESC' : 'ASC';
+            out.push(`${NestjsxCrudRequestStrategy._sortKey}=${sort.field},${direction}`);
+        });
+    }
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into @nestjsx/crud's
+     * `$operator||value` condition segment
+     *
+     * The mapping is library-canonical → @nestjsx/crud-native:
+     * - `EQ`/`GT`/`GTE`/`LT`/`LTE`/`IN` → identity (same operator name)
+     * - `CONTAINS` → `$cont`; `ILIKE` → `$contL` (case-insensitive contains)
+     * - `SW` → `$starts`
+     * - `BTW` → `$between` with `min,max` (arity-checked)
+     * - `NOT` → `$ne` (single value) / `$notin` (multi-value)
+     * - `NULL` → `$isnull` (when value is `true`) / `$notnull` (when value
+     *   is `false`); both emit **no value segment**; arity- and type-checked
+     *
+     * PostgREST's full-text-search operators (`FTS`, `PHFTS`, `PLFTS`,
+     * `WFTS`) have no @nestjsx/crud equivalent and throw
+     * `UnsupportedFilterOperatorError`.
+     *
+     * @param filter - The operator filter to translate
+     * @returns The `$operator||value` (or bare `$operator`) condition segment
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator is a
+     * PostgREST-only FTS variant
+     */
+    _formatOperatorCondition(filter) {
+        const sep = NestjsxCrudRequestStrategy._separator;
+        const { operator, values } = filter;
+        const first = values[0];
+        switch (operator) {
+            case FilterOperatorEnum.EQ: return `$eq${sep}${first}`;
+            case FilterOperatorEnum.GT: return `$gt${sep}${first}`;
+            case FilterOperatorEnum.GTE: return `$gte${sep}${first}`;
+            case FilterOperatorEnum.LT: return `$lt${sep}${first}`;
+            case FilterOperatorEnum.LTE: return `$lte${sep}${first}`;
+            case FilterOperatorEnum.CONTAINS: return `$cont${sep}${first}`;
+            case FilterOperatorEnum.ILIKE: return `$contL${sep}${first}`;
+            case FilterOperatorEnum.IN: return `$in${sep}${values.join(',')}`;
+            case FilterOperatorEnum.SW: return `$starts${sep}${first}`;
+            case FilterOperatorEnum.BTW: {
+                if (values.length !== 2) {
+                    throw new InvalidFilterOperatorValueError(operator, 'BTW requires exactly 2 values (min, max)');
+                }
+                return `$between${sep}${values.join(',')}`;
+            }
+            case FilterOperatorEnum.NOT:
+                return values.length === 1
+                    ? `$ne${sep}${first}`
+                    : `$notin${sep}${values.join(',')}`;
+            case FilterOperatorEnum.NULL: {
+                if (values.length !== 1 || typeof first !== 'boolean') {
+                    throw new InvalidFilterOperatorValueError(operator, 'NULL requires exactly 1 boolean value (true → IS NULL, false → IS NOT NULL)');
+                }
+                return first ? '$isnull' : '$notnull';
+            }
+            case FilterOperatorEnum.FTS:
+            case FilterOperatorEnum.PHFTS:
+            case FilterOperatorEnum.PLFTS:
+            case FilterOperatorEnum.WFTS:
+                throw new UnsupportedFilterOperatorError();
+        }
+    }
+}
 
 /**
- * Thrown when a filter operator receives a value array of the wrong shape
+ * Response strategy for the @nestjsx/crud driver
  *
- * Some operators have arity or type constraints that the library enforces
- * at call time so misuse fails loudly instead of silently emitting invalid
- * server requests:
- *
- * - `BTW` requires exactly two values (min, max).
- * - `NULL` requires exactly one boolean value (`true` for `IS NULL`,
- *   `false` for `IS NOT NULL`).
+ * Parses @nestjsx/crud's `getMany` envelope:
+ * ```json
+ * {
+ *   "data": [{ "id": 1, "name": "John" }],
+ *   "count": 10,
+ *   "total": 48,
+ *   "page": 2,
+ *   "pageCount": 5
+ * }
+ * ```
  *
- * Operators with looser shape rules leave validation to the server; this
- * error is reserved for cases where the library itself can detect the
- * problem unambiguously from the call site.
- */
-class InvalidFilterOperatorValueError extends Error {
-    /**
-     * @param operator - The operator that rejected the values
-     * @param reason - Short human-readable explanation of the constraint
-     */
-    constructor(operator, reason) {
-        super(`Invalid values for filter operator ${operator}: ${reason}`);
-        this.name = 'InvalidFilterOperatorValueError';
-    }
+ * Default key paths are configured in `NestjsxCrudResponseOptions`. The
+ * envelope carries no `from`/`to` indices and no navigation links, so
+ * `from`/`to` are computed from `page` × `count` by the inherited
+ * traversal algorithm and the URL slots resolve to `undefined` unless
+ * the consumer overrides their paths via `IPaginationConfig`.
+ *
+ * Note that `count` is the number of entities **on the current page**,
+ * not the requested page size — on the last page of a result set the
+ * derived `from`/`to` can underestimate. Consumers needing exact
+ * indices should compute them from the requested limit instead.
+ *
+ * The dot-notation traversal is inherited from
+ * `AbstractDotPathResponseStrategy`; this class exists so
+ * `DriverEnum.NESTJSX_CRUD` resolves to a distinct identity at the DI
+ * layer even though the parsing logic is shared with JSON:API, NestJS,
+ * and Strapi.
+ *
+ * @see https://github.com/nestjsx/crud/wiki/Requests
+ */
+class NestjsxCrudResponseStrategy extends AbstractDotPathResponseStrategy {
 }
 
+/**
+ * Enum representing the wire-level pagination mechanism
+ *
+ * `QUERY` (default) — the request strategy emits `limit` and `offset` (or
+ * equivalent) query parameters on the URL.
+ *
+ * `RANGE` — the request strategy omits URL-based pagination and the
+ * consumer instead applies HTTP request headers returned by
+ * `NgQubeeService.paginationHeaders()`. Currently honoured only by the
+ * PostgREST driver, which maps it to `Range-Unit: items` + `Range: 0-9`.
+ * Other drivers ignore the setting.
+ */
+var PaginationModeEnum;
+(function (PaginationModeEnum) {
+    PaginationModeEnum["QUERY"] = "query";
+    PaginationModeEnum["RANGE"] = "range";
+})(PaginationModeEnum || (PaginationModeEnum = {}));
+
 /**
  * Request strategy for the PostgREST driver
  *
@@ -1296,6 +2145,228 @@ class PostgrestResponseStrategy {
     }
 }
 
+/**
+ * Request strategy for the Sieve (.NET) driver
+ *
+ * Generates URIs in [Sieve's compact expression format](https://github.com/Biarity/Sieve):
+ * - Filters: a single `filters=` parameter holding comma-joined (AND)
+ *   `Field{op}Value` terms; multi-value terms use the pipe (OR) on the
+ *   value side (`status==active|pending`)
+ * - Operator filters: translated from `FilterOperatorEnum` — see the
+ *   mapping on `_formatOperatorTerms`
+ * - Sorts: `sorts=field,-other` (CSV, `-` prefix = DESC)
+ * - Pagination: `page=N&pageSize=N`
+ *
+ * Sieve has no per-model field selection, no relation includes, no flat
+ * column selection, and no global search parameter — the corresponding
+ * fluent methods throw the matching `Unsupported*Error`. PostgREST-native
+ * full-text search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+ * `UnsupportedFilterOperatorError`.
+ *
+ * @see https://github.com/Biarity/Sieve
+ */
+class SieveRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Filters, operator filters, sorts — no per-model fields, no includes,
+     * no flat select, no global search (use `CONTAINS` / `ILIKE` operator
+     * filters for partial matches)
+     */
+    capabilities = {
+        fields: false,
+        filters: true,
+        includes: false,
+        operatorFilters: true,
+        search: false,
+        select: false,
+        sort: true
+    };
+    /**
+     * Sieve-native names of the three hardcoded query keys
+     *
+     * Sieve's model binder reads `filters`, `sorts`, and `pageSize` (the
+     * plural forms differ from the library-wide `filter` / `sort` /
+     * `limit` defaults); these keys are intentionally not configurable
+     * through `QueryBuilderOptions` and live as private statics so they
+     * are visible in one place.
+     */
+    static _filtersKey = 'filters';
+    static _pageSizeKey = 'pageSize';
+    static _sortsKey = 'sorts';
+    /**
+     * Emit Sieve-format query-string segments in canonical order:
+     * filters → sorts → page → pageSize
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration (used
+     * for `page`, whose default matches the wire format; the `filters` /
+     * `sorts` / `pageSize` keys are fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    parts(state, options) {
+        const out = [];
+        this._appendFilters(state, out);
+        this._appendSorts(state, out);
+        this._appendPage(state, options, out);
+        this._appendPageSize(state, out);
+        return out;
+    }
+    /**
+     * Append the single `filters=` parameter combining simple and operator
+     * filters
+     *
+     * Each term is one `Field{op}Value` expression; terms join with the
+     * comma (Sieve's AND). Simple single-value filters fold to `==`;
+     * simple multi-value filters fold to a value-level pipe OR
+     * (`field==v1|v2`).
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendFilters(state, out) {
+        const terms = [];
+        Object.keys(state.filters).forEach(field => {
+            const values = state.filters[field];
+            if (!values.length) {
+                return;
+            }
+            terms.push(`${field}==${values.join('|')}`);
+        });
+        state.operatorFilters.forEach((filter) => {
+            terms.push(...this._formatOperatorTerms(filter));
+        });
+        if (!terms.length) {
+            return;
+        }
+        out.push(`${SieveRequestStrategy._filtersKey}=${terms.join(',')}`);
+    }
+    /**
+     * Append the page parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendPage(state, options, out) {
+        out.push(`${options.page}=${state.page}`);
+    }
+    /**
+     * Append the pageSize parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendPageSize(state, out) {
+        out.push(`${SieveRequestStrategy._pageSizeKey}=${state.limit}`);
+    }
+    /**
+     * Append the `sorts=field,-other` CSV parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendSorts(state, out) {
+        if (!state.sorts.length) {
+            return;
+        }
+        const fields = state.sorts.map(sort => sort.order === SortEnum.DESC ? `-${sort.field}` : sort.field);
+        out.push(`${SieveRequestStrategy._sortsKey}=${fields.join(',')}`);
+    }
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into one or more
+     * Sieve `Field{op}Value` terms
+     *
+     * The mapping is library-canonical → Sieve-native:
+     * - `EQ` → `==`; `GT`/`GTE`/`LT`/`LTE` → `>` / `>=` / `<` / `<=`
+     * - `CONTAINS` → `@=`; `ILIKE` → `@=*` (case-insensitive contains)
+     * - `SW` → `_=` (starts with)
+     * - `IN` → `==` with a value-level pipe OR (`field==v1|v2`)
+     * - `BTW` → **two** AND-ed terms (`field>=min` and `field<=max`,
+     *   arity-checked)
+     * - `NOT` → `!=` — one term per value, AND-ed (`field!=v1,field!=v2`)
+     * - `NULL` → `==null` (when value is `true`) / `!=null` (when value is
+     *   `false`); arity- and type-checked
+     *
+     * PostgREST's full-text-search operators (`FTS`, `PHFTS`, `PLFTS`,
+     * `WFTS`) have no Sieve equivalent and throw
+     * `UnsupportedFilterOperatorError`.
+     *
+     * @param filter - The operator filter to translate
+     * @returns One or more `Field{op}Value` terms ready to AND-join
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator is a
+     * PostgREST-only FTS variant
+     */
+    _formatOperatorTerms(filter) {
+        const { field, operator, values } = filter;
+        const first = values[0];
+        switch (operator) {
+            case FilterOperatorEnum.EQ: return [`${field}==${first}`];
+            case FilterOperatorEnum.GT: return [`${field}>${first}`];
+            case FilterOperatorEnum.GTE: return [`${field}>=${first}`];
+            case FilterOperatorEnum.LT: return [`${field}<${first}`];
+            case FilterOperatorEnum.LTE: return [`${field}<=${first}`];
+            case FilterOperatorEnum.CONTAINS: return [`${field}@=${first}`];
+            case FilterOperatorEnum.ILIKE: return [`${field}@=*${first}`];
+            case FilterOperatorEnum.SW: return [`${field}_=${first}`];
+            case FilterOperatorEnum.IN: return [`${field}==${values.join('|')}`];
+            case FilterOperatorEnum.BTW: {
+                if (values.length !== 2) {
+                    throw new InvalidFilterOperatorValueError(operator, 'BTW requires exactly 2 values (min, max)');
+                }
+                return [`${field}>=${values[0]}`, `${field}<=${values[1]}`];
+            }
+            case FilterOperatorEnum.NOT:
+                return values.map(value => `${field}!=${value}`);
+            case FilterOperatorEnum.NULL: {
+                if (values.length !== 1 || typeof first !== 'boolean') {
+                    throw new InvalidFilterOperatorValueError(operator, 'NULL requires exactly 1 boolean value (true → IS NULL, false → IS NOT NULL)');
+                }
+                return first ? [`${field}==null`] : [`${field}!=null`];
+            }
+            case FilterOperatorEnum.FTS:
+            case FilterOperatorEnum.PHFTS:
+            case FilterOperatorEnum.PLFTS:
+            case FilterOperatorEnum.WFTS:
+                throw new UnsupportedFilterOperatorError();
+        }
+    }
+}
+
+/**
+ * Response strategy for the Sieve (.NET) driver
+ *
+ * Sieve itself does not define a response envelope — it returns an
+ * `IQueryable` that the ASP.NET developer wraps in a paging DTO of their
+ * choosing. This strategy therefore ships a **sensible default mapping**
+ * for the common hand-rolled `PagedResult<T>` shape:
+ * ```json
+ * {
+ *   "data": [{ "id": 1, "title": "Hello" }],
+ *   "page": 2,
+ *   "pageSize": 10,
+ *   "total": 48,
+ *   "totalPages": 5
+ * }
+ * ```
+ *
+ * Every key path is configurable through `IConfig.response` (dot
+ * notation supported), so any wrapper shape — `{ items, meta: {...} }`,
+ * `{ results, pagination: {...} }` — can be mapped without subclassing.
+ * Defaults are encoded in `SieveResponseOptions`. `from`/`to` are
+ * computed from `page` × `pageSize` by the inherited traversal
+ * algorithm, and the navigation-URL slots resolve to `undefined` unless
+ * paths are provided.
+ *
+ * The dot-notation traversal is inherited from
+ * `AbstractDotPathResponseStrategy`; this class exists so
+ * `DriverEnum.SIEVE` resolves to a distinct identity at the DI layer.
+ *
+ * @see https://github.com/Biarity/Sieve
+ */
+class SieveResponseStrategy extends AbstractDotPathResponseStrategy {
+}
+
 /**
  * Request strategy for the Spatie Query Builder driver
  *
@@ -1442,7 +2513,8 @@ class SpatieRequestStrategy extends AbstractRequestStrategy {
 /**
  * Response strategy for the Spatie Query Builder driver
  *
- * Parses flat Laravel pagination responses:
+ * Parses flat Laravel-style pagination responses (Spatie's Query Builder
+ * is built on Laravel's pagination):
  * ```json
  * {
  *   "data": [...],
@@ -1455,32 +2527,216 @@ class SpatieRequestStrategy extends AbstractRequestStrategy {
  * }
  * ```
  *
+ * The traversal algorithm (flat `response[options.X]` lookups) is
+ * inherited from `AbstractFlatResponseStrategy`; this class exists so
+ * `DriverEnum.SPATIE` resolves to a distinct identity at the DI layer
+ * even though the parsing logic is shared with the plain Laravel driver.
+ *
  * @see https://spatie.be/docs/laravel-query-builder
  */
-class SpatieResponseStrategy {
+class SpatieResponseStrategy extends AbstractFlatResponseStrategy {
+}
+
+/**
+ * Request strategy for the Spring Data REST driver
+ *
+ * Generates URIs in [Spring Data REST's pagination format](https://docs.spring.io/spring-data/rest/reference/paging-and-sorting.html):
+ * - Sorts: `sort=field,asc&sort=other,desc` (repeatable param, one per rule)
+ * - Pagination: `page=N&size=N` — **`page` is 0-indexed on the wire**;
+ *   the library state stays 1-indexed and the strategy subtracts 1 at
+ *   emission time
+ *
+ * Spring Data REST defines no standard query parameter convention for
+ * filtering, field selection, includes, or global search — those are
+ * implemented server-side via custom query methods or Specifications.
+ * The corresponding fluent methods (`addFilter`, `addFilterOperator`,
+ * `addSelect`, `addFields`, `addIncludes`, `setSearch`) throw the
+ * matching `Unsupported*Error` on this driver.
+ *
+ * @see https://docs.spring.io/spring-data/rest/reference/paging-and-sorting.html
+ */
+class SpringRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Sorts only — Spring Data REST has no standard wire convention for
+     * filters, operator filters, per-model fields, flat select, includes,
+     * or global search
+     */
+    capabilities = {
+        fields: false,
+        filters: false,
+        includes: false,
+        operatorFilters: false,
+        search: false,
+        select: false,
+        sort: true
+    };
     /**
-     * Parse a flat Laravel pagination response into a PaginatedCollection
+     * Spring-native name of the hardcoded page-size query key
      *
-     * @param response - The raw API response object
-     * @param options - The response key name configuration
-     * @returns A typed PaginatedCollection instance
+     * The wire format is fixed (Spring's `PageableHandlerMethodArgumentResolver`
+     * reads `size` by default); the key is intentionally not configurable
+     * through `QueryBuilderOptions` and lives as a private static so it is
+     * visible in one place.
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    paginate(response, options) {
-        return new PaginatedCollection(response[options.data], response[options.currentPage], response[options.from], response[options.to], response[options.total], response[options.perPage], response[options.prevPageUrl], response[options.nextPageUrl], response[options.lastPage], response[options.firstPageUrl], response[options.lastPageUrl]);
+    static _sizeKey = 'size';
+    /**
+     * Emit Spring-format query-string segments in canonical order:
+     * sort → page → size
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration (used
+     * for `page` and `sort`, whose defaults match the wire format; the
+     * `size` key is fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    parts(state, options) {
+        const out = [];
+        this._appendSort(state, options, out);
+        this._appendPage(state, options, out);
+        this._appendSize(state, out);
+        return out;
+    }
+    /**
+     * Append the 0-indexed page parameter
+     *
+     * The library state is 1-indexed (page 1 is the first page); Spring's
+     * `page` request parameter is 0-indexed, so the strategy subtracts 1
+     * at emission time.
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendPage(state, options, out) {
+        out.push(`${options.page}=${state.page - 1}`);
+    }
+    /**
+     * Append the size parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendSize(state, out) {
+        out.push(`${SpringRequestStrategy._sizeKey}=${state.limit}`);
+    }
+    /**
+     * Append `sort=field,asc` params, one per sort rule (repeatable)
+     *
+     * Spring parses each `sort` occurrence independently — multiple rules
+     * are expressed by repeating the parameter, not by comma-joining the
+     * fields.
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    _appendSort(state, options, out) {
+        state.sorts.forEach(sort => {
+            const direction = sort.order === SortEnum.DESC ? 'desc' : 'asc';
+            out.push(`${options.sort}=${sort.field},${direction}`);
+        });
     }
 }
 
 /**
- * Error thrown when filter operators are attempted with a driver that does not support them
+ * Response strategy for the Spring Data REST driver
  *
- * Filter operators are only supported by the NestJS driver.
- * Use `addFilter()` for Spatie implicit equality filters.
+ * Parses Spring Data REST's HAL envelope:
+ * ```json
+ * {
+ *   "_embedded": { "users": [{ "id": 1, "name": "John" }] },
+ *   "_links": {
+ *     "first": { "href": "..." },
+ *     "prev": { "href": "..." },
+ *     "next": { "href": "..." },
+ *     "last": { "href": "..." }
+ *   },
+ *   "page": { "size": 20, "totalElements": 100, "totalPages": 5, "number": 1 }
+ * }
+ * ```
+ *
+ * Two HAL quirks are absorbed here on top of the inherited dot-path
+ * traversal:
+ *
+ * - **`page.number` is 0-indexed** — the strategy adds 1 so the library
+ *   state stays 1-indexed (mirroring `SpringRequestStrategy`, which
+ *   subtracts 1 on the way out).
+ * - **The collection key under `_embedded` is the resource rel name**
+ *   (e.g. `_embedded.users`), which cannot be known statically. The
+ *   default `data` path is plain `_embedded`; when it resolves to an
+ *   object rather than an array, the strategy picks the first array
+ *   value inside it. Consumers with multiple embedded rels can pin the
+ *   exact path via `IConfig.response` (e.g. `data: '_embedded.users'`).
+ *
+ * Default key paths are configured in `SpringResponseOptions`.
+ *
+ * @see https://docs.spring.io/spring-data/rest/reference/paging-and-sorting.html
  */
-class UnsupportedFilterOperatorError extends Error {
-    constructor() {
-        super('Filter operators are only supported by the NestJS driver. Use addFilter() for Spatie.');
-        this.name = 'UnsupportedFilterOperatorError';
+class SpringResponseStrategy extends AbstractDotPathResponseStrategy {
+    /**
+     * Parse a Spring Data REST HAL response into a PaginatedCollection
+     *
+     * @param response - The raw API response body
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paginate(response, options) {
+        const data = this._resolveData(response, options);
+        const currentPage = this._resolveCurrentPage(response, options);
+        const total = this.resolve(response, options.total);
+        const perPage = this.resolve(response, options.perPage);
+        const lastPage = this.resolve(response, options.lastPage);
+        const from = this.resolveFrom(response, options, currentPage, perPage);
+        const to = this.resolveTo(response, options, currentPage, perPage, total);
+        const prevPageUrl = this.resolve(response, options.prevPageUrl);
+        const nextPageUrl = this.resolve(response, options.nextPageUrl);
+        const firstPageUrl = this.resolve(response, options.firstPageUrl);
+        const lastPageUrl = this.resolve(response, options.lastPageUrl);
+        return new PaginatedCollection(data, currentPage, from, to, total, perPage, prevPageUrl, nextPageUrl, lastPage, firstPageUrl, lastPageUrl);
+    }
+    /**
+     * Resolve the 1-indexed current page from the 0-indexed `page.number`
+     *
+     * Falls back to page 1 when the path is missing entirely (defensive —
+     * Spring always emits the `page` block on paged endpoints).
+     *
+     * @param response - The raw response object
+     * @param options - The response key name configuration
+     * @returns The 1-indexed current page number
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _resolveCurrentPage(response, options) {
+        const pageNumber = this.resolve(response, options.currentPage);
+        return (pageNumber ?? 0) + 1;
+    }
+    /**
+     * Resolve the data array from the HAL `_embedded` wrapper
+     *
+     * When the configured path resolves directly to an array (a consumer
+     * pinned `data: '_embedded.users'`), it is used as-is. When it
+     * resolves to an object (the default `_embedded` path), the first
+     * array value inside it is used — Spring emits exactly one collection
+     * rel per listing endpoint. An empty array is returned when nothing
+     * matches (e.g. Spring omits `_embedded` on empty result sets).
+     *
+     * @param response - The raw response object
+     * @param options - The response key name configuration
+     * @returns The resolved data array (possibly empty)
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _resolveData(response, options) {
+        const raw = this.resolve(response, options.data);
+        if (Array.isArray(raw)) {
+            return raw;
+        }
+        if (raw && typeof raw === 'object') {
+            const firstArray = Object.values(raw).find(value => Array.isArray(value));
+            if (firstArray) {
+                return firstArray;
+            }
+        }
+        return [];
     }
 }
 
@@ -1764,6 +3020,11 @@ class StrapiResponseStrategy extends AbstractDotPathResponseStrategy {
  * `switch` blocks.
  */
 const DRIVERS = {
+    [DriverEnum.DRF]: {
+        createRequestStrategy: () => new DrfRequestStrategy(),
+        createResponseStrategy: () => new DrfResponseStrategy(),
+        createResponseOptions: (config) => new DrfResponseOptions(config)
+    },
     [DriverEnum.JSON_API]: {
         createRequestStrategy: () => new JsonApiRequestStrategy(),
         createResponseStrategy: () => new JsonApiResponseStrategy(),
@@ -1779,16 +3040,31 @@ const DRIVERS = {
         createResponseStrategy: () => new NestjsResponseStrategy(),
         createResponseOptions: (config) => new NestjsResponseOptions(config)
     },
+    [DriverEnum.NESTJSX_CRUD]: {
+        createRequestStrategy: () => new NestjsxCrudRequestStrategy(),
+        createResponseStrategy: () => new NestjsxCrudResponseStrategy(),
+        createResponseOptions: (config) => new NestjsxCrudResponseOptions(config)
+    },
     [DriverEnum.POSTGREST]: {
         createRequestStrategy: (mode) => new PostgrestRequestStrategy(mode),
         createResponseStrategy: () => new PostgrestResponseStrategy(),
         createResponseOptions: (config) => new ResponseOptions(config)
     },
+    [DriverEnum.SIEVE]: {
+        createRequestStrategy: () => new SieveRequestStrategy(),
+        createResponseStrategy: () => new SieveResponseStrategy(),
+        createResponseOptions: (config) => new SieveResponseOptions(config)
+    },
     [DriverEnum.SPATIE]: {
         createRequestStrategy: () => new SpatieRequestStrategy(),
         createResponseStrategy: () => new SpatieResponseStrategy(),
         createResponseOptions: (config) => new ResponseOptions(config)
     },
+    [DriverEnum.SPRING]: {
+        createRequestStrategy: () => new SpringRequestStrategy(),
+        createResponseStrategy: () => new SpringResponseStrategy(),
+        createResponseOptions: (config) => new SpringResponseOptions(config)
+    },
     [DriverEnum.STRAPI]: {
         createRequestStrategy: () => new StrapiRequestStrategy(),
         createResponseStrategy: () => new StrapiResponseStrategy(),
@@ -3149,5 +4425,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { DriverEnum, FilterOperatorEnum, InvalidFilterOperatorValueError, InvalidLimitError, InvalidPageNumberError, InvalidResourceNameError, JsonApiRequestStrategy, JsonApiResponseStrategy, KeyNotFoundError, LaravelRequestStrategy, LaravelResponseStrategy, NG_QUBEE_DRIVER, NG_QUBEE_REQUEST_OPTIONS, NG_QUBEE_REQUEST_STRATEGY, NG_QUBEE_RESPONSE_OPTIONS, NG_QUBEE_RESPONSE_STRATEGY, NestjsRequestStrategy, NestjsResponseStrategy, NgQubeeModule, NgQubeeService, PaginatedCollection, PaginationModeEnum, PaginationNotSyncedError, PaginationService, PostgrestRequestStrategy, PostgrestResponseStrategy, SortEnum, SpatieRequestStrategy, SpatieResponseStrategy, StrapiRequestStrategy, StrapiResponseStrategy, UnselectableModelError, UnsupportedFieldSelectionError, UnsupportedFilterError, UnsupportedFilterOperatorError, UnsupportedIncludesError, UnsupportedSearchError, UnsupportedSelectError, UnsupportedSortError, buildNgQubeeProviders, provideNgQubee, provideNgQubeeInstance, readHeader };
+export { DrfRequestStrategy, DrfResponseStrategy, DriverEnum, FilterOperatorEnum, InvalidFilterOperatorValueError, InvalidLimitError, InvalidPageNumberError, InvalidResourceNameError, JsonApiRequestStrategy, JsonApiResponseStrategy, KeyNotFoundError, LaravelRequestStrategy, LaravelResponseStrategy, NG_QUBEE_DRIVER, NG_QUBEE_REQUEST_OPTIONS, NG_QUBEE_REQUEST_STRATEGY, NG_QUBEE_RESPONSE_OPTIONS, NG_QUBEE_RESPONSE_STRATEGY, NestjsRequestStrategy, NestjsResponseStrategy, NestjsxCrudRequestStrategy, NestjsxCrudResponseStrategy, NgQubeeModule, NgQubeeService, PaginatedCollection, PaginationModeEnum, PaginationNotSyncedError, PaginationService, PostgrestRequestStrategy, PostgrestResponseStrategy, SieveRequestStrategy, SieveResponseStrategy, SortEnum, SpatieRequestStrategy, SpatieResponseStrategy, SpringRequestStrategy, SpringResponseStrategy, StrapiRequestStrategy, StrapiResponseStrategy, UnselectableModelError, UnsupportedFieldSelectionError, UnsupportedFilterError, UnsupportedFilterOperatorError, UnsupportedIncludesError, UnsupportedSearchError, UnsupportedSelectError, UnsupportedSortError, buildNgQubeeProviders, provideNgQubee, provideNgQubeeInstance, readHeader };
 //# sourceMappingURL=ng-qubee.mjs.map