ng-qubee 3.5.0 → 3.6.0

package/fesm2022/ng-qubee.mjs

@@ -78,8 +78,11 @@ var DriverEnum;
     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 = {}));
 
@@ -202,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
  *
@@ -1400,6 +1492,273 @@ class NestjsRequestStrategy extends AbstractRequestStrategy {
 class NestjsResponseStrategy extends AbstractDotPathResponseStrategy {
 }
 
+/**
+ * Request strategy for the @nestjsx/crud driver
+ *
+ * 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`
+ *
+ * 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`.
+ *
+ * @see https://github.com/nestjsx/crud/wiki/Requests
+ */
+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();
+        }
+    }
+}
+
+/**
+ * Response strategy for the @nestjsx/crud driver
+ *
+ * Parses @nestjsx/crud's `getMany` envelope:
+ * ```json
+ * {
+ *   "data": [{ "id": 1, "name": "John" }],
+ *   "count": 10,
+ *   "total": 48,
+ *   "page": 2,
+ *   "pageCount": 5
+ * }
+ * ```
+ *
+ * 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
  *
@@ -1786,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
  *
@@ -1956,6 +2537,209 @@ class SpatieRequestStrategy extends AbstractRequestStrategy {
 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
+    };
+    /**
+     * Spring-native name of the hardcoded page-size query key
+     *
+     * 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.
+     */
+    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}`);
+        });
+    }
+}
+
+/**
+ * Response strategy for the Spring Data REST driver
+ *
+ * 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 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 [];
+    }
+}
+
 /**
  * Request strategy for the Strapi driver
  *
@@ -2256,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(),
@@ -3626,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